LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x97700
cmpq $0x0, %rax
jne 0x5c3ea
movl $0x10, %edi
callq 0x102e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
callq 0x97760
jmp 0x5c3b9
movq -0x68(%rbp), %rdi
leaq 0xb8d2c(%rip), %rsi     # 0x1150f0
leaq 0x3b455(%rip), %rdx     # 0x97820
callq 0x10a40
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x10470
jmp 0x5c4c5
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97840
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x97870
movq %rax, %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x97300
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5c423
jmp 0x5c474
movl $0x10, %edi
callq 0x102e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x97890
jmp 0x5c446
movq -0x70(%rbp), %rdi
leaq 0xb8c87(%rip), %rsi     # 0x1150d8
leaq 0x3afc8(%rip), %rdx     # 0x97420
callq 0x10a40
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x10470
jmp 0x5c4c5
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97840
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x97870
movq %rax, %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x97440
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x97470
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x10290
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10a90
nop
// File: 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string inifile::dget(const std::string& section,
                            const std::string& key,
                            const std::string& default_value) const {
    try {
      return this->get(section, key);
    }
    catch(unknown_section_error& ex) { /* ignore */ }
    catch(unknown_entry_error& ex) { /* ignore */ }

    return default_value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5c360
jmp 0x5c94a
jmp 0x5c9a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5c988
movq -0x30(%rbp), %rdi
callq 0x10270
movq %rax, -0x48(%rbp)
callq 0x109e0
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10290
jmp 0x5c9a8
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5c9b2
movq -0x30(%rbp), %rdi
callq 0x10270
movq %rax, -0x40(%rbp)
callq 0x109e0
jmp 0x5c979
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10a90
nopl (%rax,%rax)
// File: wagnerflo[P]inipp/./inipp.hh
// Function: inipp::_private::trim(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&)
inline std::string _private::trim(const std::string& str,
                                    const std::string& whitespace) {
    size_t startpos = str.find_first_not_of(whitespace);
    size_t endpos = str.find_last_not_of(whitespace);

    // only whitespace, return empty line
    if(startpos == std::string::npos || endpos == std::string::npos) {
      return std::string();
    }

    // trim leading and trailing whitespace
    return str.substr(startpos, endpos - startpos + 1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10500
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0x10b70
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x94aba
cmpq $-0x1, -0x28(%rbp)
jne 0x94ac5
movq -0x38(%rbp), %rdi
callq 0x108d0
jmp 0x94ae2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x10650
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10c20
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x94c70
movb $0x0, -0x1(%rbp)
jmp 0x94d1a
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x10650
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x107c0
leaq -0x50(%rbp), %rdi
callq 0x10c38
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10430
movq %rax, %rcx
movq -0x90(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10430
subq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10430
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
subq %rax, %rcx
leaq -0x70(%rbp), %rdi
callq 0x10650
movq -0x28(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x107c0
leaq -0x70(%rbp), %rdi
callq 0x10c38
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, (%rax)
movq $0x1, 0x8(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x78e3
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/src/parser/constval.cpp
// Function: ValueBox::Destroy()
void ValueBox::Destroy()
{
        if(this->RefCount==1)
        {
                delete this;
        }
        else
        {
                this->RefCount--;
        }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x8(%rax)
jne 0x79b0
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x79ae
movq 0x8(%rsp), %rdi
callq 0x78f0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x6300
jmp 0x79c1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x128(%rsp)
movq 0x128(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x6150
movq %rax, %rdi
leaq 0x5ce28(%rip), %rsi     # 0x64b97
leaq 0x18(%rsp), %rdx
movb $0x0, %al
callq 0x62c0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x7dda
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x5ce00(%rip), %rsi     # 0x64b97
movb $0x0, %al
callq 0x60c0
leaq 0x20(%rsp), %rdi
callq 0x6170
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
addq $0x10, %rdi
callq 0x6150
movq %rax, %rdi
callq 0x6170
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x7dd8
movb $0x1, 0x137(%rsp)
jmp 0x7de2
jmp 0x7dda
movb $0x0, 0x137(%rsp)
movb 0x137(%rsp), %al
andb $0x1, %al
addq $0x138, %rsp            # imm = 0x138
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/constval.cpp
// Function: StringValue::LooksLikeDecimal()
bool StringValue::LooksLikeDecimal()
{
        mpf_t temp;
        mpf_init(temp);
        if(mpf_set_str(temp, this->Value.c_str(), 10)==0)
        {
                mpf_clear(temp);
                return true;
        }
        mpf_clear(temp);
        return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x33650
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0x6150
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0xa, %edx
callq 0x337b0
cmpl $0x0, %eax
jne 0x7e5b
leaq 0x10(%rsp), %rdi
callq 0x34c10
movb $0x1, 0x37(%rsp)
jmp 0x7e6a
leaq 0x10(%rsp), %rdi
callq 0x34c10
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x488, %rsp            # imm = 0x488
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x480(%rsp)
movq %rsi, 0x478(%rsp)
movq 0x478(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x10, %rdi
callq 0x36b40
movq 0x30(%rsp), %r8
movl %eax, 0x6c(%rsp)
leaq 0x70(%rsp), %rdi
movl 0x6c(%rsp), %ecx
addq $0x10, %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x5668c(%rip), %rdx     # 0x5f0f8
movb $0x0, %al
callq 0x55e80
leaq 0x70(%rsp), %rdi
leaq 0x585bd(%rip), %rsi     # 0x6103c
callq 0x60d0
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x8ae2
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x70(%rsp), %rsi
callq 0x7240
jmp 0x8ab6
leaq 0x5f(%rsp), %rdi
callq 0x6350
jmp 0x8b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x6350
jmp 0x8ba7
movq 0x60(%rsp), %rdi
callq 0x6170
subq $0x1, %rax
movl %eax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movslq 0x48(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, 0x17(%rsp)
jne 0x8b2c
movq 0x40(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2e, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x8b36
jmp 0x8b46
movq 0x40(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x8b06
movq 0x40(%rsp), %rax
movb $0x0, 0x1(%rax)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6560
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x70(%rsp), %rsi
callq 0x7240
jmp 0x8b74
leaq 0x3f(%rsp), %rdi
callq 0x6350
jmp 0x8b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x6350
jmp 0x8ba7
movq 0x28(%rsp), %rax
addq $0x488, %rsp            # imm = 0x488
retq
movq 0x50(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x77(%rsp)
leaq 0x76(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x5607a(%rip), %rsi     # 0x5f109
callq 0x7240
jmp 0x9096
leaq 0x76(%rsp), %rdi
callq 0x6350
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x40(%rsp), %rdi
callq *%rax
jmp 0x90b9
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x65c0
jmp 0x90ca
leaq 0x40(%rsp), %rdi
callq 0x61e0
movq 0x10(%rsp), %rdi
leaq 0x5602b(%rip), %rsi     # 0x5f10b
callq 0x65a0
jmp 0x90e7
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x7a20
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
callq *%rax
jmp 0x9108
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x65c0
jmp 0x9119
leaq 0x20(%rsp), %rdi
callq 0x61e0
movq 0x10(%rsp), %rdi
leaq 0x55fde(%rip), %rsi     # 0x5f10d
callq 0x65a0
jmp 0x9136
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x91ac
jmp 0x91a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x76(%rsp), %rdi
callq 0x6350
jmp 0x91c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x91b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61e0
jmp 0x91b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61e0
jmp 0x91b8
movq 0x10(%rsp), %rdi
callq 0x61e0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61e0
movq 0x68(%rsp), %rdi
callq 0x6550
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x6b9be(%rip), %rcx     # 0x74da8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x28(%rsp), %rdi
callq 0xab50
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xab70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xabc0
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x9440
jmp 0x9466
leaq 0x28(%rsp), %rdi
callq 0xac40
movq 0x20(%rax), %rdi
callq 0x7970
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xacb0
movq %rax, 0x10(%rsp)
jmp 0x9418
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xad00
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xacf0
movq 0x8(%rsp), %rdi
callq 0x7850
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x9020
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x10, %rdi
callq 0xad10
movq %rax, 0x30(%rsp)
jmp 0x9534
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x90(%rsp)
addq $0x10, %rdi
callq 0xabc0
movq %rax, 0x78(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x956c
jmp 0x95b5
leaq 0x90(%rsp), %rdi
callq 0xac40
movq 0x20(%rax), %rdi
callq 0x7970
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x98(%rsp), %rsi
callq 0xad40
jmp 0x959a
jmp 0x95b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x966b
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x9030
movq %rax, %rdi
callq 0x7a30
movq %rax, 0x18(%rsp)
jmp 0x95df
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xad70
jmp 0x9602
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xabf0
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x961c
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xaca0
leaq 0x98(%rsp), %rdi
callq 0x61e0
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xaca0
leaq 0x98(%rsp), %rdi
callq 0x61e0
movq 0x88(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0xad10
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
callq 0xabc0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x970e
jmp 0x9723
leaq 0x18(%rsp), %rdi
callq 0xac40
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x972c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x77(%rsp)
leaq 0x76(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6560
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x55900(%rip), %rsi     # 0x5f10f
callq 0x7240
jmp 0x9816
leaq 0x76(%rsp), %rdi
callq 0x6350
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xadb0
movl %eax, 0x60(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xab50
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xab70
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xabc0
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xaba0
testb $0x1, %al
jne 0x9884
jmp 0x999d
movq 0x10(%rsp), %rdi
leaq 0x55879(%rip), %rsi     # 0x5f109
callq 0x65a0
jmp 0x9897
leaq 0x58(%rsp), %rdi
callq 0xac40
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x65c0
jmp 0x98b0
movq 0x10(%rsp), %rdi
leaq 0x5584f(%rip), %rsi     # 0x5f10b
callq 0x65a0
jmp 0x98c3
leaq 0x58(%rsp), %rdi
callq 0xac40
movq 0x20(%rax), %rdi
callq 0x7a20
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
callq *%rax
jmp 0x98e9
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x65c0
jmp 0x98fa
leaq 0x28(%rsp), %rdi
callq 0x61e0
movq 0x10(%rsp), %rdi
leaq 0x557fd(%rip), %rsi     # 0x5f10d
callq 0x65a0
jmp 0x9917
cmpl $0x1, 0x60(%rsp)
jle 0x997a
movq 0x10(%rsp), %rdi
leaq 0x557e1(%rip), %rsi     # 0x5f10b
callq 0x65a0
jmp 0x9931
jmp 0x997a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x76(%rsp), %rdi
callq 0x6350
jmp 0x99dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x99d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
jmp 0x99d2
jmp 0x997c
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xacb0
movq %rax, 0x20(%rsp)
movl 0x60(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x9859
movq 0x10(%rsp), %rdi
leaq 0x55768(%rip), %rsi     # 0x5f111
callq 0x65a0
jmp 0x99b0
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x99c6
movq 0x10(%rsp), %rdi
callq 0x61e0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61e0
movq 0x68(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x7, %esi
callq 0x7820
movq 0x18(%rsp), %rdi
leaq 0x6afc1(%rip), %rax     # 0x74de8
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
callq 0xadc0
movl 0x5c(%rsp), %esi
leaq 0x44(%rsp), %rdi
callq 0x99f0
jmp 0x9e48
movq 0x18(%rsp), %rax
movl 0x5c(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq 0x48(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x6030
movq %rax, 0x10(%rsp)
jmp 0x9e7b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rdi)
movq 0x50(%rsp), %rsi
addq $0x18, %rdi
callq 0xadd0
jmp 0x9e99
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
jge 0x9f5d
leaq 0x44(%rsp), %rdi
callq 0x9a10
movq %rax, 0x8(%rsp)
jmp 0x9ed0
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x10, %edi
callq 0x62f0
movq %rax, (%rsp)
jmp 0x9eea
movq (%rsp), %rdi
callq 0x7880
jmp 0x9ef5
movq 0x18(%rsp), %rax
movq (%rsp), %rsi
movq 0x10(%rax), %rcx
movslq 0x30(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rsi
callq 0x79d0
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x9eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x9f62
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0x9f62
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xb090
movq 0x18(%rsp), %rdi
callq 0x7850
movq 0x38(%rsp), %rdi
callq 0x6550
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x6ae3e(%rip), %rcx     # 0x74dd8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %rax
cmpq 0x30(%rcx), %rax
jge 0x9ff4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9fe5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7970
jmp 0x9fe7
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9fa9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xa017
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x6300
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0xb090
movq 0x10(%rsp), %rdi
callq 0x7850
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/src/parser/constval.cpp
// Function: ArrayValue::GetElementBox(std::vector<long, std::allocator<long>>&)
ValueBox * ArrayValue::GetElementBox(vector<long>& keys)
{
        int i = 0;
        int j = 0;

        if(keys.size()!=this->Dim.size())
        {
                return NULL;
        }
        for(int i = 0; i < keys.size(); i++)
        {
                if(keys[i]<0 || keys[i]>=this->Dim[i])
                {
                        return NULL;
                }
        }

        long index = 0;

        for(i = 0; i < keys.size() - 1; i++)
        {
                long weight = 1;
                for(j = i + 1; j< keys.size(); j++)
                {
                        weight *= this->Dim[j];
                }

                index += keys[i] * weight;
        }

        index+=keys[i];
        return this->Value[index];
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f0
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
callq 0xb0f0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
je 0xa0d0
movq $0x0, 0x60(%rsp)
jmp 0xa268
movl $0x0, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xa165
movq 0x50(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xb110
cmpq $0x0, (%rax)
jl 0xa145
movq 0x50(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xb110
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0xb110
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
jl 0xa153
movq $0x0, 0x60(%rsp)
jmp 0xa268
jmp 0xa155
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xa0d8
movq $0x0, 0x38(%rsp)
movl $0x0, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xa232
movq $0x1, 0x30(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
movslq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xb0f0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xa200
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x48(%rsp), %rsi
callq 0xb110
movq (%rax), %rax
imulq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0xa1b3
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xb110
movq (%rax), %rax
imulq 0x30(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xa176
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xb110
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
addq 0x38(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x67(%rsp)
leaq 0x66(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x6560
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x54d25(%rip), %rsi     # 0x5f10f
callq 0x7240
jmp 0xa3f1
leaq 0x66(%rsp), %rdi
callq 0x6350
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl %eax, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0xa51b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7a20
cmpq $0x0, %rax
je 0xa4d0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7a20
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
callq *%rax
jmp 0xa469
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x65c0
jmp 0xa47a
leaq 0x28(%rsp), %rdi
callq 0x61e0
jmp 0xa4e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x66(%rsp), %rdi
callq 0x6350
jmp 0xa558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xa54e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x61e0
jmp 0xa54e
movq 0x18(%rsp), %rdi
leaq 0x54c37(%rip), %rsi     # 0x5f113
callq 0x65a0
jmp 0xa4e3
jmp 0xa4e5
movl 0x4c(%rsp), %eax
movl 0x50(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa509
movq 0x18(%rsp), %rdi
leaq 0x54c0b(%rip), %rsi     # 0x5f10b
callq 0x65a0
jmp 0xa507
jmp 0xa509
jmp 0xa50b
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xa410
movq 0x18(%rsp), %rdi
leaq 0x54bea(%rip), %rsi     # 0x5f111
callq 0x65a0
jmp 0xa52e
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xa544
movq 0x18(%rsp), %rdi
callq 0x61e0
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x61e0
movq 0x58(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4a0
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd4c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd510
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd4f0
testb $0x1, %al
jne 0xd23a
jmp 0xd2be
leaq 0x38(%rsp), %rdi
callq 0xd540
movq (%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0xd24f
jmp 0xd2a8
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd540
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x146f0
leaq 0x38(%rsp), %rdi
callq 0xd540
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x14130
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14610
cmpl $0x0, 0x24(%rsp)
je 0xd2a6
movl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xd2c6
jmp 0xd2a8
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xd570
movq %rax, 0x18(%rsp)
jmp 0xd20f
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd4a0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd4c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd510
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd4f0
testb $0x1, %al
jne 0xd38f
jmp 0xd3de
leaq 0x20(%rsp), %rdi
callq 0xd540
movq (%rsp), %rsi
movq (%rax), %rdi
callq 0x14180
leaq 0x20(%rsp), %rdi
callq 0xd540
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xd3c9
movb $0x0, 0x37(%rsp)
jmp 0xd3e3
jmp 0xd3cb
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0xd570
movq %rax, 0x8(%rsp)
jmp 0xd368
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd4a0
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd4c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xd510
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd4f0
testb $0x1, %al
jne 0xd44f
jmp 0xd488
leaq 0x20(%rsp), %rdi
callq 0xd540
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xd473
movb $0x0, 0x37(%rsp)
jmp 0xd48d
jmp 0xd475
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0xd570
movq %rax, 0x8(%rsp)
jmp 0xd428
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: BinaryExpression::Calculate(NodeContext*)
ConstValue * BinaryExpression::Calculate(NodeContext * context)
{
        ConstValue * left_store = this->left->Calculate(context);
        ConstValue * right_store = this->right->Calculate(context);

        ConstValue * result = this->CarryOut(left_store, right_store);

        delete left_store;
        delete right_store;

        return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rax), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xdc3d
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xdc58
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0xda00
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0xda00
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdcbf
movb $0x0, 0x17(%rsp)
jmp 0xdce3
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdcde
movb $0x0, 0x17(%rsp)
jmp 0xdce3
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x78a0
jmp 0xddc4
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x20, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x8e80
jmp 0xddf3
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7970
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0xde4b
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x6300
movq 0x20(%rsp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0xe34f
jmp 0xe3a5
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 0xe390
movb $0x0, 0x37(%rsp)
jmp 0xe3aa
jmp 0xe392
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0xe328
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: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11270
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11290
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x112e0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0xe41f
jmp 0xe458
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 0xe443
movb $0x0, 0x37(%rsp)
jmp 0xe45d
jmp 0xe445
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x8(%rsp)
jmp 0xe3f8
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe520
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xef0e
movl $0x10, %edi
callq 0x62f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x7aa0
jmp 0xeee5
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xef26
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x10, %esi
callq 0x6300
jmp 0xef30
movq 0x18(%rsp), %rdi
callq 0x7a20
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x6550
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x40, %rdi
callq 0x11500
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x11550
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x11530
testb $0x1, %al
jne 0xef8c
jmp 0xf040
leaq 0x40(%rsp), %rdi
callq 0x11580
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11290
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x112e0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0xefd1
jmp 0xf028
leaq 0x28(%rsp), %rdi
callq 0x11310
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
movq 0x10(%rax), %rsi
callq 0xda00
leaq 0x28(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xf013
movb $0x0, 0x57(%rsp)
jmp 0xf045
jmp 0xf015
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x18(%rsp)
jmp 0xefad
jmp 0xf02a
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x11600
movq %rax, 0x10(%rsp)
jmp 0xef61
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rsi
movq %rsi, (%rsp)
movq $0x0, 0x90(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6160
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x143e0
movq %rax, 0x18(%rsp)
jmp 0xf0b1
leaq 0x68(%rsp), %rdi
callq 0x61e0
movq 0x18(%rsp), %rax
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0xf13e
movq 0x66f16(%rip), %rdi     # 0x75ff0
leaq 0x500f9(%rip), %rsi     # 0x5f1da
callq 0x62d0
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
callq 0x62a0
movq %rax, %rdi
leaq 0x500fa(%rip), %rsi     # 0x5f1fa
callq 0x62d0
movq %rax, %rdi
movq 0x66ea9(%rip), %rsi     # 0x75fb8
callq 0x6320
movb $0x0, 0xa7(%rsp)
jmp 0xf23d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x61e0
jmp 0xf24e
movq (%rsp), %rdi
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rdi)
movq 0x90(%rsp), %rax
movq %rax, 0x58(%rdi)
addq $0x40, %rdi
callq 0x11500
movq %rax, 0x50(%rsp)
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x11550
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x11530
testb $0x1, %al
jne 0xf192
jmp 0xf22b
leaq 0x50(%rsp), %rdi
callq 0x11580
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11290
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x112e0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x112c0
testb $0x1, %al
jne 0xf1d7
jmp 0xf213
leaq 0x38(%rsp), %rdi
callq 0x11310
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xf1fe
movb $0x0, 0xa7(%rsp)
jmp 0xf23d
jmp 0xf200
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x11380
movq %rax, 0x28(%rsp)
jmp 0xf1b3
jmp 0xf215
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x11600
movq %rax, 0x20(%rsp)
jmp 0xf168
movq (%rsp), %rdi
callq 0xda20
andb $0x1, %al
movb %al, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x6550
nopl (%rax,%rax)
// File: marxn[P]pupp/src/parser/expression.cpp
// Function: FunctionExpression::FunctionExpression(Expression*, std::__cxx11::list<Expression*, std::allocator<Expression*>>*)
FunctionExpression::FunctionExpression(Expression * object, list<Expression*> * exprlist)
{
        this->FuncObj     = object;
        this->ExprList    = exprlist;
        this->ThreadNum   = -1;
        this->ThreadCount = 0;
        pthread_mutex_init(&this->AccessLock, NULL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd9b0
movq 0x8(%rsp), %rdi
leaq 0x65dd2(%rip), %rax     # 0x75090
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rdi)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rdi)
movq $-0x1, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x64c0
addq $0x28, %rsp
retq
nopl (%rax)