LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::manhattan() const
unsigned manhattan() const {
        unsigned sum = 0;
        for( unsigned p = 0; p < rows()*cols(); ++p )
            if( p != blank() ) {
                unsigned t = tile(p);
                int r = ((1+t)/cols()) - (p/cols()), c = ((1+t)%cols()) - (p%cols());
                sum += (r<0?-r:r) + (c<0?-c:c);
            }
        return sum;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %r14d
movl %r14d, %r8d
shrl $0x4, %r8d
andl $0xf, %r8d
movl %r14d, %r9d
shrl $0x8, %r9d
andl $0xf, %r9d
imull %r9d, %r8d
testl %r8d, %r8d
je 0x91f0
andl $0xf, %r14d
xorl %r10d, %r10d
movl $0xff, %r11d
xorl %edx, %edx
xorl %ebx, %ebx
cmpl %ebx, %r14d
je 0x91e3
leal -0x20(%r10), %eax
xorl %ecx, %ecx
cmpl $0x8, %ebx
setae %cl
movl 0x4(%rdi,%rcx,4), %ebp
movzbl %al, %ecx
cmovbl %r10d, %ecx
shrl %cl, %ebp
andb $0xf, %bpl
incb %bpl
movzbl %bpl, %eax
divb %r9b
movl %eax, %ecx
movzbl %ah, %ebp
movzbl %bl, %eax
divb %r9b
movzbl %ah, %esi
movzbl %cl, %ecx
movzbl %al, %eax
subl %eax, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
andl %r11d, %eax
subl %esi, %ebp
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
andl %r11d, %ecx
addl %ecx, %edx
addl %eax, %edx
incl %ebx
addl $0x4, %r10d
cmpl %ebx, %r8d
jne 0x9187
jmp 0x91f2
xorl %edx, %edx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/puzzle/./puzzle.h
// Function: state_t::print(std::ostream&) const
void print(std::ostream &os) const {
        os << "|" << std::setw(2) << blank() << "|";
        for( unsigned i = 0; i < rows() * cols(); ++i ) {
            os << (i == blank() ? 0 : 1+tile(i));
            os << (i < rows() * cols() - 1 ? "," : "|");
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12629(%rip), %r15     # 0x25bed
movl $0x1, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x5250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movl (%r14), %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0x5160
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5250
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl %eax, %edx
shrl $0x8, %edx
testb $0xf, %dl
sete %dl
testb $0xf, %cl
sete %cl
orb %dl, %cl
jne 0x136ae
xorl %r12d, %r12d
leaq 0x124b7(%rip), %r13     # 0x25ae4
xorl %ebp, %ebp
andl $0xf, %eax
cmpl %eax, %ebp
jne 0x1363a
xorl %esi, %esi
jmp 0x1365a
leal -0x20(%r12), %eax
xorl %ecx, %ecx
cmpl $0x8, %ebp
setae %cl
movl 0x4(%r14,%rcx,4), %esi
movzbl %al, %ecx
cmovbl %r12d, %ecx
shrl %cl, %esi
andl $0xf, %esi
incl %esi
movq %rbx, %rdi
callq 0x5160
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
shrl $0x8, %eax
andl $0xf, %eax
imull %ecx, %eax
decl %eax
cmpl %eax, %ebp
movq %r15, %rsi
cmovbq %r13, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5250
incl %ebp
movl (%r14), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
movl %eax, %edx
shrl $0x8, %edx
andl $0xf, %edx
imull %ecx, %edx
addl $0x4, %r12d
cmpl %edx, %ebp
jb 0x1362f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::inifile::dget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string inifile::dget(const std::string& key,
                            const std::string& default_value) const {
    try {
      return this->get(key);
    }
    catch(unknown_entry_error& ex) { /* ignore */ }

    return default_value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x4ad0c
addq $0x38, %r13
cmpq %r13, %rax
je 0x37d93
movq %r12, %rdi
movq %r15, %rsi
callq 0x4ad0c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4baae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xe210
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x4ac0c
leaq 0x406fe(%rip), %rsi     # 0x784b0
movq 0x431ff(%rip), %rdx     # 0x7afb8
movq %r12, %rdi
callq 0xe800
movq %rdx, %r13
movq %rax, %r15
movq %r12, %rdi
callq 0xe360
jmp 0x37dd7
movq %rdx, %r13
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r13d
jne 0x37e08
callq 0xe1e0
callq 0xe790
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4baae
jmp 0x37d81
callq 0xe840
nop
// File: /workspace/github_cpp_makefile_star2_O3/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::inifile::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string inifile::get(const std::string& section,
                           const std::string& key) const {
    if(!this->_sections.count(section)) {
      throw unknown_section_error(section);
    }

    if(!this->_sections.find(section)->second.count(key)) {
      throw unknown_entry_error(section, key);
    }

    return this->_sections.find(section)->second.find(key)->second;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4b0f0
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x37ea3
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b0f0
movq %rax, %r13
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x4ad0c
addq $0x48, %r13
cmpq %r13, %rax
je 0x37ec4
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b0f0
leaq 0x40(%rax), %rdi
movq %r15, %rsi
callq 0x4ad0c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4baae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xe210
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4adcc
leaq 0x40606(%rip), %rsi     # 0x784c8
jmp 0x37ee6
movl $0x10, %edi
callq 0xe210
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4aecc
leaq 0x405ca(%rip), %rsi     # 0x784b0
movq 0x430cb(%rip), %rdx     # 0x7afb8
movq %rbx, %rdi
callq 0xe800
jmp 0x37ef7
movq %rax, %r14
movq %rbx, %rdi
callq 0xe360
movq %r14, %rdi
callq 0xe840
// File: /workspace/github_cpp_makefile_star2_O3/wagnerflo[P]inipp/./inipp.hh
// Function: inipp::_private::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool _private::split(const std::string& in, const std::string& sep,
                              std::string& first, std::string& second) {
    size_t eqpos = in.find(sep);

    if(eqpos == std::string::npos) {
      return false;
    }

    first = in.substr(0, eqpos);
    second = in.substr(eqpos + sep.size(), in.size() - eqpos - sep.size());

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r12), %rcx
xorl %edx, %edx
callq 0xe820
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x4a2f7
movq %r14, -0x30(%rbp)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe4d0
movq %r13, %rdi
movq %r14, %rsi
callq 0xe5c0
movq (%r14), %rdi
leaq -0x40(%rbp), %r13
cmpq %r13, %rdi
je 0x4a2bd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0xe4b0
movq 0x8(%r12), %rdx
addq %rbx, %rdx
movq 0x8(%r15), %rcx
subq %rdx, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xe4d0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xe5c0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4a2f7
movq -0x40(%rbp), %rsi
incq %rsi
callq 0xe4b0
cmpq $-0x1, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0xbd54
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x6556
movq %r14, %rdi
callq 0xc5e8
pushq $0x70
popq %rsi
movq %r14, %rdi
callq 0x6270
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6270
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: ValueBox::ValueBox(ConstValue*)
ValueBox::ValueBox(ConstValue * value)
{
        this->Value    = NULL; 
        this->RefCount = 1;
        if(value!=NULL)
        {
                this->Value = value->DupValue();
        }
}

// Assembly:
movq $0x0, (%rdi)
movq $0x1, 0x8(%rdi)
testq %rsi, %rsi
je 0x7ddf
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: ValueBox::Destroy()
void ValueBox::Destroy()
{
        if(this->RefCount==1)
        {
                delete this;
        }
        else
        {
                this->RefCount--;
        }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x1, %rax
jne 0x7e48
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e3a
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6270
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: StringValue::LooksLikeInteger()
bool StringValue::LooksLikeInteger()
{
        char buf[256];
        long value;
        int n = sscanf(this->Value.c_str(), "%ld", &value);
        if(n>0)
        {
                sprintf(buf, "%ld", value);

                if(strlen(buf)==strlen(this->Value.c_str()))
                {
                        return true;
                }
        }
        return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x327c3(%rip), %rsi     # 0x3a817
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x6240
testl %eax, %eax
jle 0x809d
movq 0x8(%rsp), %rdx
leaq 0x327a7(%rip), %rsi     # 0x3a817
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x60a0
movq %r14, %rdi
callq 0x6120
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x6120
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r14
je 0x809f
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: DecimalValue::toString[abi:cxx11]()
string DecimalValue::toString()
{
        char result[1024];
        int prec = mpf_get_prec(this->Value);
        gmp_snprintf (result, sizeof(result), "%.*Ff", prec, this->Value);
        
        char * p = strstr(result, ".");
        if(p==NULL)
        {
            return result;
        }
        
        int len = strlen(p) - 1;
        
        char * q = p + len;
        
        while(*q == '0' && *(q-1)!='.')
        {
            q--;
        }
        
        *(q+1) = '\0';
        
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0x1ba4c
leaq 0x2ca34(%rip), %rdx     # 0x350f8
movq %rsp, %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movl %eax, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x2fab4
movq %r15, %rdi
movl $0x2e, %esi
callq 0x6100
testq %rax, %rax
je 0x871d
movq %rax, %r14
movq %rax, %rdi
callq 0x6120
decl %eax
movslq %eax, %rcx
movb (%r14,%rcx), %al
leaq (%r14,%rcx), %rdx
incq %rdx
movq %rdx, %rcx
cmpb $0x30, %al
jne 0x871a
movb -0x2(%rcx), %al
leaq -0x1(%rcx), %rdx
cmpb $0x2e, %al
jne 0x8708
movb $0x0, (%rcx)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x6120
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cec
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: KVValue::toString[abi:cxx11]()
string KVValue::toString()
{
        string ret = "<";
        ret.append(this->Key->toString());
        ret.append(",");
        ret.append(this->Value->GetVal()->toString());
        ret.append(">");
        return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2c7ba(%rip), %rsi     # 0x35109
leaq 0x2c7b4(%rip), %rdx     # 0x3510a
callq 0x7cec
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8998
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x2c76c(%rip), %rsi     # 0x3510b
movq %rbx, %rdi
callq 0x64a0
movq 0x18(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x89e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x2c724(%rip), %rsi     # 0x3510d
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x8a22
jmp 0x8a36
jmp 0x8a33
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8a36
jmp 0x8a33
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8a49
movq (%r15), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::~MapValue()
MapValue::~MapValue()
{
        map<string, ValueBox*>::iterator i;
        for(i=this->Value.begin();i!=this->Value.end();i++)
        {
                i->second->Destroy();
        }
        this->Value.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3d235(%rip), %rax     # 0x45db8
movq %rax, (%rdi)
movq 0x28(%rdi), %r14
leaq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x8bac
movq 0x40(%r14), %rdi
callq 0x7e1e
movq %r14, %rdi
callq 0x61c0
movq %rax, %r14
cmpq %r15, %rax
jne 0x8b93
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x9c08
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x992e
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::AddKV(KVValue*)
void MapValue::AddKV(KVValue * kv)
{
        string key = kv->GetKey()->toString();
        map<string, ValueBox*>::iterator i = this->Value.find(key);

        if(i!=this->Value.end())
        {
                i->second->Destroy();
                this->Value.erase(key);
        }
        this->Value.insert(pair<string, ValueBox*>(key, kv->GetValueBox()->Dup()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9c36
addq $0x18, %r15
cmpq %r15, %rax
je 0x8c36
movq 0x40(%rax), %rdi
callq 0x7e1e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9cc0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9d74
movq 0x18(%r14), %rdi
callq 0x7e7a
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x99a6
leaq 0x20(%rsp), %rsi
movq %r14, 0x20(%rsi)
movq %rbx, %rdi
callq 0x9a3c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8c89
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ca4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x8cd1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8cd1
jmp 0x8cce
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::FindByKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ValueBox * MapValue::FindByKey(string key)
{
        map<string, ValueBox*>::iterator i = this->Value.find(key);
        if(i!=this->Value.end())
        {
                return i->second;
        }
        return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x9c36
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x8d2c
movq 0x40(%rax), %rax
jmp 0x8d2e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: MapValue::toString[abi:cxx11]()
string MapValue::toString()
{
        string ret="[";

        int size = this->Value.size();
        map<string, ValueBox*>::iterator i;
        for(i=this->Value.begin(); i!=this->Value.end(); i++, size--)
        {
                ret.append("<");
                ret.append(i->first);
                ret.append(",");
                ret.append(i->second->GetVal()->toString());
                ret.append(">");
                if(size>1)
                {
                        ret.append(",");
                }
        }
        ret.append("]");
        return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x2c36d(%rip), %rsi     # 0x3510f
leaq 0x2c367(%rip), %rdx     # 0x35110
callq 0x7cec
movq 0x28(%r15), %r14
leaq 0x18(%r15), %r13
cmpq %r13, %r14
je 0x8e6e
movl 0x38(%r15), %r15d
leaq 0x2c341(%rip), %r12     # 0x3510b
leaq 0x2c33c(%rip), %rbp     # 0x3510d
movq %rbx, %rdi
leaq 0x2c32e(%rip), %rsi     # 0x35109
callq 0x64a0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x60e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64a0
movq 0x40(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8e3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x64a0
cmpl $0x2, %r15d
jl 0x8e57
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64a0
movq %r14, %rdi
callq 0x61c0
movq %rax, %r14
decl %r15d
cmpq %r13, %rax
jne 0x8dd1
leaq 0x2c29c(%rip), %rsi     # 0x35111
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8eb4
jmp 0x8eb4
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8eb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x8eb7
movq %rax, %r14
movq (%rsp), %rax
movq (%rbx), %rdi
cmpq %rax, %rdi
je 0x8ece
movq (%rax), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: DefaultValueFactory::GetValue()
ConstValue * DefaultValueFactory::GetValue()
{
        ConstValue * result = NULL;
        switch(this->Type)
        {
                case Integer:
                        result = new IntegerValue(0);
                break;
                case String:
                        result = new StringValue("");
                break;
                case Boolean:
                        result = new BooleanValue(false);
                break;
                case Decimal:
                        result = new DecimalValue("0");
                break;
                case Map:
                        result = new MapValue();
                break;
                case Func:
                        result = new FuncValue(NULL, NULL);
                break;
                default:
                        result = new NullValue;
        }
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x7, %eax
ja 0x8f70
leaq 0x2c159(%rip), %rcx     # 0x35050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x18, %edi
callq 0x6260
movq %rax, %rbx
movl $0x1, 0x8(%rax)
leaq 0x3cddd(%rip), %rax     # 0x45cf8
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x9069
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movl $0x3, 0x8(%rax)
leaq 0x3ce12(%rip), %rax     # 0x45d58
movq %rax, (%rbx)
movb $0x0, 0xc(%rbx)
jmp 0x9069
movl $0x20, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x189b0
jmp 0x9069
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x3cd0d(%rip), %rax     # 0x45c98
movq %rax, (%rbx)
jmp 0x9069
movl $0x28, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x30fb3(%rip), %rsi     # 0x39f63
leaq 0x30fad(%rip), %rdx     # 0x39f64
movq %rsp, %rdi
callq 0x7cec
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8222
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9069
movq 0x10(%rsp), %rsi
jmp 0x9024
movl $0x30, %edi
callq 0x6260
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c023(%rip), %rdx     # 0x3501e
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x7cec
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7f4c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x9069
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x9069
movl $0x40, %edi
callq 0x6260
movq %rax, %rbx
movl $0x6, 0x8(%rax)
leaq 0x3cd6f(%rip), %rax     # 0x45db8
movq %rax, (%rbx)
leaq 0x18(%rbx), %rax
movl $0x0, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x90b0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x90b0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x90ba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x90ba
movq %rax, %r14
movl $0x30, %esi
jmp 0x90c9
movq %rax, %r14
movl $0x28, %esi
jmp 0x90c9
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::ArrayValue(DataType, std::vector<long, std::allocator<long>>&, long)
ArrayValue::ArrayValue(DataType type, vector<long>& desc, long size):ConstValue(Array)
{
        DefaultValueFactory fac(type);

        this->ElementType = type;
        this->Value = new ValueBox*[size];
        this->Dim = desc;
        this->Size = size;

        for(int i = 0; i < size; i++)
        {
                ConstValue * val = fac.GetValue();
                
                this->Value[i] = new ValueBox;
                this->Value[i]->SetVal(val);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movl $0x7, 0x8(%rdi)
leaq 0x3cce9(%rip), %rax     # 0x45de8
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl %esi, 0xc(%rsp)
movl %esi, 0xc(%rdi)
movq %rcx, %rax
shrq $0x3d, %rax
leaq (,%rcx,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
movq %r14, 0x10(%rsp)
callq 0x6030
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x97f8
movq %r15, 0x30(%rbx)
testq %r15, %r15
jle 0x91ac
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x8eda
movq %rax, %r13
movl $0x10, %edi
callq 0x6260
movq $0x0, (%rax)
movq $0x1, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x91a1
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%r14)
incq %rbp
cmpq %rbp, %r15
jne 0x915f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x91bd
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91d9
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6270
movq %r15, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::~ArrayValue()
ArrayValue::~ArrayValue()
{
        for(int i = 0; i < this->Size; i++)
        {
                if(this->Value[i]!=NULL)
                {
                        this->Value[i]->Destroy();
                }
        }

        delete this->Value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3cbf8(%rip), %rax     # 0x45de8
movq %rax, (%rdi)
movq 0x30(%rdi), %rax
testq %rax, %rax
jle 0x921d
xorl %r14d, %r14d
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x9215
callq 0x7e1e
movq 0x30(%rbx), %rax
incq %r14
cmpq %r14, %rax
jg 0x91ff
movq 0x10(%rbx), %rdi
movl $0x8, %esi
callq 0x6270
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9247
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6270
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::toString[abi:cxx11]()
string ArrayValue::toString()
{
        string ret="[";

        int size = this->Size;
        for(int i = 0; i < size; i++)
        {
                if(this->Value[i]->GetVal()!=NULL)
                {
                        ret.append(this->Value[i]->GetVal()->toString());
                }
                else
                {
                        ret.append("nil");
                }
                if(i<size-1)
                {
                        ret.append(",");
                }
        }
        ret.append("]");
        return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x2bd53(%rip), %rsi     # 0x3510f
leaq 0x2bd4d(%rip), %rdx     # 0x35110
callq 0x7cec
movq 0x30(%r14), %rbp
testl %ebp, %ebp
jle 0x945c
leal -0x1(%rbp), %eax
movslq %eax, %r12
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x9431
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9440
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x9440
movq %rbx, %rdi
leaq 0x2bcd8(%rip), %rsi     # 0x35113
callq 0x64a0
cmpq %r12, %r15
jge 0x9454
movq %rbx, %rdi
leaq 0x2bcbc(%rip), %rsi     # 0x3510b
callq 0x64a0
incq %r15
cmpq %r15, %rbp
jne 0x93e8
leaq 0x2bcae(%rip), %rsi     # 0x35111
movq %rbx, %rdi
callq 0x64a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x94a2
jmp 0x94a2
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x94a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0x94a5
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x94bd
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Invoke(NodeContext*)
int ContainerNode::Invoke(NodeContext * context)
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                if((*i)->Type==Function)
                {
                        continue;
                }

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

                if(cond!=NODE_RET_NORMAL)
                {
                        return cond;
                }
        }

        return NODE_RET_NORMAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x60(%rdi), %rax
movq (%rax), %r12
xorl %ebx, %ebx
cmpq %rax, %r12
je 0x9ed5
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%r12), %rsi
cmpl $0x1, 0x8(%rsi)
je 0x9ec8
movq %r14, %rdi
callq 0xc6ae
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0xc316
movl %eax, %ebp
movq %r14, %rdi
callq 0xc626
testl %ebp, %ebp
jne 0x9ed3
movq 0x60(%r15), %rax
movq (%r12), %r12
cmpq %rax, %r12
jne 0x9e96
jmp 0x9ed5
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Provision()
bool ContainerNode::Provision()
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                (*i)->SetParentNode(this);
                if((*i)->Provision()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %r14
movq 0x60(%rbx), %r15
cmpq %r15, %r14
je 0x9f4c
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xc342
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x9f26
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/container.cpp
// Function: ContainerNode::Check()
bool ContainerNode::Check()
{
        list<Node*>::iterator i;
        for(i = subnodelist->begin(); i != subnodelist->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %r14
movq 0x60(%rbx), %r15
cmpq %r15, %r14
je 0x9f7e
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x9f64
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: BinaryExpression::Provision()
bool BinaryExpression::Provision()
{
        left->SetParentNode(this->ParentNode);
        right->SetParentNode(this->ParentNode);

        if(left->Provision()==false)
        {
                return false;
        }
        if(right->Provision()==false)
        {
                return false;
        }

        return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdi
movq %rax, 0x10(%rdi)
movq 0x20(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xa0bf
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: KVExpression::CarryOut(ConstValue*, ConstValue*)
ConstValue * KVExpression::CarryOut(ConstValue * left_store, ConstValue * right_store)
{
        ValueBox * vb = new ValueBox(right_store);
        KVValue * result = new KVValue(left_store, vb);
        vb->Destroy();
        return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7dba
movl $0x20, %edi
callq 0x6260
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8826
movq %rbx, %rdi
callq 0x7e1e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x20, %esi
movq %r15, %rdi
jmp 0xa16d
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: SetExpression::Provision()
bool SetExpression::Provision()
{
        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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq (%r14), %r14
movq 0x18(%rbx), %r15
cmpq %r15, %r14
je 0xa3e8
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0xa3c2
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: SetExpression::Check()
bool SetExpression::Check()
{
        list<Expression*>::iterator i;
        for(i = this->ExprList->begin(); i!=this->ExprList->end(); i++)
        {
                if((*i)->Check()!=true)
                {
                        return false;
                }
        }

        return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq (%r14), %r14
movq 0x18(%rbx), %r15
cmpq %r15, %r14
je 0xa41a
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xa400
cmpq %r15, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Calculate(NodeContext*)
ConstValue * VarExpression::Calculate(NodeContext * context)
{
        ValueBox * result = this->GetVarRef(context);
        if(result==NULL)
        {
                return new NullValue;
        }

        return result->GetVal()->DupValue();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0xa4bc
testq %rax, %rax
je 0xaa62
movq %rax, %rdi
callq 0x7e76
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rcx)
movl $0x10, %edi
callq 0x6260
movq %rax, %rbx
movq %rax, %rdi
callq 0x7ed2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Provision()
bool VarExpression::Provision()
{
        for(list<list<Expression*>*>::iterator gitor = this->ExprsList.begin(); gitor!=this->ExprsList.end(); gitor++)
        {
                list<Expression*> * ExprList = *gitor;
                
                for(list<Expression*>::iterator i = ExprList->begin(); i!=ExprList->end(); i++)
                {
                    (*i)->SetParentNode(this->ParentNode);
                    if((*i)->Provision()!=true)
                    {
                            return false;
                    }
                }
        }

        return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rdi), %r15
movq 0x40(%rdi), %r12
movb $0x1, %bl
cmpq %r15, %r12
je 0xaaf1
movq %rdi, %r14
movq 0x10(%r12), %r13
movq %r13, %rbp
movq (%rbp), %rbp
cmpq %r13, %rbp
je 0xaae4
movq 0x10(%rbp), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0xaabf
jmp 0xaaef
movq (%r12), %r12
cmpq %r15, %r12
jne 0xaab7
jmp 0xaaf1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/src/parser/expression.cpp
// Function: VarExpression::Check()
bool VarExpression::Check()
{
        unsigned long layer = 0;
        VariableDef * vardef = this->ParentNode->FindVariable(this->VarName, &layer);
        if(vardef==NULL)
        {
                cerr<<"pupp provision error: Variable "<<this->VarName<<" has not been defined"<<endl;
                return false;
        }
        
        this->VarDef = vardef;
        this->VarLayer = layer;

        for(list<list<Expression*>*>::iterator gitor = this->ExprsList.begin(); gitor!=this->ExprsList.end(); gitor++)
        {
                list<Expression*> * ExprList = *gitor;
                
                for(list<Expression*>::iterator i = ExprList->begin(); i!=ExprList->end(); i++)
                {
                    if((*i)->Check()!=true)
                {
                        return false;
                }
                }
        }
        
        return Expression::Check();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq 0x10(%rdi), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x99a6
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xc4ca
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xab6a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
testq %r14, %r14
je 0xabb5
movq %r14, 0x38(%rbx)
movq (%rsp), %rax
movq %rax, 0x58(%rbx)
movq 0x40(%rbx), %r14
addq $0x40, %rbx
movb $0x1, %bpl
cmpq %rbx, %r14
je 0xac20
movq 0x10(%r14), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0xabb0
movq 0x10(%r12), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xab96
jmp 0xac1e
movq (%r14), %r14
jmp 0xab86
movq 0x3c434(%rip), %r14     # 0x46ff0
leaq 0x2a630(%rip), %rsi     # 0x351f3
movl $0x1f, %edx
movq %r14, %rdi
callq 0x62f0
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x62f0
movq %rax, %rbx
leaq 0x2a629(%rip), %rsi     # 0x35213
movl $0x15, %edx
movq %rax, %rdi
callq 0x62f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61b0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xac4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rdi
movq %rax, 0x10(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xb2ee
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0xb2f0
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0xb2c5
jmp 0xb2f0
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0xb32e
movq 0x60(%rbx), %r14
movq (%r14), %r14
cmpq 0x60(%rbx), %r14
sete %bpl
je 0xb330
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0xb311
jmp 0xb330
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6370
movq %r14, %rdi
movl $0x1, %esi
callq 0x6380
leaq -0x544b(%rip), %rdx     # 0x6532
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6480
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x6160
movb %bpl, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xbc7a
movq (%r15), %rsi
incq %rsi
callq 0x6270
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
leaq 0x18(%rdi), %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1896c
movq %r14, %rdi
movq %r12, %rsi
callq 0xc838
movq (%rax), %r12
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xc39e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
testq %r12, %r12
je 0xc40b
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rax, %rdi
je 0xc3bc
movq (%rax), %rsi
incq %rsi
callq 0x6270
movl $0x40, %esi
movq %r12, %rdi
callq 0x6270
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1896c
movq %r14, %rdi
movq %r12, %rsi
callq 0xce02
movq %r14, %rdi
movq %rax, %rsi
callq 0xceb6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc406
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1898e
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x1899a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1896c
movq %r14, %rdi
movq %r12, %rsi
callq 0xc838
movq %r15, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc45f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0xc473
movq %r15, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0xc484
addq $0x48, %rbx
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xcfa0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc4a7
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc4b4
jmp 0xc4c1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc4c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rdi
callq 0xd0dc
leaq 0x20(%r15), %rcx
cmpq %rcx, %rax
je 0xc503
movq 0x40(%rax), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r15), %r15
testq %r15, %r15
je 0xc55f
testq %rbx, %rbx
je 0xc514
incq (%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x99a6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc4ca
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc4f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
jmp 0xc4f4
xorl %ebx, %ebx
jmp 0xc4f4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc57d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x48(%rsi), %rbp
cmpq 0x50(%rsi), %rbp
je 0xc743
movq %rsi, %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq (%rbp), %r13
movq %r13, %rdi
callq 0x189a6
testb %al, %al
je 0xc718
movq %r13, %rdi
callq 0x1889e
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xc72e
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0xc739
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xd3fa
jmp 0xc739
movq %r15, %rdi
movq %r12, %rdx
callq 0xd2be
addq $0x8, %rbp
cmpq 0x50(%r14), %rbp
jne 0xc6e4
addq $0x58, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc9e6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc768
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6270
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc77d
jmp 0xc77d
jmp 0xc77d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc796
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6270
movq %rbx, %rdi
callq 0x6460