LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9c72
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x8d74
movq 0x40(%rax), %rax
jmp 0x8d76
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x2d325(%rip), %rsi     # 0x3610f
leaq 0x2d31f(%rip), %rdx     # 0x36110
callq 0x7d3c
movq 0x28(%r15), %r14
leaq 0x18(%r15), %r13
cmpq %r13, %r14
je 0x8eb6
movl 0x38(%r15), %r15d
leaq 0x2d2f9(%rip), %r12     # 0x3610b
leaq 0x2d2f4(%rip), %rbp     # 0x3610d
movq %rbx, %rdi
leaq 0x2d2e6(%rip), %rsi     # 0x36109
callq 0x64b0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x60e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64b0
movq 0x40(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8e83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64b0
cmpl $0x2, %r15d
jl 0x8e9f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64b0
movq %r14, %rdi
callq 0x61c0
movq %rax, %r14
decl %r15d
cmpq %r13, %rax
jne 0x8e19
leaq 0x2d254(%rip), %rsi     # 0x36111
movq %rbx, %rdi
callq 0x64b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8efc
jmp 0x8efc
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8eff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8eff
movq %rax, %r14
movq (%rsp), %rax
movq (%rbx), %rdi
cmpq %rax, %rdi
je 0x8f16
movq (%rax), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x7, %eax
ja 0x8fb8
leaq 0x2d111(%rip), %rcx     # 0x36050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x18, %edi
callq 0x6260
movq %rax, %rbx
movl $0x1, 0x8(%rax)
leaq 0x3dd95(%rip), %rax     # 0x46cf8
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x90b1
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movl $0x3, 0x8(%rax)
leaq 0x3ddca(%rip), %rax     # 0x46d58
movq %rax, (%rbx)
movb $0x0, 0xc(%rbx)
jmp 0x90b1
movl $0x20, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x18d04
jmp 0x90b1
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x3dcc5(%rip), %rax     # 0x46c98
movq %rax, (%rbx)
jmp 0x90b1
movl $0x28, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x31f7b(%rip), %rsi     # 0x3af73
leaq 0x31f75(%rip), %rdx     # 0x3af74
movq %rsp, %rdi
callq 0x7d3c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8270
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x90b1
movq 0x10(%rsp), %rsi
jmp 0x906c
movl $0x30, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2cfdb(%rip), %rdx     # 0x3601e
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x7d3c
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7f9a
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x90b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x90b1
movl $0x40, %edi
callq 0x6260
movq %rax, %rbx
movl $0x6, 0x8(%rax)
leaq 0x3dd27(%rip), %rax     # 0x46db8
movq %rax, (%rbx)
leaq 0x18(%rbx), %rax
movl $0x0, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x90f8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x90f8
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9102
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x9102
movq %rax, %r14
movl $0x30, %esi
jmp 0x9111
movq %rax, %r14
movl $0x28, %esi
jmp 0x9111
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdx, %r12
movq %rdi, %rbx
movl $0x7, 0x8(%rdi)
leaq 0x3dca1(%rip), %rax     # 0x46de8
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%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 %r14, 0x10(%rsp)
callq 0x6030
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x9848
movq %r15, 0x30(%rbx)
testq %r15, %r15
jle 0x91f4
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x8f22
movq %rax, %r13
movl $0x10, %edi
callq 0x6260
movq $0x0, (%rax)
movq $0x1, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x91e9
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%r14)
incq %rbp
cmpq %rbp, %r15
jne 0x91a7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9205
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9221
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6270
movq %r15, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3dbb0(%rip), %rax     # 0x46de8
movq %rax, (%rdi)
cmpq $0x0, 0x30(%rdi)
jle 0x9260
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x9257
callq 0x7e66
incq %r14
cmpq %r14, 0x30(%rbx)
jg 0x9245
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9273
movl $0x8, %esi
callq 0x6270
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x928f
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6270
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x2cd07(%rip), %rsi     # 0x3610f
leaq 0x2cd01(%rip), %rdx     # 0x36110
callq 0x7d3c
movq 0x30(%r14), %rbp
testl %ebp, %ebp
jle 0x94ad
leal -0x1(%rbp), %eax
movslq %eax, %r12
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rcx
cmpq $0x0, (%rcx)
je 0x9482
movq (%rax,%r15,8), %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9491
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x9491
movq %rbx, %rdi
leaq 0x2cc87(%rip), %rsi     # 0x36113
callq 0x64b0
cmpq %r12, %r15
jge 0x94a5
movq %rbx, %rdi
leaq 0x2cc6b(%rip), %rsi     # 0x3610b
callq 0x64b0
incq %r15
cmpq %r15, %rbp
jne 0x9434
leaq 0x2cc5d(%rip), %rsi     # 0x36111
movq %rbx, %rdi
callq 0x64b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x94f3
jmp 0x94f3
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x94f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x94f6
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x950e
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq 0x60(%rdi), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x9f02
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r12), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x9ef8
movq %rbx, %rdi
callq 0xc748
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0xc3c2
movl %eax, %r15d
movq %rbx, %rdi
callq 0xc6cc
testl %r15d, %r15d
cmovnel %r15d, %ebp
jne 0x9f04
movq (%r12), %r12
cmpq 0x60(%r14), %r12
jne 0x9ec4
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9f7c
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xc3ee
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x9f56
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9fae
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x9f94
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa0aa
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testq %rbx, %rbx
je 0xa0b8
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_O1/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 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xa0f3
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_O1/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
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7e02
movl $0x20, %edi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x886e
movq %rbx, %rdi
callq 0x7e66
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
movq %r15, %rdi
jmp 0xa1a1
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa40e
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 0xa3e8
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa440
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xa426
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa4e2
testq %rax, %rax
je 0xaac4
movq %rax, %rdi
callq 0x7ec4
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7f20
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r14, %r15
sete %bpl
je 0xab56
movq %rdi, %rbx
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0xab4a
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 0xab22
cmpq %r12, %r13
jne 0xab56
movq (%r15), %r15
cmpq %r14, %r15
sete %bpl
jne 0xab1b
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq 0x10(%rdi), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x99e8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xc57c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xabd4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
testq %r14, %r14
je 0xac1f
movq %r14, 0x38(%rbx)
movq (%rsp), %rax
movq %rax, 0x58(%rbx)
movq 0x40(%rbx), %r14
addq $0x40, %rbx
movb $0x1, %bpl
cmpq %rbx, %r14
je 0xac8a
movq 0x10(%r14), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0xac1a
movq 0x10(%r12), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xac00
jmp 0xac88
movq (%r14), %r14
jmp 0xabf0
movq 0x3d3ca(%rip), %r14     # 0x47ff0
leaq 0x2b5c6(%rip), %rsi     # 0x361f3
movl $0x1f, %edx
movq %r14, %rdi
callq 0x62f0
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x62f0
movq %rax, %rbx
leaq 0x2b5bf(%rip), %rsi     # 0x36213
movl $0x15, %edx
movq %rax, %rdi
callq 0x62f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xacb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb3aa
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0xb3ac
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 0xb381
jmp 0xb3ac
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb3ea
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0xb3ec
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xb3cd
jmp 0xb3ec
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6370
movq %r14, %rdi
movl $0x1, %esi
callq 0x6380
leaq -0x5507(%rip), %rdx     # 0x6532
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6490
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x6160
movb %bpl, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xbd36
movq (%r15), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x18(%rdi), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x18cc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xc8d2
movq (%rax), %r15
leaq 0x20(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xc447
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
testq %r15, %r15
je 0xc4af
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0xc463
movq (%rax), %rsi
incq %rsi
callq 0x6270
movl $0x40, %esi
movq %r15, %rdi
callq 0x6270
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x18cc0
movq %r14, %rdi
movq %r15, %rsi
callq 0xce8e
movq %r14, %rdi
movq %rax, %rsi
callq 0xcf36
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc4af
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x18ce2
movq 0x8(%rsp), %rdi
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x3, %rsi
callq 0x18cee
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x18cc0
movq %r14, %rdi
movq %r12, %rsi
callq 0xc8d2
movq %r15, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc50c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0xc525
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0xc536
addq $0x48, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xd020
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc559
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc566
jmp 0xc573
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc573
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd15c
leaq 0x20(%r15), %rcx
cmpq %rcx, %rax
je 0xc5b5
movq 0x40(%rax), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r15), %r15
testq %r15, %r15
je 0xc611
testq %rbx, %rbx
je 0xc5c6
incq (%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x99e8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc57c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc5a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xc5a6
xorl %ebx, %ebx
jmp 0xc5a6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc62f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x48(%rsi), %rbp
cmpq 0x50(%rsi), %rbp
je 0xc7dd
movq %rsi, %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq (%rbp), %r13
movq %r13, %rdi
callq 0x18cfa
testb %al, %al
je 0xc7b2
movq %r13, %rdi
callq 0x18bf2
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xc7c8
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0xc7d3
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xd47a
jmp 0xc7d3
movq %r15, %rdi
movq %r12, %rdx
callq 0xd33e
addq $0x8, %rbp
cmpq 0x50(%r14), %rbp
jne 0xc77e
addq $0x58, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xca7a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc802
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6270
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc817
jmp 0xc817
jmp 0xc817
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc830
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
cmpq %rdx, %r15
je 0xc87c
movq %rdx, %rbx
movq %rsi, %r14
movq 0x58(%rdi), %r12
movq 0x60(%rdi), %r13
subq %r12, %r13
shlq $0x3, %r14
movq 0x10(%r15), %rdi
callq 0x18aec
movq -0x18(%r12,%r13), %rcx
movq %rax, (%rcx,%r14)
movq (%r15), %r15
addq $0x8, %r14
cmpq %rbx, %r15
jne 0xc85e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x18(%rax)
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x8270
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfa88
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6270
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8270
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfac0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movl $0x28, %edi
callq 0x6260
movq %rax, %r14
leaq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rax, %rdi
callq 0x8606
leaq 0x48(%rsp), %rdi
callq 0x841c
leaq 0x70(%rsp), %rdi
callq 0x841c
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x6270
jmp 0xfb16
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x841c
jmp 0xfb45
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xfb45
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x841c
movq %rbx, %rdi
callq 0x6470
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb4f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xfb4f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7dee
cmpl $0x3, %eax
jne 0x13429
movq %r14, %rdi
callq 0x7dee
cmpl $0x3, %eax
jne 0x13429
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x881a
testb %al, %al
je 0x13440
movq %r14, %rdi
callq 0x881a
jmp 0x13442
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7f20
jmp 0x1344d
xorl %eax, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x87ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13458
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7dee
cmpl $0x3, %eax
jne 0x134c4
movq %r14, %rdi
callq 0x7dee
cmpl $0x3, %eax
jne 0x134c4
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x881a
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x134b7
movq %r14, %rdi
callq 0x881a
movzbl %al, %esi
movq %rbx, %rdi
callq 0x87ac
jmp 0x134d9
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7f20
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x134e4
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7dee
movl %eax, %ebp
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
cmpl $0x3, %ebp
jne 0x13533
movq %r14, %rdi
callq 0x881a
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x87ac
jmp 0x1353b
movq %rbx, %rdi
callq 0x7f20
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x13545
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x166a8
cmpl $0x3, 0x8(%rbx)
jne 0x16697
jmp 0x166ea
movq 0x31941(%rip), %r14     # 0x47ff0
leaq 0x214cc(%rip), %rsi     # 0x37b82
movl $0x3c, %edx
movq %r14, %rdi
callq 0x62f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x1671a
cmpl $0x3, 0x8(%rbx)
jne 0x16709
jmp 0x1675c
movq 0x318cf(%rip), %r14     # 0x47ff0
leaq 0x21497(%rip), %rsi     # 0x37bbf
movl $0x3f, %edx
movq %r14, %rdi
callq 0x62f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x1678c
cmpl $0x4, 0x8(%rbx)
jne 0x1677b
jmp 0x167ce
movq 0x3185d(%rip), %r14     # 0x47ff0
leaq 0x21465(%rip), %rsi     # 0x37bff
movl $0x46, %edx
movq %r14, %rdi
callq 0x62f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x167fe
cmpl $0x4, 0x8(%rbx)
jne 0x167ed
jmp 0x16840
movq 0x317eb(%rip), %r14     # 0x47ff0
leaq 0x2143a(%rip), %rsi     # 0x37c46
movl $0x4a, %edx
movq %r14, %rdi
callq 0x62f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16884
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)
movl $0x3, %eax
jmp 0x16889
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x173f0
movl %ecx, %r15d
movq %r14, %rdi
callq 0x7ec4
decl %r15d
cmpl $0x3, %r15d
ja 0x17430
leaq 0x206ce(%rip), %rcx     # 0x37aa8
movslq (%rcx,%r15,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7d8
jmp 0x17425
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7ea0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xedba
jmp 0x17425
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfa42
jmp 0x17425
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe136
movq %r14, %rdi
movq %rax, %rsi
callq 0x7ea0
testq %rbx, %rbx
je 0x17443
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/statement.cpp
// Function: AssignStatement::Provision()
bool AssignStatement::Provision()
{
        list<list<Expression*>*>* exprslist = this->Reference->GetExpsList();

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

        this->Expr->SetParentNode(this);
        if(this->Expr->Provision()==false)
        {
                return false;
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movq 0x20(%rax), %r14
movq (%r14), %r15
cmpq %r14, %r15
je 0x174ad
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x1749c
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0x9fe8
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x17477
jmp 0x174a1
movq (%r15), %r15
jmp 0x1746b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0x9fe8
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/src/parser/statement.cpp
// Function: PrintStatement::Invoke(NodeContext*)
int PrintStatement::Invoke(NodeContext * context)
{
        list<Expression*>::iterator i;
        for(i = ExprList->begin(); i!= ExprList->end(); i++)
        {
                ConstValue * value = (*i)->Calculate(context);
                if(value==NULL)
                {
                        return NODE_RET_ERROR;
                }

                fprintf(stdout, "%s", value->toString().c_str());
                fflush(stdout);
                
                delete value;
        }
        return NODE_RET_NORMAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x60(%rdi), %rcx
movq (%rcx), %rbx
xorl %eax, %eax
cmpq %rcx, %rbx
je 0x17d5a
movq %rsi, %r14
movq %rdi, %r15
movq 0x302c3(%rip), %r12     # 0x47fa8
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
testq %rax, %rax
je 0x17d55
movq %rax, %r13
movq (%r12), %rbp
movq (%rax), %rax
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x62d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17d35
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq (%r12), %rdi
callq 0x6320
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq (%rbx), %rbx
cmpq 0x60(%r15), %rbx
jne 0x17ce5
xorl %eax, %eax
jmp 0x17d5a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop