LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: LexicalAnalyze(Tree*, char const*)
bool LexicalAnalyze (Tree* tree, const char* file_path)
{
    assert (tree);
    assert (file_path);

    char* code = nullptr;
    if (!ReadTxt (&code, file_path))
        return 1;

    size_t line_now = 1;
    char* code_now = code;
    SkipSpaces (&code_now, &line_now);

    while (*code_now != '\0')
    {
        if (tree->stk.status_error != STK_GOOD)
        {
            printf ("Stack error!\n");
            return 1;
        }

        if (CheckElement (tree, &code_now))
        {
            printf ("Error in line %lu\n", line_now);
            TreeDestructor (tree);
            return 1;
        }

        SkipSpaces (&code_now, &line_now);
    }

    free (code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x146e
testq %rsi, %rsi
je 0x148d
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
movq $0x0, (%rdi)
callq 0x2c96
testq %rax, %rax
je 0x142d
leaq -0x30(%rbp), %rsi
movq $0x1, (%rsi)
movq -0x38(%rbp), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x15e5
movq (%r14), %rax
cmpb $0x0, (%rax)
setne %r14b
je 0x1422
leaq -0x28(%rbp), %r15
leaq -0x30(%rbp), %r12
cmpl $0x0, 0x30(%rbx)
jne 0x1432
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1661
testb %al, %al
jne 0x1440
movq %r15, %rdi
movq %r12, %rsi
callq 0x15e5
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
setne %r14b
jne 0x13f5
movq -0x38(%rbp), %rdi
callq 0x1110
jmp 0x145a
movb $0x1, %r14b
jmp 0x145a
leaq 0x2fc5(%rip), %rdi      # 0x43fe
callq 0x1160
jmp 0x145a
movq -0x30(%rbp), %rsi
leaq 0x2c2a(%rip), %rdi      # 0x4075
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x291d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b8f(%rip), %rdi      # 0x4004
leaq 0x2b8d(%rip), %rsi      # 0x4009
leaq 0x2bc8(%rip), %rcx      # 0x404b
movl $0x27, %edx
callq 0x1090
leaq 0x2bad(%rip), %rdi      # 0x4041
leaq 0x2b6e(%rip), %rsi      # 0x4009
leaq 0x2ba9(%rip), %rcx      # 0x404b
movl $0x28, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: LexicalParse(Tree*)
bool LexicalParse (Tree* tree)
{
    assert (tree);

    element* el_now  = tree->stk.buffer;
    const char dec_str[] = "DICK";
    char* fix_constructor = (char*) dec_str;

    ElementConstructor (tree, DEC, (char**) &fix_constructor, 4);
    fix_constructor -= 4;

    element* dec_now = tree->stk.buffer + tree->stk.size - 1;
    tree->head = dec_now;

    // ToDo: Think about going out of bounds.

    do
    {
        ElementConstructor (tree, DEC, &fix_constructor, 4);
        fix_constructor -= 4;

        dec_now->right = tree->stk.buffer + tree->stk.size - 1;
        dec_now = dec_now->right;

        dec_now->left = GetFunc (&el_now);
        if (dec_now->left == PARSE_ERR)
        {
            TreeDestructor (tree);
            return 1;
        }
    }
    while (el_now->type != DEC && tree->stk.size < tree->stk.capacity);
    
    tree->head = tree->head->right;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x15c6
movq 0x10(%rdi), %rax
leaq -0x40(%rbp), %rcx
movq %rax, (%rcx)
leaq -0x48(%rbp), %rax
movb $0x0, 0x4(%rax)
movl $0x4b434944, (%rax)     # imm = 0x4B434944
leaq -0x38(%rbp), %rbx
movq %rax, (%rbx)
movl $0x4, %ecx
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2961
movq -0x30(%rbp), %rdx
addq $-0x4, (%rbx)
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
addq %rcx, %rax
addq $-0x30, %rax
movq %rax, (%rdx)
movl $0x4, %ecx
movq %rdx, %rbx
movq %rdx, %rdi
movl $0x1, %esi
leaq -0x38(%rbp), %rdx
callq 0x2961
addq $-0x4, -0x38(%rbp)
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rax
leaq (%rax,%rax,2), %rbx
shlq $0x4, %rbx
leaq (%r15,%rbx), %r14
addq $-0x30, %r14
movq %r14, -0x20(%r13)
leaq -0x40(%rbp), %rdi
callq 0x1718
movq %rax, %r12
movq %rax, 0x8(%r14)
leaq 0x5be9(%rip), %rax      # 0x7160
movq (%rax), %r14
cmpq %r14, %r12
je 0x15a8
movq -0x40(%rbp), %rax
cmpl $0x1, (%rax)
movq -0x30(%rbp), %rdx
je 0x159c
addq %rbx, %r15
movq 0x18(%rdx), %rax
movq %r15, %r13
cmpq 0x20(%rdx), %rax
jb 0x1526
movq (%rdx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdx)
jmp 0x15b1
movq -0x30(%rbp), %rdi
callq 0x291d
cmpq %r14, %r12
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a37(%rip), %rdi      # 0x4004
leaq 0x2a35(%rip), %rsi      # 0x4009
leaq 0x2aad(%rip), %rcx      # 0x4088
movl $0x4a, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: SkipSpaces(char**, unsigned long*)
void  SkipSpaces (char** code, size_t* line_now)
{
    assert (code);
    assert (*code);

    while (**code == ' ' || **code == '\t' || **code == '\r' || **code == '\n')
    {
        if (**code == '\n')
            *line_now += 1;
        *code += 1;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1623
cmpq $0x0, (%rdi)
je 0x1642
movq (%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0xc, %ecx
jg 0x1612
cmpl $0x9, %ecx
je 0x161c
cmpl $0xa, %ecx
jne 0x1621
incq (%rsi)
jmp 0x161c
cmpl $0xd, %ecx
je 0x161c
cmpl $0x20, %ecx
jne 0x1621
movq %rax, (%rdi)
jmp 0x15f7
popq %rbp
retq
leaq 0x2aa1(%rip), %rdi      # 0x40cb
leaq 0x29d8(%rip), %rsi      # 0x4009
leaq 0x2a6f(%rip), %rcx      # 0x40a7
movl $0x6f, %edx
callq 0x1090
leaq 0x2a81(%rip), %rdi      # 0x40ca
leaq 0x29b9(%rip), %rsi      # 0x4009
leaq 0x2a50(%rip), %rcx      # 0x40a7
movl $0x70, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckElement(Tree*, char**)
bool CheckElement (Tree* tree, char** code)
{
    anal_ass;

    int lex_check = 0;

    #define TryCheck(func) lex_check = func (tree, code); \
                           if (lex_check)                 \
                              return lex_check - 1;

    TryCheck (CheckLR);
    TryCheck (CheckBody);
    TryCheck (CheckParam);
    TryCheck (CheckArith);
    TryCheck (CheckInd);
    TryCheck (CheckNum);

    #undef TryCheck
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x16e7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16f0
cmpq $0x0, (%rbx)
je 0x16f9
movq %rdi, %r14
movq %rbx, %rsi
callq 0x17fb
testl %eax, %eax
jne 0x16b7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1862
testl %eax, %eax
jne 0x16b7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18ea
testl %eax, %eax
jne 0x16b7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1972
testl %eax, %eax
je 0x16be
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a1b
testl %eax, %eax
je 0x16d5
cmpl $0x1, %eax
setne %al
jmp 0x16b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1acd
testl %eax, %eax
sete %al
jmp 0x16b9
leaq 0x2916(%rip), %rdi      # 0x4004
jmp 0x1700
leaq 0x29d4(%rip), %rdi      # 0x40cb
jmp 0x1700
leaq 0x29ca(%rip), %rdi      # 0x40ca
leaq 0x2902(%rip), %rsi      # 0x4009
leaq 0x29c2(%rip), %rcx      # 0x40d0
movl $0x7e, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetFunc(element**)
element* GetFunc      (element** el_now)
{
    parse_ass;

    require_ind;

    element* el_result = *el_now;
    next;

    el_result->left = GetFuncParam (el_now);
    check_parse (el_result->left);

    el_result->right = GetBody (el_now);
    check_parse (el_result->right);

    el_result->type = FUNC;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17d3
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x17dc
cmpl $0x9, (%r14)
jne 0x178f
cmpq $0x0, 0x18(%r14)
je 0x178f
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1bae
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x59fc(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %rcx
je 0x17c8
movq %rbx, %rdi
callq 0x1cc6
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
je 0x17c8
movl $0x2, (%r14)
movq %r14, %rax
jmp 0x17c8
leaq 0x2a82(%rip), %rdi      # 0x4218
leaq 0x2a56(%rip), %rsi      # 0x41f3
movl $0x118, %edx            # imm = 0x118
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2a88(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x599b(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a37(%rip), %rdi      # 0x4211
jmp 0x17e3
leaq 0x2a2d(%rip), %rdi      # 0x4210
leaq 0x281f(%rip), %rsi      # 0x4009
leaq 0x2a02(%rip), %rcx      # 0x41f3
movl $0x116, %edx            # imm = 0x116
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckLR(Tree*, char**)
LexResult CheckLR    (Tree* tree, char** code)
{
    anal_ass;

    if (**code == '$')
    {
        ElementConstructor (tree, LR, code, 1);
        return SUCCESS;
    }
    
    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1831
movq %rsi, %rdx
testq %rsi, %rsi
je 0x183a
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x1843
xorl %eax, %eax
cmpb $0x24, (%rcx)
jne 0x182f
movl $0x1, %ecx
movl $0x3, %esi
callq 0x2961
movl $0x1, %eax
popq %rbp
retq
leaq 0x27cc(%rip), %rdi      # 0x4004
jmp 0x184a
leaq 0x288a(%rip), %rdi      # 0x40cb
jmp 0x184a
leaq 0x2880(%rip), %rdi      # 0x40ca
leaq 0x27b8(%rip), %rsi      # 0x4009
leaq 0x28b5(%rip), %rcx      # 0x410d
movl $0x9b, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckBody(Tree*, char**)
LexResult CheckBody  (Tree* tree, char** code)
{
    anal_ass;

    if (strncmp ("AAAAH", *code, 5) == 0)
    {
        ElementConstructor (tree, BODY, code, 5);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18b9
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18c2
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x18cb
movq %rdi, %r14
leaq 0x28cd(%rip), %rdi      # 0x4155
movl $0x5, %edx
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x18b4
movl $0x5, %ecx
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
callq 0x2961
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2744(%rip), %rdi      # 0x4004
jmp 0x18d2
leaq 0x2802(%rip), %rdi      # 0x40cb
jmp 0x18d2
leaq 0x27f8(%rip), %rdi      # 0x40ca
leaq 0x2730(%rip), %rsi      # 0x4009
leaq 0x2850(%rip), %rcx      # 0x4130
movl $0xa8, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckParam(Tree*, char**)
LexResult CheckParam (Tree* tree, char** code)
{
    anal_ass;

    if (strncmp ("ass", *code, 3) == 0)
    {
        ElementConstructor (tree, PARAM, code, 3);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1941
movq %rsi, %rbx
testq %rsi, %rsi
je 0x194a
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1953
movq %rdi, %r14
leaq 0x2871(%rip), %rdi      # 0x4181
movl $0x3, %edx
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x193c
movl $0x3, %ecx
movq %r14, %rdi
movl $0x4, %esi
movq %rbx, %rdx
callq 0x2961
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x26bc(%rip), %rdi      # 0x4004
jmp 0x195a
leaq 0x277a(%rip), %rdi      # 0x40cb
jmp 0x195a
leaq 0x2770(%rip), %rdi      # 0x40ca
leaq 0x26a8(%rip), %rsi      # 0x4009
leaq 0x27f3(%rip), %rcx      # 0x415b
movl $0xb5, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckArith(Tree*, char**)
LexResult CheckArith (Tree* tree, char** code)
{
    anal_ass;

    switch (**code)
    {
        case '+':
        case '-':
        case '*':
        case '/':
        case '^':
        case '(':
        case ')':
            ElementConstructor (tree, ARITH, code, 1);
            return SUCCESS;

        case '=':
        case '>':
        case '<':
        {
            size_t strong = 1;
            if (*(*code + 1) == '=')
                strong = 2;
            ElementConstructor (tree, ARITH, code, strong);
            return SUCCESS;
        }
        case '!':
            if (*(*code + 1) == '=')
            {
                ElementConstructor (tree, ARITH, code, 2);
                return SUCCESS;
            }
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x19ea
movq %rsi, %rdx
testq %rsi, %rsi
je 0x19f3
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x19fc
movzbl (%rsi), %r8d
xorl %eax, %eax
addl $-0x21, %r8d
cmpl $0x3d, %r8d
ja 0x19d6
movl $0x1, %ecx
movabsq $0x2000000000005780, %r9 # imm = 0x2000000000005780
btq %r8, %r9
jb 0x19c7
movl $0x38000000, %ecx       # imm = 0x38000000
btq %r8, %rcx
jae 0x19d8
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rsi)
sete %cl
incq %rcx
movl $0x6, %esi
callq 0x2961
movl $0x1, %eax
popq %rbp
retq
testq %r8, %r8
jne 0x19d6
movl $0x2, %ecx
cmpb $0x3d, 0x1(%rsi)
je 0x19c7
jmp 0x19d6
leaq 0x2613(%rip), %rdi      # 0x4004
jmp 0x1a03
leaq 0x26d1(%rip), %rdi      # 0x40cb
jmp 0x1a03
leaq 0x26c7(%rip), %rdi      # 0x40ca
leaq 0x25ff(%rip), %rsi      # 0x4009
leaq 0x2774(%rip), %rcx      # 0x4185
movl $0xc2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckInd(Tree*, char**)
LexResult CheckInd   (Tree* tree, char** code)
{
    anal_ass;

    if (IsMale (*code))
    {
        size_t len = 3;

        while ((*code)[len] != '\0' && !IsMale (*code + len))
            len++;

        if ((*code)[len] == '\0')
            return ERROR;

        len += 3;
        ElementConstructor (tree, IND, code, len);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1a9c
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1aa5
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x1aae
xorl %eax, %eax
cmpb $-0x1e, (%rsi)
jne 0x1a83
cmpb $-0x67, 0x1(%rsi)
jne 0x1a83
cmpb $-0x7e, 0x2(%rsi)
jne 0x1a83
movb 0x3(%rsi), %r9b
movl $0x2, %eax
testb %r9b, %r9b
sete %r8b
je 0x1a83
movl $0x6, %ecx
cmpb $-0x1e, %r9b
jne 0x1a72
cmpb $-0x67, -0x2(%rsi,%rcx)
jne 0x1a72
cmpb $-0x7e, -0x1(%rsi,%rcx)
je 0x1a85
movb -0x2(%rsi,%rcx), %r9b
incq %rcx
testb %r9b, %r9b
sete %r8b
jne 0x1a5e
popq %rbp
retq
testb $0x1, %r8b
jne 0x1a83
movl $0x9, %esi
callq 0x2961
movl $0x1, %eax
jmp 0x1a83
leaq 0x2561(%rip), %rdi      # 0x4004
jmp 0x1ab5
leaq 0x261f(%rip), %rdi      # 0x40cb
jmp 0x1ab5
leaq 0x2615(%rip), %rdi      # 0x40ca
leaq 0x254d(%rip), %rsi      # 0x4009
leaq 0x26e8(%rip), %rcx      # 0x41ab
movl $0xe7, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckNum(Tree*, char**)
LexResult CheckNum   (Tree* tree, char** code)
{
    anal_ass;

    size_t num_len = 0;

    while ('0' <= (*code)[num_len] && (*code)[num_len] <= '9')
        num_len++;

    if ((*code)[num_len] == '.' && num_len != 0)
    {
        num_len++;
        while ('0' <= (*code)[num_len] && (*code)[num_len] <= '9')
            num_len++;
    }

    if (num_len > 0)
    {
        ElementConstructor (tree, NUM, code, num_len);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1b3f
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1b48
movq (%rdx), %rax
testq %rax, %rax
je 0x1b51
movq $-0x1, %rcx
movb 0x1(%rax,%rcx), %sil
leal -0x30(%rsi), %r8d
incq %rcx
cmpb $0xa, %r8b
jb 0x1aed
cmpb $0x2e, %sil
setne %sil
testq %rcx, %rcx
sete %r8b
orb %sil, %r8b
jne 0x1b25
movb 0x1(%rax,%rcx), %sil
incq %rcx
addb $-0x30, %sil
cmpb $0xa, %sil
jb 0x1b13
testq %rcx, %rcx
je 0x1b3b
movl $0x7, %esi
callq 0x2961
movl $0x1, %eax
jmp 0x1b3d
xorl %eax, %eax
popq %rbp
retq
leaq 0x24be(%rip), %rdi      # 0x4004
jmp 0x1b58
leaq 0x257c(%rip), %rdi      # 0x40cb
jmp 0x1b58
leaq 0x2572(%rip), %rdi      # 0x40ca
leaq 0x24aa(%rip), %rsi      # 0x4009
leaq 0x2669(%rip), %rcx      # 0x41cf
movl $0xfd, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetFuncParam(element**)
element* GetFuncParam (element** el_now)
{
    parse_ass;

    require (PARAM);
    next;

    if ((*el_now)->type == PARAM)
    {
        next;
        return nullptr;
    }

    require_ind;
    element* el_result = *el_now;
    el_result->type    = PARAM;
    next;

    while ((*el_now)->type != PARAM)
    {
        require_ind;
        (*el_now)->type = PARAM;
        ((*el_now) - 1)->left = *el_now;
        next;
    }
    
    next;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c9e
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1ca7
cmpl $0x4, (%rcx)
jne 0x1bf3
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x1c08
cmpl $0x4, %edx
jne 0x1c3b
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x1c97
leaq 0x261e(%rip), %rdi      # 0x4218
leaq 0x2654(%rip), %rsi      # 0x4255
movl $0x12b, %edx            # imm = 0x12B
jmp 0x1c71
cmpq $0x0, 0x48(%rcx)
je 0x1c3b
movl $0x4, (%rax)
movq (%rbx), %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x9, %esi
jne 0x1c50
cmpq $0x0, 0x48(%rcx)
je 0x1c5e
movl $0x4, 0x30(%rcx)
movq %rdx, 0x8(%rcx)
jmp 0x1c15
leaq 0x25d6(%rip), %rdi      # 0x4218
leaq 0x260c(%rip), %rsi      # 0x4255
movl $0x134, %edx            # imm = 0x134
jmp 0x1c71
cmpl $0x4, %esi
jne 0x1c5e
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x1c97
leaq 0x25b3(%rip), %rdi      # 0x4218
leaq 0x25e9(%rip), %rsi      # 0x4255
movl $0x13b, %edx            # imm = 0x13B
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x25b9(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x54cc(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x256c(%rip), %rdi      # 0x4211
jmp 0x1cae
leaq 0x2562(%rip), %rdi      # 0x4210
leaq 0x2354(%rip), %rsi      # 0x4009
leaq 0x2599(%rip), %rcx      # 0x4255
movl $0x129, %edx            # imm = 0x129
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetBody(element**)
element* GetBody      (element** el_now)
{
    parse_ass;

    if ((*el_now)->type != BODY)
        return GetOper (el_now);
    next;
    
    if ((*el_now)->type == BODY)
    {
        next;
        return nullptr;
    }

    element* el_result = GetOper (el_now);
    check_parse (el_result);
    element* go_LR     = el_result;

    while ((*el_now)->type != BODY)
    {
        go_LR->right = GetOper (el_now);
        go_LR = go_LR->right;
        check_parse (go_LR);
    }

    require (BODY);
    next;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1d6b
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1d74
cmpl $0x5, (%rax)
jne 0x1d06
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
cmpl $0x5, 0x30(%rax)
jne 0x1d16
addq $0x60, %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x1d62
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d93
movq %rbx, %rdi
callq 0x1d93
movq %rax, %r14
leaq 0x5438(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %r14
je 0x1d62
movq %r14, %r12
movq (%rbx), %rax
cmpl $0x5, (%rax)
je 0x1d58
movq %rbx, %rdi
callq 0x1d93
movq %rax, %rcx
movq %rax, 0x10(%r12)
movq (%r15), %rax
movq %rcx, %r12
cmpq %rax, %rcx
jne 0x1d33
jmp 0x1d62
addq $0x30, %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x249f(%rip), %rdi      # 0x4211
jmp 0x1d7b
leaq 0x2495(%rip), %rdi      # 0x4210
leaq 0x2287(%rip), %rsi      # 0x4009
leaq 0x24ee(%rip), %rcx      # 0x4277
movl $0x147, %edx            # imm = 0x147
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetOper(element**)
element* GetOper      (element** el_now)
{
    parse_ass;
    require_ind;

    element* el_result = nullptr;

    #define TryGet(func) el_result = func (el_now);         \
                         if (el_result)                     \
                         {                                  \
                             check_parse (el_result);       \
                             require (LR);                  \
                             (*el_now)->left = el_result;   \
                             el_result = *el_now;           \
                             next;                          \
                             return el_result;              \
                         }

    TryGet (GetArith);
    TryGet (GetCall);
    TryGet (GetReturn);

    #undef TryGet
    return GetCond (el_now);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ef5
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1efe
cmpl $0x9, (%rax)
jne 0x1e01
cmpq $0x0, 0x18(%rax)
je 0x1e01
movq %rbx, %rdi
callq 0x1f1d
testq %rax, %rax
je 0x1e3f
movq %rax, %rcx
leaq 0x538b(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e3a
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1ea2
leaq 0x2428(%rip), %rdi      # 0x4218
leaq 0x249d(%rip), %rsi      # 0x4294
movl $0x175, %edx            # imm = 0x175
jmp 0x1ed1
leaq 0x2410(%rip), %rdi      # 0x4218
leaq 0x2485(%rip), %rsi      # 0x4294
movl $0x166, %edx            # imm = 0x166
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2416(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x5329(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x202f
testq %rax, %rax
je 0x1e7b
movq %rax, %rcx
leaq 0x530a(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e3a
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1ea2
leaq 0x23ab(%rip), %rdi      # 0x4218
leaq 0x2420(%rip), %rsi      # 0x4294
movl $0x176, %edx            # imm = 0x176
jmp 0x1ed1
movq %rbx, %rdi
callq 0x20fd
testq %rax, %rax
je 0x1eb2
movq %rax, %rcx
leaq 0x52ce(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e3a
movq (%rbx), %rax
cmpl $0x3, (%rax)
jne 0x1ebe
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
jmp 0x1e3a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d6
leaq 0x2353(%rip), %rdi      # 0x4218
leaq 0x23c8(%rip), %rsi      # 0x4294
movl $0x177, %edx            # imm = 0x177
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2359(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
movq (%r14), %rax
jmp 0x1e3a
leaq 0x2315(%rip), %rdi      # 0x4211
jmp 0x1f05
leaq 0x230b(%rip), %rdi      # 0x4210
leaq 0x20fd(%rip), %rsi      # 0x4009
leaq 0x2381(%rip), %rcx      # 0x4294
movl $0x165, %edx            # imm = 0x165
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetArith(element**)
element* GetArith     (element** el_now)
{
    parse_ass;
    require_ind;

    if ((*el_now + 1)->type != ARITH)
        return nullptr;

    if (strcmp ("=", (*el_now + 1)->ind))
        require_exit;

    element* el_result = *el_now + 1;
    el_result->left    = *el_now;

    (*el_now)->type = VAR;
    el_result->type = EQUAL;

    next; next;
    el_result->right   = GetE (el_now);

    check_parse (el_result->right);
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2007
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x2010
cmpl $0x9, (%r15)
jne 0x1f7c
cmpq $0x0, 0x18(%r15)
je 0x1f7c
cmpl $0x6, 0x30(%r15)
jne 0x1fc3
movq 0x48(%r15), %rsi
leaq 0x2371(%rip), %rdi      # 0x42cf
callq 0x1130
testl %eax, %eax
je 0x1fc8
leaq 0x22aa(%rip), %rdi      # 0x4218
leaq 0x233c(%rip), %rsi      # 0x42b1
movl $0x186, %edx            # imm = 0x186
jmp 0x1f8f
leaq 0x2295(%rip), %rdi      # 0x4218
leaq 0x2327(%rip), %rsi      # 0x42b1
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x229b(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x51ae(%rip), %rax      # 0x7160
movq (%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x1fb5
leaq 0x30(%r15), %r14
movq %r15, 0x38(%r15)
movq (%rbx), %rax
movl $0x8, (%rax)
movl $0xe, 0x30(%r15)
addq $0x60, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x23c0
movq %rax, 0x40(%r15)
leaq 0x5165(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %r14
jmp 0x1fb5
leaq 0x2203(%rip), %rdi      # 0x4211
jmp 0x2017
leaq 0x21f9(%rip), %rdi      # 0x4210
leaq 0x1feb(%rip), %rsi      # 0x4009
leaq 0x228c(%rip), %rcx      # 0x42b1
movl $0x17f, %edx            # imm = 0x17F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetCall(element**)
element* GetCall      (element** el_now)
{
    parse_ass;
    require_ind;

    if ((*el_now + 1)->type != PARAM)
        return nullptr;

    element* el_result = *el_now;
    next;

    el_result->left = GetCallParam (el_now);
    check_parse (el_result->left);
    el_result->type = CALL;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x20d5
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x20de
cmpl $0x9, (%r14)
jne 0x2093
cmpq $0x0, 0x18(%r14)
je 0x2093
cmpl $0x4, 0x30(%r14)
jne 0x20d1
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2490
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x50e1(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x20cc
movl $0xd, (%r14)
movq %r14, %rax
jmp 0x20cc
leaq 0x217e(%rip), %rdi      # 0x4218
leaq 0x2230(%rip), %rsi      # 0x42d1
movl $0x198, %edx            # imm = 0x198
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2184(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x5097(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x20cc
leaq 0x2135(%rip), %rdi      # 0x4211
jmp 0x20e5
leaq 0x212b(%rip), %rdi      # 0x4210
leaq 0x1f1d(%rip), %rsi      # 0x4009
leaq 0x21de(%rip), %rcx      # 0x42d1
movl $0x197, %edx            # imm = 0x197
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetReturn(element**)
element* GetReturn    (element** el_now)
{
    parse_ass;
    require_ind;

    // Old code:

    /* const size_t without_backslash_0 = 1;
    const size_t return_size  = sizeof (RETURN_STR) - without_backslash_0;

    if ((*el_now)->len != return_size + 2 * MALE_LEN || 
        strncmp (RETURN_STR, (*el_now)->ind + MALE_LEN, return_size))
        return nullptr; */

    if (strcmp (RETURN_STR, (*el_now)->ind))
        return nullptr;

    element* el_result = *el_now;
    next;

    el_result->left = GetE (el_now);
    check_parse (el_result->left);
    el_result->type = RET;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x21ae
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x21b7
cmpl $0x9, (%r14)
jne 0x213f
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x213f
leaq 0x22de(%rip), %rdi      # 0x4410
callq 0x1130
testl %eax, %eax
je 0x217d
xorl %eax, %eax
jmp 0x2178
leaq 0x20d2(%rip), %rdi      # 0x4218
leaq 0x21c3(%rip), %rsi      # 0x4310
movl $0x1cf, %edx            # imm = 0x1CF
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x20d8(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x4feb(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x23c0
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x4fc6(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x2178
movl $0xa, (%r14)
movq %r14, %rax
jmp 0x2178
leaq 0x205c(%rip), %rdi      # 0x4211
jmp 0x21be
leaq 0x2052(%rip), %rdi      # 0x4210
leaq 0x1e44(%rip), %rsi      # 0x4009
leaq 0x2144(%rip), %rcx      # 0x4310
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetE(element**)
element* GetE         (element** el_now)
{
    parse_ass;

    element* el_result = GetT (el_now);

    while ((*el_now)->type == ARITH           && 
          (strcmp ("+", (*el_now)->ind) == 0  ||
           strcmp ("-", (*el_now)->ind) == 0))
    {
        (*el_now)->left = el_result;
        el_result = *el_now;
        next;
        el_result->right = GetT (el_now);
        check_parse (el_result->right);
    }

    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2468
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2471
movq %rbx, %rdi
callq 0x25b4
movq %rax, %r14
leaq 0x1f70(%rip), %r15      # 0x4366
movq (%rbx), %r12
cmpl $0x6, (%r12)
jne 0x2456
movq 0x18(%r12), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x2427
leaq 0x1f4d(%rip), %rdi      # 0x4368
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
jne 0x2456
movq %r14, 0x8(%r12)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x25b4
movq %rax, %rcx
movq %rax, 0x10(%r14)
leaq 0x4d14(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
jne 0x23f6
jmp 0x2459
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1da2(%rip), %rdi      # 0x4211
jmp 0x2478
leaq 0x1d98(%rip), %rdi      # 0x4210
leaq 0x1b8a(%rip), %rsi      # 0x4009
leaq 0x1ec6(%rip), %rcx      # 0x434c
movl $0x232, %edx            # imm = 0x232
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetCallParam(element**)
element* GetCallParam (element** el_now)
{
    parse_ass;

    require (PARAM);
    next;

    if ((*el_now)->type == PARAM)
    {
        next;
        return nullptr;
    }

    if ((*el_now)->type != NUM)
    {
        require_ind;
        (*el_now)->type = VAR;
    }

    element* el_result = *el_now;
    next;

    while ((*el_now)->type != PARAM)
    {
        if ((*el_now)->type != NUM)
        {
            require_ind;
            (*el_now)->type = VAR;
        }

        ((*el_now) - 1)->left = *el_now;
        next;
    }

    next;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x258c
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2595
cmpl $0x4, (%rcx)
jne 0x24da
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x24ef
cmpl $0x7, %edx
je 0x24fc
cmpl $0x4, %edx
jne 0x2529
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x2585
leaq 0x1d37(%rip), %rdi      # 0x4218
leaq 0x1e06(%rip), %rsi      # 0x42ee
movl $0x1aa, %edx            # imm = 0x1AA
jmp 0x255f
cmpq $0x0, 0x48(%rcx)
je 0x2529
movl $0x8, (%rax)
movq %rax, %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x7, %esi
je 0x2520
cmpl $0x9, %esi
jne 0x253e
cmpq $0x0, 0x48(%rcx)
je 0x254c
movl $0x8, (%rdx)
movq %rdx, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x24ff
leaq 0x1ce8(%rip), %rdi      # 0x4218
leaq 0x1db7(%rip), %rsi      # 0x42ee
movl $0x1b5, %edx            # imm = 0x1B5
jmp 0x255f
cmpl $0x4, %esi
jne 0x254c
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x2585
leaq 0x1cc5(%rip), %rdi      # 0x4218
leaq 0x1d94(%rip), %rsi      # 0x42ee
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1ccb(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x4bde(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1c7e(%rip), %rdi      # 0x4211
jmp 0x259c
leaq 0x1c74(%rip), %rdi      # 0x4210
leaq 0x1a66(%rip), %rsi      # 0x4009
leaq 0x1d44(%rip), %rcx      # 0x42ee
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetT(element**)
element* GetT         (element** el_now)
{
    parse_ass;

    element* el_result = GetDegree (el_now);

    while ((*el_now)->type == ARITH &&
          (strcmp ("*", (*el_now)->ind) == 0 ||
           strcmp ("/", (*el_now)->ind) == 0))
    {
        (*el_now)->left = el_result;
        el_result = *el_now;
        next;
        el_result->right = GetDegree (el_now);
        check_parse (el_result->right);
    }

    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x265c
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2665
movq %rbx, %rdi
callq 0x2684
movq %rax, %r14
leaq 0x1d9a(%rip), %r15      # 0x4384
movq (%rbx), %r12
cmpl $0x6, (%r12)
jne 0x264a
movq 0x18(%r12), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x261b
leaq 0x1d77(%rip), %rdi      # 0x4386
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
jne 0x264a
movq %r14, 0x8(%r12)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2684
movq %rax, %rcx
movq %rax, 0x10(%r14)
leaq 0x4b20(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
jne 0x25ea
jmp 0x264d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bae(%rip), %rdi      # 0x4211
jmp 0x266c
leaq 0x1ba4(%rip), %rdi      # 0x4210
leaq 0x1996(%rip), %rsi      # 0x4009
leaq 0x1cf0(%rip), %rcx      # 0x436a
movl $0x246, %edx            # imm = 0x246
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetDegree(element**)
element* GetDegree    (element** el_now)
{
    parse_ass;

    element* el_result = GetUnary (el_now);

    if ((*el_now)->type == ARITH && strcmp ("^", (*el_now)->ind) == 0)
    {
        (*el_now)->left = el_result;
        el_result = *el_now;
        next;
        el_result->right = GetDegree (el_now);
        check_parse (el_result->right);
    }

    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x26fd
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x2706
movq %r14, %rdi
callq 0x2725
movq %rax, %rbx
movq (%r14), %r15
cmpl $0x6, (%r15)
jne 0x26ef
movq 0x18(%r15), %rsi
leaq 0x1cec(%rip), %rdi      # 0x43a7
callq 0x1130
testl %eax, %eax
jne 0x26ef
movq %rbx, 0x8(%r15)
movq (%r14), %rbx
leaq 0x30(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
callq 0x2684
movq %rax, 0x10(%rbx)
leaq 0x4a7b(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b0d(%rip), %rdi      # 0x4211
jmp 0x270d
leaq 0x1b03(%rip), %rdi      # 0x4210
leaq 0x18f5(%rip), %rsi      # 0x4009
leaq 0x1c6d(%rip), %rcx      # 0x4388
movl $0x25a, %edx            # imm = 0x25A
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetUnary(element**)
element* GetUnary     (element** el_now)
{
    parse_ass;

    if ((*el_now + 1)->type == PARAM)
    {
        element* el_result = GetCall (el_now);
        if (!el_result)
            require_exit;
        return el_result;
    }

    return GetP (el_now);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x279c
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x27a5
cmpl $0x4, 0x30(%rax)
jne 0x278e
movq %rbx, %rdi
callq 0x202f
testq %rax, %rax
jne 0x2787
leaq 0x1ac3(%rip), %rdi      # 0x4218
leaq 0x1c4d(%rip), %rsi      # 0x43a9
movl $0x272, %edx            # imm = 0x272
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1ac9(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x49dc(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27c4
leaq 0x1a6e(%rip), %rdi      # 0x4211
jmp 0x27ac
leaq 0x1a64(%rip), %rdi      # 0x4210
leaq 0x1856(%rip), %rsi      # 0x4009
leaq 0x1bef(%rip), %rcx      # 0x43a9
movl $0x26c, %edx            # imm = 0x26C
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetP(element**)
element* GetP         (element** el_now)
{
    parse_ass;

    element* el_result = PARSE_ERR;

    switch ((*el_now)->type)
    {
        case ARITH:
            if (strcmp ("(", (*el_now)->ind))
                require_exit;

            next;
            el_result = GetE (el_now);

            if (strcmp (")", (*el_now)->ind))
                require_exit;
            next;
            break;

        case IND:
            el_result = *el_now;
            next;
            el_result->type = VAR;
            break;

        case NUM:
            el_result = *el_now;
            next;
            break;

        default:
            return PARSE_ERR;
    }

    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28b7
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x28c0
movl (%r14), %eax
cmpl $0x9, %eax
je 0x282e
cmpl $0x7, %eax
je 0x2825
cmpl $0x6, %eax
jne 0x2896
movq 0x18(%r14), %rsi
leaq 0x1bda(%rip), %rdi      # 0x43e1
callq 0x1130
testl %eax, %eax
je 0x283e
leaq 0x1a01(%rip), %rdi      # 0x4218
leaq 0x1ba9(%rip), %rsi      # 0x43c7
movl $0x283, %edx            # imm = 0x283
jmp 0x287a
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
jmp 0x28a0
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movl $0x8, (%r14)
jmp 0x28a0
addq $0x30, %r14
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x23c0
movq %rax, %r14
movq (%rbx), %r15
movq 0x18(%r15), %rsi
leaq 0x1ebf(%rip), %rdi      # 0x471d
callq 0x1130
testl %eax, %eax
je 0x28ae
leaq 0x19aa(%rip), %rdi      # 0x4218
leaq 0x1b52(%rip), %rsi      # 0x43c7
movl $0x289, %edx            # imm = 0x289
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x19b0(%rip), %rdi      # 0x423f
xorl %eax, %eax
callq 0x1040
leaq 0x48c3(%rip), %rax      # 0x7160
movq (%rax), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x30, %r15
movq %r15, (%rbx)
jmp 0x28a0
leaq 0x1953(%rip), %rdi      # 0x4211
jmp 0x28c7
leaq 0x1949(%rip), %rdi      # 0x4210
leaq 0x173b(%rip), %rsi      # 0x4009
leaq 0x1af2(%rip), %rcx      # 0x43c7
movl $0x27b, %edx            # imm = 0x27B
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/lemire[P]validateutf8-experiments/benchmarks/benchstream.cpp
// Function: main
int main(int argc, char **argv) {
  if (argc < 2) {
    printf("please provide a numerical parameter which indicates the number of "
           "repetitions\n");
    return EXIT_FAILURE;
  }

  size_t samples = 100;
  event_collector collector;
  if (collector.has_events()) {
    printf(
        "# columns match size in bytes then (ins/byte, branch miss /KB, GB/s, ins/cycle)");
  } else {
    printf("# columns match size in bytes then (GB/s)");
  }
  printf("# the validators are memcpy, branchy, dfa, lookup3, branchy/ascii, lookup4\n");

  size_t repeat = atoll(argv[1]);
  printf("# number of repetitions %zu \n", repeat);

  Benchmark bench{samples, repeat, 1024, 65536};
  bench.run();

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1498, %rsp           # imm = 0x1498
cmpl $0x1, %edi
jg 0x5b72
leaq 0x4e8c(%rip), %rdi      # 0xa9ef
callq 0x21a0
movl $0x1, %eax
jmp 0x5c2f
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5edc
leaq 0x4c37(%rip), %rax      # 0xa7c0
leaq 0x4c80(%rip), %rdi      # 0xa810
cmpb $0x0, 0x2c(%r14)
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x4dfd(%rip), %rdi      # 0xa9a4
callq 0x21a0
movq 0x8(%rbx), %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x4c7b(%rip), %rdi      # 0xa83a
movq %rax, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x110(%rsp), %rbx
movq $0x64, -0x20(%rbx)
movq %r14, -0x18(%rbx)
movq $0x400, -0x10(%rbx)     # imm = 0x400
movq $0x10000, -0x8(%rbx)    # imm = 0x10000
movq %rbx, %rdi
callq 0x6640
leaq 0xf0(%rsp), %rdi
callq 0x5fba
movq %rbx, %rdi
callq 0x2110
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x85a2
movq -0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5c2d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
xorl %eax, %eax
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r14
retq
jmp 0x5c49
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x5c54
movq %rax, %rdi
callq 0x6365
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x604a
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/CobaltXII[P]cxcc/cxcc.cpp
// Function: usage(char*)
void usage(char* exe) {
	std::cerr << "Usage: " << exe << " <in> [out [-o]]" << std::endl;
	std::cerr << "    Compiles C source <in> to x86-64 assembly and stores the    " << std::endl;
	std::cerr << "    output in [out]. If no value for [out] is provided, the     " << std::endl;
	std::cerr << "    output is stored in the file <in>.s. If the option -o is    " << std::endl;
	std::cerr << "    provided, gcc is used to assemble [out] and store the image " << std::endl;
	std::cerr << "    in [out].                                                   " << std::endl;
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x1aece(%rip), %rbx     # 0x1fff0
leaq 0x145cf(%rip), %rsi     # 0x196f8
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
leaq 0x145bd(%rip), %rsi     # 0x19700
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x145b7(%rip), %rsi     # 0x19711
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x145e1(%rip), %rsi     # 0x19752
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x1460b(%rip), %rsi     # 0x19793
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x14635(%rip), %rsi     # 0x197d4
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x1465f(%rip), %rsi     # 0x19815
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
movl $0x1, %edi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O1/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse()
std::vector<function_t> parse() {
		std::vector<function_t> functions;
		while (!input.eof()) {
			token_t peek = input.peek();
			functions.push_back({
				parse_type(),
				parse_identifier(),
				parse_parameters(),
				parse_statements(),
				long(peek.lineno),
				long(peek.colno - peek.text.length() - 1)
			});
		}
		return functions;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xb8(%rsi), %r13
imulq $0x38, 0xd0(%rsi), %rax
cmpl $0x4, (%r13,%rax)
je 0x63c6
movq %rsi, %r14
addq %rax, %r13
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %rbp
leaq 0x68(%rsp), %r15
movl (%r13), %eax
movl %eax, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x17a38
movups 0x28(%r13), %xmm0
movups %xmm0, 0x20(%r12)
movq %r14, %rdi
callq 0x932c
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x9466
movq %r15, %rdi
movq %r14, %rsi
callq 0x94ba
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x96d8
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x98(%rsp)
notq %rax
addq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
callq 0x98ac
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x636e
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %r15, %rdi
callq 0x9812
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x6392
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x63a9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
imulq $0x38, 0xd0(%r14), %rax
movq 0xb8(%r14), %rcx
leaq (%rcx,%rax), %r13
cmpl $0x4, (%rcx,%rax)
jne 0x62c2
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6437
movq %rax, %r14
jmp 0x63f0
movq %rax, %r14
movq %r15, %rdi
callq 0x9812
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x6420
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x6420
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x986e
jmp 0x6420
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6437
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x6d6e
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_identifier()
token_t read_identifier() {
		std::string str = read_while(chr_id);
		if (str == "if") {
			return {tk_if, str, TOKEN_DEBUG};
		} else if (str == "int") {
			return {tk_int, str, TOKEN_DEBUG};
		} else if (str == "else") {
			return {tk_else, str, TOKEN_DEBUG};
		} else if (str == "while") {
			return {tk_while, str, TOKEN_DEBUG};
		} else if (str == "return") {
			return {tk_return, str, TOKEN_DEBUG};
		} else if (str == "break") {
			return {tk_break, str, TOKEN_DEBUG};
		} else if (str == "continue") {
			return {tk_continue, str, TOKEN_DEBUG};
		} else {
			return {tk_identifier, str, TOKEN_DEBUG};
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x65c(%rip), %rdx       # 0x8f26
movq %rsp, %r15
movq %r15, %rdi
callq 0x8e56
leaq 0x11013(%rip), %rsi     # 0x198ef
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8975
leaq 0x10bb7(%rip), %rsi     # 0x194aa
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x897d
leaq 0x10fec(%rip), %rsi     # 0x198f2
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8985
leaq 0x10fde(%rip), %rsi     # 0x198f7
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x898d
leaq 0x10fd1(%rip), %rsi     # 0x198fd
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8995
leaq 0x10fc5(%rip), %rsi     # 0x19904
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x899d
leaq 0x10fb8(%rip), %rsi     # 0x1990a
movq %rsp, %rdi
callq 0x30b0
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
testl %eax, %eax
je 0x89f8
movl $0x0, (%rbx)
jmp 0x89fe
movl $0x5, (%rbx)
jmp 0x89a3
movl $0x6, (%rbx)
jmp 0x89a3
movl $0x7, (%rbx)
jmp 0x89a3
movl $0x8, (%rbx)
jmp 0x89a3
movl $0x9, (%rbx)
jmp 0x89a3
movl $0xa, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x17a38
movq 0x68(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x70(%r14), %rax
movq %rax, 0x30(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0xb, (%rbx)
movq %rcx, 0x8(%rbx)
jmp 0x89af
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_while[abi:cxx11](bool (*)(int))
std::string read_while(bool (*predicate)(int)) {
		std::string str = "";
		while (!input.eof() && predicate(input.peek())) {
			str += input.next();
		}
		return str;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x10ea8(%rip), %rdx     # 0x19d1d
movq %rdx, %rsi
callq 0x9052
movq 0x60(%r15), %rax
cmpq 0x48(%r15), %rax
jae 0x8ecc
movq 0x40(%r15), %rcx
movsbl (%rcx,%rax), %edi
callq *%r14
testb %al, %al
je 0x8ecc
movq 0x40(%r15), %rax
movq 0x60(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x60(%r15)
movb (%rax,%rcx), %al
cmpb $0xa, %al
jne 0x8ebb
incq 0x68(%r15)
movq $0x0, 0x70(%r15)
jmp 0x8ebf
incq 0x70(%r15)
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31f0
jmp 0x8e7d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x8ef2
movq (%r12), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0