LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: FunctionExpression::Provision()
bool FunctionExpression::Provision()
{
        this->FuncObj->SetParentNode(this->ParentNode);
        if(this->FuncObj->Provision()!=true)
        {
                return false;
        }

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

        return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0xda00
movq (%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x10031
movb $0x0, 0x37(%rsp)
jmp 0x100d9
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x1007e
jmp 0x100d4
leaq 0x20(%rsp), %rdi
callq 0x11310
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rdi
movq 0x10(%rax), %rsi
callq 0xda00
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x100bf
movb $0x0, 0x37(%rsp)
jmp 0x100d9
jmp 0x100c1
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0x10057
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: FunctionExpression::Check()
bool FunctionExpression::Check()
{
        if(this->FuncObj->Check()!=true)
        {
                return false;
        }

        list<Expression*>::iterator i;

        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return Expression::Check();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x10120
movb $0x0, 0x37(%rsp)
jmp 0x101b5
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x1016d
jmp 0x101a6
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x10191
movb $0x0, 0x37(%rsp)
jmp 0x101b5
jmp 0x10193
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0x10146
movq (%rsp), %rdi
callq 0xda20
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: AsynFuncCallContext::AsynCall()
int AsynCall()
        {
                pthread_t thid;
                pthread_attr_t attr;

                pthread_attr_init(&attr);
                pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

                pthread_create(&thid, &attr, ThreadWrapper, this);
                return 0;
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6410
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x6440
movq 0x8(%rsp), %rcx
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x84e(%rip), %rdx       # 0x12060
callq 0x6580
xorl %eax, %eax
addq $0x58, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: AsynFuncCallContext::ThreadWrapper(void*)
static void * ThreadWrapper(void * arg)
        {
                AsynFuncCallContext * ctx = static_cast<AsynFuncCallContext*>(arg);
                
                int rtn = ctx->FuncNode->Run(ctx->Context);
                delete ctx->Context;
                delete ctx;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x137c0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x120ba
movq 0x8(%rsp), %rdi
callq 0x145b0
movq 0x8(%rsp), %rdi
movl $0x70, %esi
callq 0x6300
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x120e0
movq (%rsp), %rdi
callq 0x120f0
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x6300
ud2
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: marxn[P]pupp/src/parser/function.cpp
// Function: ClosureVarDesc::ClosureVarDesc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
ClosureVarDesc::ClosureVarDesc(string name, bool b)
{
        this->Name  = name;
        this->isRef = b;
        this->SrcLayer = 0;
        this->SrcDef   = NULL;
        this->DstDef   = NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x6460
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6060
jmp 0x135e3
movq 0x8(%rsp), %rax
movb 0x37(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x61e0
movq 0x28(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/node.cpp
// Function: Node::AddVariable(VariableDef*)
void Node::AddVariable(VariableDef * var)
{       
        VariableDef * thevar = this->VariableDefTable[var->GetVarName()];
        if(thevar != NULL)
        {
                delete thevar;
                this->VariableDefTable.erase(var->GetVarName());
        }

        var->SetAttachedNode(this);
        var->SetVarIndex(this->VarDefArray.size());
        
        this->VariableDefTable[var->GetVarName()] = var;
        this->VarDefArray.push_back(var);
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x18, %rax
movq %rax, 0x58(%rsp)
movq 0xe8(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x31030
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x14ad0
movq %rax, 0x68(%rsp)
jmp 0x1420d
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x61e0
movq 0x48(%rsp), %rax
movq %rax, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
je 0x14303
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x1426f
movq 0x40(%rsp), %rdi
callq 0x14bc0
movq 0x40(%rsp), %rdi
movl $0x40, %esi
callq 0x6300
movq 0x50(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x31030
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x14bd0
jmp 0x142a8
leaq 0x90(%rsp), %rdi
callq 0x61e0
jmp 0x14303
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x61e0
jmp 0x143d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x61e0
jmp 0x143d0
movq 0x50(%rsp), %rsi
movq 0xe8(%rsp), %rdi
callq 0x31060
movq 0x50(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
callq 0x14c00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x31090
movq 0x50(%rsp), %rax
movq 0xe8(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x18, %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x31030
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x14ad0
movq %rax, 0x28(%rsp)
jmp 0x1437d
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x70(%rsp), %rdi
callq 0x61e0
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
leaq 0xe8(%rsp), %rsi
callq 0x14c20
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x61e0
movq 0xb8(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: marxn[P]pupp/src/parser/node.cpp
// Function: Node::FindVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long*)
VariableDef * Node::FindVariable(string varname, unsigned long * layer)
{
        map<string, VariableDef*>::iterator i = this->VariableDefTable.find(varname);
        if(i!=this->VariableDefTable.end())
        {
                return i->second;
        }

        if(this->ParentNode!=NULL)
        {
                if(layer)
                {
                        (*layer)++;
                }
                
                VariableDef * result = this->ParentNode->FindVariable(varname, layer);
                return result;
        }

        return NULL;
}

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x18, %rdi
callq 0x14c90
movq 0x28(%rsp), %rdi
movq %rax, 0x70(%rsp)
addq $0x18, %rdi
callq 0x14ce0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x14cc0
testb $0x1, %al
jne 0x14444
jmp 0x1445f
leaq 0x70(%rsp), %rdi
callq 0x14d10
movq 0x20(%rax), %rax
movq %rax, 0x90(%rsp)
jmp 0x1450c
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14500
cmpq $0x0, 0x78(%rsp)
je 0x14486
movq 0x78(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6160
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x143e0
movq %rax, 0x18(%rsp)
jmp 0x144c3
leaq 0x40(%rsp), %rdi
callq 0x61e0
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x1450c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61e0
jmp 0x1451c
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/node.cpp
// Function: NodeContext::PopFrame()
void NodeContext::PopFrame()
{
        if(this->VarTable.size()<=0)
        {
                return;
        }
        
        vector<Variable*>& frame = this->VarTable.back();
        vector<Variable*>::iterator i;
        	
        for(i = frame.begin(); i!=frame.end(); i++)
        {
                delete *i;
        }

        this->VarTable.pop_back();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x58, %rdi
callq 0x14ef0
cmpq $0x0, %rax
ja 0x14637
jmp 0x146e5
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
callq 0x151a0
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x151e0
movq 0x38(%rsp), %rdi
callq 0x15200
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x15270
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x15230
testb $0x1, %al
jne 0x14691
jmp 0x146d7
leaq 0x30(%rsp), %rdi
callq 0x152a0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x146c2
movq 0x8(%rsp), %rdi
callq 0x30960
movq 0x8(%rsp), %rdi
movl $0x38, %esi
callq 0x6300
jmp 0x146c4
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x152b0
movq %rax, 0x18(%rsp)
jmp 0x1466d
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
callq 0x152f0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/src/parser/node.cpp
// Function: NodeContext::AddFrame(Node*)
void NodeContext::AddFrame(Node * snapshot)
{
        vector<Variable*> frame;

        vector<VariableDef*>::iterator i;
        for(i = snapshot->VarDefArray.begin(); i!=snapshot->VarDefArray.end(); i++)
        {
                VariableDef * def = *i;
                if((*i)->NeedInstance())
                {
                        Variable * var = def->GetInstance();
                        frame.push_back(var);
                }
                else
                {
                        frame.push_back(NULL);
                }
        }
        
        this->VarTable.push_back(frame);
        
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x14f10
leaq 0x68(%rsp), %rdi
callq 0x14f20
movq 0x88(%rsp), %rdi
addq $0x48, %rdi
callq 0x14f40
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rdi
addq $0x48, %rdi
callq 0x14fb0
movq %rax, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x14f70
testb $0x1, %al
jne 0x14776
jmp 0x1482b
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x14fe0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x50(%rsp)
callq 0x14fe0
movq (%rax), %rdi
callq 0x310c0
movb %al, 0x1f(%rsp)
jmp 0x147a5
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x147af
jmp 0x147f7
movq 0x50(%rsp), %rdi
callq 0x30f00
movq %rax, 0x8(%rsp)
jmp 0x147c0
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x14ff0
jmp 0x147db
jmp 0x14813
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15140
jmp 0x14852
movq $0x0, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x15060
jmp 0x14811
jmp 0x14813
jmp 0x14815
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x15090
movq %rax, 0x28(%rsp)
jmp 0x14748
movq 0x20(%rsp), %rdi
addq $0x58, %rdi
leaq 0x70(%rsp), %rsi
callq 0x150d0
jmp 0x14840
leaq 0x70(%rsp), %rdi
callq 0x15140
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: marxn[P]pupp/src/parser/node.cpp
// Function: NodeContext::ReplaceVariable(unsigned long, std::__cxx11::list<Variable*, std::allocator<Variable*>>*)
void NodeContext::ReplaceVariable(unsigned long start_index, list<Variable*> * closurevars)
{
        int i = 0;
        vector<Variable*>& frame = this->VarTable[this->VarTable.size() - 1];
        
        list<Variable*>::iterator closurevarindex;
                
        for(closurevarindex = closurevars->begin(); closurevarindex != closurevars->end(); closurevarindex++)
        {
                frame[start_index + i] = (*closurevarindex)->CreateVarRef();
                i++;
        }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl $0x0, 0x3c(%rsp)
movq %rdi, %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rdi
callq 0x14ef0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x15310
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x15330
movq 0x40(%rsp), %rdi
callq 0x15350
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x12f80
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x15380
testb $0x1, %al
jne 0x148f2
jmp 0x14944
leaq 0x28(%rsp), %rdi
callq 0x153a0
movq (%rax), %rdi
callq 0x30d80
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movslq 0x3c(%rsp), %rax
addq %rax, %rsi
callq 0x153d0
movq (%rsp), %rcx
movq %rcx, (%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x153f0
movq %rax, 0x10(%rsp)
jmp 0x148ce
addq $0x58, %rsp
retq
nopl (%rax)
// File: marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::DivOperation(ConstValue*, ConstValue*)
ConstValue * Operation::DivOperation(ConstValue * left, ConstValue * right)
{
        DecimalValue * result = NULL;

        DecimalValue value1(left->toString());
        DecimalValue value2(right->toString());

        result = new DecimalValue(value1 / value2);

        return result;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq $0x0, 0xc0(%rsp)
movq 0xd0(%rsp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq *%rax
movq 0x18(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x8220
jmp 0x1de22
leaq 0x78(%rsp), %rdi
callq 0x61e0
movq 0xc8(%rsp), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
callq *%rax
jmp 0x1de44
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8220
jmp 0x1de55
leaq 0x20(%rsp), %rdi
callq 0x61e0
movl $0x28, %edi
callq 0x62f0
movq %rax, 0x10(%rsp)
jmp 0x1de70
movq 0x10(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x8800
jmp 0x1de89
movq 0x10(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8540
leaq 0x98(%rsp), %rdi
callq 0x8540
movq 0x8(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x61e0
jmp 0x1df4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1df42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61e0
jmp 0x1df42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1df38
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
movl $0x28, %esi
callq 0x6300
leaq 0x40(%rsp), %rdi
callq 0x8540
leaq 0x98(%rsp), %rdi
callq 0x8540
movq 0x70(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::ANDOperation(ConstValue*, ConstValue*)
ConstValue * Operation::ANDOperation(ConstValue * left, ConstValue * right)
{
        ConstValue * result = NULL;

        if(left->GetType()==Boolean && right->GetType()==Boolean)
        {
                result = new BooleanValue(static_cast<BooleanValue*>(left)->GetValue() && static_cast<BooleanValue*>(right)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
jne 0x25278
movq 0x38(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
jne 0x25278
movl $0x10, %edi
callq 0x62f0
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8d50
movb %al, 0x23(%rsp)
jmp 0x2520c
movb 0x23(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x2521d
jmp 0x25237
movq 0x38(%rsp), %rdi
callq 0x8d50
movb %al, 0x16(%rsp)
jmp 0x2522d
movb 0x16(%rsp), %al
movb %al, 0x17(%rsp)
jmp 0x25237
movq 0x18(%rsp), %rdi
movb 0x17(%rsp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x8c00
jmp 0x2524d
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x252bf
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x252c9
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7aa0
jmp 0x25294
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x252bf
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x252c9
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::OROperation(ConstValue*, ConstValue*)
ConstValue * Operation::OROperation(ConstValue * left, ConstValue * right)
{
        ConstValue * result = NULL;

        if(left->GetType()==Boolean && right->GetType()==Boolean)
        {
                result = new BooleanValue(static_cast<BooleanValue*>(left)->GetValue() || static_cast<BooleanValue*>(right)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
jne 0x253a8
movq 0x38(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
jne 0x253a8
movl $0x10, %edi
callq 0x62f0
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8d50
movb %al, 0x23(%rsp)
jmp 0x2533c
movb 0x23(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x25367
jmp 0x2534d
movq 0x38(%rsp), %rdi
callq 0x8d50
movb %al, 0x16(%rsp)
jmp 0x2535d
movb 0x16(%rsp), %al
movb %al, 0x17(%rsp)
jmp 0x25367
movq 0x18(%rsp), %rdi
movb 0x17(%rsp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x8c00
jmp 0x2537d
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x253ef
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x253f9
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7aa0
jmp 0x253c4
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x253ef
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x253f9
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/operation.cpp
// Function: Operation::NOTOperation(ConstValue*)
ConstValue * Operation::NOTOperation(ConstValue * value)
{
        ConstValue * result = NULL;

        if(value->GetType()==Boolean)
        {
                result = new BooleanValue(!static_cast<BooleanValue*>(value)->GetValue());
        }
        else
        {
                result = new NullValue;
        }
        return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7870
cmpl $0x3, %eax
jne 0x25493
movl $0x10, %edi
callq 0x62f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8d50
movb %al, 0x1b(%rsp)
jmp 0x25450
movq 0x10(%rsp), %rdi
movb 0x1b(%rsp), %al
notb %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x8c00
jmp 0x25468
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x254da
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x254e4
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7aa0
jmp 0x254af
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x254da
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x254e4
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6550
nop
// File: marxn[P]pupp/src/parser/scan.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 41 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 40);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq 0x4ade5(%rip), %rax     # 0x763b0
movq %rax, -0x10(%rsp)
movb $0x1, -0x11(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x3515f(%rip), %rax     # 0x60740
cmpw $0x0, (%rax,%rcx,2)
je 0x2b5fe
movl -0x4(%rsp), %eax
movl %eax, 0x4adca(%rip)     # 0x763bc
movq -0x10(%rsp), %rax
movq %rax, 0x4adc2(%rip)     # 0x763c0
jmp 0x2b600
movslq -0x4(%rsp), %rcx
leaq 0x35224(%rip), %rax     # 0x60830
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3517f(%rip), %rax     # 0x607a0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rsp), %eax
je 0x2b65d
movslq -0x4(%rsp), %rcx
leaq 0x35259(%rip), %rax     # 0x60890
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0x29, -0x4(%rsp)
jl 0x2b65b
movzbl -0x11(%rsp), %eax
movl %eax, %ecx
leaq 0x3529c(%rip), %rax     # 0x608f0
movb (%rax,%rcx), %al
movb %al, -0x11(%rsp)
jmp 0x2b600
movslq -0x4(%rsp), %rcx
leaq 0x351c7(%rip), %rax     # 0x60830
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x35292(%rip), %rax     # 0x60910
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0x28, -0x4(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0x2b6a6
xorl %eax, %eax
movl %eax, -0x18(%rsp)
jmp 0x2b6ae
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: BreakStatement::Check()
bool BreakStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Loop)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: break statement must appear in a loop."<<endl;
        return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c81c
movq (%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x2c80e
movb $0x1, 0x17(%rsp)
jmp 0x2c843
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c7f6
movq 0x497cd(%rip), %rdi     # 0x75ff0
leaq 0x34488(%rip), %rsi     # 0x60cb2
callq 0x62d0
movq %rax, %rdi
movq 0x4977f(%rip), %rsi     # 0x75fb8
callq 0x6320
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: ContinueStatement::Check()
bool ContinueStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Loop)
                {
                        return true;
                }
                
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: continue statement must appear in a loop."<<endl;
        return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c8ac
movq (%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x2c89e
movb $0x1, 0x17(%rsp)
jmp 0x2c8d3
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c886
movq 0x4973d(%rip), %rdi     # 0x75ff0
leaq 0x34435(%rip), %rsi     # 0x60cef
callq 0x62d0
movq %rax, %rdi
movq 0x496ef(%rip), %rsi     # 0x75fb8
callq 0x6320
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: RollbackStatement::Check()
bool RollbackStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Transaction)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: rollback statement must appear in a transaction."<<endl;
        return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c93c
movq (%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x2c92e
movb $0x1, 0x17(%rsp)
jmp 0x2c963
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c916
movq 0x496ad(%rip), %rdi     # 0x75ff0
leaq 0x343e5(%rip), %rsi     # 0x60d2f
callq 0x62d0
movq %rax, %rdi
movq 0x4965f(%rip), %rsi     # 0x75fb8
callq 0x6320
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: CommitStatement::Check()
bool CommitStatement::Check()
{
        Node * node = this->ParentNode;
        while(node!=NULL)
        {
                if(node->Type==Transaction)
                {
                        return true;
                }
                node = node->ParentNode;
        }

        cerr<<"pupp provision error: commit statement must appear in a transaction block."<<endl;
        return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c9cc
movq (%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x2c9be
movb $0x1, 0x17(%rsp)
jmp 0x2c9f3
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c9a6
movq 0x4961d(%rip), %rdi     # 0x75ff0
leaq 0x3439c(%rip), %rsi     # 0x60d76
callq 0x62d0
movq %rax, %rdi
movq 0x495cf(%rip), %rsi     # 0x75fb8
callq 0x6320
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: ReturnStatement::Invoke(NodeContext*)
int ReturnStatement::Invoke(NodeContext * context)
{
        ConstValue * value = this->Expr->Calculate(context);
        if(value==NULL)
        {
                return NODE_RET_ERROR;
        }

        context->FunctionRet = value->DupValue();

        delete value;
        return NODE_RET_NEEDRETURN;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ca39
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ca71
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2ca69
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x3, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: AssignStatement::AdjustValue(ValueBox*, ConstValue*, int)
void AssignStatement::AdjustValue(ValueBox * vbox, ConstValue * ad, int oper)
{
        if(oper==0)
        {
                vbox->SetVal(ad);
                return;
        }
        
        ConstValue * holder = vbox->GetVal();
        
        switch(oper)
        {
                case 1:
                        vbox->SetVal(Operation::AddOperation(holder, ad));
                        break;
                case 2:
                        vbox->SetVal(Operation::SubOperation(holder, ad));
                        break;
                case 3:
                        vbox->SetVal(Operation::MulOperation(holder, ad));
                        break;
                case 4:
                        vbox->SetVal(Operation::DivOperation(holder, ad));
                        break;
        }
        
        delete ad;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x2db32
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x79d0
jmp 0x2dc23
movq 0x48(%rsp), %rdi
callq 0x7a20
movq %rax, 0x30(%rsp)
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x28(%rsp)
subl $0x3, %eax
ja 0x2dc0a
movq 0x28(%rsp), %rax
leaq 0x33075(%rip), %rcx     # 0x60bd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x19e50
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x79d0
jmp 0x2dc0a
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1af20
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x79d0
jmp 0x2dc0a
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1c670
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x79d0
jmp 0x2dc0a
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1ddd0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x79d0
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2dc23
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: AssignStatement::Provision()
bool AssignStatement::Provision()
{
        list<list<Expression*>*>* exprslist = this->Reference->GetExpsList();

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

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

        return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rax), %rdi
callq 0x2cbc0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11500
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11550
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11530
testb $0x1, %al
jne 0x2dcc6
jmp 0x2dd72
leaq 0x38(%rsp), %rdi
callq 0x11580
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11290
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x112e0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x2dd0b
jmp 0x2dd5a
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rsp), %rsi
movq (%rax), %rdi
callq 0xda00
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2dd45
movb $0x0, 0x57(%rsp)
jmp 0x2dda3
jmp 0x2dd47
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x10(%rsp)
jmp 0x2dce7
jmp 0x2dd5c
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x11600
movq %rax, 0x8(%rsp)
jmp 0x2dc9f
movq (%rsp), %rsi
movq 0x70(%rsi), %rdi
callq 0xda00
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2dd9e
movb $0x0, 0x57(%rsp)
jmp 0x2dda3
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: PrintStatement::Invoke(NodeContext*)
int PrintStatement::Invoke(NodeContext * context)
{
        list<Expression*>::iterator i;
        for(i = ExprList->begin(); i!= ExprList->end(); i++)
        {
                ConstValue * value = (*i)->Calculate(context);
                if(value==NULL)
                {
                        return NODE_RET_ERROR;
                }

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

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x11270
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11290
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x112e0
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x2eafa
jmp 0x2ebb5
leaq 0x58(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq 0x60(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2eb2c
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ebbd
movq 0x47475(%rip), %rax     # 0x75fa8
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0x6150
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x32508(%rip), %rsi     # 0x6106a
movb $0x0, %al
callq 0x6490
leaq 0x20(%rsp), %rdi
callq 0x61e0
movq 0x4742e(%rip), %rax     # 0x75fa8
movq (%rax), %rdi
callq 0x63c0
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2eb9d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2eb9f
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x18(%rsp)
jmp 0x2eacf
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x2ec4f
jmp 0x2ec9e
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rsp), %rsi
movq (%rax), %rdi
callq 0xda00
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2ec89
movb $0x0, 0x37(%rsp)
jmp 0x2eca3
jmp 0x2ec8b
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0x2ec28
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0x2ed0f
jmp 0x2ed48
leaq 0x20(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2ed33
movb $0x0, 0x37(%rsp)
jmp 0x2ed4d
jmp 0x2ed35
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0x2ece8
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ed99
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ee06
movq 0x8(%rsp), %rdi
callq 0x7870
cmpl $0x1, %eax
je 0x2edd4
movq 0x47241(%rip), %rdi     # 0x75ff0
leaq 0x322b7(%rip), %rsi     # 0x6106d
callq 0x62d0
movq %rax, %rdi
movq 0x471f3(%rip), %rsi     # 0x75fb8
callq 0x6320
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ee06
movq 0x8(%rsp), %rdi
callq 0x7fe0
movl %eax, %edi
callq 0x6480
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2edfe
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: marxn[P]pupp/src/parser/statement.cpp
// Function: CallStatement::Invoke(NodeContext*)
int CallStatement::Invoke(NodeContext * context)
{
        this->RetVal = this->Expr->Calculate(context);
        if(this->RetVal==NULL)
        {
                return NODE_RET_ERROR;
        }

        return NODE_RET_NORMAL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x60(%rax)
jne 0x2ef14
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2ef1c
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6460
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq $0x0, (%rax)
movq $0x0, 0x30(%rax)
callq 0x6060
jmp 0x30924
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x61e0
movq 0x28(%rsp), %rdi
callq 0x6550
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x30b3a
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7880
jmp 0x30b0b
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x30b3a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x30bb4
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7870
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jne 0x30b82
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x79d0
jmp 0x30baf
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0xa620
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x30(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x79d0
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6550
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x30c60
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7880
jmp 0x30bff
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl 0x8(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x99f0
leaq 0x18(%rsp), %rdi
callq 0x9a10
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x79d0
jmp 0x30c7c
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x30c86
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x7a20
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6550
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x30d57
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7880
jmp 0x30cf6
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl 0x8(%rax), %esi
leaq 0x20(%rsp), %rdi
callq 0x99f0
leaq 0x20(%rsp), %rdi
callq 0x9a10
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x30(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x79d0
jmp 0x30d57
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x30d72
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x7a20
movq %rax, %rdi
callq 0x7870
addq $0x38, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x38, %edi
callq 0x62f0
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
movb $0x1, 0x1b(%rsp)
addq $0x10, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6160
jmp 0x30dbc
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x28(%rsp), %rsi
callq 0x308d0
jmp 0x30dd5
movb $0x0, 0x1b(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq (%rax), %rsi
callq 0x309e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x30e71
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x7950
movq 0x8(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x30(%rax), %rsi
callq 0x30a10
jmp 0x30e71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x30e57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
testb $0x1, 0x1b(%rsp)
jne 0x30e60
jmp 0x30e6f
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0x6300
jmp 0x30e7b
movq 0x48(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)