LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator+=(V_VALUE const&)
V_VALUE &V_VALUE::operator+=(const V_VALUE &rhs)
{
    switch(type)
    {
        case T_INT:
            v_int+=rhs.toInt();
            break;
        case T_FLOAT:
            v_float+=rhs.toFloat();
            break;
        case T_STRING:
            *v_string+=rhs.toString();
            break;
        case T_ARRAY:
            if(rhs.type==T_ARRAY)
                v_array->insert(v_array->end(),rhs.v_array->begin(),rhs.v_array->end());
            else
                v_array->push_back(rhs);
        default:
            setNull();
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x70(%rbp)
subl $0x3, %eax
ja 0x1561e
movq -0x70(%rbp), %rax
leaq 0x42dba(%rip), %rcx     # 0x582c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x15640
movl %eax, %ecx
movq -0x78(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x15627
movq -0x10(%rbp), %rdi
callq 0x156d0
movq -0x78(%rbp), %rax
cvtss2sd %xmm0, %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x15627
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x15770
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rsi
movq 0x8(%rax), %rdi
callq 0x7410
jmp 0x15571
leaq -0x30(%rbp), %rdi
callq 0x71d0
jmp 0x15627
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x71d0
jmp 0x15634
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x1560b
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rdi
callq 0x109b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x16960
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10b40
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x109b0
movq -0x88(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x168b0
movq %rax, -0x68(%rbp)
jmp 0x1561c
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10790
jmp 0x1561e
movq -0x78(%rbp), %rdi
callq 0x15ac0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x75e0
nopl (%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::toInt() const
int V_VALUE::toInt() const
{
    switch(type)
    {
        case T_INT:
            return v_int;
        case T_FLOAT:
            return v_float;
        case T_STRING:
            return atoi(v_string->c_str());
        case T_BOOL:
            return v_bool;
        default:
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x156b7
movq -0x18(%rbp), %rax
leaq 0x42c66(%rip), %rcx     # 0x582d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x156be
movq -0x20(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x156be
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7120
movq %rax, %rdi
callq 0x7530
movl %eax, -0x4(%rbp)
jmp 0x156be
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x156be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::toFloat() const
float V_VALUE::toFloat() const
{
    switch(type)
    {
        case T_INT:
            return v_int;
        case T_FLOAT:
            return v_float;
        case T_STRING:
            return atof(v_string->c_str());
        case T_BOOL:
            return v_bool;
        default:
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x1575b
movq -0x18(%rbp), %rax
leaq 0x42be6(%rip), %rcx     # 0x582e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x15763
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x15763
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7120
movq %rax, %rdi
callq 0x73e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x15763
movq -0x20(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x15763
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator-=(V_VALUE const&)
V_VALUE &V_VALUE::operator-=(const V_VALUE &rhs)
{
    switch(type)
    {
        case T_INT:
            v_int-=rhs.toInt();
            break;
        case T_FLOAT:
            v_float-=rhs.toFloat();
            break;
        default:
            setNull();
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x15b0e
jmp 0x15b04
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x15b27
jmp 0x15b48
movq -0x10(%rbp), %rdi
callq 0x15640
movl %eax, %edx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0x15b51
movq -0x10(%rbp), %rdi
callq 0x156d0
movq -0x20(%rbp), %rax
cvtss2sd %xmm0, %xmm1
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x15b51
movq -0x20(%rbp), %rdi
callq 0x15ac0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator*=(V_VALUE const&)
V_VALUE &V_VALUE::operator*=(const V_VALUE &rhs)
{
    switch(type)
    {
        case T_INT:
            v_int*=rhs.toInt();
            break;
        case T_FLOAT:
            v_float*=rhs.toFloat();
            break;
        case T_STRING:
            if(int t=rhs.toInt())
            {
                string s=*v_string;
                while(--t)(*v_string)+=s;
            }
            else setNull();
            break;
        default:
            setNull();
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl %eax, -0x48(%rbp)
subl $0x2, %eax
je 0x15b9b
jmp 0x15b84
movl -0x48(%rbp), %eax
subl $0x3, %eax
je 0x15bb6
jmp 0x15b8e
movl -0x48(%rbp), %eax
subl $0x4, %eax
je 0x15bd3
jmp 0x15c46
movq -0x10(%rbp), %rdi
callq 0x15640
movl %eax, %ecx
movq -0x50(%rbp), %rax
imull 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x15c4f
movq -0x10(%rbp), %rdi
callq 0x156d0
movq -0x50(%rbp), %rax
cvtss2sd %xmm0, %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x15c4f
movq -0x10(%rbp), %rdi
callq 0x15640
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x15c3b
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x7130
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x15c30
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7410
jmp 0x15c17
jmp 0x15bf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x71d0
jmp 0x15c59
leaq -0x38(%rbp), %rdi
callq 0x71d0
jmp 0x15c44
movq -0x50(%rbp), %rdi
callq 0x15ac0
jmp 0x15c4f
movq -0x50(%rbp), %rdi
callq 0x15ac0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator++()
V_VALUE &V_VALUE::operator++()
{
    if(type==T_INT)v_int++;
    else if(type==T_FLOAT)v_float++;
    else setNull();
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x2, (%rax)
jne 0x15f08
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x15f34
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x15f29
movq -0x10(%rbp), %rax
movsd 0x42433(%rip), %xmm0    # 0x58350
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x15f32
movq -0x10(%rbp), %rdi
callq 0x15ac0
jmp 0x15f34
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator<(V_VALUE const&) const
bool V_VALUE::operator<(const V_VALUE &rhs) const
{
    switch(type)
    {
        case T_INT:
            return v_int<rhs.toInt();
        case T_FLOAT:
            return v_float<rhs.toFloat();
        case T_STRING:
            return *v_string<rhs.toString();
        default:
            return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x2, %eax
je 0x1645b
jmp 0x16444
movl -0x3c(%rbp), %eax
subl $0x3, %eax
je 0x1647f
jmp 0x1644e
movl -0x3c(%rbp), %eax
subl $0x4, %eax
je 0x164ad
jmp 0x164e3
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15640
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x164e7
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x156d0
movsd -0x58(%rbp), %xmm1
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x164e7
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x15770
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12080
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x71d0
jmp 0x164e7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator==(V_VALUE const&) const
bool V_VALUE::operator==(const V_VALUE &rhs) const
{
    if(type!=rhs.type)return false;
    switch(type)
    {
        case T_NULL:
            return true;
        case T_INT:
            return v_int==rhs.v_int;
        case T_FLOAT:
            return v_float==rhs.v_float;
        case T_BOOL:
            return v_bool==rhs.v_bool;
        case T_STRING:
            return *v_string==*rhs.v_string;
        case T_ARRAY:
            return *v_array==*rhs.v_array;
        case T_OBJECT:
            return *v_object==*rhs.v_object;
        case T_NATIVE_FUNCTION:
            return v_native_function==rhs.v_native_function;
        case T_FUNCTION:
            return v_function.func==rhs.v_function.func&&
                v_function.external==rhs.v_function.external;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x165bb
movb $0x0, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x8, %rax
ja 0x166ec
movq -0x28(%rbp), %rax
leaq 0x41d3e(%rip), %rcx     # 0x58318
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x169a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x16a30
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x16ab0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x166e2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x166ee
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::toBool() const
bool V_VALUE::toBool() const
{
    switch(type)
    {
        case T_INT:
            return v_int;
        case T_FLOAT:
            return v_float;
        case T_NULL:
            return false;
        case T_BOOL:
            return v_bool;
        default:
            return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x167c9
movq -0x18(%rbp), %rax
leaq 0x41bc5(%rip), %rcx     # 0x5833c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x167cd
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x167cd
movb $0x0, -0x1(%rbp)
jmp 0x167cd
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x167cd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/symbol.cpp
// Function: Symbol::lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
SYMTYPE Symbol::lookup(const string &str,int &idx)
{
    if(table.count(str))
    {
        idx=table[str];
        if(scope==SCOPE_GLOBAL)return ST_GLOBAL;
        else return ST_LOCAL;
    }
    if(parent)
    {
        if(scope==SCOPE_FUNCTION)
        {
            auto ret=parent->lookup(str,idx);
            if(ret!=ST_EMPTY&&ret!=ST_GLOBAL)ret=ST_EXTERNAL;
            return ret;
        }
        else return parent->lookup(str,idx);
    }
    return ST_EMPTY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x18850
cmpq $0x0, %rax
je 0x18547
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x188b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %edx
movq -0x20(%rbp), %rcx
movl %edx, (%rcx)
cmpl $0x0, 0x40(%rax)
jne 0x1853e
movl $0x0, -0x4(%rbp)
jmp 0x185ad
movl $0x2, -0x4(%rbp)
jmp 0x185ad
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x185a6
movq -0x30(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0x1858d
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x184e0
movl %eax, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
je 0x18585
cmpl $0x0, -0x24(%rbp)
je 0x18585
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x185ad
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x184e0
movl %eax, -0x4(%rbp)
jmp 0x185ad
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_method.cpp
// Function: astMethodInit()
void astMethodInit()
{
    scope_map.clear();
    CLEAR(continueStack);
    CLEAR(breakStack);
    CLEAR(defaultClauseStack);
    CLEAR(functionStack);
    sp=0;
    this_count=0;
    next_label=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
leaq 0x70846(%rip), %rdi     # 0x8a768
callq 0x1a100
leaq -0x50(%rbp), %rdi
callq 0x1a060
leaq 0x70861(%rip), %rdi     # 0x8a798
leaq -0x50(%rbp), %rsi
callq 0x1a120
leaq -0x50(%rbp), %rdi
callq 0x1a090
leaq -0xa0(%rbp), %rdi
callq 0x1a060
leaq 0x7088c(%rip), %rdi     # 0x8a7e8
leaq -0xa0(%rbp), %rsi
callq 0x1a120
leaq -0xa0(%rbp), %rdi
callq 0x1a090
leaq -0xf0(%rbp), %rdi
callq 0x1a060
leaq 0x708b1(%rip), %rdi     # 0x8a838
leaq -0xf0(%rbp), %rsi
callq 0x1a120
leaq -0xf0(%rbp), %rdi
callq 0x1a090
leaq -0x140(%rbp), %rdi
callq 0x1a0b0
leaq 0x708d6(%rip), %rdi     # 0x8a888
leaq -0x140(%rbp), %rsi
callq 0x1a150
leaq -0x140(%rbp), %rdi
callq 0x1a0e0
movl $0x0, 0x70904(%rip)     # 0x8a8d8
movl $0x0, 0x708fe(%rip)     # 0x8a8dc
movl $0x0, 0x708f8(%rip)     # 0x8a8e0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_ConditionalExpression::print()
DEF_AST_METHOD(ConditionalExpression,AST_PRINT)
{
    PRINTAST(expr);
    PUTS(" ? ");
    PRINTAST(trueExpr);
    PUTS(" : ");
    PRINTAST(falseExpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d8ac(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b39a(%rip), %rdi     # 0x583e0
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d881(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b373(%rip), %rdi     # 0x583e4
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_IfStatement::print()
DEF_AST_METHOD(IfStatement,AST_PRINT)
{
    PUTS("if (");
    PRINTAST(expr);
    PUTS(") ");
    PRINTAST(statement);
    if(elseStatement)
    {
        PUTS("else ");
        PRINTAST(elseStatement);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d76d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b263(%rip), %rdi     # 0x583e8
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d742(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b23d(%rip), %rdi     # 0x583ed
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x1d1dd
jmp 0x1d208
leaq 0x6d704(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b202(%rip), %rdi     # 0x583f0
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_VariableDeclaration::print()
DEF_AST_METHOD(VariableDeclaration,AST_PRINT)
{
    PRINTAST(identifier);
    if(assignExpr)
    {
        PUTS(" = ");
        PRINTAST(assignExpr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x1d248
jmp 0x1d273
leaq 0x6d699(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b19d(%rip), %rdi     # 0x583f6
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_ForStatement::print()
DEF_AST_METHOD(ForStatement,AST_PRINT)
{
    PUTS("for (");
    PRINTAST(init);
    PRINTAST(expr);
    PUTS(";");
    PRINTAST(loopExpr);
    PUTS(") ");
    PRINTAST(statement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d64d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b155(%rip), %rdi     # 0x583fa
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d60d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b11b(%rip), %rdi     # 0x58400
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d5e2(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b0dd(%rip), %rdi     # 0x583ed
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_DoStatement::print()
DEF_AST_METHOD(DoStatement,AST_PRINT)
{
    PUTS("do ");
    PRINTAST(statement);
    PUTS("while (");
    PRINTAST(expr);
    PUTS(");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d59d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b0ad(%rip), %rdi     # 0x58402
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d572(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b086(%rip), %rdi     # 0x58406
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d547(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b063(%rip), %rdi     # 0x5840e
callq 0x7370
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_WhileStatement::print()
DEF_AST_METHOD(WhileStatement,AST_PRINT)
{
    PUTS("while (");
    PRINTAST(expr);
    PUTS(")");
    PRINTAST(statement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d50d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3b021(%rip), %rdi     # 0x58406
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d4e2(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3ae9f(%rip), %rdi     # 0x582af
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_CaseClause::print()
DEF_AST_METHOD(CaseClause,AST_PRINT)
{
    if(expr)
    {
        PUTS("case ");
        PRINTAST(expr);
    }
    else PUTS("default\n");
    PUTS(":\n");
    PRINTAST(stmtList);
    PUTS("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x1d453
jmp 0x1d480
leaq 0x6d48e(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3afae(%rip), %rdi     # 0x58412
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0x1d496
leaq 0x6d461(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3af87(%rip), %rdi     # 0x58418
callq 0x7370
leaq 0x6d44b(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3c437(%rip), %rdi     # 0x598de
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d420(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3c55c(%rip), %rdi     # 0x59a2e
callq 0x7370
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_SwitchStatement::print()
DEF_AST_METHOD(SwitchStatement,AST_PRINT)
{
    PUTS("switch (");
    PRINTAST(expr);
    PUTS(") ");
    PRINTAST(caseBlock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d38d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3aebc(%rip), %rdi     # 0x58421
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d362(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3ae5d(%rip), %rdi     # 0x583ed
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_print.cpp
// Function: AST_FunctionExpression::print()
DEF_AST_METHOD(FunctionExpression,AST_PRINT)
{
    PUTS("function(");
    if(formalParameterList)PRINTAST(formalParameterList);
    PUTS(")");
    PRINTAST(block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6d31d(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3ae55(%rip), %rdi     # 0x5842a
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x1d5ed
jmp 0x1d602
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x6d2df(%rip), %rax     # 0x8a8e8
movq (%rax), %rsi
leaq 0x3ac9c(%rip), %rdi     # 0x582af
callq 0x7370
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_check.cpp
// Function: AST_ForStatement::check(Symbol*)
DEF_AST_METHOD(ForStatement,AST_CHECK)
{
    GET_SCOPE();
    CHECKAST(init);
    CHECKAST(expr);
    CHECKAST(loopExpr);
    CHECKAST(statement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq 0x6aba5(%rip), %rdi     # 0x8a768
leaq -0x18(%rbp), %rsi
callq 0x20310
movq %rax, %rdi
callq 0x203f0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_check.cpp
// Function: AST_ContinueStatement::check(Symbol*)
DEF_AST_METHOD(ContinueStatement,AST_CHECK)
{
    if(
        !MATCHSCOPE(FOR)&&
        !MATCHSCOPE(DO)&&
        !MATCHSCOPE(WHILE))CHECK_ERROR(GET_LITERAL(literal),"unexpection continue");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20113
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20113
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20113
movb $0x1, -0x45(%rbp)
movl $0x70, %edi
callq 0x7180
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0xabd0
addq $0x8, %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x75f0
movq -0x58(%rbp), %rdx
leaq 0x38776(%rip), %rsi     # 0x5880f
leaq -0x30(%rbp), %rdi
callq 0xf990
jmp 0x200a4
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xac90
jmp 0x200b7
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x68b3a(%rip), %rsi     # 0x88c00
leaq 0x213(%rip), %rdx       # 0x202e0
callq 0x75c0
jmp 0x20122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x200f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x71d0
leaq -0x31(%rbp), %rdi
callq 0x7310
testb $0x1, -0x45(%rbp)
jne 0x20108
jmp 0x20111
movq -0x68(%rbp), %rdi
callq 0x7230
jmp 0x20119
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_check.cpp
// Function: AST_BreakStatement::check(Symbol*)
DEF_AST_METHOD(BreakStatement,AST_CHECK)
{
    if(
        !MATCHSCOPE(FOR)&&
        !MATCHSCOPE(DO)&&
        !MATCHSCOPE(WHILE)&&
        !MATCHSCOPE(SWITCH))CHECK_ERROR(GET_LITERAL(literal),"unexpection break");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20259
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20259
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20259
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x185c0
testb $0x1, %al
jne 0x20259
movb $0x1, -0x45(%rbp)
movl $0x70, %edi
callq 0x7180
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0xabd0
addq $0x8, %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x75f0
movq -0x58(%rbp), %rdx
leaq 0x38645(%rip), %rsi     # 0x58824
leaq -0x30(%rbp), %rdi
callq 0xf990
jmp 0x201ea
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xac90
jmp 0x201fd
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x689f4(%rip), %rsi     # 0x88c00
leaq 0xcd(%rip), %rdx        # 0x202e0
callq 0x75c0
jmp 0x20268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2023d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x71d0
leaq -0x31(%rbp), %rdi
callq 0x7310
testb $0x1, -0x45(%rbp)
jne 0x2024e
jmp 0x20257
movq -0x68(%rbp), %rdi
callq 0x7230
jmp 0x2025f
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x75e0
nopl (%rax,%rax)
// File: Eronana[P]strawberry/src/memory.cpp
// Function: mark_alive(void*, DATATYPE)
bool mark_alive(void *p,DATATYPE type)
{
    if(!memory_table.count(p))return false;
    if(memory_table[p].alive)return false;
    memory_table[p].alive=true;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x6912a(%rip), %rdi     # 0x8a8f0
leaq -0x10(%rbp), %rsi
callq 0x21f20
cmpq $0x0, %rax
jne 0x217db
movb $0x0, -0x1(%rbp)
jmp 0x2180d
leaq 0x6910e(%rip), %rdi     # 0x8a8f0
leaq -0x10(%rbp), %rsi
callq 0x21f80
testb $0x1, (%rax)
je 0x217f6
movb $0x0, -0x1(%rbp)
jmp 0x2180d
leaq 0x690f3(%rip), %rdi     # 0x8a8f0
leaq -0x10(%rbp), %rsi
callq 0x21f80
movb $0x1, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Eronana[P]strawberry/src/memory.cpp
// Function: sweep()
void sweep()
{
    // re-calculate total size
    total_size=0;
    for(decltype(memory_table)::iterator next=memory_table.begin(),iter;next!=memory_table.end();)
    {
        iter=next++;
        if(iter->second.alive)
        {
            total_size+=iter->second.size;
            continue;
        }
        switch(iter->second.type)
        {
            case T_STRING:
                delete reinterpret_cast<STRING_TYPE>(iter->first);
                break;
            case T_ARRAY:
                delete reinterpret_cast<ARRAY_TYPE>(iter->first);
                break;
            case T_OBJECT:
                delete reinterpret_cast<OBJECT_TYPE>(iter->first);
                break;
            default:
                break;
        }
        memory_table.erase(iter);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq $0x0, 0x68d7d(%rip) # 0x8a920
leaq 0x68d46(%rip), %rdi     # 0x8a8f0
callq 0x22060
movq %rax, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22220
leaq 0x68d2d(%rip), %rdi     # 0x8a8f0
callq 0x22090
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x220c0
testb $0x1, %al
jne 0x21be2
jmp 0x21d02
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x22240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22280
testb $0x1, 0x8(%rax)
je 0x21c25
leaq -0x10(%rbp), %rdi
callq 0x22280
movq 0x10(%rax), %rax
addq 0x68d04(%rip), %rax     # 0x8a920
movq %rax, 0x68cfd(%rip)     # 0x8a920
jmp 0x21bbc
leaq -0x10(%rbp), %rdi
callq 0x22280
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x4, %eax
je 0x21c52
jmp 0x21c3b
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x21c81
jmp 0x21c45
movl -0x34(%rbp), %eax
subl $0x6, %eax
je 0x21cb0
jmp 0x21cdf
leaq -0x10(%rbp), %rdi
callq 0x22280
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x21c7f
movq -0x40(%rbp), %rdi
callq 0x71d0
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x72d0
jmp 0x21ce1
leaq -0x10(%rbp), %rdi
callq 0x22280
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x21cae
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0x72d0
jmp 0x21ce1
leaq -0x10(%rbp), %rdi
callq 0x22280
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x21cdd
movq -0x50(%rbp), %rdi
callq 0x9720
movq -0x50(%rbp), %rdi
movl $0x30, %esi
callq 0x72d0
jmp 0x21ce1
jmp 0x21ce1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x68bfc(%rip), %rdi     # 0x8a8f0
callq 0x222a0
movq %rax, -0x30(%rbp)
jmp 0x21bbc
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_ForStatement::fill(Symbol*)
DEF_AST_METHOD(ForStatement,AST_FILL)
{
    ENTRY_SCOPE(FOR);
    FILLAST(init);
    FILLAST(expr);
    FILLAST(loopExpr);
    FILLAST(statement);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x181d0
jmp 0x2525f
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25c90
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25d20
jmp 0x25293
leaq 0x654ce(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x25ce0
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x252ac
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25d60
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x2539b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x25392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25d60
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x18(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_DoStatement::fill(Symbol*)
DEF_AST_METHOD(DoStatement,AST_FILL)
{
    ENTRY_SCOPE(DO);
    FILLAST(statement);
    FILLAST(expr);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x181d0
jmp 0x253ef
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25c90
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25dc0
jmp 0x25423
leaq 0x6533e(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x25d80
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x2543c
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25e00
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x254f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x254ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25e00
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x18(%rbp), %rdi
callq 0x75e0
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_WhileStatement::fill(Symbol*)
DEF_AST_METHOD(WhileStatement,AST_FILL)
{
    ENTRY_SCOPE(WHILE);
    FILLAST(expr);
    FILLAST(statement);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x181d0
jmp 0x2553f
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25c90
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25e60
jmp 0x25573
leaq 0x651ee(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x25e20
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x2558c
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25ea0
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x25647
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2563e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25ea0
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x18(%rbp), %rdi
callq 0x75e0
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_SwitchStatement::fill(Symbol*)
DEF_AST_METHOD(SwitchStatement,AST_FILL)
{
    ENTRY_SCOPE(SWITCH);
    FILLAST(expr);
    FILLAST(caseBlock);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0x5, %edx
callq 0x181d0
jmp 0x2572f
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25c90
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25f00
jmp 0x25763
leaq 0x64ffe(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x25ec0
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x2577c
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25f40
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x25837
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2582e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25f40
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x18(%rbp), %rdi
callq 0x75e0
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_FunctionExpression::fill(Symbol*)
DEF_AST_METHOD(FunctionExpression,AST_FILL)
{
    ENTRY_SCOPE(FUNCTION);
    if(formalParameterList)FILLAST(formalParameterList);
    FILLAST(block);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x181d0
jmp 0x2587f
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x25c90
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25fa0
jmp 0x258b3
leaq 0x64eae(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x25f60
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x258cc
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25fe0
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x258ff
jmp 0x25965
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x25965
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x2599e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2595a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25fe0
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
jmp 0x2599e
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x75e0
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_fill.cpp
// Function: AST_Program::fill(Symbol*)
DEF_AST_METHOD(Program,AST_FILL)
{
    ENTRY_SCOPE(GLOBAL);
    symbol->insert("system");
    FILLAST(stmtList);
    EXIT_SCOPE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x48, %edi
callq 0x72c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x181d0
jmp 0x25a6f
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x25c90
movq -0x90(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x26040
jmp 0x25aac
leaq 0x64cb5(%rip), %rdi     # 0x8a768
leaq -0x30(%rbp), %rsi
callq 0x26000
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x25acb
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movb %al, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26080
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x75f0
movq -0xa8(%rbp), %rdx
leaq 0x32d4b(%rip), %rsi     # 0x58865
leaq -0x70(%rbp), %rdi
callq 0xf990
jmp 0x25b25
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x182f0
jmp 0x25b37
leaq -0x70(%rbp), %rdi
callq 0x71d0
leaq -0x71(%rbp), %rdi
callq 0x7310
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x18680
movq -0x10(%rbp), %rdi
callq 0x184c0
movq %rax, -0x10(%rbp)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x72d0
jmp 0x25bfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x25bc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26080
leaq -0x40(%rbp), %rdi
callq 0x1a4b0
jmp 0x25bfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x25bf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x71d0
leaq -0x71(%rbp), %rdi
callq 0x7310
movq -0x18(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
nop
// File: Eronana[P]strawberry/src/parser.cpp
// Function: Parser::isLiteral()
bool Parser::isLiteral()
{
    return accept(TOKEN_BIN_INTEGER_LITERAL)||
    accept(TOKEN_OCT_INTEGER_LITERAL)||
    accept(TOKEN_DEC_INTEGER_LITERAL)||
    accept(TOKEN_HEX_INTEGER_LITERAL)||
    accept(TOKEN_FLOAT_LITERAL)||
    accept(TOKEN_STRING_LITERAL)||
    accept(TOKEN_BOOL_LITERAL)||
    accept(TOKEN_NULL_LITERAL)||
    accept(TOKEN_IDENTIFIER);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x30, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x31, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x32, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x33, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x36, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x34, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x35, %esi
xorl %edx, %edx
callq 0x27960
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x27b13
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x27960
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop