LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_CREATE_FUNCTION()
DEF_FUNC(CREATE_FUNCTION)
{
    ARRAY_TYPE external=STOP.v_array;
    STOP.type=T_FUNCTION;
    auto prototype = newObject();
    (*prototype)["__proto__"]=reg_system["prototypes"][string("Function")];
    STOP.v_function={get_int32(),external,prototype};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq -0x18(%rax), %r13
movl $0x8, -0x20(%rax)
callq 0x10e9c
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x17ea0(%rip), %rsi     # 0x20184
leaq 0x17ea3(%rip), %rdx     # 0x2018e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xb1b4
leaq 0x4a8(%rbx), %rdi
movq %r15, %rsi
callq 0xac8e
movq %rax, %r15
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x17e61(%rip), %rsi     # 0x2017b
leaq 0x17e62(%rip), %rdx     # 0x20183
leaq 0x48(%rsp), %rdi
callq 0xb1b4
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0xcd5c
movq %rax, %r15
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x17e43(%rip), %rsi     # 0x2018f
leaq 0x17e45(%rip), %rdx     # 0x20198
leaq 0x28(%rsp), %rdi
callq 0xb1b4
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xac8e
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x8391
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6230
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x83a8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6230
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x83c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movslq 0x500(%rbx), %rax
movq 0x60(%rbx), %rcx
movq 0x70(%rbx), %rdx
movl 0x1(%rcx,%rax), %eax
movl %eax, -0x18(%rdx)
movq %r13, -0x10(%rdx)
movq %r14, -0x8(%rdx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x8412
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x8412
jmp 0x840f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8430
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x8430
jmp 0x842d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x844c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_OBJECT_SET()
DEF_FUNC(OBJECT_SET)
{
    if(reg_this.type==T_OBJECT)
    {
        string key=SPOP.toString();
        object_set(reg_this,key,STOP);
    }
    
    else if(reg_this.type==T_ARRAY)
    {
        int key=SPOP.toInt();
        (*reg_this.v_array)[key]=STOP;
    }
    else STOP.setNull();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x468(%rdi), %eax
cmpl $0x5, %eax
je 0x8e49
cmpl $0x6, %eax
jne 0x8eac
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
leaq 0x20(%rsp), %r14
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
decq %rsi
callq 0xb010
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc740
movq 0x70(%rbx), %r14
movq 0x470(%rbx), %rdi
movq %r15, %rsi
callq 0xad48
movups -0x20(%r14), %xmm0
movups -0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ea2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0x8ea2
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
movq %rsp, %r14
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
decq %rsi
callq 0xb010
movq %r14, %rdi
callq 0xc6ce
movq 0x70(%rbx), %rcx
movq 0x470(%rbx), %rdx
cltq
movq (%rdx), %rdx
shlq $0x5, %rax
movups -0x20(%rcx), %xmm0
movups -0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rdx,%rax)
movups %xmm0, (%rdx,%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rdi
addq $-0x20, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xc882
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ee0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_ADD()
DEF_FUNC(ADD)
{
    auto a=SPOP;
    if(STOP.type==T_STRING)
    {
        STRING_TYPE s=newString();
        *s=*STOP.v_string+a.toString();
        STOP.v_string=s;
    }
    else STOP+=a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
addq $0x68, %rdi
movq 0x70(%rbx), %rsi
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
decq %rsi
callq 0xb010
movq 0x70(%rbx), %rdi
cmpl $0x4, -0x20(%rdi)
jne 0x91e9
callq 0x10d24
movq %rax, %r14
movq 0x70(%rbx), %rax
movq -0x18(%rax), %r12
movq %rsp, %r15
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0xc740
movq (%r12), %rcx
movq 0x8(%r12), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6290
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x91f9
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x9201
addq $-0x20, %rdi
leaq 0x40(%rsp), %rsi
callq 0xc5c4
jmp 0x9260
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x62e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x923d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6230
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9258
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq 0x70(%rbx), %rax
movq %r14, -0x18(%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x928a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::call(int)
void VirtualMachine::call(int argc)
{
    V_VALUE &func=v_stack.top(argc);
    if(func.type==T_FUNCTION)
    {
        stack_frame.push({l_stack,next_ip,v_stack.size()-argc});
        l_stack=v_stack.size();
        ip=func.v_function.func;
        KEEP_INS;
    }
    else if(func.type==T_NATIVE_FUNCTION)
    {
        auto size=v_stack.size();
        reg_ret.setNull();
        func.v_native_function(argc,*this);
        v_stack.resize(size);
        v_stack.sub(argc);
        STOP=reg_ret;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %r15
movslq %esi, %r14
movq %r14, %rax
shlq $0x5, %rax
movq %r15, %r13
subq %rax, %r13
negq %rax
movl -0x20(%r15,%rax), %eax
cmpl $0x7, %eax
je 0x992b
cmpl $0x8, %eax
jne 0x9989
movl 0x80(%rbx), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl 0x504(%rbx), %eax
movl %eax, 0x4(%rsi)
subq 0x68(%rbx), %r15
leaq 0x88(%rbx), %rdi
sarq $0x5, %r15
subq %r14, %r15
movq %r15, 0x8(%rsi)
callq 0xba90
movq 0x70(%rbx), %rax
subq 0x68(%rbx), %rax
shrq $0x5, %rax
movl %eax, 0x80(%rbx)
movl -0x18(%r13), %eax
movl %eax, 0x500(%rbx)
movl %eax, 0x504(%rbx)
jmp 0x9989
leaq 0x68(%rbx), %r12
subq 0x68(%rbx), %r15
sarq $0x5, %r15
leaq 0x488(%rbx), %rdi
callq 0xc882
movl %r14d, %edi
movq %rbx, %rsi
callq *-0x18(%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0xb010
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
subq %r14, %rsi
movq %r12, %rdi
callq 0xb010
movq 0x70(%rbx), %rax
movups 0x498(%rbx), %xmm0
movups %xmm0, -0x10(%rax)
movups 0x488(%rbx), %xmm0
movups %xmm0, -0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::F_RET()
DEF_FUNC(RET)
{
    l_stack=stack_frame.top().sp;
    ip=stack_frame.top().ip;
    KEEP_INS;
    reg_ret=STOP;
    v_stack.resize(stack_frame.top().size);
    STOP=reg_ret;
    stack_frame.pop();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
je 0x99eb
movl -0x10(%rax), %ecx
movl %ecx, 0x80(%rbx)
movl -0xc(%rax), %ecx
movl %ecx, 0x500(%rbx)
movl %ecx, 0x504(%rbx)
movq 0x70(%rbx), %rcx
leaq 0x488(%rbx), %r15
movups -0x20(%rcx), %xmm0
movups -0x10(%rcx), %xmm1
movups %xmm0, 0x488(%rbx)
movups %xmm1, 0x498(%rbx)
jmp 0x9a3e
movq 0x70(%rbx), %rax
movq 0xd0(%rbx), %rcx
movq -0x8(%rcx), %rdx
movl 0x1f0(%rdx), %esi
movl %esi, 0x80(%rbx)
movl 0x1f4(%rdx), %edx
movl %edx, 0x500(%rbx)
movl %edx, 0x504(%rbx)
leaq 0x488(%rbx), %r15
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm1, 0x498(%rbx)
movups %xmm0, 0x488(%rbx)
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x68(%rbx), %rdi
leaq 0x88(%rbx), %r14
movq -0x8(%rax), %rsi
callq 0xb010
movq 0x70(%rbx), %rax
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, -0x10(%rax)
movups %xmm0, -0x20(%rax)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb8cc
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void VirtualMachine::push(const string &s)
{
    v_stack.add();
    STOP.type=T_STRING;
    STOP.v_string=newString();
    *STOP.v_string=s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x68, %rdi
movq 0x70(%r14), %rsi
subq 0x68(%r14), %rsi
sarq $0x5, %rsi
incq %rsi
callq 0xb010
movq 0x70(%r14), %rax
movl $0x4, -0x20(%rax)
callq 0x10d24
movq 0x70(%r14), %rcx
movq %rax, -0x18(%rcx)
movq 0x70(%r14), %rax
movq -0x18(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6160
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::load(char const*)
bool VirtualMachine::load(const char *filename)
{
    if(!code_data.load(filename))return false;
    l_stack=0;
    v_stack.add();
    STOP.type=T_OBJECT;
    STOP.v_object=&reg_system;
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ca78
movl %eax, %ebp
testb %al, %al
je 0xaaef
movl $0x0, 0x80(%rbx)
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
incq %rsi
callq 0xb010
movq 0x70(%rbx), %rax
movl $0x6, -0x20(%rax)
addq $0x4a8, %rbx            # imm = 0x4A8
movq %rbx, -0x18(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::callReturn(int)
V_VALUE VirtualMachine::callReturn(int argc)
{
    DATATYPE type=v_stack.top(argc).type;
    call(argc);
    if(type==T_FUNCTION)runReturn();
    return SPOP;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %rax
movslq %edx, %rsi
movq %rsi, %rcx
shlq $0x5, %rcx
negq %rcx
movl -0x20(%rax,%rcx), %ebp
movq %r14, %rdi
callq 0x989e
cmpl $0x8, %ebp
jne 0xab2c
movq %r14, %rdi
callq 0xab5c
leaq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
subq 0x68(%r14), %rsi
sarq $0x5, %rsi
decq %rsi
callq 0xb010
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::runStep()
void VirtualMachine::runStep()
{
    //discode(CUR_INS,code_data,stdout);
    //continue;
    gc_enable=false;
    next_ip=ip+CUR_INS_LEN;
    if(CUR_INS>=0&&CUR_INS<=OP_HALT)(this->*op_func[CUR_INS])();
    else printf("Unknow instructor: %d\n",CUR_INS);
    //printf("STACK SIZE: %d\n",v_stack.size());
    //puts("-----------------");
    ip=next_ip;
    gc_enable=true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24cca(%rip), %r14     # 0x2f868
movb $0x0, (%r14)
movslq 0x500(%rdi), %rax
movq 0x60(%rdi), %rcx
movzbl (%rcx,%rax), %edx
leaq 0x160a8(%rip), %rsi     # 0x20c60
movl (%rsi,%rdx,8), %edx
addl %eax, %edx
movl %edx, 0x504(%rdi)
movzbl (%rcx,%rax), %esi
cmpq $0x38, %rsi
ja 0xabf3
shll $0x4, %esi
movq 0xd8(%rbx,%rsi), %rax
movq 0xe0(%rbx,%rsi), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0xabef
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
jmp 0xac01
leaq 0x15621(%rip), %rdi     # 0x2021b
xorl %eax, %eax
callq 0x6050
movl 0x504(%rbx), %eax
movl %eax, 0x500(%rbx)
movb $0x1, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/vm.cpp
// Function: VirtualMachine::run()
void VirtualMachine::run()
{
    clock_t t=clock();
    ip=code_data.config.entry_point;
    int code_raw_size=code_data.config.code_raw_size;
    while(ip>=0&&ip<code_raw_size&&CUR_INS!=OP_HALT)runStep();
    printf("halt in %lu clocks.\n",clock()-t);
    //printf("memory_table: %u\n",memory_table.size());
    //gc();printf("memory_table: %u\n",memory_table.size());
    
    //printf("STACK SIZE: %d\n",v_stack.size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x6190
movq %rax, %rbx
movq 0x28(%r14), %r15
movq 0x38(%r14), %rax
movl %eax, 0x500(%r14)
testl %eax, %eax
setns %cl
cmpl %r15d, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xac6f
movl %eax, %eax
movq 0x60(%r14), %rcx
cmpb $0x38, (%rcx,%rax)
je 0xac6f
movq %r14, %rdi
callq 0xab90
movl 0x500(%r14), %eax
testl %eax, %eax
js 0xac6f
cmpl %r15d, %eax
jl 0xac4b
callq 0x6190
subq %rbx, %rax
leaq 0x155b4(%rip), %rdi     # 0x20232
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x6050
nop
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_inscans_(int, VirtualMachine&)
BUILD_FUNC_SIGN(scans)
{
    char s[1000];
    vm.reg_ret.type=T_STRING;
    scanf("%s",s);
    vm.reg_ret.v_string=newString();
    *vm.reg_ret.v_string=s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rsi, %rbx
movl $0x4, 0x488(%rsi)
leaq 0x155dd(%rip), %rdi     # 0x2142b
movq %rsp, %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x62b0
callq 0x10d24
movq %rax, %r15
movq %rax, 0x490(%rbx)
movq 0x8(%rax), %rbx
movq %r14, %rdi
callq 0x6130
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x63e0
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_inlen_(int, VirtualMachine&)
BUILD_FUNC_SIGN(len)
{
    vm.reg_ret.type=T_INT;
    switch(GET_ARGV(0).type)
    {
        case T_ARRAY:
            vm.reg_ret.v_int=GET_ARGV(0).v_array->size();
            break;
        case T_OBJECT:
            vm.reg_ret.v_int=GET_ARGV(0).v_object->size();
            break;
        case T_STRING:
            vm.reg_ret.v_int=GET_ARGV(0).v_string->length();
            break;
        default:
            vm.reg_ret.v_int=1;
    }
}

// Assembly:
movl $0x2, 0x488(%rsi)
movq 0x70(%rsi), %rcx
movl -0x20(%rcx), %edx
cmpl $0x4, %edx
je 0xbee0
cmpl $0x6, %edx
je 0xbed7
movl $0x1, %eax
cmpl $0x5, %edx
jne 0xbee7
movq -0x18(%rcx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x5, %rax
jmp 0xbee7
movq -0x18(%rcx), %rax
movl 0x28(%rax), %eax
jmp 0xbee7
movq -0x18(%rcx), %rax
movl 0x8(%rax), %eax
movl %eax, 0x490(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_inclear_(int, VirtualMachine&)
BUILD_FUNC_SIGN(clear)
{
    if(GET_ARGV(0).type==T_ARRAY)GET_ARGV(0).v_array->clear();
    else if(GET_ARGV(0).type==T_OBJECT)GET_ARGV(0).v_object->clear();
    else return;
    vm.reg_ret=GET_ARGV(0);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x70(%rsi), %rax
movl -0x20(%rax), %ecx
cmpl $0x6, %ecx
je 0xbfa0
cmpl $0x5, %ecx
jne 0xbfc3
movq -0x18(%rax), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0xbfa9
movq %rcx, 0x8(%rax)
jmp 0xbfa9
movq -0x18(%rax), %rdi
callq 0xc562
movq 0x70(%rbx), %rax
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, 0x488(%rbx)
movups %xmm1, 0x498(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_inget_keys_(int, VirtualMachine&)
BUILD_FUNC_SIGN(get_keys)
{
    vm.reg_ret.type=T_ARRAY;
    vm.reg_ret.v_array=newArray();
    if(GET_ARGV(0).type==T_OBJECT)
    {
        int i=0;
        vm.reg_ret.v_array->resize(GET_ARGV(0).v_object->size());
        for(auto &x:*GET_ARGV(0).v_object)
        {
            (*vm.reg_ret.v_array)[i].type=T_STRING;
            (*vm.reg_ret.v_array)[i].v_string=newString();
            *(*vm.reg_ret.v_array)[i].v_string=x.first;
            i++;
        }
    }
    else if(GET_ARGV(0).type==T_ARRAY)
    {
        int size=GET_ARGV(0).v_array->size();
        vm.reg_ret.v_array->resize(size);
        for(int i=0;i<size;i++)
        {
            (*vm.reg_ret.v_array)[i].type=T_INT;
            (*vm.reg_ret.v_array)[i].v_int=i;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl $0x5, 0x488(%rsi)
callq 0x10dfc
movq %rax, 0x490(%rbx)
movq 0x70(%rbx), %rcx
movl -0x20(%rcx), %edx
cmpl $0x5, %edx
je 0xc0cf
cmpl $0x6, %edx
jne 0xc127
movq -0x18(%rcx), %rcx
movq 0x28(%rcx), %rsi
movq %rax, %rdi
callq 0xb010
movq 0x70(%rbx), %rax
movq -0x18(%rax), %r12
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0xc127
xorl %r13d, %r13d
leaq 0x20(%r14), %r15
movq 0x490(%rbx), %rax
movq (%rax), %rax
movl $0x4, (%rax,%r13)
callq 0x10d24
movq 0x490(%rbx), %rcx
movq (%rcx), %rcx
movq %rax, 0x8(%rcx,%r13)
movq 0x490(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax,%r13), %rdi
movq %r15, %rsi
callq 0x6160
movq %r14, %rdi
callq 0x61a0
movq %rax, %r14
addq $0x20, %r13
cmpq %r12, %rax
jne 0xc078
jmp 0xc127
movq -0x18(%rcx), %rcx
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x5, %r15
movslq %r15d, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xb010
testl %r14d, %r14d
jle 0xc127
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x490(%rbx), %rdx
movq (%rdx), %rdx
movl $0x2, (%rdx,%rax)
movq 0x490(%rbx), %rdx
movq (%rdx), %rdx
movl %ecx, 0x8(%rdx,%rax)
incq %rcx
addq $0x20, %rax
cmpq %rcx, %r15
jne 0xc0fc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_ineach_(int, VirtualMachine&)
BUILD_FUNC_SIGN(each)
{
    auto v=GET_ARGV(0);
    auto f=GET_ARGV(1);
    if(v.type==T_ARRAY)
    {
        for(int i=0;i<v.v_array->size();i++)
        {
            vm.push(f);
            vm.push(f); //callee
            vm.push(vm.v_stack[0]); // this
            vm.push((*v.v_array)[i]);
            vm.push(i);
            vm.callReturn(4);
        }
    }
    else if(v.type==T_OBJECT)
    {
        for(auto &x:*v.v_object)
        {
            vm.push(f);
            vm.push(f); //callee
            vm.push(vm.v_stack[0]); // this
            vm.push(x.first);
            vm.push(x.second);
            vm.callReturn(4);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x70(%rsi), %rcx
movl -0x20(%rcx), %eax
movq -0x18(%rcx), %rbp
movups -0x40(%rcx), %xmm0
movups -0x30(%rcx), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x6, %eax
je 0xc1f7
cmpl $0x5, %eax
jne 0xc269
movq 0x8(%rbp), %rax
cmpq (%rbp), %rax
je 0xc269
xorl %r13d, %r13d
movq %rsp, %r14
leaq 0x28(%rsp), %r15
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa2a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa2a
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0xaa2a
movq (%rbp), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0xaa2a
movq %rbx, %rdi
movl %r12d, %esi
callq 0x808c
movq %r15, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0xaaf8
movq 0x8(%rbp), %rax
subq (%rbp), %rax
incq %r12
sarq $0x5, %rax
addq $0x20, %r13
cmpq %r12, %rax
ja 0xc191
jmp 0xc269
movq 0x18(%rbp), %r14
addq $0x8, %rbp
cmpq %rbp, %r14
je 0xc269
movq %rsp, %r15
leaq 0x28(%rsp), %r12
leaq 0x20(%r14), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa2a
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0xaa2a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaa54
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0xaa2a
movq %r12, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0xaaf8
movq %r14, %rdi
callq 0x61a0
movq %rax, %r14
cmpq %rbp, %rax
jne 0xc20c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Eronana[P]strawberry/src/buildin.cpp
// Function: build_incall_(int, VirtualMachine&)
BUILD_FUNC_SIGN(call)
{
    auto &_this=GET_ARGV(0);
    auto &f=GET_ARGV(1);
    vm.push(f); // function
    vm.push(f); // callee
    vm.push(_this); // this
    for(int i=0;i<ARGC-2;i++)vm.push(GET_ARGV(ARGC+2));
    vm.callReturn(ARGC);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x70(%rsi), %r15
leaq -0x20(%r15), %r12
addq $-0x40, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0xaa2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa2a
movq %rbx, %rdi
movq %r12, %rsi
callq 0xaa2a
cmpl $0x5, %r14d
jl 0xc2e3
movl %r14d, %r15d
negq %r15
leal -0x4(%r14), %ebp
shlq $0x5, %r15
movq 0x70(%rbx), %rax
leaq (%rax,%r15), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0xaa2a
decl %ebp
jne 0xc2cb
addl $-0x2, %r14d
movq %rsp, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xaaf8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc5bc
movl $0x6, (%r12)
callq 0x10e9c
movq %rax, 0x8(%r12)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x13e45(%rip), %rsi     # 0x2018f
leaq 0x13e47(%rip), %rdx     # 0x20198
leaq 0x8(%rsp), %rdi
callq 0xb1b4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd5c
movl $0x6, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc387
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq -0x8(%r15), %r13
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13df5(%rip), %rsi     # 0x2018f
leaq 0x13df7(%rip), %rdx     # 0x20198
callq 0xb1b4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd5c
movq %r13, 0x8(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc3d0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13ed1(%rip), %rsi     # 0x202b0
leaq 0x13ed5(%rip), %rdx     # 0x202bb
callq 0xb1b4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd5c
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 0xc425
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa2a
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xaa2a
cmpl $0x4, %r14d
jl 0xc474
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 0xaa2a
decl %ebp
jne 0xc45c
addl $-0x2, %r14d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xaaf8
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 0xc4b7
jmp 0xc4d3
jmp 0xc4b7
jmp 0xc4d3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc4d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc4d6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc695
movq %rsi, %rdx
leaq 0x13cd6(%rip), %rcx     # 0x202bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %rdi
callq 0xc6ce
addl %eax, 0x8(%rbx)
jmp 0xc69c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xc740
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 0xc69c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc69c
cmpl $0x5, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rsi
jne 0xc673
movq 0x8(%rdx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xcff2
jmp 0xc695
movq %rdx, %rdi
callq 0xc700
cvtss2sd %xmm0, %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xc69c
cmpq 0x10(%rdi), %rsi
je 0xc690
movupd (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
addq $0x20, 0x8(%rdi)
jmp 0xc695
callq 0xaeb2
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 0xc6c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc6fd
leaq 0x13bee(%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_O3/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 0x13b99(%rip), %rcx     # 0x202ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13c72(%rip), %rsi     # 0x203dc
leaq 0x13c6f(%rip), %rdx     # 0x203e0
jmp 0xc86e
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 0x7ce4
jmp 0xc876
movl 0x8(%rsi), %edx
leaq 0x14c7f(%rip), %rsi     # 0x21421
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x6070
jmp 0xc7ca
movsd 0x8(%rsi), %xmm0
leaq 0x13be3(%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 0xc871
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13bb8(%rip), %rsi     # 0x203ae
leaq 0x13bc2(%rip), %rdx     # 0x203bf
jmp 0xc86e
xorl %eax, %eax
cmpl $0x0, 0x8(%rsi)
leaq 0x13b9c(%rip), %rcx     # 0x203a8
leaq 0x13b90(%rip), %rsi     # 0x203a3
cmoveq %rcx, %rsi
sete %al
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rsi,%rax), %rdx
addq $0x4, %rdx
jmp 0xc86e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13b92(%rip), %rsi     # 0x203cb
leaq 0x13b92(%rip), %rdx     # 0x203d2
jmp 0xc86e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13b83(%rip), %rsi     # 0x203d3
leaq 0x13b84(%rip), %rdx     # 0x203db
jmp 0xc86e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13b59(%rip), %rsi     # 0x203c0
leaq 0x13b5c(%rip), %rdx     # 0x203ca
movq %rbx, %rdi
callq 0xb1b4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc8a7
cmpl $0x2, %eax
jne 0xc8c3
movq %rsi, %rdi
callq 0xc6ce
subl %eax, 0x8(%rbx)
jmp 0xc8ca
movq %rsi, %rdi
callq 0xc700
cvtss2sd %xmm0, %xmm0
movsd 0x8(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
jmp 0xc8ca
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc912
cmpl $0x3, %eax
je 0xc8fa
cmpl $0x2, %eax
jne 0xc957
movq %rsi, %rdi
callq 0xc6ce
imull 0x8(%rbx), %eax
jmp 0xc95b
movq %rsi, %rdi
callq 0xc700
cvtss2sd %xmm0, %xmm0
mulsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xc95e
movq %rsi, %rdi
callq 0xc6ce
testl %eax, %eax
je 0xc957
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 0x7ce4
decl %ebp
je 0xc96a
movq 0x8(%rbx), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x60e0
jmp 0xc93f
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 0xc95e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xc95e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xc99b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6230
movq %rbx, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcaf3
cmpl $0x2, %ecx
jne 0xcb06
incl 0x8(%rax)
retq
movsd 0x8(%rax), %xmm0
addsd 0x13878(%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_O3/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 0xcdb0
cmpl $0x3, %eax
je 0xcd90
cmpl $0x2, %eax
jne 0xcdee
movl 0x8(%rdi), %ebx
movq %rsi, %rdi
callq 0xc6ce
cmpl %eax, %ebx
setl %bl
jmp 0xcdf0
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %rsi, %rdi
callq 0xc700
cvtss2sd %xmm0, %xmm0
ucomisd (%rsp), %xmm0
seta %bl
jmp 0xcdf0
movq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc740
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 0xcdf0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
jmp 0xcdf0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x79b7
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0xcf16
movb $0x1, %al
movl %ecx, %ecx
leaq 0x134e8(%rip), %rdx     # 0x20330
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jmp 0xcea4
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rsi
movq 0x8(%rcx), %rdx
cmpq 0x8(%rsi), %rdx
jne 0xcf16
testq %rdx, %rdx
je 0xcf18
movq (%rsi), %rsi
movq (%rcx), %rdi
callq 0x6240
testl %eax, %eax
jmp 0xcea4
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0xcf18
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
jmp 0xcf18
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
movq (%rcx), %rbx
movq 0x8(%rcx), %r15
movq %r15, %rcx
subq %rbx, %rcx
movq (%rdx), %r14
movq 0x8(%rdx), %rdx
subq %r14, %rdx
cmpq %rdx, %rcx
jne 0xcf16
cmpq %r15, %rbx
je 0xcf18
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce2e
testb %al, %al
je 0xcf18
addq $0x20, %rbx
addq $0x20, %r14
jmp 0xcecd
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0xcf16
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd1f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
sete %cl
movq 0x10(%rsi), %rax
cmpq %rax, 0x10(%rdi)
sete %al
andb %cl, %al
jmp 0xcf18
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcf76
leaq 0x13405(%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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xd774
leaq 0x10(%r14), %rcx
cmpq %rcx, %rax
jne 0xd490
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd4ad
cmpl $0x1, 0x40(%r14)
movq %rdi, %r14
jne 0xd447
movq %r15, %rsi
movq %rbx, %rdx
callq 0xd436
movl %eax, %ecx
testl %eax, %eax
movl $0x1, %eax
cmovel %ecx, %eax
cmpl $0x3, %ecx
cmovel %ecx, %eax
jmp 0xd4b2
movq %r12, %rdi
movq %r15, %rsi
callq 0xd504
movl (%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
cmpl $0x0, 0x40(%r14)
setne %al
addl %eax, %eax
jmp 0xd4b2
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20f97(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11ba0(%rip), %rdi     # 0x2041b
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11b8c(%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_O3/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 0x20f0c(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11b1d(%rip), %rdi     # 0x20423
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11b0a(%rip), %rdi     # 0x20428
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpq $0x0, 0x18(%rbx)
je 0xe952
movq (%r14), %rsi
leaq 0x11aee(%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_O3/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 0xe98e
leaq 0x20e93(%rip), %rax     # 0x2f808
movq (%rax), %rsi
leaq 0x11ab2(%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_O3/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 0x20e6a(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11a8d(%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 0x11a72(%rip), %rdi     # 0x2043b
callq 0x6280
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a47(%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_O3/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 0x20e04(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x11a2f(%rip), %rdi     # 0x2043d
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a1b(%rip), %rdi     # 0x20441
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x11a0b(%rip), %rdi     # 0x20449
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20db0(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x119df(%rip), %rdi     # 0x20441
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x1182f(%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_O3/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 0x20d65(%rip), %r14     # 0x2f808
movq (%r14), %rsi
je 0xeabf
leaq 0x1199e(%rip), %rdi     # 0x2044d
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0xeacb
leaq 0x1198d(%rip), %rdi     # 0x20453
callq 0x6280
movq (%r14), %rsi
leaq 0x12c39(%rip), %rdi     # 0x2170e
callq 0x6280
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x12d71(%rip), %rdi     # 0x2185e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20cc4(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x1190e(%rip), %rdi     # 0x2045c
callq 0x6280
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x118c2(%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_O3/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 0x20c7e(%rip), %r14     # 0x2f808
movq (%r14), %rsi
leaq 0x118d1(%rip), %rdi     # 0x20465
callq 0x6280
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xeba7
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rsi
leaq 0x116f8(%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_O3/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 0x1f0a2(%rip), %rdi     # 0x2f688
callq 0x10a90
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_O3/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 0xd4be
testb %al, %al
jne 0x10879
movq %rbx, %rdi
movl $0x3, %esi
callq 0xd4be
testb %al, %al
jne 0x10879
movq %rbx, %rdi
movl $0x4, %esi
callq 0xd4be
testb %al, %al
je 0x10884
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 0xffaa(%rip), %rsi      # 0x2084f
leaq 0xffb7(%rip), %rdx      # 0x20863
leaq 0x8(%rsp), %rdi
callq 0xb1b4
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1d362(%rip), %rsi     # 0x2dc38
leaq 0x163(%rip), %rdx       # 0x10a40
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x108ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x10909
jmp 0x10911
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
movq %r14, %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd4be
testb %al, %al
jne 0x1096e
movq %rbx, %rdi
movl $0x3, %esi
callq 0xd4be
testb %al, %al
jne 0x1096e
movq %rbx, %rdi
movl $0x4, %esi
callq 0xd4be
testb %al, %al
jne 0x1096e
movq %rbx, %rdi
movl $0x5, %esi
callq 0xd4be
testb %al, %al
je 0x10979
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 0xfeca(%rip), %rsi      # 0x20864
leaq 0xfed4(%rip), %rdx      # 0x20875
leaq 0x8(%rsp), %rdi
callq 0xb1b4
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7bdc
xorl %ebp, %ebp
leaq 0x1d26d(%rip), %rsi     # 0x2dc38
leaq 0x6e(%rip), %rdx        # 0x10a40
movq %rbx, %rdi
callq 0x6440
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x109f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6230
testb %bpl, %bpl
jne 0x109fe
jmp 0x10a06
movq %rax, %r14
movq %rbx, %rdi
callq 0x61c0
movq %r14, %rdi
callq 0x6450