LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x38, %edi
callq 0x62f0
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
movb $0x1, 0x2b(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6160
jmp 0x30f38
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %edx
leaq 0x38(%rsp), %rsi
callq 0x308d0
jmp 0x30f51
movb $0x0, 0x2b(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x61e0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rsi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x309e0
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
leaq 0x24(%rsp), %rdi
callq 0x99f0
leaq 0x24(%rsp), %rdi
callq 0x9a10
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x30a40
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x30fdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x61e0
testb $0x1, 0x2b(%rsp)
jne 0x30fe4
jmp 0x30ff3
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x6300
jmp 0x30ff5
movq 0x30(%rsp), %rdi
callq 0x6550
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x449fe(%rip), %rcx     # 0x75b68
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x15330
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x31245
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x15350
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12f80
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x15380
testb $0x1, %al
jne 0x311d0
jmp 0x31216
leaq 0x38(%rsp), %rdi
callq 0x153a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x31201
movq 0x10(%rsp), %rdi
callq 0x30960
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x6300
jmp 0x31203
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x153f0
movq %rax, 0x20(%rsp)
jmp 0x311a8
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x31243
movq 0x8(%rsp), %rdi
callq 0x314b0
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x6300
jmp 0x31245
movq 0x18(%rsp), %rdi
callq 0x7850
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0x312fe
movl $0x20, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x310f0
jmp 0x312cd
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x313fc
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x20, %esi
callq 0x6300
jmp 0x31406
movl $0x18, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
callq 0x11820
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x15330
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x15350
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12f80
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x15380
testb $0x1, %al
jne 0x3136e
jmp 0x313a7
leaq 0x48(%rsp), %rdi
callq 0x153a0
movq (%rax), %rdi
callq 0x30d80
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11940
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x153f0
movq %rax, 0x28(%rsp)
jmp 0x31346
movl $0x20, %edi
callq 0x62f0
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0x310f0
jmp 0x313d1
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x313fc
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x20, %esi
callq 0x6300
jmp 0x31406
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x6550
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x31770
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x316fb
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x70(%rax), %rsi
callq 0x146f0
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x14130
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x14610
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x31760
cmpl $0x0, 0x1c(%rsp)
jne 0x31756
movq 0x8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x3174c
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x78(%rax), %rsi
callq 0x146f0
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x14130
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x14610
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x31760
movl $0x0, 0x34(%rsp)
jmp 0x31760
jmp 0x31758
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x317ac
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x31868
movq 0x28(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
je 0x31828
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0xa620
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x31803
movq 0x44812(%rip), %rdi     # 0x75ff0
leaq 0x2f92e(%rip), %rsi     # 0x61113
callq 0x62d0
movq %rax, %rdi
movq 0x447c4(%rip), %rsi     # 0x75fb8
callq 0x6320
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x31868
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3181e
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8d50
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x31853
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x68(%rsi), %rdi
callq 0xda00
movq (%rsp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3191a
movb $0x0, 0x17(%rsp)
jmp 0x31984
movq (%rsp), %rsi
movq 0x70(%rsi), %rdi
callq 0x14180
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31946
movb $0x0, 0x17(%rsp)
jmp 0x31984
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x3197f
movq (%rsp), %rsi
movq 0x78(%rsi), %rdi
callq 0x14180
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3197d
movb $0x0, 0x17(%rsp)
jmp 0x31984
jmp 0x3197f
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x319bd
movb $0x0, 0x17(%rsp)
jmp 0x31a0d
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x319dc
movb $0x0, 0x17(%rsp)
jmp 0x31a0d
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x31a08
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31a06
movb $0x0, 0x17(%rsp)
jmp 0x31a0d
jmp 0x31a08
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/src/parser/loop.cpp
// Function: LoopNode::Provision()
bool LoopNode::Provision()
{
        if(ContainerNode::Provision()==false)
        {
                return false;
        }

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

        return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd330
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31cd8
movb $0x0, 0x17(%rsp)
jmp 0x31d09
movq (%rsp), %rsi
movq 0x68(%rsi), %rdi
callq 0xda00
movq (%rsp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31d04
movb $0x0, 0x17(%rsp)
jmp 0x31d09
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/loop.cpp
// Function: LoopNode::Check()
bool LoopNode::Check()
{
        if(ContainerNode::Check()==false)
        {
                return false;
        }

        if(condition->Check()==false)
        {
                return false;
        }
 
        return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd3f0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31d48
movb $0x0, 0x17(%rsp)
jmp 0x31d6c
movq (%rsp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x31d67
movb $0x0, 0x17(%rsp)
jmp 0x31d6c
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x31dbc
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x31e78
movq 0x28(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
je 0x31e38
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0xa620
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x31e13
movq 0x44202(%rip), %rdi     # 0x75ff0
leaq 0x2f379(%rip), %rsi     # 0x6116e
callq 0x62d0
movq %rax, %rdi
movq 0x441b4(%rip), %rsi     # 0x75fb8
callq 0x6320
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x31e78
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x31e2e
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8d50
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x31e63
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x70(%rax)
jne 0x31ef5
movb $0x1, 0x27(%rsp)
jmp 0x31f3a
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x70(%rax), %rsi
callq 0x146f0
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x14130
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14610
cmpl $0x0, 0xc(%rsp)
je 0x31f35
movb $0x0, 0x27(%rsp)
jmp 0x31f3a
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x78(%rax)
jne 0x31f75
movb $0x1, 0x27(%rsp)
jmp 0x31fba
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x70(%rax), %rsi
callq 0x146f0
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x14130
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14610
cmpl $0x0, 0xc(%rsp)
je 0x31fb5
movb $0x0, 0x27(%rsp)
jmp 0x31fba
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x31cb0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x31ff8
movb $0x0, 0x17(%rsp)
jmp 0x3206f
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x32031
movq (%rsp), %rsi
movq 0x70(%rsi), %rdi
callq 0x14180
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x3202f
movb $0x0, 0x17(%rsp)
jmp 0x3206f
jmp 0x32031
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x3206a
movq (%rsp), %rsi
movq 0x78(%rsi), %rdi
callq 0x14180
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x32068
movb $0x0, 0x17(%rsp)
jmp 0x3206f
jmp 0x3206a
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x31d20
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x320a8
movb $0x0, 0x17(%rsp)
jmp 0x32105
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x320d4
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x320d2
movb $0x0, 0x17(%rsp)
jmp 0x32105
jmp 0x320d4
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x32100
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x320fe
movb $0x0, 0x17(%rsp)
jmp 0x32105
jmp 0x32100
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x32161
movb $0x0, 0x57(%rsp)
jmp 0x32270
movq 0x38(%rsp), %rdi
callq 0x7870
cmpl $0x6, %eax
je 0x321b4
movq 0x43e79(%rip), %rdi     # 0x75ff0
leaq 0x2f045(%rip), %rsi     # 0x611c3
callq 0x62d0
movq %rax, %rdi
movq 0x43e2b(%rip), %rsi     # 0x75fb8
callq 0x6320
movq 0x40(%rsp), %rdi
movq $0x0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x32930
movb $0x1, 0x57(%rsp)
jmp 0x32270
movl $0x18, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x32960
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
callq 0x9740
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xab70
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x32980
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xabc0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x3225c
jmp 0x3226b
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x32280
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rdi
callq 0x329b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0xc0(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x18(%rsp)
callq 0x14950
movq 0x18(%rsp), %rsi
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq 0x88(%rsp), %rdi
movq 0xc8(%rax), %rdx
callq 0x14950
movq %rax, 0x70(%rsp)
movl $0x30, %edi
callq 0x62f0
movq %rax, 0x28(%rsp)
movb $0x1, 0x3b(%rsp)
movq 0x80(%rsp), %rdi
addq $0x10, %rdi
callq 0xac40
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x6160
jmp 0x32340
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7c00
jmp 0x32351
movb $0x0, 0x3b(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x61e0
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x30ad0
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x32394
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x80(%rsp), %rdi
addq $0x10, %rdi
callq 0xac40
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x7a20
movq %rax, %rdi
callq 0x7870
movq (%rsp), %rdi
movl %eax, %esi
callq 0x30c90
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7a20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x30ad0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x32425
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x61e0
testb $0x1, 0x3b(%rsp)
jne 0x3242e
jmp 0x3243d
movq 0x28(%rsp), %rdi
movl $0x30, %esi
callq 0x6300
jmp 0x3243f
movq 0x40(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x329b0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x32489
movb $0x1, 0x47(%rsp)
jmp 0x324e8
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0xacb0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xabc0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x324d4
jmp 0x324e3
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x32280
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x329b0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x32571
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x32550
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3256f
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x6300
jmp 0x32571
movq 0x28(%rsp), %rdi
callq 0x329c0
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32110
addq $0x38, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::Evaluate(NodeContext*)
int ForeachLoopNode::Evaluate(NodeContext * context)
{
        ForeachLoopCtx * ctx = context->ForeachCtx.top();
        if(ctx==NULL)
        {
                return EVA_FALSE;
        }

        bool ret = ctx->ValueHandle!=ctx->SetValueHolder->end();
        return ret?EVA_TRUE:EVA_FALSE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x329b0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x325c2
movl $0x0, 0x34(%rsp)
jmp 0x3260b
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xabc0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0xaba0
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x40, %edi
callq 0x62f0
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
movb $0x1, 0x53(%rsp)
subq $-0x80, %rsi
leaq 0x60(%rsp), %rdi
callq 0x6160
jmp 0x326d5
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x30e90
jmp 0x326e6
movb $0x0, 0x53(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x61e0
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x40, %edi
callq 0x62f0
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x27(%rsp)
addq $0xa0, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6160
jmp 0x3272e
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x30e90
jmp 0x3273f
movb $0x0, 0x27(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x80(%rsp), %rdi
movl $0x4, %esi
callq 0x31000
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x31000
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x141b0
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x141b0
movq 0x80(%rsp), %rdi
callq 0x310b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc0(%rax)
movq 0x48(%rsp), %rdi
callq 0x310b0
movq 0x10(%rsp), %rdi
movq %rax, 0xc8(%rdi)
callq 0x31fd0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x32870
movb $0x0, 0x97(%rsp)
jmp 0x328af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x32811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x61e0
testb $0x1, 0x53(%rsp)
jne 0x3281a
jmp 0x32829
movq 0x18(%rsp), %rdi
movl $0x40, %esi
callq 0x6300
jmp 0x328c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x32856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
testb $0x1, 0x27(%rsp)
jne 0x3285f
jmp 0x3286e
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x6300
jmp 0x328c0
movq 0x10(%rsp), %rsi
movq 0xd0(%rsi), %rdi
callq 0xda00
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x328a7
movb $0x0, 0x97(%rsp)
jmp 0x328af
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x6550
nopw (%rax,%rax)
// File: marxn[P]pupp/src/parser/loop.cpp
// Function: ForeachLoopNode::Check()
bool ForeachLoopNode::Check()
{
        if(ForLoopNode::Check()!=true)
        {
                return false;
        }

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

        return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x32080
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x328f8
movb $0x0, 0x17(%rsp)
jmp 0x3291f
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3291a
movb $0x0, 0x17(%rsp)
jmp 0x3291f
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x42cb5(%rip), %rax     # 0x76318
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x42c8c(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x336fc
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33706
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x3374c
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x28(%rbp)
jl 0x3376d
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x33777
xorl %eax, %eax
subq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x33786
jmp 0x33788
jmp 0x3378a
jmp 0x3378c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x554c6
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x418f1(%rip), %rax     # 0x76318
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x418df(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
andq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x41851(%rip), %rax     # 0x76318
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x4183f(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jl 0x34b0e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x34b23
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
andq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
jl 0x34b6e
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x34b78
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x4176e(%rip), %rax     # 0x76318
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x41745(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x337b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x36ad3
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x36a2d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x36a37
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x36a7d
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
shlq $0x3, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x36a7f
jmp 0x36a81
jmp 0x36a83
jmp 0x36a85
jmp 0x36a87
jmp 0x36a89
jmp 0x36a8b
jmp 0x36a8d
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x554c6
jmp 0x36aa0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
jl 0x36ac1
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x36acb
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3711f
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x37105
movq $0x0, -0x8(%rbp)
jmp 0x3716e
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x370d4
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq (%rax), %rcx
andq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x37166
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x10(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rdx
callq 0x37180
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x3a1de
jmp 0x3a1e0
jmp 0x3a1e2
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x3a2b7
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x3a2b7
movq -0x18(%rbp), %rdi
shlq %rdi
callq 0x4f3b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a3c0
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3a270
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a3c0
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x48(%rbp)
jmp 0x3a291
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a3c0
movq %rax, %rsi
shlq $0x3, %rsi
leaq -0x40(%rbp), %rdi
callq 0x56430
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x4ebf0
jmp 0x3a384
movq -0x18(%rbp), %rdi
addq -0x28(%rbp), %rdi
callq 0x4eb40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3a420
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3a32a
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3a420
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x50(%rbp)
jmp 0x3a34f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3a420
movq %rax, %rsi
shlq $0x3, %rsi
leaq -0x40(%rbp), %rdi
callq 0x56430
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x38(%rbp), %rax
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x4e150
addq $0x10, %rsp
jmp 0x3a386
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3a3af
movq -0x40(%rbp), %rdi
callq 0x564a0
jmp 0x3a3b1
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/../gmp-impl.h
// Function: mpn_sqrmod_bnm1_itch
static inline mp_size_t
mpn_sqrmod_bnm1_itch (mp_size_t rn, mp_size_t an) {
  mp_size_t n, itch;
  n = rn >> 1;
  itch = rn + 3 +
    (an > n ? an : 0);
  return itch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x3a3f7
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3a3ff
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3a3ff
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/mpn/../gmp-impl.h
// Function: mpn_mulmod_bnm1_itch
static inline mp_size_t
mpn_mulmod_bnm1_itch (mp_size_t rn, mp_size_t an, mp_size_t bn) {
  mp_size_t n, itch;
  n = rn >> 1;
  itch = rn + 4 +
    (an > n ? (bn > n ? rn : n) : 0);
  return itch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
sarq %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x3a477
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x3a465
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3a46d
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3a47f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x3a47f
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42860
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x36c80
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop