LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22ef
movq %rsi, %rbx
testq %rsi, %rsi
je 0x230e
movq 0x10(%rdi), %r15
movb $0x1, %r14b
testq %r15, %r15
je 0x22e3
movq 0x8(%rdi), %r12
addq $0x28, %r12
movq -0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x22df
addq $0x30, %r12
decq %r15
jne 0x22c3
jmp 0x22e3
movb (%r12), %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31c3(%rip), %rdi      # 0x54b9
leaq 0x2dcb(%rip), %rsi      # 0x50c8
leaq 0x31e8(%rip), %rcx      # 0x54ec
movl $0x1ab, %edx            # imm = 0x1AB
callq 0x1090
leaq 0x31fd(%rip), %rdi      # 0x5512
leaq 0x2dac(%rip), %rsi      # 0x50c8
leaq 0x31c9(%rip), %rcx      # 0x54ec
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x240b
movq %rsi, %r15
testq %rsi, %rsi
je 0x2414
movq %rdx, %r12
testq %rdx, %rdx
je 0x241d
movq 0x8(%r15), %rax
movb $0x1, %bl
testq %rax, %rax
je 0x23fc
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x23fc
cmpl $0x8, (%rax)
jne 0x23fc
movq %rdi, %r14
movq %r12, %rdx
callq 0x27c6
testb %al, %al
je 0x23be
leaq 0x30dd(%rip), %rdi      # 0x5471
leaq 0x31a8(%rip), %rsi      # 0x5543
movl $0x1dd, %edx            # imm = 0x1DD
xorl %eax, %eax
callq 0x1040
movq 0x18(%r15), %rdx
leaq 0x30e4(%rip), %rdi      # 0x5496
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x23fc
movq 0x8(%r15), %rax
movq 0x18(%rax), %rsi
movq %r12, %rdi
callq 0x2297
movb %al, -0x21(%rbp)
cmpb $0x1, %al
je 0x23fc
leaq 0x3192(%rip), %rsi      # 0x556e
movl $0x4, %edx
movq %r14, %rdi
callq 0x15a4
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x15a4
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2efc(%rip), %rdi      # 0x530e
jmp 0x2424
leaq 0x3032(%rip), %rdi      # 0x544d
jmp 0x2424
leaq 0x3095(%rip), %rdi      # 0x54b9
leaq 0x2c9d(%rip), %rsi      # 0x50c8
leaq 0x3111(%rip), %rcx      # 0x5543
movl $0x1d8, %edx            # imm = 0x1D8
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2590
movq %rsi, %r15
testq %rsi, %rsi
je 0x2599
movq %rdx, %r14
testq %rdx, %rdx
je 0x25a2
movq %rdi, %rbx
movq 0x18(%r15), %rsi
leaq 0x2c1e(%rip), %rdi      # 0x5093
callq 0x1150
testl %eax, %eax
je 0x255e
movq %rbx, %rdi
callq 0x2cea
leaq -0x20(%rbp), %rcx
movl $0x0, (%rcx)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2dad
movb $0x1, %r14b
testb %al, %al
jne 0x2582
movq 0x18(%r15), %rsi
movq 0x50(%rbx), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x1717
leaq 0x2bda(%rip), %rsi      # 0x50a2
movl $0x5, %edx
movq %rbx, %rdi
callq 0x15a4
leaq 0x30ec(%rip), %rsi      # 0x55c8
movl $0x3, %edx
movq %rbx, %rdi
callq 0x15a4
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movb 0x60(%rbx), %al
cmpb $0xf, %al
jg 0x2576
cmpb $0x8, %al
leaq 0x30c2(%rip), %rax      # 0x55cc
leaq 0x30c0(%rip), %rsi      # 0x55d1
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movsbl 0x60(%rbx), %eax
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0x18, %ecx
leal 0x1(%rax), %edx
subl %ecx, %eax
shlb $0x3, %al
addb $-0x40, %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
movb %dl, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
movq %rbx, %rdi
callq 0x2f0d
xorl %r14d, %r14d
jmp 0x2582
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2be5
leaq 0x335d(%rip), %rdi      # 0x58da
callq 0x1180
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d77(%rip), %rdi      # 0x530e
jmp 0x25a9
leaq 0x2ead(%rip), %rdi      # 0x544d
jmp 0x25a9
leaq 0x2f10(%rip), %rdi      # 0x54b9
leaq 0x2b18(%rip), %rsi      # 0x50c8
leaq 0x2fe7(%rip), %rcx      # 0x559e
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x265d
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2666
testq %rdx, %rdx
je 0x266f
cmpl $0xa, (%rbx)
jne 0x262a
movq %rdi, %r14
movq 0x8(%rbx), %rsi
callq 0x27c6
testb %al, %al
je 0x2631
leaq 0x2e6f(%rip), %rdi      # 0x5471
leaq 0x2fcd(%rip), %rsi      # 0x55d6
movl $0x219, %edx            # imm = 0x219
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x2e76(%rip), %rdi      # 0x5496
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2fc7(%rip), %rsi      # 0x55ff
movl $0x5, %edx
movq %r14, %rdi
callq 0x15a4
leaq 0x2bf9(%rip), %rsi      # 0x5245
movl $0x5, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x15a4
leaq 0x2caa(%rip), %rdi      # 0x530e
jmp 0x2676
leaq 0x2de0(%rip), %rdi      # 0x544d
jmp 0x2676
leaq 0x2e43(%rip), %rdi      # 0x54b9
leaq 0x2a4b(%rip), %rsi      # 0x50c8
leaq 0x2f52(%rip), %rcx      # 0x55d6
movl $0x214, %edx            # imm = 0x214
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
testq %rdi, %rdi
je 0x2795
movq %rsi, %r14
testq %rsi, %rsi
je 0x279e
movq %rdx, %r12
testq %rdx, %rdx
je 0x27a7
movl (%r14), %eax
addl $-0xb, %eax
movb $0x1, %r15b
cmpl $0x1, %eax
ja 0x2783
movq %rdi, %rbx
movl 0x50(%rdi), %eax
movl %eax, -0x2c(%rbp)
movq 0x8(%r14), %rsi
movq %r12, %rdx
callq 0x2fe6
movb $0x1, %r15b
testb %al, %al
jne 0x2783
movq 0x50(%rbx), %r13
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x273c
movq %rbx, %rdi
movq %r12, %rdx
callq 0x212f
testb %al, %al
je 0x273c
leaq 0x2d5f(%rip), %rdi      # 0x5471
leaq 0x2eec(%rip), %rsi      # 0x5605
movl $0x22d, %edx            # imm = 0x22D
xorl %eax, %eax
callq 0x1040
movq 0x18(%r14), %rdx
leaq 0x2d66(%rip), %rdi      # 0x5496
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x2783
cmpl $0xc, (%r14)
jne 0x2771
leaq 0x2ee6(%rip), %rsi      # 0x562f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
leaq -0x2c(%rbp), %rsi
movl (%rsi), %eax
subl 0x50(%rbx), %eax
addl $-0x4, %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movl 0x50(%rbx), %eax
subl %r13d, %eax
movq 0x40(%rbx), %rcx
movl %eax, -0x4(%rcx,%r13)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b72(%rip), %rdi      # 0x530e
jmp 0x27ae
leaq 0x2ca8(%rip), %rdi      # 0x544d
jmp 0x27ae
leaq 0x2d0b(%rip), %rdi      # 0x54b9
leaq 0x2913(%rip), %rsi      # 0x50c8
leaq 0x2e49(%rip), %rcx      # 0x5605
movl $0x221, %edx            # imm = 0x221
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2802
testq %rsi, %rsi
je 0x280b
testq %rdx, %rdx
je 0x2814
movl (%rsi), %eax
cmpl $0x7, %eax
je 0x27f6
cmpl $0x8, %eax
je 0x27f0
cmpl $0xd, %eax
jne 0x27fc
popq %rbp
jmp 0x243c
popq %rbp
jmp 0x2941
popq %rbp
jmp 0x2833
popq %rbp
jmp 0x2a3d
leaq 0x2b05(%rip), %rdi      # 0x530e
jmp 0x281b
leaq 0x2c3b(%rip), %rdi      # 0x544d
jmp 0x281b
leaq 0x2c9e(%rip), %rdi      # 0x54b9
leaq 0x28a6(%rip), %rsi      # 0x50c8
leaq 0x2d4a(%rip), %rcx      # 0x5573
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2903
testq %rsi, %rsi
je 0x2922
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0x1130
leaq -0x20(%rbp), %r14
movsd %xmm0, (%r14)
leaq 0x2e5a(%rip), %rsi      # 0x56c6
movl $0x2, %edx
movq %rbx, %rdi
callq 0x15a4
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15a4
movb 0x60(%rbx), %r14b
cmpb $0xf, %r14b
jle 0x28a1
leaq 0x3040(%rip), %rdi      # 0x58da
callq 0x1180
jmp 0x28f3
cmpb $0x8, %r14b
leaq 0x2d20(%rip), %rax      # 0x55cc
leaq 0x2d1e(%rip), %rsi      # 0x55d1
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movsbl 0x60(%rbx), %eax
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0x18, %ecx
leal 0x1(%rax), %edx
subl %ecx, %eax
shlb $0x3, %al
addb $-0x40, %al
leaq -0x11(%rbp), %rsi
movb %al, (%rsi)
movb %dl, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
cmpb $0x10, %r14b
setge %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a04(%rip), %rdi      # 0x530e
leaq 0x27b7(%rip), %rsi      # 0x50c8
leaq 0x2db7(%rip), %rcx      # 0x56cf
movl $0x2a9, %edx            # imm = 0x2A9
callq 0x1090
leaq 0x2b24(%rip), %rdi      # 0x544d
leaq 0x2798(%rip), %rsi      # 0x50c8
leaq 0x2d98(%rip), %rcx      # 0x56cf
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a0c
testq %rsi, %rsi
je 0x2a15
testq %rdx, %rdx
je 0x2a1e
movq %rdi, %rbx
cmpb $0xf, 0x60(%rdi)
jg 0x299b
movq 0x18(%rsi), %rsi
movq %rdx, %rdi
callq 0x2297
movb %al, -0x11(%rbp)
cmpb $0x1, %al
sete %r14b
je 0x2a00
cmpb $0x7, 0x60(%rbx)
jg 0x29ac
leaq 0x2d8e(%rip), %rsi      # 0x5722
movl $0x3, %edx
jmp 0x29b8
leaq 0x2faf(%rip), %rdi      # 0x5951
callq 0x1180
movb $0x1, %r14b
jmp 0x2a00
leaq 0x2d73(%rip), %rsi      # 0x5726
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movsbl 0x60(%rbx), %eax
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0x18, %ecx
leal 0x1(%rax), %edx
subl %ecx, %eax
shlb $0x3, %al
addb $0x45, %al
leaq -0x12(%rbp), %rsi
movb %al, (%rsi)
movb %dl, 0x60(%rbx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28fb(%rip), %rdi      # 0x530e
jmp 0x2a25
leaq 0x2a31(%rip), %rdi      # 0x544d
jmp 0x2a25
leaq 0x2a94(%rip), %rdi      # 0x54b9
leaq 0x269c(%rip), %rsi      # 0x50c8
leaq 0x2cc1(%rip), %rcx      # 0x56f4
movl $0x2b6, %edx            # imm = 0x2B6
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cb9
testq %rsi, %rsi
je 0x2cc2
testq %rdx, %rdx
je 0x2ccb
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl (%rsi), %eax
movb $0x1, %r14b
cmpl $0x8, %eax
je 0x2c2f
cmpl $0x7, %eax
jne 0x2cad
movq %rbx, %rdi
callq 0x2833
jmp 0x2c37
movq %rbx, %rdi
callq 0x2941
testb %al, %al
jne 0x2cad
movsbl 0x60(%rbx), %eax
leal -0x1(%rax), %ecx
leal 0x6(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $0x18, %edx
negl %edx
leal (%rax,%rdx), %ecx
decl %ecx
shlb $0x3, %cl
addb $-0x40, %cl
movb %cl, -0x11(%rbp)
cmpl $0x8, %eax
jg 0x2c76
leaq 0x2b68(%rip), %rsi      # 0x57d1
movl $0x3, %edx
movq %rbx, %rdi
callq 0x15a4
cmpb $0x8, 0x60(%rbx)
leaq 0x2b54(%rip), %rax      # 0x57d5
leaq 0x2b52(%rip), %rsi      # 0x57da
cmoveq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x15a4
movl %eax, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x264e(%rip), %rdi      # 0x530e
jmp 0x2cd2
leaq 0x2784(%rip), %rdi      # 0x544d
jmp 0x2cd2
leaq 0x27e7(%rip), %rdi      # 0x54b9
leaq 0x23ef(%rip), %rsi      # 0x50c8
leaq 0x2ac7(%rip), %rcx      # 0x57a7
movl $0x323, %edx            # imm = 0x323
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d8e
movq %rdi, %rbx
movb 0x60(%rdi), %r12b
movl %r12d, %eax
decb %al
js 0x2d7d
leal (,%r12,8), %r13d
addb $-0x8, %r13b
leaq -0x29(%rbp), %r14
leaq 0x29a7(%rip), %r15      # 0x56cd
decb %r12b
cmpb $0x8, %r12b
leaq 0x2a55(%rip), %rsi      # 0x5789
leaq 0x2a49(%rip), %rax      # 0x5784
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
movl %r13d, %eax
orb $-0x40, %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15a4
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15a4
addb $-0x8, %r13b
testb %r12b, %r12b
jg 0x2d26
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2579(%rip), %rdi      # 0x530e
leaq 0x232c(%rip), %rsi      # 0x50c8
leaq 0x29c8(%rip), %rcx      # 0x576b
movl $0x302, %edx            # imm = 0x302
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2eb0
movq %rdx, %r13
testq %rdx, %rdx
je 0x2ecf
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2eee
movq %rsi, %r15
testq %rsi, %rsi
je 0x2e9b
movq %rdi, %r14
movq 0x8(%r15), %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2dad
movb $0x1, %r12b
testb %al, %al
jne 0x2e9e
movl (%r15), %eax
cmpl $0x8, %eax
je 0x2e4c
cmpl $0x7, %eax
jne 0x2e9e
movq 0x18(%r15), %rdi
callq 0x1130
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
leaq 0x2894(%rip), %rsi      # 0x56c6
movl $0x2, %edx
movq %r14, %rdi
callq 0x15a4
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x2e7f
movq 0x18(%r15), %rsi
movq %r13, %rdi
callq 0x2297
movb %al, -0x29(%rbp)
cmpb $0x1, %al
je 0x2e9e
leaq 0x2863(%rip), %rsi      # 0x56c9
movl $0x3, %edx
movq %r14, %rdi
callq 0x15a4
leaq -0x29(%rbp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x15a4
leaq 0x2842(%rip), %rsi      # 0x56cd
movl $0x1, %edx
movq %r14, %rdi
callq 0x15a4
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 0x2457(%rip), %rdi      # 0x530e
leaq 0x220a(%rip), %rsi      # 0x50c8
leaq 0x27c0(%rip), %rcx      # 0x5685
movl $0x285, %edx            # imm = 0x285
callq 0x1090
leaq 0x25e3(%rip), %rdi      # 0x54b9
leaq 0x21eb(%rip), %rsi      # 0x50c8
leaq 0x27a1(%rip), %rcx      # 0x5685
movl $0x286, %edx            # imm = 0x286
callq 0x1090
leaq 0x27c6(%rip), %rdi      # 0x56bb
leaq 0x21cc(%rip), %rsi      # 0x50c8
leaq 0x2782(%rip), %rcx      # 0x5685
movl $0x287, %edx            # imm = 0x287
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fc7
movq %rdi, %rbx
cmpb $0x2, 0x60(%rdi)
jl 0x2fb6
xorl %r13d, %r13d
movb $0x1, %r12b
leaq -0x29(%rbp), %r15
leal -0x1(%r12), %r14d
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x2816(%rip), %rsi      # 0x5765
callq 0x15a4
cmpb $0x8, %r14b
leaq 0x2672(%rip), %rsi      # 0x55d1
leaq 0x2666(%rip), %rax      # 0x55cc
cmovlq %rax, %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x15a4
leal 0x7(%r13), %eax
testl %r13d, %r13d
cmovnsl %r13d, %eax
andl $0x18, %eax
subl %eax, %r13d
shlb $0x3, %r13b
addb $-0x40, %r13b
movb %r13b, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15a4
movsbl %r12b, %r13d
movsbl 0x60(%rbx), %eax
decl %eax
incb %r12b
cmpl %r13d, %eax
jg 0x2f3b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2340(%rip), %rdi      # 0x530e
leaq 0x20f3(%rip), %rsi      # 0x50c8
leaq 0x27b2(%rip), %rcx      # 0x578e
movl $0x311, %edx            # imm = 0x311
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31aa
movq $0x0, (%rdi)
addq $0x8, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
jmp 0x3a98
pushq %rbp
movq %rsp, %rbp
leaq 0x282d(%rip), %rdi      # 0x59e2
leaq 0x282b(%rip), %rsi      # 0x59e7
leaq 0x2836(%rip), %rcx      # 0x59f9
movl $0xc, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31f2
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3f06
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x27e9(%rip), %rdi      # 0x59e2
leaq 0x27e7(%rip), %rsi      # 0x59e7
leaq 0x280f(%rip), %rcx      # 0x5a16
movl $0x16, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq (%rdx), %r15
testq %r15, %r15
je 0x3266
movq %rdx, %r12
movl %esi, -0x2c(%rbp)
leaq 0x1(%r14), %rdi
movl $0x1, %esi
callq 0x10a0
testq %rax, %rax
je 0x32b0
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1070
addq %r14, %r15
movq %r15, (%r12)
movl -0x2c(%rbp), %esi
jmp 0x326e
testq %r14, %r14
jne 0x32cd
xorl %r13d, %r13d
leaq 0x8(%rbx), %rdi
movl %esi, -0x60(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x58(%rbp)
movq %r13, -0x48(%rbp)
movq %r14, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x40(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x4062
cmpl $0x0, 0x30(%rbx)
setne %al
jmp 0x32be
leaq 0x29e9(%rip), %rdi      # 0x5ca0
callq 0x1180
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x275e(%rip), %rdi      # 0x5a32
leaq 0x270c(%rip), %rsi      # 0x59e7
leaq 0x2755(%rip), %rcx      # 0x5a37
movl $0x2f, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3318
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x212e(%rip), %rdi      # 0x544d
leaq 0x26c1(%rip), %rsi      # 0x59e7
leaq 0x2742(%rip), %rcx      # 0x5a6f
movl $0x3c, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x33ec
movq %rdi, %r14
leaq 0x2759(%rip), %rdi      # 0x5aaa
leaq 0x2946(%rip), %rsi      # 0x5c9e
callq 0x1110
testq %rax, %rax
je 0x340b
movq %rax, %rbx
leaq 0x2751(%rip), %rdi      # 0x5ac1
movl $0x2b, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x11a0
movq (%r14), %rdx
testq %rdx, %rdx
je 0x33ae
movl (%rdx), %ecx
movq 0x18(%rdx), %r8
leaq 0x27d8(%rip), %rsi      # 0x5b6f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x342a
jmp 0x33c7
leaq 0x2738(%rip), %rdi      # 0x5aed
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11a0
movl $0x7d, %edi
movq %rbx, %rsi
callq 0x1140
movq %rbx, %rdi
callq 0x10f0
leaq 0x271a(%rip), %rdi      # 0x5afd
popq %rbx
popq %r14
popq %rbp
jmp 0x10d0
leaq 0x25ef(%rip), %rdi      # 0x59e2
leaq 0x25ed(%rip), %rsi      # 0x59e7
leaq 0x2690(%rip), %rcx      # 0x5a91
movl $0x45, %edx
callq 0x1090
leaq 0x26a9(%rip), %rdi      # 0x5abb
leaq 0x25ce(%rip), %rsi      # 0x59e7
leaq 0x2671(%rip), %rcx      # 0x5a91
movl $0x48, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x270f(%rip), %r15      # 0x5b50
testq %r14, %r14
je 0x34d3
testq %rbx, %rbx
je 0x34f2
movq 0x8(%rbx), %r9
cmpq 0x5d12(%rip), %r9       # 0x9170
jbe 0x348f
movl (%rbx), %ecx
movq 0x18(%rbx), %r8
movl (%r9), %r10d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
pushq 0x18(%r9)
pushq %r10
callq 0x1160
addq $0x10, %rsp
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x342a
movq 0x10(%rbx), %r9
cmpq 0x5cd6(%rip), %r9       # 0x9170
jbe 0x34c8
movl (%rbx), %ecx
movq 0x18(%rbx), %r8
movl (%r9), %r10d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
pushq 0x18(%r9)
pushq %r10
callq 0x1160
addq $0x10, %rsp
movq 0x10(%rbx), %rbx
jmp 0x3441
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e1(%rip), %rdi      # 0x5abb
leaq 0x2506(%rip), %rsi      # 0x59e7
leaq 0x2643(%rip), %rcx      # 0x5b2b
movl $0x5f, %edx
callq 0x1090
leaq 0x1f54(%rip), %rdi      # 0x544d
leaq 0x24e7(%rip), %rsi      # 0x59e7
leaq 0x2624(%rip), %rcx      # 0x5b2b
movl $0x60, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x2, %edx
callq 0x1100
movq %rbx, %rdi
callq 0x1030
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1100
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x35f7
movq %rsi, %r12
testq %rsi, %rsi
je 0x3616
movq %rdi, %rbx
leaq 0x28d6(%rip), %rsi      # 0x5e46
movq %r12, %rdi
callq 0x1110
testq %rax, %rax
je 0x35c6
movq %rax, %r15
movq %rax, %rdi
callq 0x3511
movslq %eax, %r14
leaq 0x4(%r14), %rdi
movl $0x1, %esi
callq 0x10a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x35dc
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1170
movq %r15, %rdi
callq 0x10f0
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
jmp 0x35eb
leaq 0x25f0(%rip), %rdi      # 0x5bbd
xorl %r14d, %r14d
movq %r12, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x35eb
leaq 0x26cb(%rip), %rdi      # 0x5cae
callq 0x1180
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ddf(%rip), %rdi      # 0x53dd
leaq 0x23e2(%rip), %rsi      # 0x59e7
leaq 0x2581(%rip), %rcx      # 0x5b8d
movl $0x84, %edx
callq 0x1090
leaq 0x2596(%rip), %rdi      # 0x5bb3
leaq 0x23c3(%rip), %rsi      # 0x59e7
leaq 0x2562(%rip), %rcx      # 0x5b8d
movl $0x85, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3688
movq %rdi, %rbx
leaq 0x25b0(%rip), %rdi      # 0x5bfb
leaq 0x264c(%rip), %rsi      # 0x5c9e
callq 0x1110
testq %rax, %rax
je 0x3678
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36a7
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10f0
leaq 0x2651(%rip), %rdi      # 0x5cd0
popq %rbx
popq %r14
popq %rbp
jmp 0x1180
leaq 0x2353(%rip), %rdi      # 0x59e2
leaq 0x2351(%rip), %rsi      # 0x59e7
leaq 0x2548(%rip), %rcx      # 0x5be5
movl $0xa2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: SaveElem(element*, _IO_FILE*, int)
void SaveElem (element* el, FILE* tree_file, int tab)
{
    assert (tree_file);

    if (!el)
    {
        fprintf (tree_file, "\n");
        return;
    }

    fprintf (tree_file, "%*s%s %s\n", tab * 4, "", TYPES_STR[el->type], el->ind);

    #define next(direction) fprintf (tree_file, "%*s{\n", tab * 4, "");   \
                            SaveElem (el->direction, tree_file, tab + 1); \
                            fprintf (tree_file, "%*s}\n", tab * 4, "")   

    next (left);
    next (right);
    #undef next
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x37ae
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x3793
movl %edx, %r14d
leal (,%r14,4), %r12d
movl (%r15), %eax
leaq 0x5a0e(%rip), %rcx      # 0x90f0
movq (%rcx,%rax,8), %r8
movq 0x18(%r15), %r9
leaq 0x2558(%rip), %rsi      # 0x5c49
leaq 0x1f80(%rip), %r13      # 0x5678
movq %rbx, %rdi
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1160
leaq 0x2544(%rip), %rsi      # 0x5c53
movq %rbx, %rdi
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1160
movq 0x8(%r15), %rdi
incl %r14d
movq %rbx, %rsi
movl %r14d, %edx
callq 0x36a7
leaq 0x2521(%rip), %rsi      # 0x5c59
movq %rbx, %rdi
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1160
movq %rbx, %rdi
leaq 0x2501(%rip), %rsi      # 0x5c53
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1160
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x36a7
movq %rbx, %rdi
leaq 0x24e1(%rip), %rsi      # 0x5c59
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1160
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
leaq 0x2464(%rip), %rdi      # 0x5c19
leaq 0x222b(%rip), %rsi      # 0x59e7
leaq 0x2460(%rip), %rcx      # 0x5c23
movl $0xb2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Tree.cpp
// Function: LoadTree(Tree*)
bool LoadTree (Tree* tree)
{
    assert (tree);
    
    if (tree->head)
    {
        printf ("Load error: Tree maybe is already created.\n");
        return 0;
    }

    char* tree_file = nullptr;
    ReadTxt (&tree_file, "CompileResult/CreatedTree.txt");
    char* pos_now = tree_file;
    tree->head = LoadElem (tree, &pos_now);
    
    free (tree_file);
    return tree->head != PARSE_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3843
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x37f6
leaq 0x2523(%rip), %rdi      # 0x5d10
callq 0x1180
xorl %eax, %eax
jmp 0x383a
leaq -0x20(%rbp), %r14
movq $0x0, (%r14)
leaq 0x23f3(%rip), %rsi      # 0x5bfb
movq %r14, %rdi
callq 0x3546
movq (%r14), %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3862
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x1120
movq (%rbx), %rax
cmpq 0x5939(%rip), %rax      # 0x9170
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2198(%rip), %rdi      # 0x59e2
leaq 0x2196(%rip), %rsi      # 0x59e7
leaq 0x2407(%rip), %rcx      # 0x5c5f
movl $0xc8, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackConstructor(Stack*, unsigned long)
void StackConstructor (Stack* stk, const size_t max_size)
{
	assert (stk);
	assert (max_size);

	if (!((stk->buffer == ERR_FREE && stk->status_error == STK_DEL) ||
		  (stk->buffer == nullptr  && stk->status_error == NOT_CREATED)))
	{
		stk->status_error = BAD_CREATE;
		StackLog (stk);
		return;
	}

	stk_type* buf = (stk_type*) calloc (max_size + 2, sizeof (stk_type));
	
	if (!buf)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}
	
	*((storm*)  buf)				 = STORMY_PETREL;
	*((storm*) (buf + max_size + 1)) = STORMY_PETREL;

	StackPoison (buf + 1, max_size);

	stk->buffer		  = buf + 1;
	stk->status_error = STK_GOOD;
	stk->capacity     = max_size;
	stk->min_capacity = max_size;

	RecountHash (stk);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3b9d
movq %rsi, %r14
testq %rsi, %rsi
je 0x3bbc
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3ae2
cmpq $0xe4, %rax
jne 0x3b77
cmpl $0x2, 0x28(%rbx)
je 0x3aec
testq %rax, %rax
jne 0x3b77
cmpl $0xc, 0x28(%rbx)
jne 0x3b77
leaq 0x2(%r14), %rdi
movl $0x30, %esi
callq 0x10a0
testq %rax, %rax
je 0x3b94
movq %rax, %r15
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, (%r15)
leaq (%r14,%r14,2), %rcx
shlq $0x4, %rcx
movq %rax, 0x30(%r15,%rcx)
leaq 0x30(%r15), %r12
addq $0x48, %r15
movq %r14, %r13
movq (%r15), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x1(%r15)
movups %xmm0, -0x8(%r15)
movups %xmm0, -0x18(%r15)
addq $0x30, %r15
decq %r13
jne 0x3b2b
movq %r12, 0x8(%rbx)
movl $0x0, 0x28(%rbx)
movq %r14, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3e68
movl $0xd, 0x28(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bdb
movl $0xb, 0x28(%rbx)
jmp 0x3b7e
leaq 0x2250(%rip), %rdi      # 0x5df4
leaq 0x224d(%rip), %rsi      # 0x5df8
leaq 0x2259(%rip), %rcx      # 0x5e0b
movl $0xa, %edx
callq 0x1090
leaq 0x2275(%rip), %rdi      # 0x5e38
leaq 0x222e(%rip), %rsi      # 0x5df8
leaq 0x223a(%rip), %rcx      # 0x5e0b
movl $0xb, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPoison(element*, unsigned long)
void StackPoison (stk_type* buffer, size_t num)
{
	assert (buffer);
	
	for (size_t elem = 0; elem < num; elem++)
	{
		free (buffer[elem].ind);
		buffer[elem] = STK_POISON;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3e49
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3e44
movq %rdi, %r14
movq 0x18(%r14), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
addq $0x30, %r14
decq %rbx
jne 0x3e21
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1ff1(%rip), %rdi      # 0x5e41
leaq 0x1fa1(%rip), %rsi      # 0x5df8
leaq 0x1fea(%rip), %rcx      # 0x5e48
movl $0x43, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: RecountHash(Stack*)
void RecountHash (Stack* stk)
{
	assert (stk);
	
	stk->stk_hash = 0;
	stk->buf_hash = 0;
	
	stk->stk_hash = CountHash ((char*) stk,			STK_HASH);
	stk->buf_hash = CountHash ((char*) stk->buffer, stk->capacity * sizeof (stk_type));

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x3ee7
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
xorl %eax, %eax
xorl %ecx, %ecx
movsbq (%rdi,%rax), %rdx
addq %rcx, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
shrl $0x3, %edx
movsbq %dl, %rcx
addq %rsi, %rcx
incq %rax
cmpq $0x44, %rax
jne 0x3e7c
movq %rcx, 0x30(%rdi)
movq 0x18(%rdi), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rax
testq %rax, %rax
je 0x3edf
movq 0x8(%rdi), %rcx
xorl %edx, %edx
xorl %esi, %esi
movsbq (%rcx,%rdx), %r8
addq %rsi, %r8
movq %r8, %r9
shlq $0x5, %r9
shrl $0x3, %r8d
movsbq %r8b, %rsi
addq %r9, %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x3ebb
jmp 0x3ee1
xorl %esi, %esi
movq %rsi, 0x38(%rdi)
popq %rbp
retq
leaq 0x1f06(%rip), %rdi      # 0x5df4
leaq 0x1f03(%rip), %rsi      # 0x5df8
leaq 0x240c(%rip), %rcx      # 0x6308
movl $0x186, %edx            # imm = 0x186
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackDestructor(Stack*)
void StackDestructor (Stack* stk)
{
	ASSERT_OK
	
	stk->buffer -= 1;

	StackPoison (stk->buffer, stk->capacity + 2);

	free (stk->buffer);

	stk->buffer = ERR_FREE;
	stk->size = 0;
	stk->capacity = 0;
	stk->status_error = STK_DEL;
	stk->buf_hash = 0;
	stk->stk_hash = 0;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f99
testl %eax, %eax
je 0x3f2e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3bdb
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %r15
leaq -0x30(%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x2, %r15
je 0x3f6b
addq $-0x18, %r14
movq (%r14), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x1(%r14)
movups %xmm0, -0x8(%r14)
movups %xmm0, -0x18(%r14)
addq $0x30, %r14
decq %r15
jne 0x3f48
movq 0x8(%rbx), %rdi
callq 0x1120
movq $0xe4, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x2, 0x28(%rbx)
movups %xmm0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackError(Stack*)
int StackError (Stack* stk)
{
	if (!stk)
		return STK_NULL;

	if (stk->stormy_petrel_begin != STORMY_PETREL)
		return stk->status_error = STK_PETREL_B;

	if (stk->stormy_petrel_end != STORMY_PETREL)
		return stk->status_error = STK_PETREL_E;
	
	if (stk->buffer == ERR_FREE)
		return stk->status_error = STK_DEL;
	
	if (!stk->buffer)
		return stk->status_error = BUF_NULL;
	
	if (stk->size > stk->capacity)
		return stk->status_error = BAD_SIZE_CAP;

	if (stk->capacity < stk->min_capacity)
		return stk->status_error = BAD_CAP;
	
	if (*((storm*) (stk->buffer - 1)) != STORMY_PETREL)
		return stk->status_error = BUF_PETREL_B;

	if (*((storm*) (stk->buffer + stk->capacity)) != STORMY_PETREL)
		return stk->status_error = BUF_PETREL_E;

	if (stk->status_error != 0)
		return stk->status_error;

	// Warning^ It's isn't standart stack mode.
	// This return is used for agree to use all data.
	return STK_GOOD;

	unsigned long long hash1 = stk->stk_hash;
	unsigned long long hash2 = stk->buf_hash;
	RecountHash (stk);

	if (stk->stk_hash != hash1)
		return stk->status_error = ERR_HASH_STK;

	if (stk->buf_hash != hash2)
		return stk->status_error = ERR_HASH_BUF;
	
	return STK_GOOD;
}

// Assembly:
testq %rdi, %rdi
je 0x3fd2
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
cmpq %rax, (%rdi)
jne 0x3fd8
cmpq %rax, 0x40(%rdi)
jne 0x3fe5
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3ff2
cmpq $0xe4, %rcx
jne 0x3fff
movl $0x2, 0x28(%rdi)
movl $0x2, %eax
retq
movl $0x1, %eax
retq
movl $0x7, 0x28(%rdi)
movl $0x7, %eax
retq
movl $0x8, 0x28(%rdi)
movl $0x8, %eax
retq
movl $0x3, 0x28(%rdi)
movl $0x3, %eax
retq
movq 0x18(%rdi), %rdx
cmpq %rdx, 0x10(%rdi)
jbe 0x4016
movl $0x4, 0x28(%rdi)
movl $0x4, %eax
retq
cmpq 0x20(%rdi), %rdx
jae 0x4029
movl $0x6, 0x28(%rdi)
movl $0x6, %eax
retq
pushq %rbp
movq %rsp, %rbp
cmpq %rax, -0x30(%rcx)
jne 0x4046
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
cmpq %rax, (%rcx,%rdx)
jne 0x4054
movl 0x28(%rdi), %eax
jmp 0x4060
movl $0x9, 0x28(%rdi)
movl $0x9, %eax
jmp 0x4060
movl $0xa, 0x28(%rdi)
movl $0xa, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPush(Stack*, element)
void StackPush (Stack* stk, stk_type elem)
{
	ASSERT_OK

	/*
	if (stk->size == stk->capacity)
		StackResizeUp (stk);

	if (stk->status_error == DO_MEM_ERR)
		return;
	*/

	if (stk->size == stk->capacity)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	char* new_ind = (char*) calloc (elem.len + 1, sizeof (char));
	if (!new_ind)
	{
		stk->status_error = DO_MEM_ERR;
		StackLog (stk);
		return;
	}

	strncpy (new_ind, elem.ind, elem.len + 1);

	char* elem_ind_save = elem.ind;
	elem.ind = new_ind;

	*(stk->buffer + (stk->size)++) = elem;
	elem.ind = elem_ind_save;

	RecountHash (stk);

	ASSERT_OK

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f99
testl %eax, %eax
jne 0x4129
movq 0x10(%rbx), %r12
cmpq 0x18(%rbx), %r12
je 0x4122
leaq 0x10(%rbp), %r13
movq 0x20(%r13), %r14
incq %r14
movl $0x1, %esi
movq %r14, %rdi
callq 0x10a0
testq %rax, %rax
je 0x4122
movq %rax, %r15
movq 0x18(%r13), %rsi
movq %rsi, -0x30(%rbp)
movq %rax, %rdi
movq %r14, %rdx
callq 0x1070
movq %r15, 0x18(%r13)
movq 0x8(%rbx), %rax
leaq 0x1(%r12), %rcx
movq %rcx, 0x10(%rbx)
leaq (%r12,%r12,2), %rcx
shlq $0x4, %rcx
movups (%r13), %xmm0
movups %xmm0, (%rax,%rcx)
movups 0x10(%r13), %xmm0
movups 0x19(%r13), %xmm1
movups %xmm0, 0x10(%rax,%rcx)
movups %xmm1, 0x19(%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r13)
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rdi
callq 0x3f99
testl %eax, %eax
jne 0x4129
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xb, 0x28(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bdb
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/TreeBase/Stack.cpp
// Function: StackPop(Stack*)
stk_type StackPop (Stack* stk)
{
	ASSERT_OK_POP
	
	if (stk->size == 0)
	{
		stk->status_error = BAD_SIZE_ZERO;
		StackLog (stk);
		return STK_POISON;
	}
	
	if (stk->capacity > stk->min_capacity &&
		stk->capacity >= STK_RESIZE * STK_RESIZE * stk->size)
			StackResizeDown(stk);

	if (stk->status_error == DO_MEM_ERR)
		return STK_POISON;

	stk_type popped = stk->buffer[--(stk->size)];
	*(stk->buffer + stk->size) = STK_POISON;

	RecountHash(stk);

	ASSERT_OK_POP

	return popped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3f99
testl %eax, %eax
je 0x417e
movq %r14, %rdi
callq 0x3bdb
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4220
movq 0x18(%r14), %rcx
shlq $0x2, %rax
cmpq %rax, %rcx
jb 0x41a6
cmpq 0x20(%r14), %rcx
jbe 0x41a6
movq %r14, %rdi
callq 0x422d
cmpl $0xb, 0x28(%r14)
je 0x4164
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
decq %rcx
movq %rcx, 0x10(%r14)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movups 0x20(%rax,%rcx), %xmm2
movaps %xmm2, -0x20(%rbp)
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movups %xmm0, 0x10(%rax,%rcx)
movq %r14, %rdi
callq 0x3e68
movq %r14, %rdi
callq 0x3f99
testl %eax, %eax
jne 0x415c
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
jmp 0x416f
movl $0x5, 0x28(%r14)
jmp 0x415c