LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17da2
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x9fe8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x17d7c
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17dd4
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x17dba
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17e66
movq %rax, %r14
movq %rax, %rdi
callq 0x7dee
cmpl $0x1, %eax
jne 0x17e24
movq %r14, %rdi
callq 0x81ae
movl %eax, %edi
callq 0x63b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x17e66
movq 0x301c5(%rip), %r14     # 0x47ff0
leaq 0x20108(%rip), %rsi     # 0x37f3a
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r15
movq %r15, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movq %rax, (%rdi)
movq %rax, 0x30(%rdi)
movq %rbx, %rdi
callq 0x6160
movl %ebp, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x18896
movq (%r15), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1898d
movl $0x10, %edi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
callq 0x7df2
movq %r15, 0x30(%rbx)
movl 0x8(%rbx), %ebp
movq %r14, %rdi
callq 0x7dee
cmpl %eax, %ebp
jne 0x189a7
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
jmp 0x189b2
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x957b
movq 0x30(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ea0
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18a05
callq 0x7ec4
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
movl $0x10, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x7df2
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x8f1e
movq %r14, %rdi
callq 0x8f22
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x7ea0
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 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x30(%rdi)
jne 0x18abb
movl $0x10, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
callq 0x7df2
movq %r14, 0x30(%rbx)
movl 0x8(%rbx), %esi
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x8f1e
movq %r14, %rdi
callq 0x8f22
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x7ea0
movq 0x30(%rbx), %rdi
callq 0x7ec4
movq %rax, %rdi
callq 0x7dee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99e8
movl 0x8(%r14), %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x18840
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18b46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x18b62
callq 0x7e60
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 0x18b8d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x18b8d
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99e8
movl 0x20(%r14), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x18840
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x18c50
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
movq %r14, (%rbx)
movl 0x20(%r14), %esi
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x8f1e
movq %r14, %rdi
callq 0x8f22
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1890c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x18ca3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x18ca3
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ee35(%rip), %rax     # 0x47b78
movq %rax, (%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x18dad
movq (%rax), %r15
movq 0x18(%rbx), %r14
cmpq %r14, %r15
je 0x18d7e
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x18d79
movq %r14, %rdi
callq 0x1889e
movl $0x38, %esi
movq %r14, %rdi
callq 0x6270
movq (%r15), %r15
jmp 0x18d52
testq %r14, %r14
je 0x18dad
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x18da0
movq (%rdi), %r15
movl $0x18, %esi
callq 0x6270
movq %r15, %rdi
cmpq %r14, %r15
jne 0x18d8b
movl $0x18, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9816
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18e76
movq %rdi, %r15
movl $0x18, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%r15), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x18e44
movq 0x10(%r12), %rdi
callq 0x18aec
movq %rax, %r14
movl $0x18, %edi
callq 0x6260
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6070
incq 0x10(%rbx)
movq (%r12), %r12
cmpq 0x18(%r15), %r12
jne 0x18e10
movl $0x20, %edi
callq 0x6260
movq %rax, %r14
movq 0x10(%r15), %r15
movq %rax, %rdi
movl $0x8, %esi
callq 0x7dde
leaq 0x2ed0f(%rip), %rax     # 0x47b78
movq %rax, (%r14)
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
jmp 0x18ea2
movl $0x20, %edi
callq 0x6260
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
callq 0x7dde
leaq 0x2ece1(%rip), %rax     # 0x47b78
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 0x18eb3
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
callq 0x6470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18f7c
testl %eax, %eax
je 0x18f47
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
jne 0x18f73
movq 0x70(%r14), %rsi
addq $0x70, %r14
jmp 0x18f54
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x18f78
addq $0x78, %r14
movq %rbx, %rdi
callq 0xc748
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xc3c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc6cc
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x18f73
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1902c
movq %rax, %rbx
movq %rax, %rdi
callq 0x7dee
cmpl $0x3, %eax
je 0x19015
movq %rbx, %rdi
movl $0x3, %esi
callq 0x957b
movq %rax, %r14
testq %rax, %rax
je 0x18fce
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rbx
jmp 0x19010
movq 0x2f01b(%rip), %r15     # 0x47ff0
leaq 0x1f004(%rip), %rsi     # 0x37fe0
movl $0x4d, %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
testq %r14, %r14
je 0x1902c
movq %rbx, %rdi
callq 0x881a
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movzbl %bpl, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9fe8
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x190a7
movq 0x70(%rbx), %rdi
movq %rbx, %rsi
callq 0xc3ee
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x190a7
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x190a3
movq %rbx, %rsi
callq 0xc3ee
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x190a7
movb $0x1, %al
jmp 0x190a9
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x190e3
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x190e3
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x190df
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x190e3
movb $0x1, %al
jmp 0x190e5
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x19225
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
cmpl $-0x1, %eax
je 0x19225
cmpl $0x1, %eax
jne 0x19223
movq 0x60(%r14), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x191dd
movq 0x10(%r12), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x191cb
movq %rbx, %rdi
callq 0xc748
movq 0x10(%r12), %rdi
movq %rbx, %rsi
callq 0xc3c2
movl %eax, %r15d
movq %rbx, %rdi
callq 0xc6cc
cmpl $-0x1, %r15d
je 0x191b6
cmpl $0x1, %r15d
je 0x191b2
cmpl $0x2, %r15d
jne 0x191c3
movl $0x4, %r15d
jmp 0x191c6
xorl %ebp, %ebp
jmp 0x191c6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r15d
jmp 0x191c6
xorl %r15d, %r15d
testl %r15d, %r15d
jne 0x191d7
movq (%r12), %r12
cmpq 0x60(%r14), %r12
jne 0x1916d
jmp 0x191dd
cmpl $0x4, %r15d
jne 0x19213
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
testb %al, %al
je 0x19208
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
xorl %r15d, %r15d
cmpl $-0x1, %eax
sete %r15b
cmovel %eax, %ebp
jmp 0x19218
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r15d
movl $0x1, %eax
testl %r15d, %r15d
je 0x19158
jmp 0x19225
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1932a
movq %rax, %rbx
movq %rax, %rdi
callq 0x7dee
cmpl $0x3, %eax
je 0x19313
movq %rbx, %rdi
movl $0x3, %esi
callq 0x957b
movq %rax, %r14
testq %rax, %rax
je 0x192cc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rbx
jmp 0x1930e
movq 0x2ed1d(%rip), %r15     # 0x47ff0
leaq 0x1ed61(%rip), %rsi     # 0x3803b
movl $0x54, %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
testq %r14, %r14
je 0x1932a
movq %rbx, %rdi
callq 0x881a
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movzbl %bpl, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1937c
movq %rdi, %r14
movq %rbx, %rdi
callq 0xc748
movq 0x70(%r14), %rdi
movq %rbx, %rsi
callq 0xc3c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc6cc
testl %ebp, %ebp
sete %al
jmp 0x1937e
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x193c1
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rsi
movq %rbx, %rdi
callq 0xc748
movq 0x78(%r14), %rdi
movq %rbx, %rsi
callq 0xc3c2
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc6cc
testl %ebp, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19236
testb %al, %al
je 0x19413
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x193f0
movq %rbx, %rsi
callq 0xc3ee
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x19413
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1940f
movq %rbx, %rsi
callq 0xc3ee
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x19413
movb $0x1, %al
jmp 0x19415
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9f88
testb %al, %al
je 0x1945d
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x1945d
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x19446
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1945d
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x19459
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x1945d
movb $0x1, %al
jmp 0x1945f
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %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 0x1956a
movq %rbx, %rdi
callq 0x7dee
cmpl $0x6, %eax
jne 0x194e7
movl $0x18, %edi
callq 0x6260
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rbx, (%rax)
movq %rbx, %rdi
callq 0x8d78
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rcx)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
je 0x1953f
movq %rcx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x1954c
movq 0x2eb02(%rip), %r15     # 0x47ff0
leaq 0x1eb9b(%rip), %rsi     # 0x38090
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
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %r14, %rdi
callq 0x19a58
jmp 0x1956a
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x19cb4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
cmpq %rcx, 0x10(%rax)
je 0x1956a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1957a
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x195a4
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 0xc886
movq %rax, %r15
movq 0xc8(%r14), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc886
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 0x99e8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7f9a
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1961f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18960
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x10(%r12), %rax
movq 0x40(%rax), %rbx
movq %rbx, %rdi
callq 0x7ec4
movq %rax, %rdi
callq 0x7dee
movq %r14, %rdi
movl %eax, %esi
callq 0x18a68
movq %rbx, %rdi
callq 0x7ec4
movq %r14, %rdi
movq %rax, %rsi
callq 0x18960
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19695
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x19695
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x196cc
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r15
testq %r15, %r15
je 0x196fa
movq 0x10(%r15), %rdi
callq 0x61c0
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x196fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1957a
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19720
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r14
testq %r14, %r14
je 0x19744
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19737
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 0x19d7c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movl $0x40, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x99e8
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18ba2
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19826
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
movl $0x40, %edi
callq 0x6260
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x99e8
movq %rsp, %rsi
movq %r15, %rdi
callq 0x18ba2
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19877
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
movl $0x4, %esi
callq 0x18cb8
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x18cb8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc3f8
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3f8
movq %rbx, %rdi
callq 0x18cf4
movq %rax, 0xc0(%r14)
movq %r15, %rdi
callq 0x18cf4
movq %rax, 0xc8(%r14)
movq %r14, %rdi
callq 0x193c4
testb %al, %al
je 0x198ee
movq 0xd0(%r14), %rdi
movq %r14, %rsi
callq 0x9fe8
movq 0xd0(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1991b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x1991b
movq %rax, %r14
movq %r15, %rbx
jmp 0x1993f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1993f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x1993f
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e4bd(%rip), %rax     # 0x48290
movq (%rax), %rax
movl $0x0, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
movl %eax, (%rdi)
leaq 0x2e4aa(%rip), %rcx     # 0x48298
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpf/set.c
// Function: _gmpf_set
void
mpf_set (mpf_ptr r, mpf_srcptr u)
{
  mp_ptr rp, up;
  mp_size_t size, asize;
  mp_size_t prec;

  prec = r->_mp_prec + 1;		/* lie not to lose precision in assignment */
  size = u->_mp_size;
  asize = ABS (size);
  rp = r->_mp_d;
  up = u->_mp_d;

  if (asize > prec)
    {
      up += asize - prec;
      asize = prec;
    }

  r->_mp_exp = u->_mp_exp;
  r->_mp_size = size >= 0 ? asize : -asize;
  MPN_COPY_INCR (rp, up, asize);
}

// Assembly:
movslq (%rdi), %rdx
incq %rdx
movl 0x4(%rsi), %r8d
movl %r8d, %ecx
negl %ecx
cmovsl %r8d, %ecx
xorl %eax, %eax
movq %rcx, %r9
subq %rdx, %r9
cmovlq %rcx, %rdx
cmovgq %r9, %rax
shlq $0x3, %rax
addq 0x10(%rsi), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rdi)
movl %edx, %esi
negl %esi
testl %r8d, %r8d
cmovnsl %edx, %esi
movl %esi, 0x4(%rdi)
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x2f4c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dbaf(%rip), %rax     # 0x48290
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2dbab(%rip), %rcx     # 0x48298
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_O1/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 0x2db52(%rip), %rax     # 0x48290
movq (%rax), %rax
movl %eax, (%rdi)
leaq 0x2db4e(%rip), %rcx     # 0x48298
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_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2db00(%rip), %rax     # 0x48290
movq (%rax), %rax
movl $0x0, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
movl %eax, (%rdi)
leaq 0x2daed(%rip), %rcx     # 0x48298
leaq 0x8(,%rax,8), %rdi
callq *(%rcx)
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x19e50
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpf/neg.c
// Function: _gmpf_neg
void
mpf_neg (mpf_ptr r, mpf_srcptr u)
{
  mp_size_t size;

  size = -u->_mp_size;
  if (r != u)
    {
      mp_size_t prec;
      mp_size_t asize;
      mp_ptr rp, up;

      prec = r->_mp_prec + 1;	/* lie not to lose precision in assignment */
      asize = ABS (size);
      rp = r->_mp_d;
      up = u->_mp_d;

      if (asize > prec)
	{
	  up += asize - prec;
	  asize = prec;
	}

      MPN_COPY (rp, up, asize);
      r->_mp_exp = u->_mp_exp;
      size = size >= 0 ? asize : -asize;
    }
  r->_mp_size = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rsi), %rax
movq %rax, %r15
negq %r15
cmpq %rsi, %rdi
je 0x1bf45
movq %rsi, %r14
movslq (%rbx), %rcx
incq %rcx
movq %r15, %rdx
negq %rdx
testl %eax, %eax
cmovleq %r15, %rdx
xorl %esi, %esi
movq %rdx, %rdi
subq %rcx, %rdi
cmovgeq %rcx, %rdx
cmovgq %rdi, %rsi
movl %edx, %r15d
negl %r15d
testl %eax, %eax
cmovlel %edx, %r15d
movq 0x10(%rbx), %rdi
shlq $0x3, %rsi
addq 0x10(%r14), %rsi
callq 0x2f4c6
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rsi), %rax
testq %rax, %rax
jne 0x1c2d3
leaq -0x1(%rdx), %r8
xorl %ebx, %ebx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq $0x0, (%rdi,%r9,8)
cmpq %r9, %r8
je 0x1c2f0
movq 0x8(%rsi,%r9,8), %rax
incq %r9
addq $-0x8, %rcx
testq %rax, %rax
je 0x1c2ac
subq %r9, %rdx
subq %rcx, %rsi
subq %rcx, %rdi
negq %rax
movq %rax, (%rdi)
movl $0x1, %ebx
decq %rdx
je 0x1c2f0
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x1c300
movq %rbx, %rax
popq %rbx
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpn/nussbaumer_mul.c
// Function: _gmpn_nussbaumer_mul
void
mpn_nussbaumer_mul (mp_ptr pp,
		    mp_srcptr ap, mp_size_t an,
		    mp_srcptr bp, mp_size_t bn)
{
  mp_size_t rn;
  mp_ptr tp;
  TMP_DECL;

  ASSERT (an >= bn);
  ASSERT (bn > 0);

  TMP_MARK;

  if ((ap == bp) && (an == bn))
    {
      rn = mpn_sqrmod_bnm1_next_size (2*an);
      tp = TMP_ALLOC_LIMBS (mpn_sqrmod_bnm1_itch (rn, an));
      mpn_sqrmod_bnm1 (pp, rn, ap, an, tp);
    }
  else
    {
      rn = mpn_mulmod_bnm1_next_size (an + bn);
      tp = TMP_ALLOC_LIMBS (mpn_mulmod_bnm1_itch (rn, an, bn));
      mpn_mulmod_bnm1 (pp, rn, ap, an, bp, bn, tp);
    }

  TMP_FREE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq %rsi, %rax
xorq %rcx, %rax
movq %rdx, %rcx
xorq %r8, %rcx
orq %rax, %rcx
jne 0x1e91c
leaq (%rbx,%rbx), %rdi
callq 0x2b355
movq %rax, %r15
sarq %rax
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovlq %rbx, %rcx
addq %r15, %rcx
leaq 0x18(,%rcx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1e9a6
movq %rsp, %r8
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r8
movq %r8, %rsp
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2af5c
jmp 0x1e987
movq %r8, %r12
leaq (%r8,%rbx), %rdi
callq 0x2aee3
movq %rax, %r15
sarq %rax
cmpq %r12, %rax
movq %rax, %rcx
cmovlq %r15, %rcx
xorl %edx, %edx
cmpq %rbx, %rax
cmovlq %rcx, %rdx
addq %r15, %rdx
leaq 0x20(,%rdx,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1e9b7
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
subq $0x8, %rsp
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %r12, %r9
pushq %rax
callq 0x2a886
addq $0x10, %rsp
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
jne 0x1e99f
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x301a3
jmp 0x1e990
leaq -0x30(%rbp), %rdi
callq 0x30170
movq %rax, %r8
jmp 0x1e908
leaq -0x30(%rbp), %rdi
callq 0x30170
jmp 0x1e966
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpn/toom63_mul.c
// Function: abs_sub_add_n
static int
abs_sub_add_n (mp_ptr rm, mp_ptr rp, mp_srcptr rs, mp_size_t n) {
  int result;
  result = abs_sub_n (rm, rp, rs, n);
  ASSERT_NOCARRY(mpn_add_n (rp, rp, rs, n));
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
testq %rcx, %rcx
jle 0x2345d
movq %rbx, %rcx
movq -0x8(%r14,%rcx,8), %rax
cmpq %rax, -0x8(%r15,%rcx,8)
jne 0x2343e
movq $0x0, -0x8(%rdi,%rcx,8)
decq %rcx
leaq 0x1(%rcx), %rax
cmpq $0x1, %rax
jg 0x2341a
jmp 0x2345d
jbe 0x2344d
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c1c0
jmp 0x2345d
movq %r14, %rsi
movq %r15, %rdx
callq 0x1c1c0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1bfa0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpn/toom_couple_handling.c
// Function: _gmpn_toom_couple_handling
void
mpn_toom_couple_handling (mp_ptr pp, mp_size_t n, mp_ptr np,
			  int nsign, mp_size_t off, int ps, int ns)
{
  if (nsign) {
#ifdef HAVE_NATIVE_mpn_rsh1sub_n
    mpn_rsh1sub_n (np, pp, np, n);
#else
    mpn_sub_n (np, pp, np, n);
    mpn_rshift (np, np, n, 1);
#endif
  } else {
#ifdef HAVE_NATIVE_mpn_rsh1add_n
    mpn_rsh1add_n (np, pp, np, n);
#else
    mpn_add_n (np, pp, np, n);
    mpn_rshift (np, np, n, 1);
#endif
  }

#ifdef HAVE_NATIVE_mpn_rsh1sub_n
  if (ps == 1)
    mpn_rsh1sub_n (pp, pp, np, n);
  else
#endif
  {
    mpn_sub_n (pp, pp, np, n);
    if (ps > 0)
      mpn_rshift (pp, pp, n, ps);
  }
  if (ns > 0)
    mpn_rshift (np, np, n, ns);
  pp[n] = mpn_add_n (pp+off, pp+off, np, n-off);
  ASSERT_NOCARRY (mpn_add_1(pp+n, np+n-off, off, pp[n]) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %r12, %rsi
testl %ecx, %ecx
je 0x26dd2
movq %r15, %rcx
callq 0x2fa30
jmp 0x26dda
movq %r15, %rcx
callq 0x2f8f0
movl 0x40(%rsp), %r13d
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
cmpl $0x1, %ebp
jne 0x26df7
callq 0x2fa30
jmp 0x26e10
callq 0x1c1c0
testl %ebp, %ebp
jle 0x26e10
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x30480
testl %r13d, %r13d
jle 0x26e26
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x30480
leaq (%r12,%rbx,8), %rdi
leaq (,%rbx,8), %r13
movq %r15, %rcx
subq %rbx, %rcx
movq %rdi, %rsi
movq %r14, %rdx
callq 0x1bfa0
leaq (%r12,%r15,8), %rcx
movq %rax, (%rcx)
leaq (%r14,%r15,8), %rdx
subq %r13, %rdx
addq (%rdx), %rax
movq %rax, (%rcx)
jae 0x26ead
cmpq $0x2, %rbx
movl $0x1, %edi
movl $0x1, %esi
cmovgeq %rbx, %rsi
cmpq %rdi, %rsi
je 0x26ed5
movq (%rdx,%rdi,8), %r8
leaq 0x1(%rdi), %rax
incq %r8
movq %r8, (%rcx,%rdi,8)
movq %rax, %rdi
je 0x26e6b
cmpq %rcx, %rdx
setne %sil
cmpq %rbx, %rax
setl %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x26ed5
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rcx,%rax,8)
incq %rax
cmpq %rbx, %rax
jl 0x26e9b
jmp 0x26ed5
cmpq %rcx, %rdx
sete %al
cmpq $0x2, %rbx
setl %sil
orb %al, %sil
jne 0x26ed5
movl $0x1, %eax
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rcx,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x26ec5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq