LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%r15), %r15
cmpq %r14, %r15
je 0x13dd5
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x13d97
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0x89f2
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x13da6
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0x89f2
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_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: AssignStatement::Check()
bool AssignStatement::Check()
{
        unsigned long layer = 1;
        
        Node * parent = this->GetParentNode();
        this->VarDef = parent->FindVariable(this->Reference->GetVarName(), &layer);
        
        if(this->VarDef==NULL)
        {
                cerr<<"pupp provision error: Variable "<<this->Reference->GetVarName()<<"has not defined"<<endl;
                return false;
        }
        
        this->VarLayer = layer;
        
        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++)
                {
                        if((*i)->Check()==false)
                        {
                                return false;
                        }
                }
        }
        
        if(this->Expr->Check()==false)
        {
                return false;
        }

        return true;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x1, (%r14)
callq 0xa9b0
movq %rax, %r15
movq 0x68(%rbx), %rsi
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x6380
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xaaac
movq %rax, 0x78(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x6130
cmpq $0x0, 0x78(%rbx)
je 0x13e8f
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rbx)
movq 0x68(%rbx), %rax
movq 0x20(%rax), %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x13ef2
movq 0x10(%r15), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x13e63
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x13e76
jmp 0x13ee2
movq 0x2f15a(%rip), %rdi     # 0x42ff0
leaq 0x1b356(%rip), %rsi     # 0x2f1f3
callq 0x6240
movq %rax, %r14
movq 0x68(%rbx), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x6380
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6210
leaq 0x1cfb9(%rip), %rsi     # 0x30e81
movq %rax, %rdi
callq 0x6240
movq %rax, %rdi
callq 0x6140
leaq 0x10(%rsp), %rdi
callq 0x6130
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x13ee4
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x13f10
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/statement.cpp
// Function: VarDefinitionStatement::Provision()
bool VarDefinitionStatement::Provision()
{
        Node * parent = this->GetParentNode();

        if(parent)
        {
                string varname = *(this->Ident);
                if(parent->FindVariable(varname, NULL))
                {
                        cerr<<"pupp provision error: Duplicated variable: "<<varname<<endl;
                        return false;
                }

                this->VarDef = new VariableDef(varname);
                this->VarDef->SetVarType(this->VarType->GetVarType());

                //Variable type has to be determined before Lambda expression defined.
                if(this->InitExpr!=NULL && this->InitExpr->IsLambdaExp())
                {
                        this->VarDef->SetVarType(Func);
                }

                parent->AddVariable(this->VarDef);
        }

        if(this->InitExpr)
        {
                this->InitExpr->SetParentNode(this);
                return this->InitExpr->Provision();
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0xa9b0
testq %rax, %rax
je 0x142ed
movq %rax, %r15
movq 0x70(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6380
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6380
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0xaaac
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6130
testq %r14, %r14
je 0x1426c
movq 0x2eda7(%rip), %rdi     # 0x42ff0
leaq 0x1ccba(%rip), %rsi     # 0x30f0a
callq 0x6240
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x6210
movq %rax, %rdi
callq 0x6140
jmp 0x142da
pushq $0x40
popq %rdi
callq 0x6260
movq %rax, %r12
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6380
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x1501a
movq %r12, 0x60(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x6130
movq 0x60(%rbx), %rdi
movq 0x78(%rbx), %rax
movl (%rax), %esi
callq 0x150ee
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x142ce
callq 0x8a06
testb %al, %al
je 0x142ce
movq 0x60(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x150ee
movq 0x60(%rbx), %rsi
movq %r15, %rdi
callq 0xa9c0
leaq 0x8(%rsp), %rdi
callq 0x6130
testq %r14, %r14
je 0x142ed
xorl %eax, %eax
jmp 0x1430c
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1430a
movq %rbx, %rsi
callq 0x89f2
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1430c
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6130
jmp 0x1432a
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x6270
jmp 0x14349
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6130
jmp 0x14349
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, (%rsp)
movq %rdi, %r15
movq 0x60(%rdi), %rax
leaq 0x8(%rsp), %r12
movq %rax, %rbx
movq (%rbx), %rbx
cmpq %rax, %rbx
je 0x143f0
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq (%rsp), %rsi
callq *0x10(%rax)
testq %rax, %rax
je 0x143f4
movq %rax, %r13
movq 0x2ebf4(%rip), %r14     # 0x42fa8
movq (%r14), %rbp
movq (%rax), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x62c0
movq %r12, %rdi
callq 0x6130
movq (%r14), %rdi
callq 0x62f0
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq 0x60(%r15), %rax
jmp 0x1438f
xorl %eax, %eax
jmp 0x143f7
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1443e
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x89f2
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x14418
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14470
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x14456
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x144d9
movq %rax, %r14
movq %rax, %rdi
callq 0x6cbc
cmpl $0x1, %eax
jne 0x144be
movq %r14, %rdi
callq 0x6fe4
movl %eax, %edi
callq 0x6390
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x144d9
movq 0x2eb2b(%rip), %rdi     # 0x42ff0
leaq 0x1ca6a(%rip), %rsi     # 0x30f36
callq 0x6240
movq %rax, %rdi
callq 0x6140
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/transaction.cpp
// Function: TransNode::Check()
bool TransNode::Check()
{
        Node * parent = this->GetParentNode();
        
        list<string*>::iterator i;
        for(i = this->IdList->begin(); i!= this->IdList->end(); i++)
        {
                unsigned long layer = 1;
                
                VariableDef * vardef = parent->FindVariable(**i, &layer);
                if(vardef==NULL)
                {
                        cerr<<"pupp provision error: Variable "<<**i<<" has not been defined"<<endl;
                        return false;
                }

                VariableDef * newvardef = new VariableDef(**i);
                newvardef->SetVarType(vardef->GetVarType());
                this->AddVariable(newvardef);
                
                TransIdentDesc desc = {vardef, newvardef, layer};

                this->VarDefList.push_back(desc);
        }
        
        return ContainerNode::Check();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xa9b0
movq %rax, 0x18(%rsp)
movq 0x68(%rbx), %rax
leaq 0x70(%rbx), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x58(%rsp), %r12
leaq 0x38(%rsp), %rbp
movq %rax, %r14
movq (%r14), %r14
cmpq %rax, %r14
je 0x14b67
movq $0x1, 0x8(%rsp)
movq 0x10(%r14), %rsi
movq %r12, %rdi
callq 0x6380
movq 0x18(%rsp), %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0xaaac
movq %rax, %r15
movq %r12, %rdi
callq 0x6130
testq %r15, %r15
je 0x14b71
pushq $0x40
popq %rdi
callq 0x6260
movq %rax, %r13
movq 0x10(%r14), %rsi
movq %rbp, %rdi
callq 0x6380
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1501a
movq %rbp, %rdi
callq 0x6130
movq %r15, %rdi
callq 0x150f2
movq %r13, %rdi
movl %eax, %esi
callq 0x150ee
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa9c0
movq %r15, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x14bec
movq 0x68(%rbx), %rax
jmp 0x14ab1
movq %rbx, %rdi
callq 0x88d0
jmp 0x14ba9
movq 0x2e478(%rip), %rdi     # 0x42ff0
leaq 0x1a674(%rip), %rsi     # 0x2f1f3
callq 0x6240
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x6210
leaq 0x1a67c(%rip), %rsi     # 0x2f213
movq %rax, %rdi
callq 0x6240
movq %rax, %rdi
callq 0x6140
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14bca
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6130
pushq $0x40
popq %rsi
movq %r13, %rdi
callq 0x6270
jmp 0x14be4
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/variable.cpp
// Function: Variable::Variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, DataType)
Variable::Variable(string name, DataType type)
{
        this->Source   = NULL;
        this->VBox     = NULL;
        this->VarName  = name;
        this->VarType  = type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
andq $0x0, (%rdi)
leaq 0x10(%rdi), %r15
andq $0x0, 0x30(%rdi)
movq %r15, %rdi
callq 0x6160
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14e39
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
callq 0x6cc0
movq %r15, 0x30(%rbx)
movl 0x8(%rbx), %ebp
movq %r14, %rdi
callq 0x6cbc
cmpl %eax, %ebp
jne 0x14e53
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
jmp 0x14e5e
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x7fa3
movq 0x30(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6d42
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14eaf
callq 0x6d66
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x6cc0
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x7a58
movq %r14, %rdi
callq 0x7a5c
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x6d42
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14f65
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x6cc0
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x7a58
movq %r14, %rdi
callq 0x7a5c
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x6d42
movq 0x30(%rbx), %rdi
callq 0x6d66
movq %rax, %rdi
callq 0x6cbc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6380
movl 0x8(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14d20
leaq 0x8(%rsp), %rdi
callq 0x6130
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x14fea
callq 0x6d10
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x15007
movq %rax, %r14
pushq $0x38
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6380
movl 0x20(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14d20
leaq 0x8(%rsp), %rdi
callq 0x6130
movq %r14, (%rbx)
movl 0x20(%r14), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x7a58
movq %r14, %rdi
callq 0x7a5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14dbc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x150db
movq %rax, %r14
pushq $0x38
popq %rsi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2da10(%rip), %rax     # 0x42b78
movq %rax, (%rdi)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x151bf
pushq $0x38
popq %r15
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x151a7
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x15196
movq %r14, %rdi
callq 0x14d6e
movq %r14, %rdi
movq %r15, %rsi
callq 0x6270
movq 0x18(%rbx), %r14
jmp 0x1517b
testq %r14, %r14
je 0x151b4
movq %r14, %rdi
callq 0x152cc
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x817e
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x10(%rdi)
je 0x1525f
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x6260
movq %rax, %r14
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq 0x18(%rbx), %rax
movq %rsp, %r15
movq %rax, %r12
movq (%r12), %r12
cmpq %rax, %r12
je 0x15243
movq 0x10(%r12), %rdi
callq 0x14f90
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f9c
movq 0x18(%rbx), %rax
jmp 0x1521b
pushq $0x20
popq %rdi
callq 0x6260
movq %rax, %r15
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x15128
jmp 0x15276
pushq $0x20
popq %rdi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15128
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x15287
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15374
testl %eax, %eax
je 0x1533a
cmpl $0x1, %eax
jne 0x15368
movq 0x70(%r14), %rsi
addq $0x70, %r14
jmp 0x15347
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x1536d
addq $0x78, %r14
movq %rbx, %rdi
callq 0xac22
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xa98a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xabba
movl %ebp, %eax
jmp 0x1536f
pushq $-0x1
popq %rax
jmp 0x1536f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x153d0
movq %rax, %r14
movq %rax, %rdi
callq 0x6cbc
cmpl $0x3, %eax
je 0x153ba
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7fa3
testq %rax, %rax
je 0x153d8
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, %rdi
callq 0x7504
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 0x2dc11(%rip), %rdi     # 0x42ff0
leaq 0x1bbf6(%rip), %rsi     # 0x30fdc
callq 0x6240
movq %rax, %rdi
callq 0x6140
jmp 0x153d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x89f2
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x15463
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0xa9b6
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x15463
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1545f
movq %rbx, %rsi
callq 0xa9b6
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x15463
movb $0x1, %al
jmp 0x15465
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1549f
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1549f
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1549b
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1549f
movb $0x1, %al
jmp 0x154a1
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
pushq $-0x1
popq %r12
testb %al, %al
je 0x15589
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
cmpl $-0x1, %eax
je 0x15589
xorl %ebp, %ebp
cmpl $0x1, %eax
jne 0x1558c
movq 0x60(%r14), %rax
movq %rax, %r13
movq (%r13), %r13
cmpq %rax, %r13
je 0x15568
movq 0x10(%r13), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x1551e
movq %rbx, %rdi
callq 0xac22
movq 0x10(%r13), %rdi
movq %rbx, %rsi
callq 0xa98a
movl %eax, %r15d
movq %rbx, %rdi
callq 0xabba
cmpl $-0x1, %r15d
je 0x15589
cmpl $0x1, %r15d
je 0x1558c
cmpl $0x2, %r15d
je 0x15568
movq 0x60(%r14), %rax
jmp 0x1551e
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
testb %al, %al
je 0x15589
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
cmpl $-0x1, %eax
jne 0x15512
movl %r12d, %ebp
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_O2/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)
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x15644
movq %rax, %r14
movq %rax, %rdi
callq 0x6cbc
cmpl $0x3, %eax
je 0x1562e
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7fa3
testq %rax, %rax
je 0x1564c
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, %rdi
callq 0x7504
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 0x2d99d(%rip), %rdi     # 0x42ff0
leaq 0x1b9dd(%rip), %rsi     # 0x31037
callq 0x6240
movq %rax, %rdi
callq 0x6140
jmp 0x15644
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x156ae
movq %rdi, %r14
movq %rbx, %rdi
callq 0xac22
movq 0x70(%r14), %rdi
movq %rbx, %rsi
callq 0xa98a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xabba
testl %ebp, %ebp
sete %al
jmp 0x156b0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x156f3
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rsi
movq %rbx, %rdi
callq 0xac22
movq 0x78(%r14), %rdi
movq %rbx, %rsi
callq 0xa98a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xabba
testl %ebp, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x155a4
testb %al, %al
je 0x15745
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x15722
movq %rbx, %rsi
callq 0xa9b6
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x15745
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x15741
movq %rbx, %rsi
callq 0xa9b6
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x15745
movb $0x1, %al
jmp 0x15747
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x155cc
testb %al, %al
je 0x15781
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1576a
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x15781
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1577d
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x15781
movb $0x1, %al
jmp 0x15783
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0xd0(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x15849
movq %rbx, %rdi
callq 0x6cbc
cmpl $0x6, %eax
jne 0x1581d
pushq $0x18
popq %rdi
callq 0x6260
movq %rax, %r12
andq $0x0, 0x10(%rax)
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0x7910
movq %rax, 0x8(%r12)
movq 0x18(%rax), %rax
movq %rax, 0x10(%r12)
movq %r14, %rdi
movq %r13, %rsi
callq 0x15ec0
movq (%r13), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
cmpq %rcx, 0x10(%rax)
je 0x15849
movq %r15, %rdi
movq %r14, %rsi
callq 0x1585e
jmp 0x15849
movq 0x2d7cc(%rip), %rdi     # 0x42ff0
leaq 0x1b861(%rip), %rsi     # 0x3108c
callq 0x6240
movq %rax, %rdi
callq 0x6140
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %r14, %rdi
callq 0x15c60
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
cmpq 0x38(%rsi), %rax
jne 0x15886
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 0xad28
movq %rax, %r15
movq 0xc8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xad28
movq %rax, %rbx
pushq $0x30
popq %rdi
callq 0x6260
movq %rax, %r14
movq 0x10(%r12), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x6380
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6e18
leaq 0x8(%rsp), %rdi
callq 0x6130
movq %r15, %rdi
movq %r14, %rsi
callq 0x14e0e
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x10(%r12), %rax
movq 0x40(%rax), %r14
movq %r14, %rdi
callq 0x6d66
movq %rax, %rdi
callq 0x6cbc
movq %rbx, %rdi
movl %eax, %esi
callq 0x14f0e
movq %r14, %rdi
callq 0x6d66
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14e0e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x1594f
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15984
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r15
testq %r15, %r15
je 0x159b1
leaq 0x10(%r15), %rdi
xorl %esi, %esi
callq 0x15bca
movq 0x8(%r15), %rax
addq $0x8, %rax
cmpq %rax, 0x10(%r15)
je 0x159b1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1585e
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x159d8
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r14
testq %r14, %r14
je 0x159fa
movq (%r14), %rdi
testq %rdi, %rdi
je 0x159ef
movq (%rdi), %rax
callq *0x8(%rax)
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15f5c
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::Provision()
bool ForeachLoopNode::Provision()
{
        VariableDef * key = new VariableDef(this->Key);
        VariableDef * value = new VariableDef(this->Value);

        key->SetVarType(String);
        value->SetVarType(Null);

        this->AddVariable(key);
        this->AddVariable(value);
        
        this->KeyIndex   = key->GetVarIndex();
        this->ValueIndex = value->GetVarIndex();
        
        if(ForLoopNode::Provision()!=true)
        {
                return false;
        }

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

        return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0x6260
movq %rax, %r14
leaq 0x80(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x6380
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x1501a
leaq 0x28(%rsp), %rdi
callq 0x6130
pushq $0x40
popq %rdi
callq 0x6260
movq %rax, %r15
leaq 0xa0(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6380
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1501a
leaq 0x8(%rsp), %rdi
callq 0x6130
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x150ee
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x150ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa9c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa9c0
movq %r14, %rdi
callq 0x15116
movq %rax, 0xc0(%rbx)
movq %r15, %rdi
callq 0x15116
movq %rax, 0xc8(%rbx)
movq %rbx, %rdi
callq 0x156f6
testb %al, %al
je 0x15b60
movq 0xd0(%rbx), %rdi
movq %rbx, %rsi
callq 0x89f2
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6130
jmp 0x15b7f
movq %rax, %rbx
movq %r15, %r14
jmp 0x15b96
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6130
jmp 0x15b96
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/init.c
// Function: _gmpf_init
void
mpf_init (mpf_ptr r)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  r->_mp_size = 0;
  r->_mp_exp = 0;
  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2d2d1(%rip), %rax     # 0x43290
movq (%rax), %rax
andl $0x0, 0x4(%rdi)
andq $0x0, 0x8(%rdi)
movl %eax, (%rdi)
leaq 0x2d2c4(%rip), %rcx     # 0x43298
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/iset_ui.c
// Function: _gmpf_init_set_ui
void
mpf_init_set_ui (mpf_ptr r, unsigned long int val)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  mp_size_t size;

  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);
  r->_mp_d[0] = val & GMP_NUMB_MASK;
  size = (val != 0);

#if BITS_PER_ULONG > GMP_NUMB_BITS
  val >>= GMP_NUMB_BITS;
  r->_mp_d[1] = val;
  size += (val != 0);
#endif

  r->_mp_size = size;
  r->_mp_exp = size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2caaf(%rip), %rax     # 0x43290
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2caab(%rip), %rcx     # 0x43298
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%r14)
movq %rbx, (%rax)
xorl %eax, %eax
testq %rbx, %rbx
setne %al
movl %eax, 0x4(%r14)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/iset_si.c
// Function: _gmpf_init_set_si
void
mpf_init_set_si (mpf_ptr r, long int val)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  mp_size_t size;
  mp_limb_t vl;

  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);

  vl = (mp_limb_t) ABS_CAST (unsigned long int, val);

  r->_mp_d[0] = vl & GMP_NUMB_MASK;
  size = vl != 0;

#if BITS_PER_ULONG > GMP_NUMB_BITS
  vl >>= GMP_NUMB_BITS;
  r->_mp_d[1] = vl;
  size += (vl != 0);
#endif

  r->_mp_exp = size;
  r->_mp_size = val >= 0 ? size : -size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
testq %rsi, %rsi
setne %r15b
movl %r15d, %ebp
negl %ebp
testq %rsi, %rsi
leaq 0x2ca52(%rip), %rax     # 0x43290
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2ca4e(%rip), %rcx     # 0x43298
leaq 0x8(,%rax,8), %rdi
cmovnsl %r15d, %ebp
callq *(%rcx)
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movq %rax, 0x10(%rbx)
movq %rcx, (%rax)
movq %r15, 0x8(%rbx)
movl %ebp, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpf/iset_str.c
// Function: _gmpf_init_set_str
int
mpf_init_set_str (mpf_ptr r, const char *s, int base)
{
  mp_size_t prec = __gmp_default_fp_limb_precision;
  r->_mp_size = 0;
  r->_mp_exp = 0;
  r->_mp_prec = prec;
  r->_mp_d = __GMP_ALLOCATE_FUNC_LIMBS (prec + 1);

  return mpf_set_str (r, s, base);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ca06(%rip), %rax     # 0x43290
movq (%rax), %rax
andl $0x0, 0x4(%rdi)
movl %edx, %ebp
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movl %eax, (%rdi)
leaq 0x2c9f4(%rip), %rcx     # 0x43298
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x16034
nop
// File: /workspace/github_cpp_makefile_star2_O2/marxn[P]pupp/3rdparty/gmp/mpn/../gmp.h
// Function: _gmpn_neg
mp_limb_t
mpn_neg (mp_ptr __gmp_rp, mp_srcptr __gmp_up, mp_size_t __gmp_n)
{
  while (*__gmp_up == 0) /* Low zero limbs are unchanged by negation. */
    {
      *__gmp_rp = 0;
      if (!--__gmp_n) /* All zero */
	return 0;
      ++__gmp_up; ++__gmp_rp;
    }

  *__gmp_rp = (- *__gmp_up) & GMP_NUMB_MASK;

  if (--__gmp_n) /* Higher limbs get complemented. */
    mpn_com (++__gmp_rp, ++__gmp_up, __gmp_n);

  return 1;
}

// Assembly:
pushq %rbx
decq %rdx
xorl %ebx, %ebx
xorl %eax, %eax
movq (%rsi,%rax), %rcx
testq %rcx, %rcx
jne 0x17fca
andq $0x0, (%rdi,%rax)
subq $0x1, %rdx
jb 0x17fec
addq $0x8, %rax
jmp 0x17fb0
negq %rcx
movq %rcx, (%rdi,%rax)
pushq $0x1
popq %rbx
testq %rdx, %rdx
je 0x17fec
addq %rax, %rdi
addq $0x8, %rdi
addq %rax, %rsi
addq $0x8, %rsi
callq 0x18000
movq %rbx, %rax
popq %rbx
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)