LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/buildin.cpp
// Function: build_innew_(int, VirtualMachine&)
BUILD_FUNC_SIGN(new)
{
    // puts("--------[ BUILD_FUNC_SIGN(new) ]--------");
    // for(int i=0;i<ARGC;i++)puts(GET_ARGV(i).toString().c_str());
    auto &f=GET_ARGV(0);
    V_VALUE o;
    o.type=T_OBJECT;
    o.v_object=newObject();
    o[string("__proto__")].type=T_OBJECT;
    o[string("__proto__")].v_object=f.v_function.prototype;
    o[string("constructor")]=f;
    vm.push(f); // function
    vm.push(f); // callee
    vm.push(o); // this
    for(int i=0;i<ARGC-1;i++)vm.push(GET_ARGV(ARGC+2));
    vm.callReturn(ARGC);
    vm.reg_ret=o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x70(%rsi), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xc59c
movl $0x6, (%r12)
callq 0x10ea2
movq %rax, 0x8(%r12)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x13e65(%rip), %rsi     # 0x2018f
leaq 0x13e67(%rip), %rdx     # 0x20198
leaq 0x8(%rsp), %rdi
callq 0xb1a2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd3c
movl $0x6, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc367
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq -0x8(%r15), %r13
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13e15(%rip), %rsi     # 0x2018f
leaq 0x13e17(%rip), %rdx     # 0x20198
callq 0xb1a2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd3c
movq %r13, 0x8(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc3b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13ef1(%rip), %rsi     # 0x202b0
leaq 0x13ef5(%rip), %rdx     # 0x202bb
callq 0xb1a2
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd3c
addq $-0x20, %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc405
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa18
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa18
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xaa18
cmpl $0x4, %r14d
jl 0xc454
movl %r14d, %r15d
negq %r15
leal -0x3(%r14), %ebp
shlq $0x5, %r15
movq 0x70(%rbx), %rax
leaq (%rax,%r15), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0xaa18
decl %ebp
jne 0xc43c
addl $-0x2, %r14d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xaae6
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x498(%rbx)
movups %xmm0, 0x488(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc497
jmp 0xc4b3
jmp 0xc497
jmp 0xc4b3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc4b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc4b6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0xc675
movq %rsi, %rdx
leaq 0x13cf6(%rip), %rcx     # 0x202bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0xc6ae
addl %eax, 0x8(%rbx)
jmp 0xc67c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xc720
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x60e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc67c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc67c
cmpl $0x5, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rsi
jne 0xc653
movq 0x8(%rdx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xd00c
jmp 0xc675
movq %rdx, %rdi
callq 0xc6e0
cvtss2sd %xmm0, %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xc67c
cmpq 0x10(%rdi), %rsi
je 0xc670
movupd (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
addq $0x20, 0x8(%rdi)
jmp 0xc675
callq 0xaea0
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xc6dd
leaq 0x13c0e(%rip), %rcx     # 0x202cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %eax
retq
cvttsd2si 0x8(%rdi), %eax
retq
movq 0x8(%rdi), %rax
movq (%rax), %rdi
jmp 0x63f0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xc71b
leaq 0x13bec(%rip), %rcx     # 0x202dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssl 0x8(%rdi), %xmm0
retq
cvtsd2ss 0x8(%rdi), %xmm0
retq
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
callq 0x62f0
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::toString[abi:cxx11]() const
string V_VALUE::toString() const
{
    char s[30];
    switch(type)
    {
        case T_INT:
            sprintf(s,"%d",v_int);
            return s;
        case T_FLOAT:
            sprintf(s,"%f",v_float);
            return s;
        case T_STRING:
            return *v_string;
        case T_BOOL:
            return v_bool?"true":"false";
        case T_NATIVE_FUNCTION:
            return "[Native Function]";
        case T_FUNCTION:
            return "[Finction]";
        case T_ARRAY:
            return "[Array]";
        case T_OBJECT:
            return "[OBJECT]";
        case T_NULL:
            return "null";
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x13bb9(%rip), %rcx     # 0x202ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13c92(%rip), %rsi     # 0x203dc
leaq 0x13c8f(%rip), %rdx     # 0x203e0
jmp 0xc84e
movq 0x8(%rsi), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7ce8
jmp 0xc856
movl 0x8(%rsi), %edx
leaq 0x14c83(%rip), %rsi     # 0x21405
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x6070
jmp 0xc7aa
movsd 0x8(%rsi), %xmm0
leaq 0x13c03(%rip), %rsi     # 0x203a0
movq %rsp, %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x6070
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x6130
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xc851
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13bd8(%rip), %rsi     # 0x203ae
leaq 0x13be2(%rip), %rdx     # 0x203bf
jmp 0xc84e
xorl %eax, %eax
cmpl $0x0, 0x8(%rsi)
leaq 0x13bbc(%rip), %rcx     # 0x203a8
leaq 0x13bb0(%rip), %rsi     # 0x203a3
cmoveq %rcx, %rsi
sete %al
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rsi,%rax), %rdx
addq $0x4, %rdx
jmp 0xc84e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13bb2(%rip), %rsi     # 0x203cb
leaq 0x13bb2(%rip), %rdx     # 0x203d2
jmp 0xc84e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13ba3(%rip), %rsi     # 0x203d3
leaq 0x13ba4(%rip), %rdx     # 0x203db
jmp 0xc84e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13b79(%rip), %rsi     # 0x203c0
leaq 0x13b7c(%rip), %rdx     # 0x203ca
movq %rbx, %rdi
callq 0xb1a2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x3, %eax
je 0xc887
cmpl $0x2, %eax
jne 0xc8a3
movq %rsi, %rdi
callq 0xc6ae
subl %eax, 0x8(%rbx)
jmp 0xc8aa
movq %rsi, %rdi
callq 0xc6e0
cvtss2sd %xmm0, %xmm0
movsd 0x8(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
jmp 0xc8aa
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x4, %eax
je 0xc8f2
cmpl $0x3, %eax
je 0xc8da
cmpl $0x2, %eax
jne 0xc937
movq %rsi, %rdi
callq 0xc6ae
imull 0x8(%rbx), %eax
jmp 0xc93b
movq %rsi, %rdi
callq 0xc6e0
cvtss2sd %xmm0, %xmm0
mulsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xc93e
movq %rsi, %rdi
callq 0xc6ae
testl %eax, %eax
je 0xc937
movl %eax, %ebp
movq 0x8(%rbx), %rax
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x7ce8
decl %ebp
je 0xc94a
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x60e0
jmp 0xc91f
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xc93e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc93e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xc97b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movl (%rdi), %ecx
cmpl $0x3, %ecx
je 0xcad3
cmpl $0x2, %ecx
jne 0xcae6
incl 0x8(%rax)
retq
movsd 0x8(%rax), %xmm0
addsd 0x13898(%rip), %xmm0    # 0x20378
movsd %xmm0, 0x8(%rax)
retq
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
cmpl $0x4, %eax
je 0xcd90
cmpl $0x3, %eax
je 0xcd70
cmpl $0x2, %eax
jne 0xcdce
movl 0x8(%rdi), %ebx
movq %rsi, %rdi
callq 0xc6ae
cmpl %eax, %ebx
setl %bl
jmp 0xcdd0
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %rsi, %rdi
callq 0xc6e0
cvtss2sd %xmm0, %xmm0
ucomisd (%rsp), %xmm0
seta %bl
jmp 0xcdd0
movq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc720
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6040
movl %eax, %ebx
shrl $0x1f, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcdd0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xcdd0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x79c5
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xcf27
movb $0x1, %bl
movl %eax, %eax
leaq 0x13505(%rip), %rcx     # 0x20330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jmp 0xce8a
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %rdx
cmpq 0x8(%rcx), %rdx
jne 0xcf27
testq %rdx, %rdx
je 0xcf29
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x6240
testl %eax, %eax
jmp 0xce8a
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0xcf29
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %bl
jmp 0xcf29
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r14
movq 0x8(%rax), %r12
movq %r12, %rax
subq %r14, %rax
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
subq %r15, %rcx
cmpq %rcx, %rax
jne 0xcf27
cmpq %r12, %r14
sete %bl
je 0xcf29
movq %r14, %rdi
movq %r15, %rsi
callq 0xce0e
testb %al, %al
je 0xcf29
addq $0x20, %r14
addq $0x20, %r15
cmpq %r12, %r14
sete %bl
je 0xcf29
movq %r14, %rdi
movq %r15, %rsi
callq 0xce0e
addq $0x20, %r14
addq $0x20, %r15
testb %al, %al
jne 0xced5
jmp 0xcf29
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0xcf27
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd210
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
sete %al
movq 0x10(%rsi), %rcx
cmpq %rcx, 0x10(%rdi)
sete %bl
andb %al, %bl
jmp 0xcf29
nop
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/vm_data.cpp
// Function: V_VALUE::operator bool()
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:
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0xcf90
leaq 0x133eb(%rip), %rcx     # 0x20354
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x8(%rdi)
setne %al
retq
xorl %eax, %eax
retq
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %r12
movq %r12, %rdi
callq 0xd788
leaq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0xd4ac
movq %r12, %rdi
movq %r15, %rsi
callq 0xd518
movl (%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x40(%r14)
setne %al
addl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd4da
movl 0x40(%r14), %ebp
movq %r15, %rsi
movq %rbx, %rdx
callq 0xd462
cmpl $0x1, %ebp
jne 0xd4a3
testl %eax, %eax
movl $0x1, %ecx
cmovel %eax, %ecx
cmpl $0x3, %eax
cmovnel %ecx, %eax
jmp 0xd4a3
movl $0x3, %eax
jmp 0xd4a3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x20f87(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11b90(%rip), %rdi     # 0x2041b
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11b7c(%rip), %rdi     # 0x2041f
callq 0x6280
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20efc(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11b0d(%rip), %rdi     # 0x20423
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11afa(%rip), %rdi     # 0x20428
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpq $0x0, 0x18(%rbx)
je 0xe962
movq (%r14), %rsi
leaq 0x11ade(%rip), %rdi     # 0x2042b
callq 0x6280
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpq $0x0, 0x10(%rbx)
je 0xe99e
leaq 0x20e83(%rip), %rax     # 0x2f808
movq (%rax), %rsi
leaq 0x11aa2(%rip), %rdi     # 0x20431
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20e5a(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11a7d(%rip), %rdi     # 0x20435
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a62(%rip), %rdi     # 0x2043b
callq 0x6280
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a37(%rip), %rdi     # 0x20428
callq 0x6280
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20df4(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11a1f(%rip), %rdi     # 0x2043d
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a0b(%rip), %rdi     # 0x20441
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x119fb(%rip), %rdi     # 0x20449
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6280
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20da0(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x119cf(%rip), %rdi     # 0x20441
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x1181f(%rip), %rdi     # 0x202a9
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
leaq 0x20d55(%rip), %r14     # 0x2f808
movq (%r14), %rsi
je 0xeacf
leaq 0x1198e(%rip), %rdi     # 0x2044d
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0xeadb
leaq 0x1197d(%rip), %rdi     # 0x20453
callq 0x6280
movq (%r14), %rsi
leaq 0x12c0d(%rip), %rdi     # 0x216f2
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x12d45(%rip), %rdi     # 0x21842
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20cb4(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x118fe(%rip), %rdi     # 0x2045c
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x118b2(%rip), %rdi     # 0x20428
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20c6e(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x118c1(%rip), %rdi     # 0x20465
callq 0x6280
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xebb7
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x116e8(%rip), %rdi     # 0x202a9
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x1f090(%rip), %rdi     # 0x2f688
callq 0x10aac
movq (%rax), %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2, %esi
callq 0xd4e2
testb %al, %al
jne 0x1088f
movq %rbx, %rdi
movl $0x3, %esi
callq 0xd4e2
testb %al, %al
jne 0x1088f
movq %rbx, %rdi
movl $0x4, %esi
callq 0xd4e2
testb %al, %al
je 0x1089a
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq 0x8(%r14), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xff94(%rip), %rsi      # 0x2084f
leaq 0xffa1(%rip), %rdx      # 0x20863
leaq 0x8(%rsp), %rdi
callq 0xb1a2
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7be0
xorl %ebp, %ebp
leaq 0x1d34c(%rip), %rsi     # 0x2dc38
leaq 0x169(%rip), %rdx       # 0x10a5c
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1091d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x1091d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1092a
movq %rbx, %rdi
callq 0x61c0
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2, %esi
callq 0xd4e2
testb %al, %al
jne 0x10986
movq %rbx, %rdi
movl $0x3, %esi
callq 0xd4e2
testb %al, %al
jne 0x10986
movq %rbx, %rdi
movl $0x4, %esi
callq 0xd4e2
testb %al, %al
jne 0x10986
movq %rbx, %rdi
movl $0x5, %esi
callq 0xd4e2
testb %al, %al
je 0x10991
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x6140
movq %rax, %rbx
movq 0x8(%r14), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfeb2(%rip), %rsi      # 0x20864
leaq 0xfebc(%rip), %rdx      # 0x20875
leaq 0x8(%rsp), %rdi
callq 0xb1a2
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7be0
xorl %ebp, %ebp
leaq 0x1d255(%rip), %rsi     # 0x2dc38
leaq 0x72(%rip), %rdx        # 0x10a5c
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10a14
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x10a14
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x10a21
movq %rbx, %rdi
callq 0x61c0
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq %rdi, (%rsp)
movq 0x1e88e(%rip), %rdx     # 0x2f820
leaq 0x1e87f(%rip), %rax     # 0x2f818
movq %rax, %rcx
testq %rdx, %rdx
je 0x10fc0
leaq 0x1e870(%rip), %rcx     # 0x2f818
xorl %esi, %esi
cmpq %rdi, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x10fa8
cmpq %rax, %rcx
je 0x10fdf
cmpq %rdi, 0x20(%rcx)
ja 0x10fdf
leaq 0x1e83e(%rip), %rdi     # 0x2f810
movq %rsp, %rsi
callq 0x1131a
cmpb $0x0, (%rax)
je 0x10fe3
xorl %eax, %eax
popq %rcx
retq
leaq 0x1e826(%rip), %rdi     # 0x2f810
movq %rsp, %rsi
callq 0x1131a
movb $0x1, (%rax)
movb $0x1, %al
jmp 0x10fe1
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/memory.cpp
// Function: mark_value(V_VALUE&)
void mark_value(V_VALUE &val)
{
    switch(val.type)
    {
        case T_STRING:
            mark_alive(val.v_string,T_STRING);
            break;
        case T_ARRAY:
            if(mark_alive(val.v_array,T_ARRAY))for(auto &x:*val.v_array)mark_value(x); 
            break;
        case T_OBJECT:
            if(mark_alive(val.v_object,T_OBJECT))for(auto &x:*val.v_object)mark_value(x.second);
            break;
        case T_FUNCTION:
            if(mark_alive(val.v_function.external,T_ARRAY))for(auto &x:*val.v_function.external)mark_value(x);
            if(mark_alive(val.v_function.prototype,T_OBJECT))for(auto &x:*val.v_function.prototype)mark_value(x.second);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x4, %eax
ja 0x11102
movq %rdi, %rbx
leaq 0xf862(%rip), %rcx      # 0x20878
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10f86
movq 0x8(%rbx), %rdi
callq 0x10f86
testb %al, %al
je 0x11102
movq 0x8(%rbx), %r14
movq 0x18(%r14), %rbx
addq $0x8, %r14
cmpq %r14, %rbx
je 0x11102
leaq 0x40(%rbx), %rdi
callq 0x10ff9
movq %rbx, %rdi
callq 0x61a0
movq %rax, %rbx
cmpq %r14, %rax
jne 0x11053
jmp 0x11102
movq 0x8(%rbx), %rdi
callq 0x10f86
testb %al, %al
je 0x11102
movq 0x8(%rbx), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x11102
movq %rbx, %rdi
callq 0x10ff9
addq $0x20, %rbx
jmp 0x1108d
movq 0x10(%rbx), %rdi
callq 0x10f86
testb %al, %al
je 0x110cb
movq 0x10(%rbx), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x110cb
movq %r14, %rdi
callq 0x10ff9
addq $0x20, %r14
jmp 0x110b8
movq 0x18(%rbx), %rdi
callq 0x10f86
testb %al, %al
je 0x11102
movq 0x18(%rbx), %r14
movq 0x18(%r14), %rbx
addq $0x8, %r14
cmpq %r14, %rbx
je 0x11102
leaq 0x40(%rbx), %rdi
callq 0x10ff9
movq %rbx, %rdi
callq 0x61a0
movq %rax, %rbx
cmpq %r14, %rax
jne 0x110e9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x0, 0x1e68b(%rip) # 0x2f840
movq 0x1e66c(%rip), %r14     # 0x2f828
leaq 0x1e655(%rip), %r13     # 0x2f818
cmpq %r13, %r14
je 0x1128c
leaq 0x1e63d(%rip), %rbx     # 0x2f810
movq %r14, %rdi
callq 0x61a0
movq %rax, %r15
cmpb $0x1, 0x28(%r14)
jne 0x111f5
movq 0x30(%r14), %rax
addq %rax, 0x1e650(%rip)     # 0x2f840
jmp 0x11280
movl 0x38(%r14), %eax
cmpl $0x6, %eax
je 0x11257
cmpl $0x5, %eax
je 0x11231
cmpl $0x4, %eax
jne 0x11275
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x11275
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rax, %rdi
je 0x1122a
movq (%rax), %rsi
incq %rsi
callq 0x6230
movl $0x20, %esi
jmp 0x1126d
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x11275
movq (%r12), %rdi
testq %rdi, %rdi
je 0x11250
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x6230
movl $0x18, %esi
jmp 0x1126d
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x11275
movq %r12, %rdi
callq 0x7b18
movl $0x30, %esi
movq %r12, %rdi
callq 0x6230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x117d8
movq %r15, %r14
cmpq %r13, %r15
jne 0x111d3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d890(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x123ee
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x11e89
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d7ae(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x124b2
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x11f51
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d6e6(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x12576
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x12019
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movl $0x5, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d5dc(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x1263a
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x12123
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d514(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x126fe
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x121a2
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x121f0
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x6220
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xd298
leaq 0x18(%rsp), %r15
movq %r14, -0x8(%r15)
movq %rbx, (%r15)
movq $0x0, 0x8(%rsp)
leaq 0x1d431(%rip), %rdi     # 0x2f688
leaq 0x10(%rsp), %rsi
callq 0x127c2
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe616(%rip), %rsi      # 0x20899
leaq 0xe615(%rip), %rdx      # 0x2089f
leaq 0x10(%rsp), %rdi
callq 0xb1a2
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xd32e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x122b8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6230
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xd510
movq %rbx, %rdi
callq 0xd45e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x12322
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x1231d
movq %rax, %r14
jmp 0x12322
movq %rax, %r14
movq %r15, %rdi
callq 0xdc0a
leaq 0x8(%rsp), %rdi
callq 0xdc0a
jmp 0x12322
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x6230
movq %r14, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x1288c
movb $0x1, %bl
cmpl $0x30, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x31, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x32, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x33, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x36, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x2f, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x34, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x35, (%rax)
je 0x12a8c
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x2e, (%rax)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::isUnaryOperator()
bool Parser::isUnaryOperator()
{
    return accept("typeof")||
    accept(TOKEN_INCREMENT)||
    accept(TOKEN_DECREMENT)||
    accept(TOKEN_ADD)||
    accept(TOKEN_SUB)||
    accept(TOKEN_BITWISE_NOT)||
    accept(TOKEN_NEGATION);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xddee(%rip), %rsi      # 0x208a0
leaq 0xdded(%rip), %rdx      # 0x208a6
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xb1a2
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x129aa
movb $0x1, %bl
testb %al, %al
jne 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x2, (%rax)
je 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x5, (%rax)
je 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x4, (%rax)
je 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x7, (%rax)
je 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x1a, (%rax)
je 0x12b32
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x1e, (%rax)
sete %bl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12b48
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12b6d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::isRelationalOperator()
bool Parser::isRelationalOperator()
{
    return accept(TOKEN_LESS)||
    accept(TOKEN_GREATER)||
    accept(TOKEN_LESS_EQUAL)||
    accept(TOKEN_GREATER_EQUAL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x1288c
movb $0x1, %bl
cmpl $0x27, (%rax)
je 0x12c47
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x23, (%rax)
je 0x12c47
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x28, (%rax)
je 0x12c47
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x24, (%rax)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::isAssignmentOperator()
bool Parser::isAssignmentOperator()
{
    return accept(TOKEN_ASSIGN)||
    accept(TOKEN_MUL_ASSIGN)||
    accept(TOKEN_DIV_ASSIGN)||
    accept(TOKEN_MOD_ASSIGN)||
    accept(TOKEN_ADD_ASSIGN)||
    accept(TOKEN_SUB_ASSIGN)||
    accept(TOKEN_LEFT_SHIFT_ASSIGN)||
    accept(TOKEN_RIGHT_SHIFT_ASSIGN)||
    accept(TOKEN_BITWISE_AND_ASSIGN)||
    accept(TOKEN_BITWISE_XOR_ASSIGN)||
    accept(TOKEN_BITWISE_OR_ASSIGN);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x1288c
movb $0x1, %bl
cmpl $0x20, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x8, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0xa, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0xc, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x3, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x6, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x25, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x21, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x18, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x1b, (%rax)
je 0x12d2e
movq %r14, %rdi
xorl %esi, %esi
callq 0x1288c
cmpl $0x15, (%rax)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::PrefixExpression()
AST_PTR Parser::PrefixExpression()
{
    if(isUnaryOperator())
    {
        DEF_AST_RET(PrefixExpression);
        ret->optr=Literal();
        ret->expr=PrefixExpression();
        RETURN_PTR;
    }
    else return PostfixExpression();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x12a96
testb %al, %al
je 0x12f32
movl $0x18, %edi
callq 0x6220
movq %rax, %r14
leaq 0x1b80b(%rip), %rax     # 0x2e6b8
addq $0x10, %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x138e6
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq 0x10(%r14), %rdi
movq %rax, 0x10(%r14)
testq %rdi, %rdi
je 0x12eea
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x12e7a
movq %r14, %rax
addq $0x8, %rax
movq 0x8(%rsp), %rcx
movq $0x0, 0x8(%rsp)
movq (%rax), %rdi
movq %rcx, (%rax)
testq %rdi, %rdi
je 0x12f1d
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12f2d
movq (%rdi), %rax
callq *0x28(%rax)
movq %r14, (%rbx)
jmp 0x12f3d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15472
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x12f4c
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O1/Eronana[P]strawberry/src/parser.cpp
// Function: Parser::OperationList(bool (Parser::*)(), std::unique_ptr<AST, std::default_delete<AST>> (Parser::*)())
AST_PTR Parser::OperationList(PARSER_BOOL_FUNC bool_func,PARSER_AST_FUNC ast_func)
{
    DEF_AST_RET(OperationList);
    do
    {
        ret->nodes.push_back(Operation(ast_func));
    }while((this->*bool_func)());
    RETURN_PTR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
movl $0x20, %edi
callq 0x6220
leaq 0x1b2ab(%rip), %rcx     # 0x2e240
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
addq %r13, %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq 0x20(%rsp), %rcx
callq 0x15562
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18d1e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12fea
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbp, %rax
testb $0x1, %bpl
je 0x12ffc
movq (%r12), %rax
movq -0x1(%rax,%rbp), %rax
movq %r12, %rdi
callq *%rax
testb %al, %al
jne 0x12fbc
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13044
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13039
movq (%rdi), %rax
callq *0x28(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x13047
movq %rax, %rbx
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, %rdi
callq 0x6450