LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: StringValue::LooksLikeInteger()
bool StringValue::LooksLikeInteger()
{
        char buf[256];
        long value;
        int n = sscanf(this->Value.c_str(), "%ld", &value);
        if(n>0)
        {
                sprintf(buf, "%ld", value);

                if(strlen(buf)==strlen(this->Value.c_str()))
                {
                        return true;
                }
        }
        return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x2d92b(%rip), %rsi     # 0x34817
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x6230
testl %eax, %eax
jle 0x6f35
movq 0x8(%rsp), %rdx
leaq 0x2d90f(%rip), %rsi     # 0x34817
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x6090
movq %r14, %rdi
callq 0x6110
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x6110
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r14
je 0x6f37
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: DecimalValue::toString[abi:cxx11]()
string DecimalValue::toString()
{
        char result[1024];
        int prec = mpf_get_prec(this->Value);
        gmp_snprintf (result, sizeof(result), "%.*Ff", prec, this->Value);
        
        char * p = strstr(result, ".");
        if(p==NULL)
        {
            return result;
        }
        
        int len = strlen(p) - 1;
        
        char * q = p + len;
        
        while(*q == '0' && *(q-1)!='.')
        {
            q--;
        }
        
        *(q+1) = '\0';
        
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0x17c48
leaq 0x27ce8(%rip), %rdx     # 0x2f0f8
leaq 0x10(%rsp), %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movl %eax, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x29a74
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x60f0
testq %rax, %rax
je 0x7469
movq %rax, %r14
movq %rax, %rdi
callq 0x6110
decl %eax
movslq %eax, %rcx
movb (%r14,%rcx), %al
leaq (%r14,%rcx), %rdx
incq %rdx
movq %rdx, %rcx
cmpb $0x30, %al
jne 0x7466
movb -0x2(%rcx), %al
leaq -0x1(%rcx), %rdx
cmpb $0x2e, %al
jne 0x7454
movb $0x0, (%rcx)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6b9e
movq %rbx, %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: KVValue::toString[abi:cxx11]()
string KVValue::toString()
{
        string ret = "<";
        ret.append(this->Key->toString());
        ret.append(",");
        ret.append(this->Value->GetVal()->toString());
        ret.append(">");
        return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x27ad7(%rip), %rsi     # 0x2f109
leaq 0x8(%rsp), %rdx
callq 0x6b9e
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x64c0
leaq 0x8(%rsp), %rdi
callq 0x6130
leaq 0x27aa2(%rip), %rsi     # 0x2f10b
movq %rbx, %rdi
callq 0x64a0
movq 0x18(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x64c0
leaq 0x8(%rsp), %rdi
callq 0x6130
leaq 0x27a6c(%rip), %rsi     # 0x2f10d
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x76b8
jmp 0x76c9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x76cc
jmp 0x76c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x6130
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::~MapValue()
MapValue::~MapValue()
{
        map<string, ValueBox*>::iterator i;
        for(i=this->Value.begin();i!=this->Value.end();i++)
        {
                i->second->Destroy();
        }
        this->Value.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3a5e1(%rip), %rax     # 0x41db8
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
leaq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x77fd
movq 0x40(%r14), %rdi
callq 0x6d16
movq %r14, %rdi
callq 0x61b0
movq %rax, %r14
jmp 0x77e2
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x8506
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x82a2
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::AddKV(KVValue*)
void MapValue::AddKV(KVValue * kv)
{
        string key = kv->GetKey()->toString();
        map<string, ValueBox*>::iterator i = this->Value.find(key);

        if(i!=this->Value.end())
        {
                i->second->Destroy();
                this->Value.erase(key);
        }
        this->Value.insert(pair<string, ValueBox*>(key, kv->GetValueBox()->Dup()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8534
addq $0x18, %r15
cmpq %r15, %rax
je 0x7879
movq 0x40(%rax), %rdi
callq 0x6d16
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x85aa
movq 0x18(%r14), %rdi
callq 0x6d6a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x6380
leaq 0x20(%rsp), %rsi
movq %r14, 0x20(%rsi)
movq %rbx, %rdi
callq 0x8306
leaq 0x20(%rsp), %rdi
callq 0x6130
movq %rsp, %rdi
callq 0x6130
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6130
jmp 0x78d5
jmp 0x78d2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::FindByKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ValueBox * MapValue::FindByKey(string key)
{
        map<string, ValueBox*>::iterator i = this->Value.find(key);
        if(i!=this->Value.end())
        {
                return i->second;
        }
        return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x8534
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x790c
movq 0x40(%rax), %rax
jmp 0x790e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::toString[abi:cxx11]()
string MapValue::toString()
{
        string ret="[";

        int size = this->Value.size();
        map<string, ValueBox*>::iterator i;
        for(i=this->Value.begin(); i!=this->Value.end(); i++, size--)
        {
                ret.append("<");
                ret.append(i->first);
                ret.append(",");
                ret.append(i->second->GetVal()->toString());
                ret.append(">");
                if(size>1)
                {
                        ret.append(",");
                }
        }
        ret.append("]");
        return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2779c(%rip), %rsi     # 0x2f10f
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x6b9e
movl 0x38(%r14), %r12d
movq 0x28(%r14), %r13
addq $0x18, %r14
leaq 0x27778(%rip), %rbp     # 0x2f10b
cmpq %r14, %r13
je 0x7a11
movq %rbx, %rdi
leaq 0x27767(%rip), %rsi     # 0x2f109
callq 0x64a0
leaq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x64c0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64a0
movq 0x40(%r13), %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64c0
movq %r15, %rdi
callq 0x6130
movq %rbx, %rdi
leaq 0x27722(%rip), %rsi     # 0x2f10d
callq 0x64a0
cmpl $0x2, %r12d
jl 0x7a01
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64a0
movq %r13, %rdi
callq 0x61b0
movq %rax, %r13
decl %r12d
jmp 0x7993
leaq 0x276f9(%rip), %rsi     # 0x2f111
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a45
jmp 0x7a45
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x7a48
movq %rax, %r14
movq %rbx, %rdi
callq 0x6130
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: DefaultValueFactory::GetValue()
ConstValue * DefaultValueFactory::GetValue()
{
        ConstValue * result = NULL;
        switch(this->Type)
        {
                case Integer:
                        result = new IntegerValue(0);
                break;
                case String:
                        result = new StringValue("");
                break;
                case Boolean:
                        result = new BooleanValue(false);
                break;
                case Decimal:
                        result = new DecimalValue("0");
                break;
                case Map:
                        result = new MapValue();
                break;
                case Func:
                        result = new FuncValue(NULL, NULL);
                break;
                default:
                        result = new NullValue;
        }
        return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x7, %eax
ja 0x7ae3
leaq 0x275dd(%rip), %rcx     # 0x2f050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x18
popq %rdi
callq 0x6260
movq %rax, %rbx
movl $0x1, 0x8(%rax)
leaq 0x3a263(%rip), %rax     # 0x41cf8
movq %rax, (%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x7ba6
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movl $0x3, 0x8(%rax)
leaq 0x3a29d(%rip), %rax     # 0x41d58
movq %rax, (%rbx)
movb $0x0, 0xc(%rbx)
jmp 0x7ba6
pushq $0x20
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15128
jmp 0x7ba6
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
andl $0x0, 0x8(%rax)
leaq 0x3a19f(%rip), %rax     # 0x41c98
movq %rax, (%rbx)
jmp 0x7ba6
pushq $0x28
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0x2c450(%rip), %rsi     # 0x33f63
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6b9e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7098
leaq 0x8(%rsp), %rdi
jmp 0x7b69
pushq $0x30
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0x274d6(%rip), %rsi     # 0x2f01e
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6b9e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e18
leaq 0x28(%rsp), %rdi
callq 0x6130
jmp 0x7ba6
pushq $0x40
popq %rdi
callq 0x6260
movq %rax, %rbx
movl $0x6, 0x8(%rax)
leaq 0x3a22f(%rip), %rax     # 0x41db8
movq %rax, (%rbx)
leaq 0x18(%rbx), %rax
andl $0x0, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6130
jmp 0x7bd2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x7bd9
movq %rax, %r14
pushq $0x30
jmp 0x7be2
movq %rax, %r14
pushq $0x28
jmp 0x7be2
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::ArrayValue(DataType, std::vector<long, std::allocator<long>>&, long)
ArrayValue::ArrayValue(DataType type, vector<long>& desc, long size):ConstValue(Array)
{
        DefaultValueFactory fac(type);

        this->ElementType = type;
        this->Value = new ValueBox*[size];
        this->Dim = desc;
        this->Size = size;

        for(int i = 0; i < size; i++)
        {
                ConstValue * val = fac.GetValue();
                
                this->Value[i] = new ValueBox;
                this->Value[i]->SetVal(val);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movl $0x7, 0x8(%rdi)
leaq 0x3a1cf(%rip), %rax     # 0x41de8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rbx
andq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl %esi, 0xc(%rsp)
movl %esi, 0xc(%rdi)
movq %rcx, %rax
shrq $0x3d, %rax
leaq (,%rcx,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
movq %rbx, 0x10(%rsp)
callq 0x6030
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x81aa
movq %r14, 0x30(%r15)
xorl %ebx, %ebx
testq %r14, %r14
cmovleq %rbx, %r14
pushq $0x10
popq %r13
cmpq %rbx, %r14
je 0x7cc5
leaq 0xc(%rsp), %rdi
callq 0x7a5c
movq %rax, %rbp
movq %r13, %rdi
callq 0x6260
andq $0x0, (%rax)
movq $0x1, 0x8(%rax)
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x7cbc
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbp, (%r12)
incq %rbx
jmp 0x7c77
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7cd6
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x8746
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::~ArrayValue()
ArrayValue::~ArrayValue()
{
        for(int i = 0; i < this->Size; i++)
        {
                if(this->Value[i]!=NULL)
                {
                        this->Value[i]->Destroy();
                }
        }

        delete this->Value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3a0ee(%rip), %rax     # 0x41de8
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
cmpq %r14, 0x30(%rbx)
jle 0x7d1d
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x7d18
callq 0x6d16
incq %r14
jmp 0x7d00
pushq $0x8
popq %rsi
callq 0x6270
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8746
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::toString[abi:cxx11]()
string ArrayValue::toString()
{
        string ret="[";

        int size = this->Size;
        for(int i = 0; i < size; i++)
        {
                if(this->Value[i]->GetVal()!=NULL)
                {
                        ret.append(this->Value[i]->GetVal()->toString());
                }
                else
                {
                        ret.append("nil");
                }
                if(i<size-1)
                {
                        ret.append(",");
                }
        }
        ret.append("]");
        return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x27290(%rip), %rsi     # 0x2f10f
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x6b9e
movl 0x30(%r14), %ebp
leal -0x1(%rbp), %eax
movslq %eax, %r12
xorl %r13d, %r13d
testl %ebp, %ebp
cmovlel %r13d, %ebp
cmpq %r13, %rbp
je 0x7efa
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x7ed2
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64c0
movq %r15, %rdi
callq 0x6130
jmp 0x7ee1
movq %rbx, %rdi
leaq 0x27237(%rip), %rsi     # 0x2f113
callq 0x64a0
cmpq %r12, %r13
jge 0x7ef5
movq %rbx, %rdi
leaq 0x2721b(%rip), %rsi     # 0x2f10b
callq 0x64a0
incq %r13
jmp 0x7e9f
leaq 0x27210(%rip), %rsi     # 0x2f111
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f2e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x7f31
jmp 0x7f2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x6130
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Invoke(NodeContext*)
int ContainerNode::Invoke(NodeContext * context)
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                if((*i)->Type==Function)
                {
                        continue;
                }

                context->AddFrame(*i);
                int cond = (*i)->Execute(context);
                context->PopFrame();

                if(cond!=NODE_RET_NORMAL)
                {
                        return cond;
                }
        }

        return NODE_RET_NORMAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rax
movq %rax, %r15
movq (%r15), %r15
cmpq %rax, %r15
je 0x8864
movq 0x10(%r15), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x882a
movq %rbx, %rdi
callq 0xac22
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0xa98a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xabba
testl %ebp, %ebp
jne 0x8866
movq 0x60(%r14), %rax
jmp 0x882a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Provision()
bool ContainerNode::Provision()
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                (*i)->SetParentNode(this);
                if((*i)->Provision()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %r14
movq 0x60(%rbx), %r15
cmpq %r15, %r14
je 0x88c4
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xa9b6
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x889e
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Check()
bool ContainerNode::Check()
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %r14
movq 0x60(%rbx), %r15
cmpq %r15, %r14
je 0x88f6
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x88dc
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: BinaryExpression::Calculate(NodeContext*)
ConstValue * BinaryExpression::Calculate(NodeContext * context)
{
        ConstValue * left_store = this->left->Calculate(context);
        ConstValue * right_store = this->right->Calculate(context);

        ConstValue * result = this->CarryOut(left_store, right_store);

        delete left_store;
        delete right_store;

        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x28(%rax)
movq %rax, %r15
testq %r14, %r14
je 0x8aaa
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testq %rbx, %rbx
je 0x8ab8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: BinaryExpression::Provision()
bool BinaryExpression::Provision()
{
        left->SetParentNode(this->ParentNode);
        right->SetParentNode(this->ParentNode);

        if(left->Provision()==false)
        {
                return false;
        }
        if(right->Provision()==false)
        {
                return false;
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdi
movq %rax, 0x10(%rdi)
movq 0x20(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x8aef
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: KVExpression::CarryOut(ConstValue*, ConstValue*)
ConstValue * KVExpression::CarryOut(ConstValue * left_store, ConstValue * right_store)
{
        ValueBox * vb = new ValueBox(right_store);
        KVValue * result = new KVValue(left_store, vb);
        vb->Destroy();
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x6cce
pushq $0x20
popq %rdi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7554
movq %rbx, %rdi
callq 0x6d16
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x20
popq %rsi
movq %r15, %rdi
jmp 0x8b93
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: SetExpression::Provision()
bool SetExpression::Provision()
{
        list<Expression*>::iterator i;
        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
               {
                (*i)->SetParentNode(this->ParentNode);
                       if((*i)->Provision()!=true)
                {
                               return false;
                       }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq (%r14), %r14
movq 0x18(%rbx), %r15
cmpq %r15, %r14
je 0x8d9e
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x8d78
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: SetExpression::Check()
bool SetExpression::Check()
{
        list<Expression*>::iterator i;
        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq (%r14), %r14
movq 0x18(%rbx), %r15
cmpq %r15, %r14
je 0x8dd0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x8db6
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Calculate(NodeContext*)
ConstValue * VarExpression::Calculate(NodeContext * context)
{
        ValueBox * result = this->GetVarRef(context);
        if(result==NULL)
        {
                return new NullValue;
        }

        return result->GetVal()->DupValue();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x8e4c
testq %rax, %rax
je 0x9280
movq %rax, %rdi
callq 0x6d66
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x6da8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Provision()
bool VarExpression::Provision()
{
        for(list<list<Expression*>*>::iterator gitor = this->ExprsList.begin(); gitor!=this->ExprsList.end(); gitor++)
        {
                list<Expression*> * ExprList = *gitor;
                
                for(list<Expression*>::iterator i = ExprList->begin(); i!=ExprList->end(); i++)
                {
                    (*i)->SetParentNode(this->ParentNode);
                    if((*i)->Provision()!=true)
                    {
                            return false;
                    }
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x92f9
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x92c7
movq 0x10(%r13), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x92d6
cmpq %r14, %r15
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Check()
bool VarExpression::Check()
{
        unsigned long layer = 0;
        VariableDef * vardef = this->ParentNode->FindVariable(this->VarName, &layer);
        if(vardef==NULL)
        {
                cerr<<"pupp provision error: Variable "<<this->VarName<<" has not been defined"<<endl;
                return false;
        }
        
        this->VarDef = vardef;
        this->VarLayer = layer;

        for(list<list<Expression*>*>::iterator gitor = this->ExprsList.begin(); gitor!=this->ExprsList.end(); gitor++)
        {
                list<Expression*> * ExprList = *gitor;
                
                for(list<Expression*>::iterator i = ExprList->begin(); i!=ExprList->end(); i++)
                {
                    if((*i)->Check()!=true)
                {
                        return false;
                }
                }
        }
        
        return Expression::Check();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rdi, %rbx
movq 0x10(%rdi), %r12
leaq 0x18(%rdi), %r14
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x6380
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xaaac
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x6130
testq %r15, %r15
je 0x9398
movq %r15, 0x38(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rbx)
addq $0x40, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x93dd
movq 0x10(%r14), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x936f
movq 0x10(%r12), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x937e
jmp 0x93cd
movq 0x39c51(%rip), %rdi     # 0x42ff0
leaq 0x25e4d(%rip), %rsi     # 0x2f1f3
callq 0x6240
movq %rax, %rdi
movq %r14, %rsi
callq 0x6210
leaq 0x25e56(%rip), %rsi     # 0x2f213
movq %rax, %rdi
callq 0x6240
movq %rax, %rdi
callq 0x6140
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x93cf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: FunctionExpression::Provision()
bool FunctionExpression::Provision()
{
        this->FuncObj->SetParentNode(this->ParentNode);
        if(this->FuncObj->Provision()!=true)
        {
                return false;
        }

        list<Expression*>::iterator i;
        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
        {
                (*i)->SetParentNode(this->ParentNode);
                if((*i)->Provision()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rdi
movq %rax, 0x10(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x9996
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0x9998
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x996d
jmp 0x9998
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: FunctionExpression::Check()
bool FunctionExpression::Check()
{
        if(this->FuncObj->Check()!=true)
        {
                return false;
        }

        list<Expression*>::iterator i;

        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return Expression::Check();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x99d6
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0x99d8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x99b9
jmp 0x99d8
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: AsynFuncCallContext::AsynCall()
int AsynCall()
        {
                pthread_t thid;
                pthread_attr_t attr;

                pthread_attr_init(&attr);
                pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

                pthread_create(&thid, &attr, ThreadWrapper, this);
                return 0;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6340
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6360
leaq 0xdb(%rip), %rdx        # 0xa050
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6480
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/expression.cpp
// Function: AsynFuncCallContext::ThreadWrapper(void*)
static void * ThreadWrapper(void * arg)
        {
                AsynFuncCallContext * ctx = static_cast<AsynFuncCallContext*>(arg);
                
                int rtn = ctx->FuncNode->Run(ctx->Context);
                delete ctx->Context;
                delete ctx;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0xa5b6
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xa074
movq %r14, %rdi
callq 0xab84
pushq $0x70
popq %rsi
movq %r14, %rdi
callq 0x6270
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/function.cpp
// Function: ClosureVarDesc::ClosureVarDesc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
ClosureVarDesc::ClosureVarDesc(string name, bool b)
{
        this->Name  = name;
        this->isRef = b;
        this->SrcLayer = 0;
        this->SrcDef   = NULL;
        this->DstDef   = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x6160
movb %bpl, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
andq $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6130
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/node.cpp
// Function: Node::AddVariable(VariableDef*)
void Node::AddVariable(VariableDef * var)
{       
        VariableDef * thevar = this->VariableDefTable[var->GetVarName()];
        if(thevar != NULL)
        {
                delete thevar;
                this->VariableDefTable.erase(var->GetVarName());
        }

        var->SetAttachedNode(this);
        var->SetVarIndex(this->VarDefArray.size());
        
        this->VariableDefTable[var->GetVarName()] = var;
        this->VarDefArray.push_back(var);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
leaq 0x18(%rdi), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x150f6
movq %r15, %rdi
movq %r12, %rsi
callq 0xad6e
movq (%rax), %r12
movq %rsp, %rdi
callq 0x6130
testq %r12, %r12
je 0xaa34
movq %r12, %rdi
callq 0x6130
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x6270
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x150f6
movq %r15, %rdi
movq %r12, %rsi
callq 0xb3c6
movq %rsp, %rdi
callq 0x6130
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15104
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x15110
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x150f6
movq %r15, %rdi
movq %r12, %rsi
callq 0xad6e
addq $0x48, %rbx
movq %r14, (%rax)
movq %rsp, %rdi
callq 0x6130
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xadd4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaa98
jmp 0xaa98
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/node.cpp
// Function: Node::FindVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long*)
VariableDef * Node::FindVariable(string varname, unsigned long * layer)
{
        map<string, VariableDef*>::iterator i = this->VariableDefTable.find(varname);
        if(i!=this->VariableDefTable.end())
        {
                return i->second;
        }

        if(this->ParentNode!=NULL)
        {
                if(layer)
                {
                        (*layer)++;
                }
                
                VariableDef * result = this->ParentNode->FindVariable(varname, layer);
                return result;
        }

        return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rdi
callq 0xb6d4
leaq 0x20(%r15), %rcx
cmpq %rcx, %rax
je 0xaad8
movq 0x40(%rax), %rbx
jmp 0xab18
movq 0x10(%r15), %r15
testq %r15, %r15
je 0xab16
testq %rbx, %rbx
je 0xaae9
incq (%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6380
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xaaac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0xab18
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/node.cpp
// Function: NodeContext::AddFrame(Node*)
void NodeContext::AddFrame(Node * snapshot)
{
        vector<Variable*> frame;

        vector<VariableDef*>::iterator i;
        for(i = snapshot->VarDefArray.begin(); i!=snapshot->VarDefArray.end(); i++)
        {
                VariableDef * def = *i;
                if((*i)->NeedInstance())
                {
                        Variable * var = def->GetInstance();
                        frame.push_back(var);
                }
                else
                {
                        frame.push_back(NULL);
                }
        }
        
        this->VarTable.push_back(frame);
        
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq 0x48(%rsi), %rbp
leaq 0x8(%rsp), %r12
cmpq 0x50(%r14), %rbp
je 0xac97
movq (%rbp), %r13
movq %r13, %rdi
callq 0x1511c
testb %al, %al
je 0xac80
movq %r13, %rdi
callq 0x1505a
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xaed2
jmp 0xac91
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xbb72
addq $0x8, %rbp
jmp 0xac50
addq $0x58, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xaef0
leaq 0x10(%rsp), %rdi
callq 0xb9fa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xacc7
jmp 0xacc7
jmp 0xacc7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb9fa
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/node.cpp
// Function: NodeContext::ReplaceVariable(unsigned long, std::__cxx11::list<Variable*, std::allocator<Variable*>>*)
void NodeContext::ReplaceVariable(unsigned long start_index, list<Variable*> * closurevars)
{
        int i = 0;
        vector<Variable*>& frame = this->VarTable[this->VarTable.size() - 1];
        
        list<Variable*>::iterator closurevarindex;
                
        for(closurevarindex = closurevars->begin(); closurevarindex != closurevars->end(); closurevarindex++)
        {
                frame[start_index + i] = (*closurevarindex)->CreateVarRef();
                i++;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x58(%rdi), %r15
movq 0x60(%rdi), %r12
subq %r15, %r12
shlq $0x3, %r14
movq %rdx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0xad1e
movq 0x10(%r13), %rdi
callq 0x14f90
movq -0x18(%r15,%r12), %rcx
movq %rax, (%rcx,%r14)
addq $0x8, %r14
jmp 0xacfd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::DivOperation(ConstValue*, ConstValue*)
ConstValue * Operation::DivOperation(ConstValue * left, ConstValue * right)
{
        DecimalValue * result = NULL;

        DecimalValue value1(left->toString());
        DecimalValue value2(right->toString());

        result = new DecimalValue(value1 / value2);

        return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq (%rdi), %rax
leaq 0x78(%rsp), %r14
movq %r14, %rdi
callq *0x18(%rax)
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x7098
leaq 0x78(%rsp), %rdi
callq 0x6130
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7098
leaq 0x8(%rsp), %rdi
callq 0x6130
pushq $0x28
popq %rdi
callq 0x6260
movq %rax, %r14
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rax, %rdi
callq 0x7326
leaq 0x28(%rsp), %rdi
callq 0x71e2
leaq 0x50(%rsp), %rdi
callq 0x71e2
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x6270
jmp 0xd90e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x71e2
jmp 0xd92c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0xd92c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x71e2
jmp 0xd945
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::ANDOperation(ConstValue*, ConstValue*)
ConstValue * Operation::ANDOperation(ConstValue * left, ConstValue * right)
{
        ConstValue * result = NULL;

        if(left->GetType()==Boolean && right->GetType()==Boolean)
        {
                result = new BooleanValue(static_cast<BooleanValue*>(left)->GetValue() && static_cast<BooleanValue*>(right)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6cbc
cmpl $0x3, %eax
jne 0x10559
movq %r14, %rdi
callq 0x6cbc
cmpl $0x3, %eax
jne 0x10559
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x7504
testb %al, %al
je 0x1056e
movq %r14, %rdi
callq 0x7504
jmp 0x10570
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x6da8
jmp 0x1057b
xorl %eax, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x74a2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x10586
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::OROperation(ConstValue*, ConstValue*)
ConstValue * Operation::OROperation(ConstValue * left, ConstValue * right)
{
        ConstValue * result = NULL;

        if(left->GetType()==Boolean && right->GetType()==Boolean)
        {
                result = new BooleanValue(static_cast<BooleanValue*>(left)->GetValue() || static_cast<BooleanValue*>(right)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6cbc
cmpl $0x3, %eax
jne 0x105ee
movq %r14, %rdi
callq 0x6cbc
cmpl $0x3, %eax
jne 0x105ee
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x7504
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x105e1
movq %r14, %rdi
callq 0x7504
movzbl %al, %esi
movq %rbx, %rdi
callq 0x74a2
jmp 0x10601
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x6da8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1060c
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::NOTOperation(ConstValue*)
ConstValue * Operation::NOTOperation(ConstValue * value)
{
        ConstValue * result = NULL;

        if(value->GetType()==Boolean)
        {
                result = new BooleanValue(!static_cast<BooleanValue*>(value)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x6cbc
movl %eax, %ebp
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
cmpl $0x3, %ebp
jne 0x10657
movq %r14, %rdi
callq 0x7504
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x74a2
jmp 0x1065f
movq %rbx, %rdi
callq 0x6da8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10669
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: BreakStatement::Check()
bool BreakStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Loop)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: break statement must appear in a loop."<<endl;
        return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x1342f
cmpl $0x3, 0x8(%rbx)
jne 0x1341e
jmp 0x1344a
movq 0x2fbba(%rip), %rdi     # 0x42ff0
leaq 0x1d741(%rip), %rsi     # 0x30b7e
callq 0x6240
movq %rax, %rdi
callq 0x6140
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: ContinueStatement::Check()
bool ContinueStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Loop)
                {
                        return true;
                }
                
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: continue statement must appear in a loop."<<endl;
        return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x1346f
cmpl $0x3, 0x8(%rbx)
jne 0x1345e
jmp 0x1348a
movq 0x2fb7a(%rip), %rdi     # 0x42ff0
leaq 0x1d73e(%rip), %rsi     # 0x30bbb
callq 0x6240
movq %rax, %rdi
callq 0x6140
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: RollbackStatement::Check()
bool RollbackStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Transaction)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: rollback statement must appear in a transaction."<<endl;
        return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x134af
cmpl $0x4, 0x8(%rbx)
jne 0x1349e
jmp 0x134ca
movq 0x2fb3a(%rip), %rdi     # 0x42ff0
leaq 0x1d73e(%rip), %rsi     # 0x30bfb
callq 0x6240
movq %rax, %rdi
callq 0x6140
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: CommitStatement::Check()
bool CommitStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Transaction)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: commit statement must appear in a transaction block."<<endl;
        return false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x134ef
cmpl $0x4, 0x8(%rbx)
jne 0x134de
jmp 0x1350a
movq 0x2fafa(%rip), %rdi     # 0x42ff0
leaq 0x1d745(%rip), %rsi     # 0x30c42
callq 0x6240
movq %rax, %rdi
callq 0x6140
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: ReturnStatement::Invoke(NodeContext*)
int ReturnStatement::Invoke(NodeContext * context)
{
        ConstValue * value = this->Expr->Calculate(context);
        if(value==NULL)
        {
                return NODE_RET_ERROR;
        }

        context->FunctionRet = value->DupValue();

        delete value;
        return NODE_RET_NEEDRETURN;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x60(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
je 0x13545
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, 0x50(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
pushq $0x3
jmp 0x13547
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: AssignStatement::AdjustValue(ValueBox*, ConstValue*, int)
void AssignStatement::AdjustValue(ValueBox * vbox, ConstValue * ad, int oper)
{
        if(oper==0)
        {
                vbox->SetVal(ad);
                return;
        }
        
        ConstValue * holder = vbox->GetVal();
        
        switch(oper)
        {
                case 1:
                        vbox->SetVal(Operation::AddOperation(holder, ad));
                        break;
                case 2:
                        vbox->SetVal(Operation::SubOperation(holder, ad));
                        break;
                case 3:
                        vbox->SetVal(Operation::MulOperation(holder, ad));
                        break;
                case 4:
                        vbox->SetVal(Operation::DivOperation(holder, ad));
                        break;
        }
        
        delete ad;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
testl %ecx, %ecx
je 0x13d1c
movl %ecx, %r15d
movq %r14, %rdi
callq 0x6d66
decl %r15d
cmpl $0x3, %r15d
ja 0x13d5c
leaq 0x1cd9e(%rip), %rcx     # 0x30aa4
movslq (%rcx,%r15,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbe44
jmp 0x13d51
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6d42
movq %rax, %rdi
movq %rbx, %rsi
callq 0xceb4
jmp 0x13d51
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd860
jmp 0x13d51
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc50c
movq %r14, %rdi
movq %rax, %rsi
callq 0x6d42
testq %rbx, %rbx
je 0x13d6f
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
nop