LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x184a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1853
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x185c
movq %rdi, %r14
leaq 0x2934(%rip), %rdi      # 0x4155
pushq $0x5
popq %rdx
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1845
pushq $0x5
popq %rsi
pushq $0x5
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x287f
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x27b3(%rip), %rdi      # 0x4004
jmp 0x1863
leaq 0x2871(%rip), %rdi      # 0x40cb
jmp 0x1863
leaq 0x2867(%rip), %rdi      # 0x40ca
leaq 0x279f(%rip), %rsi      # 0x4009
leaq 0x28bf(%rip), %rcx      # 0x4130
movl $0xa8, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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
testq %rdi, %rdi
je 0x18c8
movq %rsi, %rdx
testq %rsi, %rsi
je 0x18d1
movq (%rdx), %rax
testq %rax, %rax
je 0x18da
movzbl (%rax), %ecx
subl $0x61, %ecx
jne 0x18b0
movzbl 0x1(%rax), %ecx
subl $0x73, %ecx
jne 0x18b0
movzbl 0x2(%rax), %eax
pushq $0x73
popq %rcx
subl %eax, %ecx
jmp 0x18b2
negl %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x18c6
pushq $0x4
popq %rsi
pushq $0x3
popq %rcx
callq 0x287f
pushq $0x1
popq %rax
popq %rbp
retq
leaq 0x2735(%rip), %rdi      # 0x4004
jmp 0x18e1
leaq 0x27f3(%rip), %rdi      # 0x40cb
jmp 0x18e1
leaq 0x27e9(%rip), %rdi      # 0x40ca
leaq 0x2721(%rip), %rsi      # 0x4009
leaq 0x286c(%rip), %rcx      # 0x415b
movl $0xb5, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1968
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1971
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x197a
movzbl (%rsi), %ecx
xorl %eax, %eax
addl $-0x21, %ecx
cmpl $0x3d, %ecx
ja 0x1957
movabsq $0x2000000000005780, %r8 # imm = 0x2000000000005780
btq %rcx, %r8
jae 0x1934
pushq $0x1
popq %rcx
jmp 0x194c
movl $0x38000000, %r8d       # imm = 0x38000000
btq %rcx, %r8
jae 0x1959
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rsi)
sete %cl
incq %rcx
pushq $0x6
popq %rsi
callq 0x287f
pushq $0x1
popq %rax
popq %rbp
retq
testq %rcx, %rcx
jne 0x1957
cmpb $0x3d, 0x1(%rsi)
jne 0x1957
pushq $0x2
jmp 0x1931
leaq 0x2695(%rip), %rdi      # 0x4004
jmp 0x1981
leaq 0x2753(%rip), %rdi      # 0x40cb
jmp 0x1981
leaq 0x2749(%rip), %rdi      # 0x40ca
leaq 0x2681(%rip), %rsi      # 0x4009
leaq 0x27f2(%rip), %rcx      # 0x4181
movl $0xc2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a1a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a23
movq %rdi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1a2c
callq 0x1ae6
xorl %r15d, %r15d
testb %al, %al
je 0x1a0e
pushq $0x3
popq %r12
pushq $0x2
popq %r15
movq (%rbx), %rdi
cmpb $0x0, (%rdi,%r12)
je 0x1a0e
addq %r12, %rdi
callq 0x1ae6
testb %al, %al
jne 0x19eb
incq %r12
jmp 0x19d0
movq (%rbx), %rax
cmpb $0x0, (%rax,%r12)
je 0x1a0e
addq $0x3, %r12
pushq $0x9
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x287f
pushq $0x1
popq %r15
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e3(%rip), %rdi      # 0x4004
jmp 0x1a33
leaq 0x26a1(%rip), %rdi      # 0x40cb
jmp 0x1a33
leaq 0x2697(%rip), %rdi      # 0x40ca
leaq 0x25cf(%rip), %rsi      # 0x4009
leaq 0x2766(%rip), %rcx      # 0x41a7
movl $0xe7, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ab5
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1abe
movq (%rdx), %rax
testq %rax, %rax
je 0x1ac7
pushq $-0x1
popq %rcx
movb 0x1(%rax,%rcx), %sil
leal -0x30(%rsi), %r8d
incq %rcx
cmpb $0xa, %r8b
jb 0x1a67
cmpb $0x2e, %sil
setne %sil
testq %rcx, %rcx
sete %r8b
orb %sil, %r8b
jne 0x1a9f
movb 0x1(%rax,%rcx), %sil
incq %rcx
addb $-0x30, %sil
cmpb $0xa, %sil
jb 0x1a8d
testq %rcx, %rcx
je 0x1ab1
pushq $0x7
popq %rsi
callq 0x287f
pushq $0x1
popq %rax
jmp 0x1ab3
xorl %eax, %eax
popq %rbp
retq
leaq 0x2548(%rip), %rdi      # 0x4004
jmp 0x1ace
leaq 0x2606(%rip), %rdi      # 0x40cb
jmp 0x1ace
leaq 0x25fc(%rip), %rdi      # 0x40ca
leaq 0x2534(%rip), %rsi      # 0x4009
leaq 0x26ef(%rip), %rcx      # 0x41cb
movl $0xfd, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c17
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1c20
cmpl $0x4, (%rcx)
jne 0x1b69
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x1b7e
cmpl $0x4, %edx
jne 0x1bb4
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x1c10
leaq 0x26a4(%rip), %rdi      # 0x4214
leaq 0x26da(%rip), %rsi      # 0x4251
movl $0x12b, %edx            # imm = 0x12B
jmp 0x1bea
cmpq $0x0, 0x48(%rcx)
je 0x1bb4
movl $0x4, (%rax)
movq %rax, %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x9, %esi
jne 0x1bc9
cmpq $0x0, 0x48(%rcx)
je 0x1bd7
movl $0x4, 0x30(%rcx)
movq %rdx, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x1b8e
leaq 0x2659(%rip), %rdi      # 0x4214
leaq 0x268f(%rip), %rsi      # 0x4251
movl $0x134, %edx            # imm = 0x134
jmp 0x1bea
cmpl $0x4, %esi
jne 0x1bd7
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x1c10
leaq 0x2636(%rip), %rdi      # 0x4214
leaq 0x266c(%rip), %rsi      # 0x4251
movl $0x13b, %edx            # imm = 0x13B
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x263c(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x5553(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x25ef(%rip), %rdi      # 0x420d
jmp 0x1c27
leaq 0x25e5(%rip), %rdi      # 0x420c
leaq 0x23db(%rip), %rsi      # 0x4009
leaq 0x261c(%rip), %rcx      # 0x4251
movl $0x129, %edx            # imm = 0x129
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ce4
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1ced
cmpl $0x5, (%rax)
jne 0x1c7f
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
cmpl $0x5, 0x30(%rax)
jne 0x1c8f
addq $0x60, %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x1cdb
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d0c
movq %rbx, %rdi
callq 0x1d0c
movq %rax, %r14
leaq 0x54bf(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %r14
je 0x1cdb
movq %r14, %r12
movq (%rbx), %rax
cmpl $0x5, (%rax)
je 0x1cd1
movq %rbx, %rdi
callq 0x1d0c
movq %rax, %rcx
movq %rax, 0x10(%r12)
movq (%r15), %rax
movq %rcx, %r12
cmpq %rax, %rcx
jne 0x1cac
jmp 0x1cdb
addq $0x30, %rax
movq %rax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2522(%rip), %rdi      # 0x420d
jmp 0x1cf4
leaq 0x2518(%rip), %rdi      # 0x420c
leaq 0x230e(%rip), %rsi      # 0x4009
leaq 0x2571(%rip), %rcx      # 0x4273
movl $0x147, %edx            # imm = 0x147
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e6e
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1e77
cmpl $0x9, (%rax)
jne 0x1d7a
cmpq $0x0, 0x18(%rax)
je 0x1d7a
movq %rbx, %rdi
callq 0x1e96
testq %rax, %rax
je 0x1db8
movq %rax, %rcx
leaq 0x5412(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1db3
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1e1b
leaq 0x24ab(%rip), %rdi      # 0x4214
leaq 0x2520(%rip), %rsi      # 0x4290
movl $0x175, %edx            # imm = 0x175
jmp 0x1e4a
leaq 0x2493(%rip), %rdi      # 0x4214
leaq 0x2508(%rip), %rsi      # 0x4290
movl $0x166, %edx            # imm = 0x166
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2499(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x53b0(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x1faa
testq %rax, %rax
je 0x1df4
movq %rax, %rcx
leaq 0x5391(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1db3
movq (%rbx), %rax
cmpl $0x3, (%rax)
je 0x1e1b
leaq 0x242e(%rip), %rdi      # 0x4214
leaq 0x24a3(%rip), %rsi      # 0x4290
movl $0x176, %edx            # imm = 0x176
jmp 0x1e4a
movq %rbx, %rdi
callq 0x2078
testq %rax, %rax
je 0x1e2b
movq %rax, %rcx
leaq 0x5355(%rip), %r14      # 0x7160
movq (%r14), %rax
cmpq %rax, %rcx
je 0x1db3
movq (%rbx), %rax
cmpl $0x3, (%rax)
jne 0x1e37
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
jmp 0x1db3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2151
leaq 0x23d6(%rip), %rdi      # 0x4214
leaq 0x244b(%rip), %rsi      # 0x4290
movl $0x177, %edx            # imm = 0x177
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x23dc(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
movq (%r14), %rax
jmp 0x1db3
leaq 0x2398(%rip), %rdi      # 0x420d
jmp 0x1e7e
leaq 0x238e(%rip), %rdi      # 0x420c
leaq 0x2184(%rip), %rsi      # 0x4009
leaq 0x2404(%rip), %rcx      # 0x4290
movl $0x165, %edx            # imm = 0x165
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f82
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1f8b
cmpl $0x9, (%r15)
jne 0x1ef7
cmpq $0x0, 0x18(%r15)
je 0x1ef7
cmpl $0x6, 0x30(%r15)
jne 0x1f3e
movq 0x48(%r15), %rcx
movzbl (%rcx), %eax
subl $0x3d, %eax
jne 0x1edc
movzbl 0x1(%rcx), %eax
negl %eax
testl %eax, %eax
je 0x1f43
leaq 0x232b(%rip), %rdi      # 0x4214
leaq 0x23bd(%rip), %rsi      # 0x42ad
movl $0x186, %edx            # imm = 0x186
jmp 0x1f0a
leaq 0x2316(%rip), %rdi      # 0x4214
leaq 0x23a8(%rip), %rsi      # 0x42ad
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x231c(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x5233(%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 0x1f30
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 0x2339
movq %rax, 0x40(%r15)
leaq 0x51ea(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %r14
jmp 0x1f30
leaq 0x2284(%rip), %rdi      # 0x420d
jmp 0x1f92
leaq 0x227a(%rip), %rdi      # 0x420c
leaq 0x2070(%rip), %rsi      # 0x4009
leaq 0x230d(%rip), %rcx      # 0x42ad
movl $0x17f, %edx            # imm = 0x17F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2050
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2059
cmpl $0x9, (%r14)
jne 0x200e
cmpq $0x0, 0x18(%r14)
je 0x200e
cmpl $0x4, 0x30(%r14)
jne 0x204c
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x23eb
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x5166(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x2047
movl $0xd, (%r14)
movq %r14, %rax
jmp 0x2047
leaq 0x21ff(%rip), %rdi      # 0x4214
leaq 0x22af(%rip), %rsi      # 0x42cb
movl $0x198, %edx            # imm = 0x198
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2205(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x511c(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x2047
leaq 0x21b6(%rip), %rdi      # 0x420d
jmp 0x2060
leaq 0x21ac(%rip), %rdi      # 0x420c
leaq 0x1fa2(%rip), %rsi      # 0x4009
leaq 0x225d(%rip), %rcx      # 0x42cb
movl $0x197, %edx            # imm = 0x197
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2129
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2132
cmpl $0x9, (%r14)
jne 0x20ba
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x20ba
leaq 0x2353(%rip), %rdi      # 0x4400
callq 0x1130
testl %eax, %eax
je 0x20f8
xorl %eax, %eax
jmp 0x20f3
leaq 0x2153(%rip), %rdi      # 0x4214
leaq 0x2242(%rip), %rsi      # 0x430a
movl $0x1cf, %edx            # imm = 0x1CF
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2159(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x5070(%rip), %rax      # 0x7160
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2339
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x504b(%rip), %rax      # 0x7160
movq (%rax), %rax
cmpq %rax, %rcx
je 0x20f3
movl $0xa, (%r14)
movq %r14, %rax
jmp 0x20f3
leaq 0x20dd(%rip), %rdi      # 0x420d
jmp 0x2139
leaq 0x20d3(%rip), %rdi      # 0x420c
leaq 0x1ec9(%rip), %rsi      # 0x4009
leaq 0x21c3(%rip), %rcx      # 0x430a
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23c3
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x23cc
movq %rbx, %rdi
callq 0x250f
movq %rax, %r14
leaq 0x4dfd(%rip), %r15      # 0x7160
movq (%rbx), %rax
cmpl $0x6, (%rax)
jne 0x23b5
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
cmpl $0x2b, %ecx
jne 0x237f
cmpb $0x0, 0x1(%rdx)
je 0x238e
jmp 0x23b5
subl $0x2d, %ecx
jne 0x2388
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x23b5
movq %r14, 0x8(%rax)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x250f
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
jne 0x2363
jmp 0x23b8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e43(%rip), %rdi      # 0x420d
jmp 0x23d3
leaq 0x1e39(%rip), %rdi      # 0x420c
leaq 0x1c2f(%rip), %rsi      # 0x4009
leaq 0x1f65(%rip), %rcx      # 0x4346
movl $0x232, %edx            # imm = 0x232
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24e7
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x24f0
cmpl $0x4, (%rcx)
jne 0x2435
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x244a
cmpl $0x7, %edx
je 0x2457
cmpl $0x4, %edx
jne 0x2484
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x24e0
leaq 0x1dd8(%rip), %rdi      # 0x4214
leaq 0x1ea5(%rip), %rsi      # 0x42e8
movl $0x1aa, %edx            # imm = 0x1AA
jmp 0x24ba
cmpq $0x0, 0x48(%rcx)
je 0x2484
movl $0x8, (%rax)
movq %rax, %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x7, %esi
je 0x247b
cmpl $0x9, %esi
jne 0x2499
cmpq $0x0, 0x48(%rcx)
je 0x24a7
movl $0x8, (%rdx)
movq %rdx, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x245a
leaq 0x1d89(%rip), %rdi      # 0x4214
leaq 0x1e56(%rip), %rsi      # 0x42e8
movl $0x1b5, %edx            # imm = 0x1B5
jmp 0x24ba
cmpl $0x4, %esi
jne 0x24a7
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x24e0
leaq 0x1d66(%rip), %rdi      # 0x4214
leaq 0x1e33(%rip), %rsi      # 0x42e8
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1d6c(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x4c83(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1d1f(%rip), %rdi      # 0x420d
jmp 0x24f7
leaq 0x1d15(%rip), %rdi      # 0x420c
leaq 0x1b0b(%rip), %rsi      # 0x4009
leaq 0x1de3(%rip), %rcx      # 0x42e8
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2599
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x25a2
movq %rbx, %rdi
callq 0x25c1
movq %rax, %r14
leaq 0x4c27(%rip), %r15      # 0x7160
movq (%rbx), %rax
cmpl $0x6, (%rax)
jne 0x258b
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
cmpl $0x2a, %ecx
jne 0x2555
cmpb $0x0, 0x1(%rdx)
je 0x2564
jmp 0x258b
subl $0x2f, %ecx
jne 0x255e
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x258b
movq %r14, 0x8(%rax)
movq (%rbx), %r14
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x25c1
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
jne 0x2539
jmp 0x258e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c6d(%rip), %rdi      # 0x420d
jmp 0x25a9
leaq 0x1c63(%rip), %rdi      # 0x420c
leaq 0x1a59(%rip), %rsi      # 0x4009
leaq 0x1da9(%rip), %rcx      # 0x4360
movl $0x246, %edx            # imm = 0x246
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2632
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x263b
movq %r14, %rdi
callq 0x265a
movq %rax, %rbx
movq (%r14), %rax
cmpl $0x6, (%rax)
jne 0x262a
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
subl $0x5e, %ecx
jne 0x25f9
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
jne 0x262a
movq %rbx, 0x8(%rax)
movq (%r14), %rbx
leaq 0x30(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
callq 0x25c1
movq %rax, 0x10(%rbx)
leaq 0x4b40(%rip), %rcx      # 0x7160
movq (%rcx), %rcx
cmpq %rcx, %rax
cmoveq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bd4(%rip), %rdi      # 0x420d
jmp 0x2642
leaq 0x1bca(%rip), %rdi      # 0x420c
leaq 0x19c0(%rip), %rsi      # 0x4009
leaq 0x1d2a(%rip), %rcx      # 0x437a
movl $0x25a, %edx            # imm = 0x25A
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26d1
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x26da
cmpl $0x4, 0x30(%rax)
jne 0x26c3
movq %rbx, %rdi
callq 0x1faa
testq %rax, %rax
jne 0x26bc
leaq 0x1b8a(%rip), %rdi      # 0x4214
leaq 0x1d08(%rip), %rsi      # 0x4399
movl $0x272, %edx            # imm = 0x272
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1b90(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x4aa7(%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 0x26f9
leaq 0x1b35(%rip), %rdi      # 0x420d
jmp 0x26e1
leaq 0x1b2b(%rip), %rdi      # 0x420c
leaq 0x1921(%rip), %rsi      # 0x4009
leaq 0x1caa(%rip), %rcx      # 0x4399
movl $0x26c, %edx            # imm = 0x26C
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27e0
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x27e9
movl (%rax), %ecx
cmpl $0x9, %ecx
je 0x2760
cmpl $0x7, %ecx
je 0x2757
cmpl $0x6, %ecx
jne 0x27c6
movq 0x18(%rax), %rdx
movzbl (%rdx), %ecx
subl $0x28, %ecx
jne 0x273c
movzbl 0x1(%rdx), %ecx
negl %ecx
testl %ecx, %ecx
je 0x276f
leaq 0x1acb(%rip), %rdi      # 0x4214
leaq 0x1c67(%rip), %rsi      # 0x43b7
movl $0x283, %edx            # imm = 0x283
jmp 0x27aa
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
jmp 0x27d0
leaq 0x30(%rax), %rcx
movq %rcx, (%rbx)
movl $0x8, (%rax)
jmp 0x27d0
addq $0x30, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2339
movq (%rbx), %rcx
movq 0x18(%rcx), %rsi
movzbl (%rsi), %edx
subl $0x29, %edx
jne 0x2791
movzbl 0x1(%rsi), %edx
negl %edx
testl %edx, %edx
je 0x27d7
leaq 0x1a76(%rip), %rdi      # 0x4214
leaq 0x1c12(%rip), %rsi      # 0x43b7
movl $0x289, %edx            # imm = 0x289
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x1a7c(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x4993(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x30, %rcx
jmp 0x275b
leaq 0x1a26(%rip), %rdi      # 0x420d
jmp 0x27f0
leaq 0x1a1c(%rip), %rdi      # 0x420c
leaq 0x1812(%rip), %rsi      # 0x4009
leaq 0x1bb9(%rip), %rcx      # 0x43b7
movl $0x27b, %edx            # imm = 0x27B
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/reverse-iter.cc
// Function: main
int main()
{
	vector<int> vec;
	istream_iterator<int> in(cin), eof;
	copy (in, eof, back_inserter(vec));

	sort(vec.begin(), vec.end()); // sorts vec in ``normal'' order
	vector<int> vec2(vec);        // vec2 is a copy of vec

	// sorts in reverse: puts the smallest element at the end of vec
	sort(vec.rbegin(), vec.rend());

	// prints vec
	ostream_iterator<int> out(cout, " ");
	copy(vec.begin(), vec.end(), out);    // reverse sort
	cout << endl;

	// prints vec2
	copy(vec2.begin(), vec2.end(), out);  // forward sort
	cout << endl;

	// it refers to the first element in vec
	auto it = vec.begin();

	// rev_it refers one before the first element in vec
	vector<int>::reverse_iterator rev_it(it);
	cout << *(rev_it.base()) << endl; // prints first element in vec
	
	// ways to print value at beginning of vec through it and rev_it
	cout << *it << endl;
	cout << *(rev_it.base()) << endl;  
	cout << *(rev_it - 1) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
movq 0x3d63(%rip), %rsi      # 0x4fe0
leaq -0x40(%rbp), %rdi
callq 0x1408
movq -0x40(%rbp), %rax
leaq -0xb8(%rbp), %rdi
movq %rax, (%rdi)
movl -0x38(%rbp), %eax
movl %eax, 0x8(%rdi)
movb -0x34(%rbp), %al
movb %al, 0xc(%rdi)
leaq -0xa8(%rbp), %rsi
andq $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
movb $0x0, 0xc(%rsi)
leaq -0x30(%rbp), %rdx
callq 0x1419
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1832
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x145c
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x78(%rbp), %rdi
movq %rcx, (%rdi)
leaq -0x70(%rbp), %rsi
movq %rax, (%rsi)
callq 0x14b3
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x3cd0(%rip), %rax      # 0x4fd0
leaq -0x98(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x1cf3(%rip), %r14      # 0x3004
movq %r14, 0x8(%rcx)
leaq -0x68(%rbp), %rdi
callq 0x14da
movq 0x3cab(%rip), %rbx      # 0x4fd0
movq %rbx, %rdi
callq 0x1060
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x88(%rbp), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
leaq -0x68(%rbp), %rdi
callq 0x14da
movq 0x3c7d(%rip), %rdi      # 0x4fd0
callq 0x1060
movq -0x30(%rbp), %rbx
movl (%rbx), %esi
movq 0x3c6b(%rip), %rdi      # 0x4fd0
callq 0x1100
movq %rax, %rdi
callq 0x1060
movl (%rbx), %esi
movq 0x3c55(%rip), %rdi      # 0x4fd0
callq 0x1100
movq %rax, %rdi
callq 0x1060
movl (%rbx), %esi
movq 0x3c3f(%rip), %rdi      # 0x4fd0
callq 0x1100
movq %rax, %rdi
callq 0x1060
movl (%rbx), %esi
movq 0x3c29(%rip), %rdi      # 0x4fd0
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq -0x58(%rbp), %rdi
callq 0x151c
leaq -0x30(%rbp), %rdi
callq 0x151c
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x13e6
jmp 0x13e6
jmp 0x13e6
jmp 0x13f4
jmp 0x13f4
jmp 0x13e6
jmp 0x13e6
jmp 0x13e6
jmp 0x13e6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x151c
jmp 0x13f7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x151c
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2aa8
leaq 0x6f74(%rip), %rdi      # 0x9a0f
callq 0x21d0
pushq $0x1
popq %rax
jmp 0x2b4c
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5a18
leaq 0x6d21(%rip), %rax      # 0x97e0
leaq 0x6d6a(%rip), %rdi      # 0x9830
cmpb $0x0, 0x2c(%r14)
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x6ee7(%rip), %rdi      # 0x99c4
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x2100
movq %rax, %r14
leaq 0x6d65(%rip), %rdi      # 0x985a
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 0x61e6
leaq 0xf0(%rsp), %rdi
callq 0x5a9a
movq %rbx, %rdi
callq 0x782e
leaq 0x8(%rsp), %rdi
callq 0x5afc
xorl %eax, %eax
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x782e
jmp 0x2b67
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5afc
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/../lexer/token.hpp
// Function: make_token_type_str_pad[abi:cxx11]()
std::vector<std::string> make_token_type_str_pad() {
	std::vector<std::string> token_type_str_pad;
	long max_length = 0;
	for (int i = 0; i < sizeof(token_type_str) / sizeof(token_type_str[0]); i++) {
		if (token_type_str[i].length() > max_length) {
			max_length = token_type_str[i].length();
		}
	}
	for (int i = 0; i < sizeof(token_type_str) / sizeof(token_type_str[0]); i++) {
		std::string padding(max_length - token_type_str[i].length(), ' ');
		token_type_str_pad.push_back(token_type_str[i] + padding);
	}
	return token_type_str_pad;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
pushq $0x8
popq %rax
xorl %r12d, %r12d
leaq 0x151ba(%rip), %r13     # 0x18450
cmpq $0x668, %rax            # imm = 0x668
je 0x32af
movq (%rax,%r13), %rcx
cmpq %r12, %rcx
cmovaq %rcx, %r12
addq $0x20, %rax
jmp 0x3296
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
cmpq $0x660, %rbp            # imm = 0x660
je 0x3313
movq %r12, %rsi
subq 0x8(%rbp,%r13), %rsi
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
pushq $0x20
popq %rdx
callq 0x2260
movq %r13, %rsi
addq %rbp, %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3a59
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf97a
movq %r15, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2100
addq $0x20, %rbp
jmp 0x32bb
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3346
movq %rax, %r14
jmp 0x333c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x3a92
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14c2a(%rip), %rbx     # 0x17ff0
leaq 0xd3a1(%rip), %rsi      # 0x1076e
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
leaq 0xd38f(%rip), %rsi      # 0x10776
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0xd389(%rip), %rsi      # 0x10787
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0xd3b3(%rip), %rsi      # 0x107c8
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0xd3dd(%rip), %rsi      # 0x10809
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0xd407(%rip), %rsi      # 0x1084a
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
leaq 0xd431(%rip), %rsi      # 0x1088b
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x2110
pushq $0x1
popq %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x20(%rsi), %rbp
leaq 0x80(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x40(%rsp), %r13
movq 0xb8(%r12), %rax
imulq $0x38, 0xd0(%r12), %rcx
cmpl $0x4, (%rax,%rcx)
je 0x3e6c
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5d52
movq %r12, %rdi
callq 0x5d72
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x5e00
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x5e68
movq %r14, %rdi
movq %r12, %rsi
callq 0x5f88
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
movq %r13, %rsi
callq 0x608e
movq %r13, %rdi
callq 0x606a
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0x3dd0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3e93
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x6048
leaq 0x48(%rsp), %rdi
callq 0x2100
jmp 0x3eb6
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x606a
jmp 0x3eb6
movq %rax, %r14
jmp 0x3ec0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x43a6
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::compile()
void compile() {
		pack_strings();
		symbol_table_t symbols;
		for (int i = 0; i < program.size(); i++) {
			function_t function = program[i];
			symbols.add_symbol(symbol_t(
				function.type,
				function.identifier,
				function.parameters
			));
			compile_function(function, symbols);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x8(%rsp)
callq 0xdf1c
leaq 0x58(%rsp), %rax
andq $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movaps %xmm0, -0x8(%rax)
movaps %xmm0, 0x8(%rax)
movb $0x0, 0x18(%rax)
xorl %edi, %edi
leaq 0x38(%rsp), %r12
leaq 0x168(%rsp), %rbp
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
subq %rsi, %rax
cqto
pushq $0x68
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x4506
movq %rdi, 0x10(%rsp)
addq %rdi, %rsi
leaq 0x98(%rsp), %rdi
callq 0xa0f0
movq 0x98(%rsp), %r15
leaq 0x18(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x22e0
movq %r12, %r13
movq %r12, %rdi
leaq 0xc0(%rsp), %rsi
callq 0xa25a
movq %rbp, %r14
movq %rbp, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %rdx
movq %r13, %rcx
callq 0xa05e
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0xa578
movq %r14, %rdi
callq 0xa0d6
movq %r13, %rdi
callq 0x6048
leaq 0x18(%rsp), %rdi
callq 0x2100
leaq 0x100(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xa0f0
movq 0x8(%rsp), %rdi
leaq 0x100(%rsp), %r14
movq %r14, %rsi
leaq 0x50(%rsp), %rdx
callq 0xdf66
movq %r14, %rdi
callq 0x606a
leaq 0x98(%rsp), %rdi
callq 0x606a
incq %rbx
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
jmp 0x4411
leaq 0x58(%rsp), %rdi
callq 0xdbb0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4579
movq %rax, %rbx
jmp 0x455d
movq %rax, %rbx
leaq 0x168(%rsp), %rdi
callq 0xa0d6
jmp 0x4553
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x606a
jmp 0x456c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6048
leaq 0x18(%rsp), %rdi
callq 0x2100
jmp 0x456c
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x606a
leaq 0x58(%rsp), %rdi
callq 0xdbb0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/../lexer/complete_token_stream.hpp
// Function: complete_token_stream_t::complete_token_stream_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, token_stream_t)
complete_token_stream_t(std::string filename = "", token_stream_t buffer = token_stream_t("")) {
		this->filename = filename;
		input = buffer;
		token_t token;
		while ((token = input.next()).type != tk_eof) {
			tokens.push_back(token);
		}
		tokens.push_back(token);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xc5cc(%rip), %rsi      # 0x10d95
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, (%rsp)
callq 0x3a1e
leaq 0xc5b2(%rip), %rsi      # 0x10d95
leaq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x3a1e
leaq 0x20(%rbx), %r14
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x4640
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0x98(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2140
movq %r14, %rdi
movq %r12, %rsi
callq 0x4a62
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x88(%rsp), %r13
leaq 0x80(%rsp), %rbp
leaq 0x48(%rsp), %r12
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4a8c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5280
movl (%rax), %ebx
movq %r13, %rdi
callq 0x2100
cmpl $0x4, %ebx
je 0x48a5
movq %r15, %rdi
movq %r12, %rsi
callq 0x52b0
jmp 0x4873
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x52b0
leaq 0x50(%rsp), %rdi
callq 0x2100
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48fa
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x2100
jmp 0x48e2
movq %rax, %r13
leaq 0x28(%rsp), %rdi
callq 0x2100
jmp 0x4917
movq %rax, %r13
jmp 0x4917
movq %rax, %r13
jmp 0x4907
jmp 0x48fa
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0x2100
movq %r15, %rdi
callq 0x52dc
movq %r14, %rdi
callq 0x4928
movq (%rsp), %rdi
callq 0x2100
movq %r13, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4fc(%rip), %rdx       # 0x58ae
movq %rsp, %r15
movq %r15, %rdi
callq 0x580c
leaq 0xb5a1(%rip), %rsi      # 0x10965
movq %r15, %rdi
callq 0x58d0
leaq 0x8(%rbx), %r15
testb %al, %al
je 0x53d8
pushq $0x5
jmp 0x5449
leaq 0xb126(%rip), %rsi      # 0x10505
movq %rsp, %rdi
callq 0x58d0
testb %al, %al
je 0x53ef
pushq $0x6
jmp 0x5449
leaq 0xb572(%rip), %rsi      # 0x10968
movq %rsp, %rdi
callq 0x58d0
testb %al, %al
je 0x5406
pushq $0x7
jmp 0x5449
leaq 0xb560(%rip), %rsi      # 0x1096d
movq %rsp, %rdi
callq 0x58d0
testb %al, %al
je 0x541d
pushq $0x8
jmp 0x5449
leaq 0xb54f(%rip), %rsi      # 0x10973
movq %rsp, %rdi
callq 0x58d0
testb %al, %al
je 0x5434
pushq $0x9
jmp 0x5449
leaq 0xb53f(%rip), %rsi      # 0x1097a
movq %rsp, %rdi
callq 0x58d0
testb %al, %al
je 0x5475
pushq $0xa
popq %rax
movl %eax, (%rbx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x22e0
movups 0x68(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb504(%rip), %rsi      # 0x10980
movq %rsp, %rdi
callq 0x58d0
xorl %ecx, %ecx
testb %al, %al
pushq $0xb
popq %rax
cmovel %ecx, %eax
jmp 0x544a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_lit_integer()
token_t read_lit_integer() {
		return {
			tk_lit_integer,
			read_while(chr_digit),
			TOKEN_DEBUG
		};
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, (%rdi)
addq $0x8, %rdi
leaq -0x25(%rip), %rdx       # 0x54a4
callq 0x580c
movups 0x68(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_lit_string()
token_t read_lit_string() {
		return {
			tk_lit_string,
			read_escaped('"'),
			TOKEN_DEBUG
		};
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, (%rdi)
addq $0x8, %rdi
pushq $0x22
popq %rdx
callq 0x58de
movups 0x68(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_lit_character()
token_t read_lit_character() {
		return {
			tk_lit_character,
			read_escaped('\''),
			TOKEN_DEBUG
		};
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, (%rdi)
addq $0x8, %rdi
pushq $0x27
popq %rdx
callq 0x58de
movups 0x68(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb571(%rip), %rsi      # 0x10d95
leaq 0x7(%rsp), %rdx
callq 0x3a1e
leaq 0x20(%r15), %r12
movq 0x60(%r15), %rax
cmpq 0x48(%r15), %rax
jae 0x5860
movq 0x40(%r15), %rcx
movsbl (%rcx,%rax), %edi
callq *%r14
testb %al, %al
je 0x5860
movq %r12, %rdi
callq 0x5542
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21d0
jmp 0x5832
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2390