LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetFunc(element**)
element* GetFunc      (element** el_now)
{
    parse_ass;

    require_ind;

    element* el_result = *el_now;
    next;

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

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

    el_result->type = FUNC;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1965
jmp 0x1984
leaq 0x48cf(%rip), %rdi      # 0x623b
leaq 0x46b2(%rip), %rsi      # 0x6025
movl $0x116, %edx            # imm = 0x116
leaq 0x489e(%rip), %rcx      # 0x621d
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1990
jmp 0x19af
leaq 0x48a3(%rip), %rdi      # 0x623a
leaq 0x4687(%rip), %rsi      # 0x6025
movl $0x116, %edx            # imm = 0x116
leaq 0x4873(%rip), %rcx      # 0x621d
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0x19c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1a0f
leaq 0x4872(%rip), %rdi      # 0x6242
leaq 0x4846(%rip), %rsi      # 0x621d
movl $0x118, %edx            # imm = 0x118
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x4874(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x774d(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1aaa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x7705(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x1a60
leaq 0x76f9(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1aaa
movq -0x10(%rbp), %rdi
callq 0x2470
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x76cd(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x1a98
leaq 0x76c1(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1aaa
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckLR(Tree*, char**)
LexResult CheckLR    (Tree* tree, char** code)
{
    anal_ass;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ad9
jmp 0x1af8
leaq 0x4540(%rip), %rdi      # 0x6020
leaq 0x453e(%rip), %rsi      # 0x6025
movl $0x9b, %edx
leaq 0x4644(%rip), %rcx      # 0x6137
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1b01
jmp 0x1b20
leaq 0x45ed(%rip), %rdi      # 0x60f5
leaq 0x4516(%rip), %rsi      # 0x6025
movl $0x9b, %edx
leaq 0x461c(%rip), %rcx      # 0x6137
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b2c
jmp 0x1b4b
leaq 0x45c1(%rip), %rdi      # 0x60f4
leaq 0x44eb(%rip), %rsi      # 0x6025
movl $0x9b, %edx
leaq 0x45f1(%rip), %rcx      # 0x6137
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x1b7a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x3, %esi
movl $0x1, %ecx
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1b81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ba9
jmp 0x1bc8
leaq 0x4470(%rip), %rdi      # 0x6020
leaq 0x446e(%rip), %rsi      # 0x6025
movl $0xa8, %edx
leaq 0x4597(%rip), %rcx      # 0x615a
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1bd1
jmp 0x1bf0
leaq 0x451d(%rip), %rdi      # 0x60f5
leaq 0x4446(%rip), %rsi      # 0x6025
movl $0xa8, %edx
leaq 0x456f(%rip), %rcx      # 0x615a
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1bfc
jmp 0x1c1b
leaq 0x44f1(%rip), %rdi      # 0x60f4
leaq 0x441b(%rip), %rsi      # 0x6025
movl $0xa8, %edx
leaq 0x4544(%rip), %rcx      # 0x615a
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x4556(%rip), %rdi      # 0x617f
movl $0x5, %edx
callq 0x1070
cmpl $0x0, %eax
jne 0x1c58
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x5, %esi
movl $0x5, %ecx
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1c5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c89
jmp 0x1ca8
leaq 0x4390(%rip), %rdi      # 0x6020
leaq 0x438e(%rip), %rsi      # 0x6025
movl $0xb5, %edx
leaq 0x44e2(%rip), %rcx      # 0x6185
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1cb1
jmp 0x1cd0
leaq 0x443d(%rip), %rdi      # 0x60f5
leaq 0x4366(%rip), %rsi      # 0x6025
movl $0xb5, %edx
leaq 0x44ba(%rip), %rcx      # 0x6185
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cdc
jmp 0x1cfb
leaq 0x4411(%rip), %rdi      # 0x60f4
leaq 0x433b(%rip), %rsi      # 0x6025
movl $0xb5, %edx
leaq 0x448f(%rip), %rcx      # 0x6185
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x44a2(%rip), %rdi      # 0x61ab
movl $0x3, %edx
callq 0x1070
cmpl $0x0, %eax
jne 0x1d38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %esi
movl $0x3, %ecx
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1d3f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d69
jmp 0x1d88
leaq 0x42b0(%rip), %rdi      # 0x6020
leaq 0x42ae(%rip), %rsi      # 0x6025
movl $0xc2, %edx
leaq 0x442c(%rip), %rcx      # 0x61af
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1d91
jmp 0x1db0
leaq 0x435d(%rip), %rdi      # 0x60f5
leaq 0x4286(%rip), %rsi      # 0x6025
movl $0xc2, %edx
leaq 0x4404(%rip), %rcx      # 0x61af
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1dbc
jmp 0x1ddb
leaq 0x4331(%rip), %rdi      # 0x60f4
leaq 0x425b(%rip), %rsi      # 0x6025
movl $0xc2, %edx
leaq 0x43d9(%rip), %rcx      # 0x61af
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x21, %eax
je 0x1e8e
jmp 0x1df3
movl -0x24(%rbp), %eax
addl $-0x28, %eax
subl $0x4, %eax
jb 0x1e2f
jmp 0x1e00
movl -0x24(%rbp), %eax
subl $0x2d, %eax
je 0x1e2f
jmp 0x1e0a
movl -0x24(%rbp), %eax
subl $0x2f, %eax
je 0x1e2f
jmp 0x1e14
movl -0x24(%rbp), %eax
addl $-0x3c, %eax
subl $0x3, %eax
jb 0x1e4f
jmp 0x1e21
movl -0x24(%rbp), %eax
subl $0x5e, %eax
jne 0x1ec0
jmp 0x1e2f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x6, %esi
movl $0x1, %ecx
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1ec7
movq $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x1e6f
movq $0x2, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x6, %esi
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1ec7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x1ebe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x6, %esi
movl $0x2, %ecx
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x1ec7
jmp 0x1ec0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ee9
jmp 0x1f08
leaq 0x4130(%rip), %rdi      # 0x6020
leaq 0x412e(%rip), %rsi      # 0x6025
movl $0xe7, %edx
leaq 0x42d2(%rip), %rcx      # 0x61d5
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1f11
jmp 0x1f30
leaq 0x41dd(%rip), %rdi      # 0x60f5
leaq 0x4106(%rip), %rsi      # 0x6025
movl $0xe7, %edx
leaq 0x42aa(%rip), %rcx      # 0x61d5
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1f3c
jmp 0x1f5b
leaq 0x41b1(%rip), %rdi      # 0x60f4
leaq 0x40db(%rip), %rsi      # 0x6025
movl $0xe7, %edx
leaq 0x427f(%rip), %rcx      # 0x61d5
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x21b0
testb $0x1, %al
jne 0x1f70
jmp 0x2005
movq $0x3, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x1fa6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq -0x20(%rbp), %rdi
callq 0x21b0
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1faf
jmp 0x1fbd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f78
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1fda
movl $0x2, -0x4(%rbp)
jmp 0x200c
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x9, %esi
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x200c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2039
jmp 0x2058
leaq 0x3fe0(%rip), %rdi      # 0x6020
leaq 0x3fde(%rip), %rsi      # 0x6025
movl $0xfd, %edx
leaq 0x41a6(%rip), %rcx      # 0x61f9
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x2061
jmp 0x2080
leaq 0x408d(%rip), %rdi      # 0x60f5
leaq 0x3fb6(%rip), %rsi      # 0x6025
movl $0xfd, %edx
leaq 0x417e(%rip), %rcx      # 0x61f9
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x208c
jmp 0x20ab
leaq 0x4061(%rip), %rdi      # 0x60f4
leaq 0x3f8b(%rip), %rsi      # 0x6025
movl $0xfd, %edx
leaq 0x4153(%rip), %rcx      # 0x61f9
callq 0x1090
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jg 0x20e8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x20f1
jmp 0x20ff
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x20b3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2174
cmpq $0x0, -0x20(%rbp)
je 0x2174
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x22(%rbp)
jg 0x215b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x2164
jmp 0x2172
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2126
jmp 0x2174
cmpq $0x0, -0x20(%rbp)
jbe 0x219a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x7, %esi
callq 0x3ad0
movl $0x1, -0x4(%rbp)
jmp 0x21a1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2485
jmp 0x24a4
leaq 0x3daf(%rip), %rdi      # 0x623b
leaq 0x3b92(%rip), %rsi      # 0x6025
movl $0x147, %edx            # imm = 0x147
leaq 0x3e02(%rip), %rcx      # 0x62a1
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24b0
jmp 0x24cf
leaq 0x3d83(%rip), %rdi      # 0x623a
leaq 0x3b67(%rip), %rsi      # 0x6025
movl $0x147, %edx            # imm = 0x147
leaq 0x3dd7(%rip), %rcx      # 0x62a1
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
je 0x24ed
movq -0x10(%rbp), %rdi
callq 0x2620
movq %rax, -0x8(%rbp)
jmp 0x260d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
jne 0x2522
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x260d
movq -0x10(%rbp), %rdi
callq 0x2620
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x6c16(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x2552
leaq 0x6c0a(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x260d
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
je 0x25a8
movq -0x10(%rbp), %rdi
callq 0x2620
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x6bbf(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x25a6
leaq 0x6bb3(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x260d
jmp 0x255a
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
je 0x25f7
leaq 0x3c87(%rip), %rdi      # 0x6242
leaq 0x3cdf(%rip), %rsi      # 0x62a1
movl $0x15e, %edx            # imm = 0x15E
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x3c89(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x6b62(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x260d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2955
jmp 0x2974
leaq 0x38df(%rip), %rdi      # 0x623b
leaq 0x36c2(%rip), %rsi      # 0x6025
movl $0x17f, %edx            # imm = 0x17F
leaq 0x396c(%rip), %rcx      # 0x62db
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2980
jmp 0x299f
leaq 0x38b3(%rip), %rdi      # 0x623a
leaq 0x3697(%rip), %rsi      # 0x6025
movl $0x17f, %edx            # imm = 0x17F
leaq 0x3941(%rip), %rcx      # 0x62db
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0x29b9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x29ff
leaq 0x3882(%rip), %rdi      # 0x6242
leaq 0x3914(%rip), %rsi      # 0x62db
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x3884(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x675d(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b0c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, 0x30(%rax)
je 0x2a19
movq $0x0, -0x8(%rbp)
jmp 0x2b0c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rsi
leaq 0x38ce(%rip), %rdi      # 0x62f9
callq 0x1140
cmpl $0x0, %eax
je 0x2a7b
leaq 0x3806(%rip), %rdi      # 0x6242
leaq 0x3898(%rip), %rsi      # 0x62db
movl $0x186, %edx            # imm = 0x186
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x3808(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x66e1(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b0c
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rax
movl $0xe, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x6661(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x2b04
leaq 0x6655(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b0c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b35
jmp 0x2b54
leaq 0x36ff(%rip), %rdi      # 0x623b
leaq 0x34e2(%rip), %rsi      # 0x6025
movl $0x197, %edx            # imm = 0x197
leaq 0x37ac(%rip), %rcx      # 0x62fb
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2b60
jmp 0x2b7f
leaq 0x36d3(%rip), %rdi      # 0x623a
leaq 0x34b7(%rip), %rsi      # 0x6025
movl $0x197, %edx            # imm = 0x197
leaq 0x3781(%rip), %rcx      # 0x62fb
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0x2b99
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2bdc
leaq 0x36a2(%rip), %rdi      # 0x6242
leaq 0x3754(%rip), %rsi      # 0x62fb
movl $0x198, %edx            # imm = 0x198
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x36a4(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x657d(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c56
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, 0x30(%rax)
je 0x2bf3
movq $0x0, -0x8(%rbp)
jmp 0x2c56
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x6521(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x2c44
leaq 0x6515(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c56
movq -0x18(%rbp), %rax
movl $0xd, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c75
jmp 0x2c94
leaq 0x35bf(%rip), %rdi      # 0x623b
leaq 0x33a2(%rip), %rsi      # 0x6025
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x36ab(%rip), %rcx      # 0x633a
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2ca0
jmp 0x2cbf
leaq 0x3593(%rip), %rdi      # 0x623a
leaq 0x3377(%rip), %rsi      # 0x6025
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x3680(%rip), %rcx      # 0x633a
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x9, (%rax)
jne 0x2cd9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2d1f
leaq 0x3562(%rip), %rdi      # 0x6242
leaq 0x3653(%rip), %rsi      # 0x633a
movl $0x1cf, %edx            # imm = 0x1CF
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x3564(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x643d(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2da8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x36df(%rip), %rdi      # 0x6410
callq 0x1140
cmpl $0x0, %eax
je 0x2d45
movq $0x0, -0x8(%rbp)
jmp 0x2da8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x63cf(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x2d96
leaq 0x63c3(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2da8
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3145
jmp 0x3164
leaq 0x30ef(%rip), %rdi      # 0x623b
leaq 0x2ed2(%rip), %rsi      # 0x6025
movl $0x232, %edx            # imm = 0x232
leaq 0x3219(%rip), %rcx      # 0x6378
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3170
jmp 0x318f
leaq 0x30c3(%rip), %rdi      # 0x623a
leaq 0x2ea7(%rip), %rsi      # 0x6025
movl $0x232, %edx            # imm = 0x232
leaq 0x31ee(%rip), %rcx      # 0x6378
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x34d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x6, (%rcx)
movb %al, -0x19(%rbp)
jne 0x31f6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x31d3(%rip), %rdi      # 0x6392
callq 0x1140
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0x31f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x31b2(%rip), %rdi      # 0x6394
callq 0x1140
cmpl $0x0, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x31ff
jmp 0x3264
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x34d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x5f06(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x325f
leaq 0x5efa(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x326c
jmp 0x319c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34e5
jmp 0x3504
leaq 0x2d4f(%rip), %rdi      # 0x623b
leaq 0x2b32(%rip), %rsi      # 0x6025
movl $0x246, %edx            # imm = 0x246
leaq 0x2e97(%rip), %rcx      # 0x6396
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3510
jmp 0x352f
leaq 0x2d23(%rip), %rdi      # 0x623a
leaq 0x2b07(%rip), %rsi      # 0x6025
movl $0x246, %edx            # imm = 0x246
leaq 0x2e6c(%rip), %rcx      # 0x6396
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x3620
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x6, (%rcx)
movb %al, -0x19(%rbp)
jne 0x3596
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x2e51(%rip), %rdi      # 0x63b0
callq 0x1140
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0x3590
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x2e30(%rip), %rdi      # 0x63b2
callq 0x1140
cmpl $0x0, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x359f
jmp 0x3604
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x5b66(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x35ff
leaq 0x5b5a(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x360c
jmp 0x353c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3635
jmp 0x3654
leaq 0x2bff(%rip), %rdi      # 0x623b
leaq 0x29e2(%rip), %rsi      # 0x6025
movl $0x25a, %edx            # imm = 0x25A
leaq 0x2d65(%rip), %rcx      # 0x63b4
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3660
jmp 0x367f
leaq 0x2bd3(%rip), %rdi      # 0x623a
leaq 0x29b7(%rip), %rsi      # 0x6025
movl $0x25a, %edx            # imm = 0x25A
leaq 0x2d3a(%rip), %rcx      # 0x63b4
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x3730
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, (%rax)
jne 0x3716
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x2d29(%rip), %rdi      # 0x63d3
callq 0x1140
cmpl $0x0, %eax
jne 0x3716
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
leaq 0x5a51(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x3714
leaq 0x5a45(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x371e
jmp 0x3716
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3745
jmp 0x3764
leaq 0x2aef(%rip), %rdi      # 0x623b
leaq 0x28d2(%rip), %rsi      # 0x6025
movl $0x26c, %edx            # imm = 0x26C
leaq 0x2c76(%rip), %rcx      # 0x63d5
callq 0x1090
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3770
jmp 0x378f
leaq 0x2ac3(%rip), %rdi      # 0x623a
leaq 0x28a7(%rip), %rsi      # 0x6025
movl $0x26c, %edx            # imm = 0x26C
leaq 0x2c4b(%rip), %rcx      # 0x63d5
callq 0x1090
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, 0x30(%rax)
jne 0x37fd
movq -0x10(%rbp), %rdi
callq 0x2b20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x37f3
leaq 0x2a8b(%rip), %rdi      # 0x6242
leaq 0x2c17(%rip), %rsi      # 0x63d5
movl $0x272, %edx            # imm = 0x272
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
leaq 0x2a8d(%rip), %rdi      # 0x6269
movb $0x0, %al
callq 0x1040
leaq 0x5966(%rip), %rax      # 0x9150
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x380a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x380a
movq -0x10(%rbp), %rdi
callq 0x3820
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x14d8, %rsp           # imm = 0x14D8
movl $0x0, 0x14d4(%rsp)
movl %edi, 0x14d0(%rsp)
movq %rsi, 0x14c8(%rsp)
cmpl $0x2, 0x14d0(%rsp)
jge 0x3839
leaq 0x100866(%rip), %rdi    # 0x104088
movb $0x0, %al
callq 0x2030
movl $0x1, 0x14d4(%rsp)
jmp 0x3973
movq $0x64, 0x14c0(%rsp)
leaq 0x13d8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf75e0
movq 0x8(%rsp), %rdi
callq 0xf7700
movb %al, 0x17(%rsp)
jmp 0x3867
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3871
jmp 0x389c
leaq 0x100860(%rip), %rdi    # 0x1040d8
xorl %eax, %eax
callq 0x2030
jmp 0x3881
jmp 0x38ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13d0(%rsp)
movl %eax, 0x13cc(%rsp)
jmp 0x3964
leaq 0x100885(%rip), %rdi    # 0x104128
xorl %eax, %eax
callq 0x2030
jmp 0x38ac
jmp 0x38ae
leaq 0x10089d(%rip), %rdi    # 0x104152
xorl %eax, %eax
callq 0x2030
jmp 0x38be
movq 0x14c8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2120
movq %rax, 0x13c0(%rsp)
movq 0x13c0(%rsp), %rsi
leaq 0x1008b8(%rip), %rdi    # 0x10419e
xorl %eax, %eax
callq 0x2030
jmp 0x38ef
movq 0x14c0(%rsp), %rsi
movq 0x13c0(%rsp), %rdx
leaq 0x18(%rsp), %rdi
movl $0x400, %ecx            # imm = 0x400
movl $0x10000, %r8d          # imm = 0x10000
callq 0xf7720
jmp 0x3916
leaq 0x18(%rsp), %rdi
callq 0xf7780
jmp 0x3922
movl $0x0, 0x14d4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xf7810
leaq 0x13d8(%rsp), %rdi
callq 0xf7830
jmp 0x3973
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13d0(%rsp)
movl %eax, 0x13cc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xf7810
leaq 0x13d8(%rsp), %rdi
callq 0xf7830
jmp 0x3982
movl 0x14d4(%rsp), %eax
addq $0x14d8, %rsp           # imm = 0x14D8
retq
movq 0x13d0(%rsp), %rdi
callq 0x2280
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x6e20
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x33, %rax
jae 0x6114
movslq -0x1c(%rbp), %rax
leaq 0x2f426(%rip), %rdi     # 0x35500
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3420
cmpq -0x18(%rbp), %rax
jbe 0x6107
movslq -0x1c(%rbp), %rax
leaq 0x2f409(%rip), %rdi     # 0x35500
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3420
movq %rax, -0x18(%rbp)
jmp 0x6109
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60c5
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0x33, %rax
jae 0x622e
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movslq -0x20(%rbp), %rax
shlq $0x5, %rax
leaq 0x2f3bd(%rip), %rdi     # 0x35500
addq %rax, %rdi
callq 0x3420
movq %rax, %rcx
movq -0xa0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x34d0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x20, %edx
callq 0x6e40
jmp 0x618d
leaq -0x41(%rbp), %rdi
callq 0x3320
movslq -0x20(%rbp), %rax
shlq $0x5, %rax
leaq 0x2f35b(%rip), %rsi     # 0x35500
addq %rax, %rsi
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x6ee0
jmp 0x61b7
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6eb0
jmp 0x61c9
leaq -0x78(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x611b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3320
jmp 0x6251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x6251
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x6244
movq -0x88(%rbp), %rdi
callq 0x6f60
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x6f60
movq -0x50(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2ec95(%rip), %rdi     # 0x34fe8
leaq 0x2209e(%rip), %rsi     # 0x283f8
callq 0x32c0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x2208b(%rip), %rsi     # 0x28400
callq 0x32c0
movq %rax, %rdi
movq 0x2ec3c(%rip), %rsi     # 0x34fc0
callq 0x3300
movq 0x2ec58(%rip), %rdi     # 0x34fe8
leaq 0x2207a(%rip), %rsi     # 0x28411
callq 0x32c0
movq %rax, %rdi
movq 0x2ec1a(%rip), %rsi     # 0x34fc0
callq 0x3300
movq 0x2ec36(%rip), %rdi     # 0x34fe8
leaq 0x22099(%rip), %rsi     # 0x28452
callq 0x32c0
movq %rax, %rdi
movq 0x2ebf8(%rip), %rsi     # 0x34fc0
callq 0x3300
movq 0x2ec14(%rip), %rdi     # 0x34fe8
leaq 0x220b8(%rip), %rsi     # 0x28493
callq 0x32c0
movq %rax, %rdi
movq 0x2ebd6(%rip), %rsi     # 0x34fc0
callq 0x3300
movq 0x2ebf2(%rip), %rdi     # 0x34fe8
leaq 0x220d7(%rip), %rsi     # 0x284d4
callq 0x32c0
movq %rax, %rdi
movq 0x2ebb4(%rip), %rsi     # 0x34fc0
callq 0x3300
movq 0x2ebd0(%rip), %rdi     # 0x34fe8
leaq 0x220f6(%rip), %rsi     # 0x28515
callq 0x32c0
movq %rax, %rdi
movq 0x2eb92(%rip), %rsi     # 0x34fc0
callq 0x3300
movl $0x1, %edi
callq 0x3380
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd340
movq -0xd0(%rbp), %rdi
addq $0x20, %rdi
callq 0xd360
movb %al, -0xe1(%rbp)
jmp 0x76a0
movb -0xe1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x76b1
jmp 0x781a
movq -0xd0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x60(%rbp), %rdi
callq 0xd3a0
jmp 0x76c7
movq -0xd0(%rbp), %rdi
leaq -0xc8(%rbp), %rax
movq %rax, -0xf8(%rbp)
callq 0xd420
movq %rax, -0xf0(%rbp)
jmp 0x76ea
movq -0xd0(%rbp), %rsi
movq -0xf8(%rbp), %rax
movq -0xf0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xd4e0
jmp 0x7717
movq -0xd0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xd530
jmp 0x7733
movq -0xd0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xd6f0
jmp 0x7748
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3420
movq -0x110(%rbp), %rcx
movq -0xe0(%rbp), %rdi
notq %rax
addq %rcx, %rax
movq %rax, -0x68(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0xd3f0
jmp 0x778a
leaq -0xc8(%rbp), %rdi
callq 0xd890
leaq -0x60(%rbp), %rdi
callq 0xb430
jmp 0x7688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x7840
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x780f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x77e9
movq -0x108(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd830
movq -0x100(%rbp), %rdi
callq 0x31c0
jmp 0x780f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xd890
leaq -0x60(%rbp), %rdi
callq 0xb430
jmp 0x7840
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7830
movq -0xe0(%rbp), %rdi
callq 0x8180
movq -0xd8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x8180
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x23c40
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x191a0
movl $0x0, -0x4c(%rbp)
movq -0x1c8(%rbp), %rdi
movslq -0x4c(%rbp), %rax
movq %rax, -0x1d0(%rbp)
addq $0x8, %rdi
callq 0xe190
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
cmpq %rcx, %rax
jae 0x8402
movq -0x1c8(%rbp), %rdi
addq $0x8, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x19400
movq %rax, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x19420
jmp 0x8266
movq -0xb8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xb0(%rbp), %rsi
leaq -0x140(%rbp), %rdi
callq 0x3130
jmp 0x8289
leaq -0x90(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0x19660
jmp 0x829e
movq -0x120(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x140(%rbp), %rdx
leaq -0x158(%rbp), %rcx
callq 0x19300
jmp 0x82c1
leaq -0x48(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x19230
jmp 0x82d3
leaq -0x118(%rbp), %rdi
callq 0x193b0
leaq -0x158(%rbp), %rdi
callq 0xd830
leaq -0x140(%rbp), %rdi
callq 0x31c0
leaq -0x1c0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x19420
jmp 0x830c
movq -0x1c8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x23cb0
jmp 0x8325
leaq -0x1c0(%rbp), %rdi
callq 0xd890
leaq -0xb8(%rbp), %rdi
callq 0xd890
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x8213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x83f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x83c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x83bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x193b0
leaq -0x158(%rbp), %rdi
callq 0xd830
leaq -0x140(%rbp), %rdi
callq 0x31c0
jmp 0x83f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xd890
leaq -0xb8(%rbp), %rdi
callq 0xd890
jmp 0x8414
leaq -0x48(%rbp), %rdi
callq 0x19c10
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x19c10
movq -0xc0(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0x118(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
callq 0x33e0
movq -0x100(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xf8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x34d0
movq -0xf0(%rbp), %rdx
leaq 0x20197(%rip), %rsi     # 0x28b06
leaq -0x38(%rbp), %rdi
callq 0x6d70
jmp 0x897a
leaq -0x71(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x34d0
movq -0x120(%rbp), %rdx
leaq 0x2016e(%rip), %rsi     # 0x28b06
leaq -0x70(%rbp), %rdi
callq 0x6d70
jmp 0x89a3
movq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x86d0
jmp 0x89b9
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x71(%rbp), %rdi
callq 0x3320
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3320
movq -0x108(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x128(%rbp)
callq 0x8da0
movq -0x108(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq $0x0, 0xb0(%rdi)
callq 0x3040
jmp 0x8a17
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdi
addq $0x20, %rdi
callq 0x8dc0
jmp 0x8a30
leaq -0xb0(%rbp), %rdi
callq 0x8e00
movq -0x108(%rbp), %rsi
addq $0x20, %rsi
leaq -0xe8(%rbp), %rdi
callq 0x8e20
jmp 0x8a55
leaq -0xb0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xb3e0
movl (%rax), %eax
movl %eax, -0x12c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xb430
movl -0x12c(%rbp), %eax
cmpl $0x4, %eax
je 0x8b1f
movq -0x108(%rbp), %rdi
addq $0x98, %rdi
leaq -0xb0(%rbp), %rsi
callq 0xb450
jmp 0x8aa7
jmp 0x8a3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8aec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8ada
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x71(%rbp), %rdi
callq 0x3320
leaq -0x38(%rbp), %rdi
callq 0x31c0
leaq -0x39(%rbp), %rdi
callq 0x3320
jmp 0x8b68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8b50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb430
jmp 0x8b50
movq -0x108(%rbp), %rdi
addq $0x98, %rdi
leaq -0xb0(%rbp), %rsi
callq 0xb450
jmp 0x8b3b
leaq -0xb0(%rbp), %rdi
callq 0xb430
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0xb4c0
movq -0xf8(%rbp), %rdi
callq 0x8b80
movq -0x100(%rbp), %rdi
callq 0x31c0
movq -0x48(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl $0x1, (%rdi)
addq $0x8, %rdi
leaq -0x64(%rip), %rdx       # 0xba70
callq 0xc0e0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movq 0x70(%rcx), %rcx
movq %rcx, 0x30(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)