LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc7e2
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 0x18798
movq -0x18(%r12,%r13), %rcx
movq %rax, (%rcx,%r14)
movq (%r15), %r15
addq $0x8, %r14
cmpq %rbx, %r15
jne 0xc7c4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8222
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf9fe
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 0x8222
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfa36
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 0x85b8
leaq 0x48(%rsp), %rdi
callq 0x83ce
leaq 0x70(%rsp), %rdi
callq 0x83ce
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x6270
jmp 0xfa8c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x83ce
jmp 0xfabb
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfabb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xfabb
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x83ce
movq %rbx, %rdi
callq 0x6460
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfac5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xfac5
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7da6
cmpl $0x3, %eax
jne 0x1339b
movq %r14, %rdi
callq 0x7da6
cmpl $0x3, %eax
jne 0x1339b
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x87d2
testb %al, %al
je 0x133b2
movq %r14, %rdi
callq 0x87d2
jmp 0x133b4
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7ed2
jmp 0x133bf
xorl %eax, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x8764
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x133ca
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7da6
cmpl $0x3, %eax
jne 0x13436
movq %r14, %rdi
callq 0x7da6
cmpl $0x3, %eax
jne 0x13436
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %r15, %rdi
callq 0x87d2
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x13429
movq %r14, %rdi
callq 0x87d2
movzbl %al, %esi
movq %rbx, %rdi
callq 0x8764
jmp 0x1344b
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7ed2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13456
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7da6
movl %eax, %ebp
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
cmpl $0x3, %ebp
jne 0x134a5
movq %r14, %rdi
callq 0x87d2
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x8764
jmp 0x134ad
movq %rbx, %rdi
callq 0x7ed2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x134b7
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1649c
cmpl $0x3, 0x8(%rbx)
jne 0x1648b
jmp 0x164de
movq 0x30b4d(%rip), %r14     # 0x46ff0
leaq 0x206d4(%rip), %rsi     # 0x36b7e
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_O3/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 0x1650e
cmpl $0x3, 0x8(%rbx)
jne 0x164fd
jmp 0x16550
movq 0x30adb(%rip), %r14     # 0x46ff0
leaq 0x2069f(%rip), %rsi     # 0x36bbb
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_O3/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 0x16580
cmpl $0x4, 0x8(%rbx)
jne 0x1656f
jmp 0x165c2
movq 0x30a69(%rip), %r14     # 0x46ff0
leaq 0x2066d(%rip), %rsi     # 0x36bfb
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_O3/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 0x165f2
cmpl $0x4, 0x8(%rbx)
jne 0x165e1
jmp 0x16634
movq 0x309f7(%rip), %r14     # 0x46ff0
leaq 0x20642(%rip), %rsi     # 0x36c42
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_O3/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 0x16678
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 0x1667d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x170e0
movl %ecx, %r15d
movq %r14, %rdi
callq 0x7e76
decl %r15d
cmpl $0x3, %r15d
ja 0x17120
leaq 0x1f9da(%rip), %rcx     # 0x36aa4
movslq (%rcx,%r15,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd750
jmp 0x17115
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7e52
movq %rax, %rdi
movq %rbx, %rsi
callq 0xed30
jmp 0x17115
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf9b8
jmp 0x17115
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe0ac
movq %r14, %rdi
movq %rax, %rsi
callq 0x7e52
testq %rbx, %rbx
je 0x17133
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_O3/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 0x1719d
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x1718c
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0x9fb8
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x17167
jmp 0x17191
movq (%r15), %r15
jmp 0x1715b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0x9fb8
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_O3/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 0x17a4a
movq %rsi, %r14
movq %rdi, %r15
movq 0x2f5d3(%rip), %r12     # 0x46fa8
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
testq %rax, %rax
je 0x17a45
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 0x17a25
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 0x179d5
xorl %eax, %eax
jmp 0x17a4a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/statement.cpp
// Function: PrintStatement::Provision()
bool PrintStatement::Provision()
{
        list<Expression*>::iterator i;
        for(i = ExprList->begin(); i!= ExprList->end(); i++)
        {
                (*i)->SetParentNode(this);
                if((*i)->Provision()==false)
                {
                        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 0x17a92
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x9fb8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x17a6c
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/statement.cpp
// Function: PrintStatement::Check()
bool PrintStatement::Check()
{
        list<Expression*>::iterator i;
        for(i = ExprList->begin(); i!= ExprList->end(); i++)
        {
                if((*i)->Check()==false)
                {
                        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 0x17ac4
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x17aaa
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/statement.cpp
// Function: SleepStatement::Invoke(NodeContext*)
int SleepStatement::Invoke(NodeContext * context)
{
        ConstValue * value = this->Expr->Calculate(context);
        if(value==NULL)
        {
                return NODE_RET_ERROR;
        }

        if(value->GetType()!=Integer)
        {
                //TODO
                cerr<<"pupp runtime error: SLEEP Statement need a Integer parameter. "<<endl;
                return NODE_RET_ERROR;
        }

        usleep(static_cast<IntegerValue*>(value)->GetValue());

        delete value;
        return NODE_RET_NORMAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x17b56
movq %rax, %r14
movq %rax, %rdi
callq 0x7da6
cmpl $0x1, %eax
jne 0x17b14
movq %r14, %rdi
callq 0x8160
movl %eax, %edi
callq 0x63a0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x17b56
movq 0x2f4d5(%rip), %r14     # 0x46ff0
leaq 0x1f414(%rip), %rsi     # 0x36f36
movl $0x3e, %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
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/variable.cpp
// Function: Variable::SetValue(ConstValue*)
void Variable::SetValue(ConstValue * value)
{
        if(this->VBox==NULL)
        {
                this->VBox = new ValueBox;
        }

        if(this->VarType==value->GetType())
        {
                ConstValue * val = value->DupValue();
                this->VBox->SetVal(val);
        }
        else
        {
                ConstValue * newvalue = ConstValueCast(value, this->VarType);
                this->VBox->SetVal(newvalue);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
jne 0x18637
movl $0x10, %edi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
callq 0x7daa
movq %r15, 0x30(%rbx)
movl 0x8(%rbx), %ebp
movq %r14, %rdi
callq 0x7da6
cmpl %eax, %ebp
jne 0x18651
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
jmp 0x1865c
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x952b
movq 0x30(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7e52
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/variable.cpp
// Function: Variable::GetValue()
ConstValue * Variable::GetValue()
{
        ConstValue * value = NULL;

        if(this->VBox==NULL)
        {
                this->VBox = new ValueBox;
                DefaultValueFactory defvalue(this->VarType);
                value = defvalue.GetValue();
                this->VBox->SetVal(value);
        }
        else
        {
                value = this->VBox->GetVal()->DupValue();
        }

        return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x186af
callq 0x7e76
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
movl $0x10, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x7daa
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x8ed6
movq %r14, %rdi
callq 0x8eda
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x7e52
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/variable.cpp
// Function: Variable::GetValueType()
DataType Variable::GetValueType()
{
        if(this->VBox==NULL)
        {
                this->VBox = new ValueBox;
                DefaultValueFactory defvalue(this->VarType);
                ConstValue * value = defvalue.GetValue();
                this->VBox->SetVal(value);
        }

        return this->VBox->GetVal()->GetType();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x1876b
movl $0x10, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x7daa
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x8ed6
movq %r14, %rdi
callq 0x8eda
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x7e52
movq 0x30(%rbx), %rdi
callq 0x7e76
movq %rax, %rdi
callq 0x7da6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/variable.cpp
// Function: Variable::CreateVarRef()
Variable * Variable::CreateVarRef()
{
        Variable * ret = new Variable(this->VarName, this->VarType);
        ret->SetSource(this->Source);

        if(this->VBox!=NULL)
        {
                this->VBox->IncRefCount();
                ret->SetVBox(this->VBox);
        }
        return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0x38, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x99a6
movl 0x8(%r14), %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x184e8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x187f2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x1880e
callq 0x7e18
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18839
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x18839
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/variable.cpp
// Function: VariableDef::GetInstance()
Variable * VariableDef::GetInstance()
{
        Variable * ret = new Variable(this->VarName, this->VarType);
        ret->SetSource(this);
        
        DefaultValueFactory fac(this->VarType);
        ConstValue * value = fac.GetValue();
        ret->SetRef(value);

        return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movl $0x38, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x99a6
movl 0x20(%r14), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x184e8
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x188fc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
movq %r14, (%rbx)
movl 0x20(%r14), %esi
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x8ed6
movq %r14, %rdi
callq 0x8eda
movq %rbx, %rdi
movq %rax, %rsi
callq 0x185b4
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1894f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x1894f
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/closure.cpp
// Function: FuncValue::~FuncValue()
FuncValue::~FuncValue()
{
        list<Variable*>::iterator i;
        if(this->ClosureVars!=NULL)
        {
                for(i = this->ClosureVars->begin(); i!=this->ClosureVars->end(); i++)
                {
                        delete *i;
                }
                delete this->ClosureVars;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2e189(%rip), %rax     # 0x46b78
movq %rax, (%rdi)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x18a61
movq (%r14), %r15
cmpq %r14, %r15
je 0x18a32
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x18a14
movq %r14, %rdi
callq 0x18546
movl $0x38, %esi
movq %r14, %rdi
callq 0x6270
movq 0x18(%rbx), %r14
movq (%r15), %r15
cmpq %r14, %r15
jne 0x18a03
testq %r14, %r14
je 0x18a51
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x18a54
movq (%rdi), %r15
movl $0x18, %esi
callq 0x6270
movq %r15, %rdi
cmpq %r14, %r15
jne 0x18a3a
jmp 0x18a54
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x97c6
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/closure.cpp
// Function: FuncValue::DupValue()
ConstValue * FuncValue::DupValue()
{
        if(this->FuncNode==NULL)
        {
                return new FuncValue(NULL, NULL);
        }
        
        list<Variable*> * cvs = new list<Variable*>;
        list<Variable*>::iterator i;

        for(i = this->ClosureVars->begin(); i!= this->ClosureVars->end(); i++)
        {
                Variable * cv = (*i)->CreateVarRef();
                cvs->push_back(cv);
        }

        return new FuncValue(this->FuncNode, cvs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x18b2c
movq %rdi, %r14
movl $0x18, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%r14), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x18afe
movq 0x10(%r12), %rdi
callq 0x18798
movq %rax, %r15
movl $0x18, %edi
callq 0x6260
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6070
incq 0x10(%rbx)
movq (%r12), %r12
cmpq 0x18(%r14), %r12
jne 0x18ac6
movq 0x10(%r14), %r15
movl $0x20, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
callq 0x7d96
leaq 0x2e059(%rip), %rax     # 0x46b78
movq %rax, (%r14)
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
jmp 0x18b58
movl $0x20, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
callq 0x7d96
leaq 0x2e02b(%rip), %rax     # 0x46b78
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x18b69
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/ifelse.cpp
// Function: BranchNode::Invoke(NodeContext*)
int BranchNode::Invoke(NodeContext * context)
{
        int ret = this->Evaluate(context);
                       
        if(ret==EVA_TRUE)
        {
                context->AddFrame(this->ifnode);
                int ret = this->ifnode->Execute(context);
                context->PopFrame();
                return ret;
        }
        else if(ret==EVA_FALSE)
        {
                if(this->elsenode!=NULL)
                {
                        context->AddFrame(this->elsenode);
                        int ret = this->elsenode->Execute(context);
                        context->PopFrame();
                        return ret;
                }

                return NODE_RET_NORMAL;
        }

        return NODE_RET_ERROR;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18c34
testl %eax, %eax
je 0x18bff
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
jne 0x18c2b
movq 0x70(%r14), %rsi
addq $0x70, %r14
jmp 0x18c0c
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x18c30
addq $0x78, %r14
movq %rbx, %rdi
callq 0xc6ae
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xc316
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc626
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x18c2b
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/ifelse.cpp
// Function: BranchNode::Evaluate(NodeContext*)
int BranchNode::Evaluate(NodeContext * context)
{
        ConstValue * eva = this->condition->Calculate(context);
        if(eva==NULL)
        {
                return EVA_ERROR;
        }

        if(eva->GetType()!=Boolean)
        {
                ConstValue * thevalue = ConstValueCast(eva, Boolean);
                
                if(thevalue==NULL)
                {
                        cerr<<"pupp runtime error: Wrong data type in if statement - expect a boolean value."<<endl;
                        return EVA_ERROR;
                }
                
                delete eva;
                eva = thevalue;
                
        }

        bool ret = static_cast<BooleanValue*>(eva)->GetValue();
        delete eva;

        return ret?EVA_TRUE:EVA_FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x18c94
movq %rax, %r14
movq %rax, %rdi
callq 0x7da6
cmpl $0x3, %eax
je 0x18c7e
movq %r14, %rdi
movl $0x3, %esi
callq 0x952b
testq %rax, %rax
je 0x18c9c
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, %rdi
callq 0x87d2
movl %eax, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movzbl %bl, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2e34d(%rip), %r14     # 0x46ff0
leaq 0x1e332(%rip), %rsi     # 0x36fdc
movl $0x4d, %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
jmp 0x18c94
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/ifelse.cpp
// Function: BranchNode::Provision()
bool BranchNode::Provision()
{
        condition->SetParentNode(this);
        if(condition->Provision()==false)
        {
               return false;
        }

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

        if(this->elsenode!=NULL)
        {
               this->elsenode->SetParentNode(this);
               if(this->elsenode->Provision()==false)
               {
                        return false;
               }
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
movq %rbx, %rsi
callq 0x9fb8
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x18d4d
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0xc342
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x18d4d
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x18d49
movq %rbx, %rsi
callq 0xc342
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x18d4d
movb $0x1, %al
jmp 0x18d4f
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/ifelse.cpp
// Function: BranchNode::Check()
bool BranchNode::Check()
{
        if(condition->Check()==false)
        {
                return false;
        }

        if(this->ifnode->Check()==false)
        {
                return false;
        }

        if(this->elsenode!=NULL)
        {
                if(this->elsenode->Check()==false)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x18d89
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x18d89
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x18d85
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x18d89
movb $0x1, %al
jmp 0x18d8b
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: LoopNode::Invoke(NodeContext*)
int LoopNode::Invoke(NodeContext * context)
{
        if(this->PreLoopStatement(context)==false)
        {
                return NODE_RET_ERROR;
        }

        int runnable = this->Evaluate(context);
        if(runnable==-1)
        {
                return NODE_RET_ERROR;
        }

        while(runnable==1)
        {
                list<Node*>::iterator i;
                for(i = subnodelist->begin(); i != subnodelist->end(); i++)
                {
                        if((*i)->Type==Function)
                        {
                                continue;
                        }

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

                        if(ret==NODE_RET_NEEDBREAK)
                        {
                                return NODE_RET_NORMAL;
                        }
                        else if(ret==NODE_RET_NEEDCONTINUE)
                        {
                                break;
                        }
                        else if(ret==NODE_RET_ERROR)
                        {
                                return ret;
                        }
                }

                if(this->PerOnceStatement(context)==false)
                {
                        return NODE_RET_ERROR;
                }

                runnable = this->Evaluate(context);
                if(runnable==-1)
                {
                        return NODE_RET_ERROR;
                }

        }

        return NODE_RET_NORMAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x18e72
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
cmpl $-0x1, %eax
je 0x18e72
xorl %ebp, %ebp
cmpl $0x1, %eax
jne 0x18e77
movq 0x60(%r14), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x18e51
movq 0x10(%r12), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x18e4b
movq %rbx, %rdi
callq 0xc6ae
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0xc316
movl %eax, %r15d
movq %rbx, %rdi
callq 0xc626
cmpl $-0x1, %r15d
je 0x18e72
cmpl $0x1, %r15d
je 0x18e77
cmpl $0x2, %r15d
je 0x18e51
movq 0x60(%r14), %rax
movq (%r12), %r12
jmp 0x18e05
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
testb %al, %al
je 0x18e72
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
cmpl $-0x1, %eax
jne 0x18df9
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: LoopNode::Evaluate(NodeContext*)
int LoopNode::Evaluate(NodeContext * context)
{
        ConstValue * eva = this->condition->Calculate(context);
        if(eva==NULL)
        {
                return EVA_ERROR;
        }

        if(eva->GetType()!=Boolean)
        {
                ConstValue * thevalue = ConstValueCast(eva, Boolean);
                
                if(thevalue==NULL)
                {
                        cerr<<"pupp runtime error: Wrong data type in while/for statement - expect a boolean value."<<endl;
                        return EVA_ERROR;
                }
                
                delete eva;
                eva = thevalue;
                
        }

        bool ret = static_cast<BooleanValue*>(eva)->GetValue();
        delete eva;

        return ret?EVA_TRUE:EVA_FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x18f2c
movq %rax, %r14
movq %rax, %rdi
callq 0x7da6
cmpl $0x3, %eax
je 0x18f16
movq %r14, %rdi
movl $0x3, %esi
callq 0x952b
testq %rax, %rax
je 0x18f34
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, %rdi
callq 0x87d2
movl %eax, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movzbl %bl, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2e0b5(%rip), %r14     # 0x46ff0
leaq 0x1e0f5(%rip), %rsi     # 0x37037
movl $0x54, %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
jmp 0x18f2c
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForLoopNode::PreLoopStatement(NodeContext*)
bool ForLoopNode::PreLoopStatement(NodeContext * context)
{
        if(this->PreLoop==NULL)
        {
                return true;
        }

        context->AddFrame(this->PreLoop);
        int ret = this->PreLoop->Execute(context);
        context->PopFrame();
        
        if(ret!=NODE_RET_NORMAL)
        {
                return false;
        }

        return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x70(%rdi), %rsi
testq %rsi, %rsi
je 0x18fbc
movq %rdi, %r14
movq %rbx, %rdi
callq 0xc6ae
movq 0x70(%r14), %rdi
movq %rbx, %rsi
callq 0xc316
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc626
testl %ebp, %ebp
sete %al
jmp 0x18fbe
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForLoopNode::PerOnceStatement(NodeContext*)
bool ForLoopNode::PerOnceStatement(NodeContext * context)
{
        if(this->PerOnce==NULL)
        {
                return true;
        }

        context->AddFrame(this->PreLoop);
        int ret = this->PerOnce->Execute(context);
        context->PopFrame();
        
        if(ret!=NODE_RET_NORMAL)
        {
                return false;
        }

        return true;
}

// Assembly:
cmpq $0x0, 0x78(%rdi)
je 0x19001
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rsi
movq %rbx, %rdi
callq 0xc6ae
movq 0x78(%r14), %rdi
movq %rbx, %rsi
callq 0xc316
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc626
testl %ebp, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForLoopNode::Provision()
bool ForLoopNode::Provision()
{
        if(LoopNode::Provision()!=true)
        {
                return false;
        }

        if(this->PreLoop)
        {
                this->PreLoop->SetParentNode(this);
                if(this->PreLoop->Provision()!=true)
                {
                        return false;
                }
        }

        if(this->PerOnce)
        {
                this->PerOnce->SetParentNode(this);
                if(this->PerOnce->Provision()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18e88
testb %al, %al
je 0x19053
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x19030
movq %rbx, %rsi
callq 0xc342
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x19053
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1904f
movq %rbx, %rsi
callq 0xc342
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x19053
movb $0x1, %al
jmp 0x19055
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForLoopNode::Check()
bool ForLoopNode::Check()
{
        if(LoopNode::Check()!=true)
        {
                return false;
        }

        if(this->PreLoop)
        {
                if(this->PreLoop->Check()!=true)
                {
                        return false;
                }
        }

        if(this->PerOnce)
        {
                if(this->PerOnce->Check()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9f58
testb %al, %al
je 0x1909d
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x1909d
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x19086
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1909d
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x19099
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1909d
movb $0x1, %al
jmp 0x1909f
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::PreLoopStatement(NodeContext*)
bool ForeachLoopNode::PreLoopStatement(NodeContext * context)
{
        ConstValue * keeper = this->CollectionExpr->Calculate(context);
        if(keeper==NULL)
        {
                return false;
        }

        if(keeper->GetType()!=Map)
        {
                cerr<<"pupp runtime warning: FOREACH need a collection as input."<<endl;
                context->ForeachCtx.push(NULL);
                return true;
        }

        ForeachLoopCtx * ctx = new ForeachLoopCtx;
        ctx->Keeper         = keeper;
        ctx->SetValueHolder = static_cast<MapValue*>(keeper)->GetValue();
        ctx->ValueHandle    = ctx->SetValueHolder->begin();

        context->ForeachCtx.push(ctx);

        if(ctx->ValueHandle!=ctx->SetValueHolder->end())
        {
                this->ProvisionKV(context);
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0xd0(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x191a8
movq %rbx, %rdi
callq 0x7da6
cmpl $0x6, %eax
jne 0x19125
movl $0x18, %edi
callq 0x6260
movq %rax, %r12
movq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0x8d30
movq %rax, 0x8(%r12)
movq 0x18(%rax), %rax
movq %rax, 0x10(%r12)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x1917b
movq %r12, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x1918d
movq 0x2dec4(%rip), %r15     # 0x46ff0
leaq 0x1df59(%rip), %rsi     # 0x3708c
movl $0x39, %edx
movq %r15, %rdi
callq 0x62f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %r15, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
movq %rsp, %rsi
movq $0x0, (%rsi)
movq %r14, %rdi
callq 0x19698
jmp 0x191a8
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x198fa
movq (%r12), %r12
movq 0x8(%r12), %rax
addq $0x8, %rax
cmpq %rax, 0x10(%r12)
je 0x191a8
movq %r15, %rdi
movq %r14, %rsi
callq 0x191ba
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::ProvisionKV(NodeContext*)
void ForeachLoopNode::ProvisionKV(NodeContext * context)
{
        ForeachLoopCtx * ctx = context->ForeachCtx.top();

        Variable * key = context->GetVariable(0, this->KeyIndex);
        Variable * value = context->GetVariable(0, this->ValueIndex);

        ConstValue * tmpkey = new StringValue(ctx->ValueHandle->first);
        key->SetValue(tmpkey);
        delete tmpkey;

        ValueBox * tmpvalue = ctx->ValueHandle->second;

        value->SetVarType(tmpvalue->GetVal()->GetType());
        value->SetValue(tmpvalue->GetVal());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
cmpq 0x38(%rsi), %rax
jne 0x191e4
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r12
movq 0xc0(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc7ec
movq %rax, %r15
movq 0xc8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc7ec
movq %rax, %r14
movl $0x30, %edi
callq 0x6260
movq %rax, %rbx
movq 0x10(%r12), %rax
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x99a6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7f4c
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1925f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1860a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x10(%r12), %rax
movq 0x40(%rax), %rbx
movq %rbx, %rdi
callq 0x7e76
movq %rax, %rdi
callq 0x7da6
movq %r14, %rdi
movl %eax, %esi
callq 0x18712
movq %rbx, %rdi
callq 0x7e76
movq %r14, %rdi
movq %rax, %rsi
callq 0x1860a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x192d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x192d5
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::PerOnceStatement(NodeContext*)
bool ForeachLoopNode::PerOnceStatement(NodeContext * context)
{
        ForeachLoopCtx * ctx = context->ForeachCtx.top();
        if(ctx==NULL)
        {
                return true;
        }

        ctx->ValueHandle++;

        if(ctx->ValueHandle!=ctx->SetValueHolder->end())
        {
                this->ProvisionKV(context);
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
cmpq 0x38(%rsi), %rax
jne 0x1930c
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r15
testq %r15, %r15
je 0x1933a
movq 0x10(%r15), %rdi
callq 0x61c0
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x1933a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x191ba
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::Swipe(NodeContext*)
void ForeachLoopNode::Swipe(NodeContext * context)
{
        ForeachLoopCtx * ctx = context->ForeachCtx.top();
        if(ctx!=NULL)
        {
                delete ctx->Keeper;
                delete ctx;
        }

        context->ForeachCtx.pop();
        ForLoopNode::Swipe(NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x30(%rsi), %rax
cmpq 0x38(%rsi), %rax
jne 0x19360
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r14
testq %r14, %r14
je 0x19384
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19377
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x18, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x199c2
nop