LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlDocument::Query(char const*)
TiHtmlResult* TiHtmlDocument::Query( const char* query ) {
    TiXmlDocument* doc = (TiXmlDocument* )internal;
    TiXmlElement* rootElement = doc ? doc ->RootElement():NULL;
    TiHtmlElement* element = new TiHtmlElement(rootElement);
    TiHtmlResult* result = element->Query(query);
    delete(element);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd0f2
movq -0x18(%rbp), %rdi
callq 0xd190
movq %rax, -0x48(%rbp)
jmp 0xd0fa
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xd0fa
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x8, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rsi
callq 0xc600
jmp 0xd121
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcb20
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xd156
movq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x3140
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x8, %esi
callq 0x3140
movq -0x30(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::checkIfValueIsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Variable::checkIfValueIsIdentifier(std::string code)
{
    std::string value;
    bool start{ false };
    int whiteSpaceCount{ 0 };
    for(const auto &c : code) 
    {    
         if (start)
            value += c;    

        if (c == ' ')
             ++whiteSpaceCount;

        if (whiteSpaceCount == 2)
            start = true;
        
    } 
    if (value.at(0) == '"')
        return false;
    
    char valueChar[value.length() + 1]; 
    std::strcpy(valueChar, value.c_str());    
    
    if (static_cast<int>(valueChar[0]) > 57)
        return true;
    
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3300
movq -0x88(%rbp), %rsi
movb $0x0, -0x39(%rbp)
movl $0x0, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x31e0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3130
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9180
testb $0x1, %al
jne 0x4986
jmp 0x49f3
leaq -0x50(%rbp), %rdi
callq 0x91c0
movq %rax, -0x60(%rbp)
testb $0x1, -0x39(%rbp)
je 0x49c7
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x49ab
jmp 0x49c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x4ab3
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x49dc
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0x2, -0x40(%rbp)
jne 0x49e6
movb $0x1, -0x39(%rbp)
jmp 0x49e8
leaq -0x50(%rbp), %rdi
callq 0x91e0
jmp 0x4973
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x33c0
movq %rax, -0x90(%rbp)
jmp 0x4a09
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x4a25
movb $0x0, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x4aa0
leaq -0x38(%rbp), %rdi
callq 0x3330
movq %rax, %rdx
movq %rdx, %rax
incq %rax
movq %rsp, %rcx
movq %rcx, -0x78(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x98(%rbp)
movq %rcx, %rsp
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x3210
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x4a8e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x4a99
movb $0x0, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq %rax, %rsp
leaq -0x38(%rbp), %rdi
callq 0x3160
movb -0x1(%rbp), %al
andb $0x1, %al
movq %rbp, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Variable::getValue(std::string code)
{
    std::string value;
    bool start{ false };
    int whiteSpaceCount{ 0 };
    for(const auto &c : code) 
    {    
         if (start)
            value += c;    

        if (c == ' ')
             ++whiteSpaceCount;

        if (whiteSpaceCount == 2)
            start = true;
        
    } 
    std::string stringValue;
    if (value.at(0) == '"')
    {
        for (int i{ 1 }; i < value.length() - 1; ++i)
        {
           stringValue += value.at(i); 
        } 
        value = stringValue;
    }
    return value; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3300
movq -0x80(%rbp), %rdx
movb $0x0, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3130
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9180
testb $0x1, %al
jne 0x4b35
jmp 0x4b9c
leaq -0x30(%rbp), %rdi
callq 0x91c0
movq %rax, -0x40(%rbp)
testb $0x1, -0x1a(%rbp)
je 0x4b70
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
callq 0x3170
jmp 0x4b5d
jmp 0x4b70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4c97
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4b85
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jne 0x4b8f
movb $0x1, -0x1a(%rbp)
jmp 0x4b91
leaq -0x30(%rbp), %rdi
callq 0x91e0
jmp 0x4b22
leaq -0x70(%rbp), %rdi
callq 0x3300
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33c0
movq %rax, -0x98(%rbp)
jmp 0x4bbe
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x4c68
movl $0x1, -0x74(%rbp)
movq -0x90(%rbp), %rdi
movslq -0x74(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x3330
movq %rax, %rcx
movq -0xa0(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x4c54
movq -0x90(%rbp), %rdi
movslq -0x74(%rbp), %rsi
callq 0x33c0
movq %rax, -0xa8(%rbp)
jmp 0x4c1b
movq -0xa8(%rbp), %rax
movsbl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x3170
jmp 0x4c30
jmp 0x4c32
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x4bd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
jmp 0x4c97
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3030
jmp 0x4c66
jmp 0x4c68
movb $0x1, -0x19(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
testb $0x1, -0x19(%rbp)
jne 0x4c87
movq -0x90(%rbp), %rdi
callq 0x3160
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3160
movq -0x48(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Variable::getIdentifier(std::string code)
{
    std::string identifier;
    bool start{ false };
    for(const auto &c : code) 
    {
        if (c == ' ' && start)
            return identifier;

        if (start)
            identifier += c;

        if (c == ' ' && !start)
            start = true;
    } 
    return "something went wrong";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdx
movb $0x0, -0x39(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x31e0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3130
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9180
testb $0x1, %al
jne 0x4d21
jmp 0x4dad
leaq -0x50(%rbp), %rdi
callq 0x91c0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4d5c
testb $0x1, -0x39(%rbp)
je 0x4d5c
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3140
movl $0x1, -0x64(%rbp)
jmp 0x4e02
testb $0x1, -0x39(%rbp)
je 0x4d87
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x4d74
jmp 0x4d87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4e1b
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4d9d
testb $0x1, -0x39(%rbp)
jne 0x4d9d
movb $0x1, -0x39(%rbp)
jmp 0x4d9f
leaq -0x50(%rbp), %rdi
callq 0x91e0
jmp 0x4d0b
leaq -0x75(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3390
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0x10283(%rip), %rsi     # 0x15055
callq 0x8eb0
jmp 0x4dd9
leaq -0x75(%rbp), %rdi
callq 0x3270
movl $0x1, -0x64(%rbp)
jmp 0x4e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x75(%rbp), %rdi
callq 0x3270
jmp 0x4e1b
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x70(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Variable::Types Variable::getType(std::string code)
{
    std::string value;
    bool start{ false };
    int whiteSpaceCount{ 0 };
    for(const auto &c : code) 
    {    
        if (start)
        {
            value += c;    
        }

        if (c == ' ')
             ++whiteSpaceCount;

        if (whiteSpaceCount == 2)
            start = true;
        
    } 
    if (value.at(0) == '"')
    {
        return STRING;
    }

    for (const auto &elem : value)
    {
        if (elem == '.')
            return FLOAT;
    }
    
    return INT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3300
movq -0x98(%rbp), %rsi
movb $0x0, -0x39(%rbp)
movl $0x0, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x31e0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3130
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9180
testb $0x1, %al
jne 0x4e96
jmp 0x4f03
leaq -0x50(%rbp), %rdi
callq 0x91c0
movq %rax, -0x60(%rbp)
testb $0x1, -0x39(%rbp)
je 0x4ed7
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x4ebb
jmp 0x4ed7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x4fd5
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4eec
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0x2, -0x40(%rbp)
jne 0x4ef6
movb $0x1, -0x39(%rbp)
jmp 0x4ef8
leaq -0x50(%rbp), %rdi
callq 0x91e0
jmp 0x4e83
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x33c0
movq %rax, -0xa0(%rbp)
jmp 0x4f19
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x4f3b
movl $0x1, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x4fc0
leaq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x31e0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x3130
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9180
testb $0x1, %al
jne 0x4f76
jmp 0x4fb2
leaq -0x80(%rbp), %rdi
callq 0x91c0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4fa5
movl $0x2, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x4fc0
jmp 0x4fa7
leaq -0x80(%rbp), %rdi
callq 0x91e0
jmp 0x4f60
movl $0x0, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3380
nop
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::printValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Variable::printValue(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
        {
            std::cout << m_variables.at(i).value << std::endl;
            return; 
        }
    } 
    std::cerr << "Print: identifier not found" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x9150
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5081
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9050
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0x4100
testb $0x1, %al
jne 0x5043
jmp 0x5074
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9050
movq %rax, %rsi
addq $0x8, %rsi
movq 0x17f5a(%rip), %rdi     # 0x1cfb8
callq 0x3200
movq %rax, %rdi
movq 0x17f33(%rip), %rsi     # 0x1cfa0
callq 0x3250
jmp 0x50a3
jmp 0x5076
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5003
movq 0x17f68(%rip), %rdi     # 0x1cff0
leaq 0xffdb(%rip), %rsi      # 0x1506a
callq 0x3220
movq %rax, %rdi
movq 0x17f02(%rip), %rsi     # 0x1cfa0
callq 0x3250
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::setVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Variable::Types)
void Variable::setVariable(std::string identifier, std::string value, Types type)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
        {
            m_variables.at(i).value = value; 
            m_variables.at(i).type = type; 
            return;
        }
    } 
    
    TypeValue typeValue; 
    typeValue.identifier = identifier;
    typeValue.value = value;
    typeValue.type = type; 
    
    m_variables.push_back(typeValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x9150
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x5180
movq -0x80(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9050
movq -0x90(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0x4100
testb $0x1, %al
jne 0x5130
jmp 0x5170
movq -0x80(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9050
movq -0x88(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x3030
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x9050
movl -0x9c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x51cb
jmp 0x5172
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x50e7
leaq -0x68(%rbp), %rdi
callq 0x9020
movq -0x90(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3030
jmp 0x519b
movq -0x88(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3030
jmp 0x51ad
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x9090
jmp 0x51c2
leaq -0x68(%rbp), %rdi
callq 0x9100
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9100
movq -0x70(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getValueVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Variable::getValueVar(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
            return m_variables.at(i).value;
    } 
    std::cout << "Get value: identifier not found\n";
    return "smt went wrong";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x9150
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x529e
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9050
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0x4100
testb $0x1, %al
jne 0x5272
jmp 0x5291
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9050
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x30e0
jmp 0x52f6
jmp 0x5293
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5232
movq 0x17d13(%rip), %rdi     # 0x1cfb8
leaq 0xfdda(%rip), %rsi      # 0x15086
callq 0x3220
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3390
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xfdda(%rip), %rsi      # 0x150a7
callq 0x8eb0
jmp 0x52d4
leaq -0x1d(%rbp), %rdi
callq 0x3270
jmp 0x52f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x3270
jmp 0x5300
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::compareVariable(Variable const&)
void Variable::compareVariable(const Variable &variable)
{
    for (int i{ 0 }; i < variable.m_variables.size(); ++i)
    {
        for (int j{ 0 }; j < m_variables.size(); ++j)
        {
            if (m_variables.at(j).identifier == variable.m_variables.at(i).identifier)
            {
                m_variables.at(j).type = variable.m_variables.at(i).type;
                m_variables.at(j).value = variable.m_variables.at(i).value;
            } 
        } 

    } 
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9150
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5426
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x9150
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5416
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x9050
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9200
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x4100
testb $0x1, %al
jne 0x53b0
jmp 0x5406
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9200
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x9050
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9200
movq -0x20(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x9050
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x3030
jmp 0x5408
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5357
jmp 0x5418
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x532f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getTypeByIdent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Variable::Types Variable::getTypeByIdent(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
            return m_variables.at(i).type;
    } 
    return STRING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x9150
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x54b4
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9050
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
callq 0x4100
testb $0x1, %al
jne 0x5493
jmp 0x54a7
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9050
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x54bb
jmp 0x54a9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5453
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Manuel123cool[P]smiley/regex.cpp
// Function: MyRegex::testString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool MyRegex::testString(std::string string, std::string test)
{
    if (string.length() < test.length())
        return false;

    bool isInString{ true };
    for (int i{ 0 }; i < test.length(); ++i)
    {
        if (string.at(i) != test.at(i))
            isInString = false;
    }
    return isInString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x3330
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x3330
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xa46c
movb $0x0, -0x1(%rbp)
jmp 0xa4da
movb $0x1, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3330
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xa4d2
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x33c0
movq -0x30(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x33c0
movq %rax, %rcx
movl -0x44(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xa4c5
movb $0x0, -0x19(%rbp)
jmp 0xa4c7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa477
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Manuel123cool[P]smiley/stack.cpp
// Function: Stack::addStackFrame()
void Stack::addStackFrame()
{
    Variable var;
    if (m_stack.size() > 0)
    {
        var = m_stack.at(m_stack.size() - 1);
    }
    m_stack.push_back(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe160
movq -0x38(%rbp), %rdi
callq 0xe180
cmpq $0x0, %rax
jbe 0xde92
movq -0x38(%rbp), %rdi
callq 0xe180
movq -0x38(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0xe1b0
movq %rax, -0x40(%rbp)
jmp 0xde6a
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xe1f0
jmp 0xde79
jmp 0xde92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe290
jmp 0xdeb0
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe220
jmp 0xdea1
leaq -0x20(%rbp), %rdi
callq 0xe290
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/stack.cpp
// Function: Stack::checkBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Stack::checkBlock(std::string code)
{
    if (code.length() <= 0)
        return;

    bool blockStart{ MyRegex::testString(code, "><") };
    bool blockEnd{ MyRegex::testString(code, "<>") };
    
    if (blockStart)
        addStackFrame();          
    
    if (blockEnd)
       popStackFrame(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, %rax
movq -0xd0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x3330
cmpq $0x0, %rax
ja 0xdfa6
jmp 0xe147
movq -0xc8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x30e0
leaq -0x59(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3390
movq -0xd8(%rbp), %rdx
leaq 0x7325(%rip), %rsi      # 0x152f9
leaq -0x58(%rbp), %rdi
callq 0x8eb0
jmp 0xdfdf
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa430
movb %al, -0xd9(%rbp)
jmp 0xdff4
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3270
leaq -0x38(%rbp), %rdi
callq 0x3160
movb -0xd9(%rbp), %al
movq -0xc8(%rbp), %rsi
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x30e0
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3390
movq -0xe8(%rbp), %rdx
leaq 0x72ae(%rip), %rsi      # 0x152fc
leaq -0xb0(%rbp), %rdi
callq 0x8eb0
jmp 0xe05c
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xa430
movb %al, -0xe9(%rbp)
jmp 0xe077
leaq -0xb0(%rbp), %rdi
callq 0x3160
leaq -0xb1(%rbp), %rdi
callq 0x3270
leaq -0x90(%rbp), %rdi
callq 0x3160
movb -0xe9(%rbp), %al
andb $0x1, %al
movb %al, -0x6d(%rbp)
testb $0x1, -0x11(%rbp)
je 0xe135
movq -0xc0(%rbp), %rdi
callq 0xde20
jmp 0xe135
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe0e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3160
leaq -0x59(%rbp), %rdi
callq 0x3270
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xe150
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe11b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3160
leaq -0xb1(%rbp), %rdi
callq 0x3270
leaq -0x90(%rbp), %rdi
callq 0x3160
jmp 0xe150
testb $0x1, -0x6d(%rbp)
je 0xe147
movq -0xc0(%rbp), %rdi
callq 0xdec0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: Manuel123cool[P]smiley/instruction.cpp
// Function: Instruction::checkJumps(int)
int Instruction::checkJumps(int num)
{
    for (int i{ 0 }; i < m_jumps.size(); ++i)
    {
        int startNum = m_jumps.at(i).start;
        if (startNum == num)
        {
            int jumpTo{ m_jumps.at(i).jumpTo };
            for (int j{ 0 }; j < m_jumps.size(); ++j)
            {
                if (m_jumps.at(j).start == startNum && m_jumps.at(j).jumpTo == jumpTo)
                    m_jumps.erase(m_jumps.begin() + j);
            }
            return jumpTo;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x12f80
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x10e51
movq -0x50(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x12fa0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x10e41
movq -0x50(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x12fa0
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x12f80
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x10e39
movq -0x50(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x12fa0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x10e29
movq -0x50(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x12fa0
movl 0x4(%rax), %eax
cmpl -0x20(%rbp), %eax
jne 0x10e29
movq -0x50(%rbp), %rdi
callq 0x13050
movq %rax, -0x40(%rbp)
movslq -0x24(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x13080
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x130c0
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12fe0
movq %rax, -0x48(%rbp)
jmp 0x10e2b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10da7
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10e58
jmp 0x10e43
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10d4e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: NormalizedValue(gaps::R3MeshVertex*)
static RNScalar
NormalizedValue(R3MeshVertex *vertex)
{
  // Return value between 0 and 1
  RNScalar value = current_property->VertexValue(vertex);
  RNScalar diameter = value_range.Diameter();
  if (diameter > 0) value = (value - value_range.Min()) / diameter;
  if (value < 0) value = 0;
  else if (value > 1) value = 1;
  return value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x1dc528(%rip), %rdi    # 0x204cb8
movq 0x20(%rsp), %rsi
callq 0x2b020
movsd %xmm0, 0x18(%rsp)
leaq 0x1dc4a1(%rip), %rdi    # 0x204c48
callq 0x2b260
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x287f2
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x1dc474(%rip), %rdi    # 0x204c48
callq 0x2ae00
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x28808
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x2882c
movsd 0x18(%rsp), %xmm0
movsd 0x16d852(%rip), %xmm1   # 0x196068
ucomisd %xmm1, %xmm0
jbe 0x2882a
movsd 0x16d844(%rip), %xmm0   # 0x196068
movsd %xmm0, 0x18(%rsp)
jmp 0x2882c
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTResize(int, int)
void GLUTResize(int w, int h)
{
  // Resize window
  glViewport(0, 0, w, h);

  // Resize viewer viewport
  viewer->ResizeViewport(0, 0, w, h);

  // Remember window size 
  GLUTwindow_width = w;
  GLUTwindow_height = h;

  // Redraw
  glutPostRedisplay();
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x22230
movq 0x1dc3f1(%rip), %rdi    # 0x204c70
movl 0x4(%rsp), %ecx
movl (%rsp), %r8d
xorl %edx, %edx
movl %edx, %esi
callq 0x2b910
movl 0x4(%rsp), %eax
movl %eax, 0x1d622a(%rip)    # 0x1feac4
movl (%rsp), %eax
movl %eax, 0x1d621d(%rip)    # 0x1feac0
callq 0x1820b0
popq %rax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMotion(int, int)
void GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // World in hand navigation 
  if (GLUTbutton[0]) viewer->RotateWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[1]) viewer->ScaleWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[2]) viewer->TranslateWorld(1.0, world_origin, x, y, dx, dy);
  if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x1d61fe(%rip), %eax    # 0x1feac0
subl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
subl 0x1dc404(%rip), %eax    # 0x204cd8
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
subl 0x1dc3fa(%rip), %eax    # 0x204cdc
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x1dc3f3(%rip)    # 0x204ce0
je 0x2891f
movq 0x1dc37a(%rip), %rdi    # 0x204c70
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x16d755(%rip), %xmm0   # 0x196068
leaq 0x1dc33e(%rip), %rsi    # 0x204c58
callq *0x58(%rax)
jmp 0x28993
cmpl $0x0, 0x1dc3be(%rip)    # 0x204ce4
je 0x28958
movq 0x1dc341(%rip), %rdi    # 0x204c70
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x16d71c(%rip), %xmm0   # 0x196068
leaq 0x1dc305(%rip), %rsi    # 0x204c58
callq *0x50(%rax)
jmp 0x28991
cmpl $0x0, 0x1dc389(%rip)    # 0x204ce8
je 0x2898f
movq 0x1dc308(%rip), %rdi    # 0x204c70
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movq (%rdi), %rax
movsd 0x16d6e3(%rip), %xmm0   # 0x196068
leaq 0x1dc2cc(%rip), %rsi    # 0x204c58
callq *0x48(%rax)
jmp 0x28991
jmp 0x28993
cmpl $0x0, 0x1dc346(%rip)    # 0x204ce0
jne 0x289ae
cmpl $0x0, 0x1dc341(%rip)    # 0x204ce4
jne 0x289ae
cmpl $0x0, 0x1dc33c(%rip)    # 0x204ce8
je 0x289b3
callq 0x1820b0
movl 0x14(%rsp), %eax
movl %eax, 0x1dc31b(%rip)    # 0x204cd8
movl 0x10(%rsp), %eax
movl %eax, 0x1dc315(%rip)    # 0x204cdc
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: SelectProperty(int)
static void
SelectProperty(int property_index)
{
  // Set current property index
  current_property_index = property_index;
  if (current_property_index < 0) current_property_index = 0;
  if (current_property_index >= properties->NProperties()) current_property_index = properties->NProperties() - 1;

  // Get current property
  current_property = properties->Property(current_property_index);

  // Set value range
  if (input_value_range.Diameter() > 0) {
    value_range = input_value_range;
  }
  else {
    percentile_range.Reset(10, 90);
    RNScalar min_value = current_property->Percentile(percentile_range.Min());
    RNScalar max_value = current_property->Percentile(percentile_range.Max());
    value_range.Reset(min_value, max_value);
  }
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x1dbe7a(%rip)    # 0x204d0c
cmpl $0x0, 0x1dbe73(%rip)    # 0x204d0c
jge 0x28ea5
movl $0x0, 0x1dbe67(%rip)    # 0x204d0c
movl 0x1dbe61(%rip), %eax    # 0x204d0c
movl %eax, 0x1c(%rsp)
movq 0x1dbe12(%rip), %rdi    # 0x204cc8
callq 0x2ae90
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jl 0x28eda
movq 0x1dbdfc(%rip), %rdi    # 0x204cc8
callq 0x2ae90
subl $0x1, %eax
movl %eax, 0x1dbe32(%rip)    # 0x204d0c
movq 0x1dbde7(%rip), %rdi    # 0x204cc8
movl 0x1dbe25(%rip), %esi    # 0x204d0c
callq 0x2b330
movq %rax, 0x1dbdc5(%rip)    # 0x204cb8
leaq 0x1dbd16(%rip), %rdi    # 0x204c10
callq 0x2b260
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x28f29
movq 0x1dbd01(%rip), %rax    # 0x204c10
movq %rax, 0x1dbd32(%rip)    # 0x204c48
movq 0x1dbcfb(%rip), %rax    # 0x204c18
movq %rax, 0x1dbd2c(%rip)    # 0x204c50
jmp 0x28fad
leaq 0x1dbd08(%rip), %rdi    # 0x204c38
movsd 0x16d110(%rip), %xmm0   # 0x196048
movsd 0x16d158(%rip), %xmm1   # 0x196098
callq 0x2aef0
movq 0x1dbd6c(%rip), %rax    # 0x204cb8
movq %rax, 0x8(%rsp)
leaq 0x1dbce0(%rip), %rdi    # 0x204c38
callq 0x2ae00
movq 0x8(%rsp), %rdi
callq 0x6d860
movsd %xmm0, 0x28(%rsp)
movq 0x1dbd44(%rip), %rax    # 0x204cb8
movq %rax, 0x10(%rsp)
leaq 0x1dbcb8(%rip), %rdi    # 0x204c38
callq 0x2ae10
movq 0x10(%rsp), %rdi
callq 0x6d860
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
leaq 0x1dbca0(%rip), %rdi    # 0x204c48
callq 0x2aef0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Initialize world origin
  if (initial_world_origin != R3unknown_point) {
    world_origin = initial_world_origin;
  }
  else {
    world_origin = mesh->BBox().Centroid();
  }

  // Initialize current property
  SelectProperty(initial_property_index);

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
subq $0x18, %rsp
leaq 0x1db8e5(%rip), %rdi    # 0x204c20
leaq 0x1def76(%rip), %rsi    # 0x2082b8
callq 0xd4bb0
cmpl $0x0, %eax
je 0x29361
leaq 0x1db905(%rip), %rdi    # 0x204c58
leaq 0x1db8c6(%rip), %rsi    # 0x204c20
callq 0xd5030
jmp 0x29388
movq 0x1db918(%rip), %rdi    # 0x204c80
callq 0x2ac50
movq %rax, %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x68(%rax)
leaq 0x1db8d8(%rip), %rdi    # 0x204c58
movq %rsp, %rsi
callq 0xd5030
movl 0x1db982(%rip), %edi    # 0x204d10
callq 0x28e80
callq 0x187120
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: main
int main(int argc, char **argv)
{
  // Initialize gaps
  if (!R3InitGraphics()) exit(-1);
  
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Read mesh
  mesh = ReadMesh(mesh_name);
  if (!mesh) exit(-1);

  // Read points
  if (points_name) {
    points = ReadPoints(mesh, points_name);
    if (!points) exit(-1);
  }

  // Read properties
  properties = ReadProperties(mesh, properties_name);
  if (!properties) exit(-1);

  // Create viewer
  viewer = CreateBirdsEyeViewer(mesh);
  if (!viewer) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x2b490
cmpl $0x0, %eax
jne 0x29c09
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x293a0
cmpl $0x0, %eax
jne 0x29c26
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x29180
movq 0x1db0f4(%rip), %rdi    # 0x204d30
callq 0x29d00
movq %rax, 0x1db038(%rip)    # 0x204c80
cmpq $0x0, 0x1db030(%rip)    # 0x204c80
jne 0x29c5c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
cmpq $0x0, 0x1db0b4(%rip)    # 0x204d18
je 0x29c96
movq 0x1db013(%rip), %rdi    # 0x204c80
movq 0x1db0a4(%rip), %rsi    # 0x204d18
callq 0x29e90
movq %rax, 0x1db010(%rip)    # 0x204c90
cmpq $0x0, 0x1db008(%rip)    # 0x204c90
jne 0x29c94
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
jmp 0x29c96
movq 0x1dafe3(%rip), %rdi    # 0x204c80
movq 0x1db094(%rip), %rsi    # 0x204d38
callq 0x2a630
movq %rax, 0x1db018(%rip)    # 0x204cc8
cmpq $0x0, 0x1db010(%rip)    # 0x204cc8
jne 0x29cc4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
movq 0x1dafb5(%rip), %rdi    # 0x204c80
callq 0x2a7c0
movq %rax, 0x1daf99(%rip)    # 0x204c70
cmpq $0x0, 0x1daf91(%rip)    # 0x204c70
jne 0x29ceb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
callq 0x29330
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  if (!mesh) {
    RNFail("Unable to allocate mesh for %s\n", filename);
    return NULL;
  }

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return mesh
  return mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf6cb0
movq 0x10(%rsp), %rdi
callq 0x2ae50
movl $0x138, %edi            # imm = 0x138
callq 0x229d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x86100
jmp 0x29d3e
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x29d93
movq 0x48(%rsp), %rsi
leaq 0x16c618(%rip), %rdi    # 0x196374
movb $0x0, %al
callq 0xfbc30
movq $0x0, 0x50(%rsp)
jmp 0x29e73
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0x229f0
jmp 0x29e7d
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x29dd4
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x29dc6
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x29e73
cmpl $0x0, 0x1daf39(%rip)    # 0x204d14
je 0x29e69
movq 0x48(%rsp), %rsi
leaq 0x16c5a7(%rip), %rdi    # 0x196394
movb $0x0, %al
callq 0x22090
leaq 0x38(%rsp), %rdi
callq 0xf6d70
leaq 0x16c5a6(%rip), %rdi    # 0x1963ab
movb $0x1, %al
callq 0x22090
movq 0x30(%rsp), %rdi
callq 0x2a9d0
movl %eax, %esi
leaq 0x16c5a3(%rip), %rdi    # 0x1963c2
movb $0x0, %al
callq 0x22090
movq 0x30(%rsp), %rdi
callq 0x2b380
movl %eax, %esi
leaq 0x16c599(%rip), %rdi    # 0x1963d2
movb $0x0, %al
callq 0x22090
movq 0x30(%rsp), %rdi
callq 0x2abd0
movl %eax, %esi
leaq 0x16c58f(%rip), %rdi    # 0x1963e2
movb $0x0, %al
callq 0x22090
movq 0x1d412f(%rip), %rax    # 0x1fdf90
movq (%rax), %rdi
callq 0x22be0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x23270
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: ReadProperties(gaps::R3Mesh*, char const*)
static R3MeshPropertySet *
ReadProperties(R3Mesh *mesh, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate properties
  R3MeshPropertySet *properties = new R3MeshPropertySet(mesh);
  if (!properties) {
    RNFail("Unable to allocate properties for %s\n", properties_name);
    return NULL;
  }

  // Read properties from file
  if (!properties->Read(filename)) {
    delete properties;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read properties from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Properties = %d\n", properties->NProperties());
    printf("  # Vertices = %d\n", properties->Mesh()->NVertices());
    fflush(stdout);
  }

  // Return property set
  return properties;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf6cb0
movq 0x8(%rsp), %rdi
callq 0x2ae50
movl $0x18, %edi
callq 0x229d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rsi
callq 0x690e0
jmp 0x2a678
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2a6cf
movq 0x1da6a7(%rip), %rsi    # 0x204d38
leaq 0x16be34(%rip), %rdi    # 0x1964cc
movb $0x0, %al
callq 0xfbc30
movq $0x0, 0x50(%rsp)
jmp 0x2a7a0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x18, %esi
callq 0x229f0
jmp 0x2a7aa
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x696f0
cmpl $0x0, %eax
jne 0x2a717
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2a709
movq (%rsp), %rdi
callq 0x69250
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x229f0
movq $0x0, 0x50(%rsp)
jmp 0x2a7a0
cmpl $0x0, 0x1da5f6(%rip)    # 0x204d14
je 0x2a796
movq 0x40(%rsp), %rsi
leaq 0x16bdc6(%rip), %rdi    # 0x1964f2
movb $0x0, %al
callq 0x22090
leaq 0x30(%rsp), %rdi
callq 0xf6d70
leaq 0x16bc67(%rip), %rdi    # 0x1963ab
movb $0x1, %al
callq 0x22090
movq 0x28(%rsp), %rdi
callq 0x2ae90
movl %eax, %esi
leaq 0x16bdb1(%rip), %rdi    # 0x19650f
movb $0x0, %al
callq 0x22090
movq 0x28(%rsp), %rdi
callq 0x2b470
movq %rax, %rdi
callq 0x2abd0
movl %eax, %esi
leaq 0x16bc62(%rip), %rdi    # 0x1963e2
movb $0x0, %al
callq 0x22090
movq 0x1d3802(%rip), %rax    # 0x1fdf90
movq (%rax), %rdi
callq 0x22be0
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x23270
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: CreateBirdsEyeViewer(gaps::R3Mesh*)
static R3Viewer *
CreateBirdsEyeViewer(R3Mesh *mesh)
{
  // Setup camera view looking down the Z axis
  R3Box bbox = mesh->BBox();
  assert(!bbox.IsEmpty());
  RNLength r = bbox.DiagonalRadius();
  assert((r > 0.0) && RNIsFinite(r));
  if (!initial_camera) initial_camera_origin = mesh->Centroid() - initial_camera_towards * (2.5 * r);
  R3Camera camera(initial_camera_origin, initial_camera_towards, initial_camera_up, 0.4, 0.4, 0.01 * r, 100.0 * r);
  R2Viewport viewport(0, 0, GLUTwindow_width, GLUTwindow_height);
  return new R3Viewer(camera, viewport);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq 0x150(%rsp), %rdi
callq 0x2ac50
movq %rax, %rsi
leaq 0x118(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbf3f0
movq 0x8(%rsp), %rdi
callq 0x2ad70
movsd %xmm0, 0x10(%rsp)
jmp 0x2a803
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
cmpl $0x0, 0x1da50f(%rip)    # 0x204d28
jne 0x2a8b1
movq 0x150(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x870a0
jmp 0x2a836
movsd 0x110(%rsp), %xmm0
movsd 0x16b859(%rip), %xmm1   # 0x1960a0
mulsd %xmm1, %xmm0
leaq 0x1da376(%rip), %rsi    # 0x204bc8
leaq 0xb8(%rsp), %rdi
callq 0xd69d0
jmp 0x2a861
leaq 0xe8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
callq 0xd5900
jmp 0x2a880
leaq 0x1da371(%rip), %rdi    # 0x204bf8
leaq 0xe8(%rsp), %rsi
callq 0xd5030
jmp 0x2a896
jmp 0x2a8b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x2a97e
movsd 0x110(%rsp), %xmm3
movsd 0x16b78e(%rip), %xmm0   # 0x196050
movaps %xmm3, %xmm2
mulsd %xmm0, %xmm2
movsd 0x16b7d7(%rip), %xmm0   # 0x1960a8
mulsd %xmm0, %xmm3
leaq 0x1da31c(%rip), %rsi    # 0x204bf8
leaq 0x1da2e5(%rip), %rdx    # 0x204bc8
leaq 0x1da2f6(%rip), %rcx    # 0x204be0
leaq 0x28(%rsp), %rdi
movsd 0x16b791(%rip), %xmm1   # 0x196088
movaps %xmm1, %xmm0
callq 0x2eed0
jmp 0x2a901
movl 0x1d41bd(%rip), %ecx    # 0x1feac4
movl 0x1d41b2(%rip), %r8d    # 0x1feac0
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x30560
jmp 0x2a91e
movl $0xa8, %edi
callq 0x229d0
movq %rax, (%rsp)
jmp 0x2a92e
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2b5f0
jmp 0x2a943
leaq 0x118(%rsp), %rdi
callq 0x2b480
movq (%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
movl $0xa8, %esi
callq 0x229f0
leaq 0x118(%rsp), %rdi
callq 0x2b480
movq 0x108(%rsp), %rdi
callq 0x23270
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::R3MeshPropertySet(gaps::R3MeshPropertySet const&)
R3MeshPropertySet::
R3MeshPropertySet(const R3MeshPropertySet& set)
  : mesh(set.mesh),
    properties()
{
  // Copy properties
  for (int i = 0; i < set.NProperties(); i++) {
    R3MeshProperty *property = set.Property(i);
    Insert(new R3MeshProperty(*property));
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x6c000
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2ae90
movl %eax, 0x14(%rsp)
jmp 0x69161
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x69200
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x2b330
movq %rax, 0x8(%rsp)
jmp 0x69186
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x448, %edi            # imm = 0x448
callq 0x229d0
movq %rax, (%rsp)
jmp 0x691a0
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6c4c0
jmp 0x691b0
movq (%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x69220
jmp 0x691c0
jmp 0x691c2
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x69149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x69205
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x448, %esi            # imm = 0x448
callq 0x229f0
jmp 0x69205
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6c010
movq 0x38(%rsp), %rdi
callq 0x23270
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::PropertyIndex(gaps::R3MeshProperty*) const
int R3MeshPropertySet::
PropertyIndex(R3MeshProperty *query_property) const
{
  // Search through properties for matching name
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);
    if (property == query_property) return i;
  }

  // Not found
  return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x2ae90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x69324
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x2b330
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x69315
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x6932c
jmp 0x69317
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x692d0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)