LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d44
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1d4d
cmpl $0x5, (%rax)
jne 0x1cdf
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
cmpl $0x5, 0x30(%rax)
jne 0x1cef
addq $0x60, %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x1d3b
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d6c
movq %rbx, %rdi
callq 0x1d6c
movq %rax, %r14
leaq 0x545f(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %r14
je 0x1d3b
movq %r14, %r12
movq (%rbx), %rax
cmpl $0x5, (%rax)
je 0x1d31
movq %rbx, %rdi
callq 0x1d6c
movq %rax, %rcx
movq %rax, 0x10(%r12)
movq (%r15), %rax
movq %rcx, %r12
cmpq %rax, %rcx
jne 0x1d0c
jmp 0x1d3b
addq $0x30, %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24c2(%rip), %rdi      # 0x420d
jmp 0x1d54
leaq 0x24b8(%rip), %rdi      # 0x420c
leaq 0x22ae(%rip), %rsi      # 0x4009
leaq 0x2511(%rip), %rcx      # 0x4273
movl $0x147, %edx            # imm = 0x147
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ece
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1ed7
cmpl $0x9, (%rax)
jne 0x1dda
cmpq $0x0, 0x18(%rax)
je 0x1dda
movq %rbx, %rdi
callq 0x1ef6
testq %rax, %rax
je 0x1e18
movq %rax, %rcx
leaq 0x53b2(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e13
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1e7b
leaq 0x244b(%rip), %rdi      # 0x4214
leaq 0x24c0(%rip), %rsi      # 0x4290
movl $0x175, %edx            # imm = 0x175
jmp 0x1eaa
leaq 0x2433(%rip), %rdi      # 0x4214
leaq 0x24a8(%rip), %rsi      # 0x4290
movl $0x166, %edx            # imm = 0x166
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2439(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x5350(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x200a
testq %rax, %rax
je 0x1e54
movq %rax, %rcx
leaq 0x5331(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e13
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1e7b
leaq 0x23ce(%rip), %rdi      # 0x4214
leaq 0x2443(%rip), %rsi      # 0x4290
movl $0x176, %edx            # imm = 0x176
jmp 0x1eaa
movq %rbx, %rdi
callq 0x20d8
testq %rax, %rax
je 0x1e8b
movq %rax, %rcx
leaq 0x52f5(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1e13
movq (%rbx), %rax
cmpl $0x3, (%rax)
jne 0x1e97
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
jmp 0x1e13
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b1
leaq 0x2376(%rip), %rdi      # 0x4214
leaq 0x23eb(%rip), %rsi      # 0x4290
movl $0x177, %edx            # imm = 0x177
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x237c(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
movq (%r14), %rax
jmp 0x1e13
leaq 0x2338(%rip), %rdi      # 0x420d
jmp 0x1ede
leaq 0x232e(%rip), %rdi      # 0x420c
leaq 0x2124(%rip), %rsi      # 0x4009
leaq 0x23a4(%rip), %rcx      # 0x4290
movl $0x165, %edx            # imm = 0x165
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fe2
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1feb
cmpl $0x9, (%r15)
jne 0x1f57
cmpq $0x0, 0x18(%r15)
je 0x1f57
cmpl $0x6, 0x30(%r15)
jne 0x1f9e
movq 0x48(%r15), %rcx
movzbl (%rcx), %eax
subl $0x3d, %eax
jne 0x1f3c
movzbl 0x1(%rcx), %eax
negl %eax
testl %eax, %eax
je 0x1fa3
leaq 0x22cb(%rip), %rdi      # 0x4214
leaq 0x235d(%rip), %rsi      # 0x42ad
movl $0x186, %edx            # imm = 0x186
jmp 0x1f6a
leaq 0x22b6(%rip), %rdi      # 0x4214
leaq 0x2348(%rip), %rsi      # 0x42ad
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x22bc(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x51d3(%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 0x1f90
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 0x239e
movq %rax, 0x40(%r15)
leaq 0x518a(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %r14
jmp 0x1f90
leaq 0x2224(%rip), %rdi      # 0x420d
jmp 0x1ff2
leaq 0x221a(%rip), %rdi      # 0x420c
leaq 0x2010(%rip), %rsi      # 0x4009
leaq 0x22ad(%rip), %rcx      # 0x42ad
movl $0x17f, %edx            # imm = 0x17F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20b0
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x20b9
cmpl $0x9, (%r14)
jne 0x206e
cmpq $0x0, 0x18(%r14)
je 0x206e
cmpl $0x4, 0x30(%r14)
jne 0x20ac
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2450
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x5106(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x20a7
movl $0xd, (%r14)
movq %r14, %rax
jmp 0x20a7
leaq 0x219f(%rip), %rdi      # 0x4214
leaq 0x224f(%rip), %rsi      # 0x42cb
movl $0x198, %edx            # imm = 0x198
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x21a5(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x50bc(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x20a7
leaq 0x2156(%rip), %rdi      # 0x420d
jmp 0x20c0
leaq 0x214c(%rip), %rdi      # 0x420c
leaq 0x1f42(%rip), %rsi      # 0x4009
leaq 0x21fd(%rip), %rcx      # 0x42cb
movl $0x197, %edx            # imm = 0x197
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2189
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2192
cmpl $0x9, (%r14)
jne 0x211a
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x211a
leaq 0x22f3(%rip), %rdi      # 0x4400
callq 0x1130
testl %eax, %eax
je 0x2158
xorl %eax, %eax
jmp 0x2153
leaq 0x20f3(%rip), %rdi      # 0x4214
leaq 0x21e2(%rip), %rsi      # 0x430a
movl $0x1cf, %edx            # imm = 0x1CF
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x20f9(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x5010(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x239e
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x4feb(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x2153
movl $0xa, (%r14)
movq %r14, %rax
jmp 0x2153
leaq 0x207d(%rip), %rdi      # 0x420d
jmp 0x2199
leaq 0x2073(%rip), %rdi      # 0x420c
leaq 0x1e69(%rip), %rsi      # 0x4009
leaq 0x2163(%rip), %rcx      # 0x430a
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x2428
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2431
movq %rbx, %rdi
callq 0x2574
movq %rax, %r14
leaq 0x4d98(%rip), %r15      # 0x7160
movq (%rbx), %rax
cmpl $0x6, (%rax)
jne 0x241a
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
cmpl $0x2b, %ecx
jne 0x23e4
cmpb $0x0, 0x1(%rdx)
je 0x23f3
jmp 0x241a
subl $0x2d, %ecx
jne 0x23ed
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x241a
movq %r14, 0x8(%rax)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2574
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
jne 0x23c8
jmp 0x241d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dde(%rip), %rdi      # 0x420d
jmp 0x2438
leaq 0x1dd4(%rip), %rdi      # 0x420c
leaq 0x1bca(%rip), %rsi      # 0x4009
leaq 0x1f00(%rip), %rcx      # 0x4346
movl $0x232, %edx            # imm = 0x232
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x254c
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2555
cmpl $0x4, (%rcx)
jne 0x249a
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x24af
cmpl $0x7, %edx
je 0x24bc
cmpl $0x4, %edx
jne 0x24e9
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x2545
leaq 0x1d73(%rip), %rdi      # 0x4214
leaq 0x1e40(%rip), %rsi      # 0x42e8
movl $0x1aa, %edx            # imm = 0x1AA
jmp 0x251f
cmpq $0x0, 0x48(%rcx)
je 0x24e9
movl $0x8, (%rax)
movq %rax, %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x7, %esi
je 0x24e0
cmpl $0x9, %esi
jne 0x24fe
cmpq $0x0, 0x48(%rcx)
je 0x250c
movl $0x8, (%rdx)
movq %rdx, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x24bf
leaq 0x1d24(%rip), %rdi      # 0x4214
leaq 0x1df1(%rip), %rsi      # 0x42e8
movl $0x1b5, %edx            # imm = 0x1B5
jmp 0x251f
cmpl $0x4, %esi
jne 0x250c
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x2545
leaq 0x1d01(%rip), %rdi      # 0x4214
leaq 0x1dce(%rip), %rsi      # 0x42e8
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1d07(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x4c1e(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1cba(%rip), %rdi      # 0x420d
jmp 0x255c
leaq 0x1cb0(%rip), %rdi      # 0x420c
leaq 0x1aa6(%rip), %rsi      # 0x4009
leaq 0x1d7e(%rip), %rcx      # 0x42e8
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x25fe
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2607
movq %rbx, %rdi
callq 0x2626
movq %rax, %r14
leaq 0x4bc2(%rip), %r15      # 0x7160
movq (%rbx), %rax
cmpl $0x6, (%rax)
jne 0x25f0
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
cmpl $0x2a, %ecx
jne 0x25ba
cmpb $0x0, 0x1(%rdx)
je 0x25c9
jmp 0x25f0
subl $0x2f, %ecx
jne 0x25c3
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x25f0
movq %r14, 0x8(%rax)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2626
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
jne 0x259e
jmp 0x25f3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c08(%rip), %rdi      # 0x420d
jmp 0x260e
leaq 0x1bfe(%rip), %rdi      # 0x420c
leaq 0x19f4(%rip), %rsi      # 0x4009
leaq 0x1d44(%rip), %rcx      # 0x4360
movl $0x246, %edx            # imm = 0x246
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x2697
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x26a0
movq %r14, %rdi
callq 0x26bf
movq %rax, %rbx
movq (%r14), %rax
cmpl $0x6, (%rax)
jne 0x268f
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
subl $0x5e, %ecx
jne 0x265e
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x268f
movq %rbx, 0x8(%rax)
movq (%r14), %rbx
leaq 0x30(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
callq 0x2626
movq %rax, 0x10(%rbx)
leaq 0x4adb(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b6f(%rip), %rdi      # 0x420d
jmp 0x26a7
leaq 0x1b65(%rip), %rdi      # 0x420c
leaq 0x195b(%rip), %rsi      # 0x4009
leaq 0x1cc5(%rip), %rcx      # 0x437a
movl $0x25a, %edx            # imm = 0x25A
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2736
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x273f
cmpl $0x4, 0x30(%rax)
jne 0x2728
movq %rbx, %rdi
callq 0x200a
testq %rax, %rax
jne 0x2721
leaq 0x1b25(%rip), %rdi      # 0x4214
leaq 0x1ca3(%rip), %rsi      # 0x4399
movl $0x272, %edx            # imm = 0x272
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1b2b(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x4a42(%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 0x275e
leaq 0x1ad0(%rip), %rdi      # 0x420d
jmp 0x2746
leaq 0x1ac6(%rip), %rdi      # 0x420c
leaq 0x18bc(%rip), %rsi      # 0x4009
leaq 0x1c45(%rip), %rcx      # 0x4399
movl $0x26c, %edx            # imm = 0x26C
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x2845
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x284e
movl (%rax), %ecx
cmpl $0x9, %ecx
je 0x27c5
cmpl $0x7, %ecx
je 0x27bc
cmpl $0x6, %ecx
jne 0x282b
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
subl $0x28, %ecx
jne 0x27a1
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
je 0x27d4
leaq 0x1a66(%rip), %rdi      # 0x4214
leaq 0x1c02(%rip), %rsi      # 0x43b7
movl $0x283, %edx            # imm = 0x283
jmp 0x280f
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
jmp 0x2835
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
movl $0x8, (%rax)
jmp 0x2835
addq $0x30, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x239e
movq (%rbx), %rcx
movq 0x18(%rcx), %rsi
movzbl (%rsi), %edx
subl $0x29, %edx
jne 0x27f6
movzbl 0x1(%rsi), %edx
negl %edx
testl %edx, %edx
je 0x283c
leaq 0x1a11(%rip), %rdi      # 0x4214
leaq 0x1bad(%rip), %rsi      # 0x43b7
movl $0x289, %edx            # imm = 0x289
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1a17(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x492e(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x30, %rcx
jmp 0x27c0
leaq 0x19c1(%rip), %rdi      # 0x420d
jmp 0x2855
leaq 0x19b7(%rip), %rdi      # 0x420c
leaq 0x17ad(%rip), %rsi      # 0x4009
leaq 0x1b54(%rip), %rcx      # 0x43b7
movl $0x27b, %edx            # imm = 0x27B
callq 0x1090
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5a59
leaq 0x4fa5(%rip), %rdi      # 0xa9ef
callq 0x21a0
movl $0x1, %eax
jmp 0x5b16
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5dc4
leaq 0x4d50(%rip), %rax      # 0xa7c0
leaq 0x4d99(%rip), %rdi      # 0xa810
cmpb $0x0, 0x2c(%r14)
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x4f16(%rip), %rdi      # 0xa9a4
callq 0x21a0
movq 0x8(%rbx), %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x4d94(%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 0x651e
leaq 0xf0(%rsp), %rdi
callq 0x5ea2
movq %rbx, %rdi
callq 0x2110
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x849a
movq -0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5b14
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
xorl %eax, %eax
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r14
retq
jmp 0x5b30
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x5b3b
movq %rax, %rdi
callq 0x6243
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5f32
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x145ff(%rip), %rsi     # 0x19728
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
leaq 0x145ed(%rip), %rsi     # 0x19730
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x145e7(%rip), %rsi     # 0x19741
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x14611(%rip), %rsi     # 0x19782
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x1463b(%rip), %rsi     # 0x197c3
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x14665(%rip), %rsi     # 0x19804
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
leaq 0x1468f(%rip), %rsi     # 0x19845
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3130
movl $0x1, %edi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xd8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xb8(%rsi), %rbp
imulq $0x38, 0xd0(%rsi), %rcx
movl (%rbp,%rcx), %eax
cmpl $0x4, %eax
je 0x63ec
movq %rsi, %r14
addq %rcx, %rbp
leaq 0x8(%rsp), %r12
leaq 0x50(%rsp), %r13
leaq 0x60(%rsp), %r15
movl %eax, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x179ce
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r12)
movq %r14, %rdi
callq 0x9256
movq %rax, 0x38(%rsp)
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9a62
movq %r13, 0x40(%rsp)
movq 0xa8(%rsp), %rax
leaq 0xb8(%rsp), %rcx
cmpq %rcx, %rax
je 0x631c
movq %rax, 0x40(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x6324
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9390
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
callq 0x95f6
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x90(%rsp)
notq %rax
addq 0x30(%rsp), %rax
movq %rax, 0x98(%rsp)
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq 0x97cc
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x6392
movq 0x88(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %r15, %rdi
callq 0x9730
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x63b1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x63cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
imulq $0x38, 0xd0(%r14), %rax
movq 0xb8(%r14), %rcx
leaq (%rcx,%rax), %rbp
movl (%rcx,%rax), %eax
cmpl $0x4, %eax
jne 0x62a5
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x645d
movq %rax, %r14
jmp 0x6416
movq %rax, %r14
movq %r15, %rdi
callq 0x9730
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x6441
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x6441
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x978e
jmp 0x6441
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x645d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x6d7e
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x658(%rip), %rdx       # 0x8ea8
movq %rsp, %r15
movq %r15, %rdi
callq 0x8dd6
leaq 0x110bd(%rip), %rsi     # 0x1991f
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0x88fb
leaq 0x10c61(%rip), %rsi     # 0x194da
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8903
leaq 0x11096(%rip), %rsi     # 0x19922
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x890b
leaq 0x11088(%rip), %rsi     # 0x19927
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8913
leaq 0x1107b(%rip), %rsi     # 0x1992d
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x891b
leaq 0x1106f(%rip), %rsi     # 0x19934
movq %rsp, %rdi
callq 0x30b0
testl %eax, %eax
je 0x8923
leaq 0x11062(%rip), %rsi     # 0x1993a
movq %rsp, %rdi
callq 0x30b0
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
testl %eax, %eax
je 0x8977
movl $0x0, (%rbx)
jmp 0x897d
movl $0x5, (%rbx)
jmp 0x8929
movl $0x6, (%rbx)
jmp 0x8929
movl $0x7, (%rbx)
jmp 0x8929
movl $0x8, (%rbx)
jmp 0x8929
movl $0x9, (%rbx)
jmp 0x8929
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 0x179ce
movups 0x68(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x896a
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 0x8935
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f58(%rip), %rdx     # 0x19d4d
movq %rdx, %rsi
callq 0x8faa
movq 0x60(%r15), %rax
cmpq 0x48(%r15), %rax
jae 0x8e4d
movq 0x40(%r15), %rcx
movsbl (%rcx,%rax), %edi
callq *%r14
testb %al, %al
je 0x8e4d
movq 0x40(%r15), %rax
movq 0x60(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x60(%r15)
movb (%rax,%rcx), %al
cmpb $0xa, %al
jne 0x8e35
incq 0x68(%r15)
xorl %ecx, %ecx
jmp 0x8e3c
movq 0x70(%r15), %rcx
incq %rcx
movq %rcx, 0x70(%r15)
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31f0
jmp 0x8dfd
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 0x8e73
movq (%r12), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_escaped[abi:cxx11](int)
std::string read_escaped(int quote) {
		bool escaped = false;
		std::string str = "";
		input.next();
		while (!input.eof()) {
			int ch = input.next();
			if (ch == '\n') {
				break;
			} else if (escaped) {
				str += ch;
				escaped = false;
			} else if (ch == '\\') {
				str += ch;
				escaped = true;
			} else if (ch == quote) {
				break;
			} else {
				str += ch;
			}
		}
		return str;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x10e65(%rip), %rdx     # 0x19d4d
movq %rdx, %rsi
callq 0x8faa
movq 0x40(%r14), %rcx
movq 0x60(%r14), %rdx
leaq 0x1(%rdx), %rax
movq %rax, 0x60(%r14)
cmpb $0xa, (%rcx,%rdx)
jne 0x8f14
incq 0x68(%r14)
movq $0x0, 0x70(%r14)
jmp 0x8f18
incq 0x70(%r14)
cmpq 0x48(%r14), %rax
jae 0x8f7f
xorl %r12d, %r12d
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%r14)
movq 0x40(%r14), %rcx
movsbl (%rcx,%rax), %esi
cmpl $0xa, %esi
je 0x8f73
incq 0x70(%r14)
testb $0x1, %r12b
jne 0x8f5c
cmpb $0x5c, %sil
jne 0x8f58
movb $0x1, %r12b
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x31f0
jmp 0x8f67
cmpl %ebp, %esi
je 0x8f7f
movq %rbx, %rdi
callq 0x31f0
xorl %r12d, %r12d
movq 0x60(%r14), %rax
cmpq 0x48(%r14), %rax
jb 0x8f21
jmp 0x8f7f
incq 0x68(%r14)
movq $0x0, 0x70(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8fa1
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_type()
type_t parse_type() {
		expect(tk_int);
		long pointer_depth = 0;
		while (input.peek().type == tk_asterisk) {
			input.next();
			pointer_depth++;
		}
		return {pointer_depth};
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x9a62
movq 0x8(%r14), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x92a0
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3280
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r15
movl (%rbp,%r15), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, 0x8(%rsp)
movq 0x8(%rbp,%r15), %rsi
movq 0x10(%rbp,%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x179ce
movups 0x28(%rbp,%r15), %xmm0
movups %xmm0, 0x20(%r14)
movl (%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9303
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x31, %ebp
jne 0x937b
movq 0xb8(%rbx), %r15
movq 0xd0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xd0(%rbx)
imulq $0x38, %rax, %rbp
movl (%r15,%rbp), %eax
movl %eax, 0x38(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, 0x40(%rsp)
movq 0x8(%r15,%rbp), %rsi
movq 0x10(%r15,%rbp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x179ce
movups 0x28(%r15,%rbp), %xmm0
movups %xmm0, 0x20(%r13)
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x9373
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
incq %r12
jmp 0x92a3
movq %r12, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_parameters()
std::vector<parameter_t> parse_parameters() {
		std::vector<parameter_t> parameters;
		expect(tk_left_parenthesis);
		while (input.peek().type != tk_right_parenthesis) {
			parameters.push_back(parse_parameter());
			if (input.peek().type != tk_right_parenthesis) {
				expect(tk_comma);
			}
		}
		expect(tk_right_parenthesis);
		return parameters;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
leaq 0xe0(%rsp), %rdi
movl $0xc, %edx
callq 0x9a62
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93ea
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x18(%rsp), %r15
leaq 0x28(%rsp), %r13
leaq 0x60(%rsp), %r12
movq 0xb8(%r14), %rbp
imulq $0x38, 0xd0(%r14), %rbx
movl (%rbp,%rbx), %eax
movl %eax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq 0x8(%rbp,%rbx), %rsi
movq 0x10(%rbp,%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x179ce
addq %rbx, %rbp
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x10(%rsp), %ebx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x9451
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0xd, %ebx
je 0x9570
movq %r14, %rdi
callq 0x9256
movq %rax, 0x48(%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9a62
movq %r12, 0x50(%rsp)
movq 0x18(%rsp), %rax
cmpq %r13, %rax
je 0x9496
movq %rax, 0x50(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x94a0
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa2de
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x94d0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0xb8(%r14), %rbp
imulq $0x38, 0xd0(%r14), %rbx
movl (%rbp,%rbx), %eax
movl %eax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq 0x8(%rbp,%rbx), %rsi
movq 0x10(%rbp,%rbx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x179ce
addq %rbx, %rbp
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x10(%rsp), %ebx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x952a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0xd, %ebx
je 0x93f9
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl $0x12, %edx
callq 0x9a62
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x93f9
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x93f9
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
movl $0xd, %edx
callq 0x9a62
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x95a6
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x95e1
jmp 0x95e1
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x95e4
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x95e4
jmp 0x95e1
jmp 0x95e1
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x9730
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_statements()
std::vector<statement_t*> parse_statements() {
		std::vector<statement_t*> statements;
		expect(tk_left_brace);
		while (input.peek().type != tk_right_brace) {
			statements.push_back(parse_statement());
		}
		expect(tk_right_brace);
		return statements;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x70(%rsp), %rdi
movl $0x10, %edx
callq 0x9a62
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x964b
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r13
movq 0xb8(%r14), %rbp
imulq $0x38, 0xd0(%r14), %r12
movl (%rbp,%r12), %eax
movl %eax, (%rsp)
movq %r13, 0x8(%rsp)
movq 0x8(%rbp,%r12), %rsi
movq 0x10(%rbp,%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x179ce
addq %r12, %rbp
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r15)
movl (%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x96ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x11, %ebp
je 0x96ca
movq %r14, %rdi
callq 0xa5b2
movq %rax, (%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xaf02
jmp 0x9655
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movl $0x11, %edx
callq 0x9a62
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x96f7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9710
jmp 0x9710
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9727
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_logical_or_term()
expression_t* parse_logical_or_term() {
		expression_t* node = parse_logical_and_term();
		while (input.peek().type == tk_bi_logical_or) {
			token_t peek = input.peek();
			expect(tk_bi_logical_or);
			node = new expression_t((binary_expression_t){node, parse_logical_and_term(), bi_logical_or}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xc478
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x179ce
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc167
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x1d, %ebp
jne 0xc2bd
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x179ce
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x1d, %edx
callq 0x9a62
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xc1e0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xc478
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0xc, 0x100(%rbp)
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc2b4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xc10a
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xc2e5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc2fc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_logical_and_term()
expression_t* parse_logical_and_term() {
		expression_t* node = parse_binary_or_term();
		while (input.peek().type == tk_bi_logical_and) {
			token_t peek = input.peek();
			expect(tk_bi_logical_and);
			node = new expression_t((binary_expression_t){node, parse_binary_or_term(), bi_logical_and}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xc694
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x179ce
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc4f7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x1c, %ebp
jne 0xc64d
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x179ce
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x1c, %edx
callq 0x9a62
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xc570
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xc694
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0xb, 0x100(%rbp)
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc644
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xc49a
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xc675
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc68c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O3/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_binary_or_term()
expression_t* parse_binary_or_term() {
		expression_t* node = parse_binary_xor_term();
		while (input.peek().type == tk_bi_binary_or) {
			token_t peek = input.peek();
			expect(tk_bi_binary_or);
			node = new expression_t((binary_expression_t){node, parse_binary_xor_term(), bi_binary_or}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xc8b0
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x179ce
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc713
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x24, %ebp
jne 0xc869
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x179ce
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x24, %edx
callq 0x9a62
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xc78c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xc8b0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0x14, 0x100(%rbp)
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc860
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xc6b6
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xc891
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc8a8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0