LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getValue(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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %r14
testq %r14, %r14
je 0x342e
movq (%rdx), %r15
xorl %r13d, %r13d
movl $0x1, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
testb $0x1, %r12b
je 0x340f
movsbl (%r15,%r13), %esi
movq 0x8(%rsp), %rdi
callq 0x2120
xorl %eax, %eax
cmpb $0x20, (%r15,%r13)
sete %al
addl %eax, %ebx
cmpl $0x2, %ebx
movzbl %r12b, %r12d
cmovel %ebp, %r12d
incq %r13
cmpq %r13, %r14
jne 0x33fa
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x34e3
movq (%rbx), %rax
cmpb $0x22, (%rax)
jne 0x34a9
movq 0x8(%rbx), %rdx
leaq -0x3(%rdx), %rax
cmpq $-0x3, %rax
ja 0x349c
movl $0x1, %r14d
leaq 0x18(%rsp), %r15
cmpq %r14, %rdx
jbe 0x34d2
movq (%rbx), %rax
movsbl (%rax,%r14), %esi
movq %r15, %rdi
callq 0x2120
incq %r14
movq 0x8(%rbx), %rdx
leaq -0x1(%rdx), %rax
cmpq %r14, %rax
ja 0x3477
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x20c0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x34c0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacac(%rip), %rdi      # 0xe185
movq %r14, %rsi
xorl %eax, %eax
callq 0x2210
leaq 0xac9b(%rip), %rdi      # 0xe185
xorl %esi, %esi
xorl %eax, %eax
callq 0x2210
jmp 0x34f7
jmp 0x34f7
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x3516
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x3516
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x3535
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x361f
movq (%rdx), %r13
leaq 0x10(%r12), %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
movb (%r13,%r14), %al
cmpb $0x20, %al
jne 0x35b0
testb $0x1, %r15b
je 0x35b0
movq %rcx, (%r12)
movq (%rsp), %rax
cmpq %rbp, %rax
je 0x35e2
movq %rax, (%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r12)
jmp 0x35e9
movq %rcx, %rbx
movb $0x1, %bpl
movb $0x1, %cl
testb $0x1, %r15b
je 0x35cc
movsbl %al, %esi
movq %rsp, %rdi
callq 0x2120
movl %r15d, %ecx
cmpb $0x20, (%r13,%r14)
movzbl %cl, %eax
movzbl %r15b, %r15d
cmovel %eax, %r15d
movq %rbx, %rcx
jmp 0x3607
movups (%rbp), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r12)
movq %rbp, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
xorl %ebp, %ebp
testb %bpl, %bpl
leaq 0x10(%rsp), %rbp
je 0x363e
incq %r14
cmpq %r14, 0x20(%rsp)
jne 0x3584
leaq 0x10(%r12), %rax
movq %rax, (%r12)
leaq 0xaa50(%rip), %rsi      # 0xe07f
leaq 0xaa5d(%rip), %rdx      # 0xe093
movq %r12, %rdi
callq 0x7c60
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x3654
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3668
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3686
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq (%rdi), %r14
movq 0x8(%rdi), %rax
subq %r14, %rax
setne %bpl
je 0x3871
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rax, %r15
movq (%rsp), %rax
movq 0x8(%rax), %r12
xorl %r13d, %r13d
cmpq $0x1, %r15
sbbq %r15, %r13
addq $0x30, %r14
movl $0x1, %ebx
movq (%r14), %rdx
cmpq %r12, %rdx
jne 0x3801
testq %rdx, %rdx
je 0x381e
movq (%rsp), %rax
movq (%rax), %rsi
movq -0x8(%r14), %rdi
callq 0x2180
testl %eax, %eax
je 0x381e
cmpq %rbx, %r15
seta %bpl
addq $0x48, %r14
leaq (%rbx,%r13), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x37e0
jmp 0x3871
movq -0x28(%r14), %rsi
movq -0x20(%r14), %rdx
movq 0xe79b(%rip), %rdi      # 0x11fc8
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
testb $0x1, %bpl
je 0x3871
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe778(%rip), %rbx      # 0x11ff0
leaq 0xa815(%rip), %rsi      # 0xe094
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x10(%rsp)
movq (%rdi), %r15
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %r14
subq %r15, %r14
setne %r13b
je 0x39b3
sarq $0x3, %r14
movabsq $-0x71c71c71c71c71c7, %rax # imm = 0x8E38E38E38E38E39
imulq %rax, %r14
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, %r14
movq %r14, %rbx
adcq $0x0, %rbx
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rax, 0x28(%rsp)
movq 0x30(%r15,%rbp), %rdx
cmpq %rax, %rdx
jne 0x3951
testq %rdx, %rdx
je 0x3966
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x28(%r15,%rbp), %rdi
callq 0x2180
testl %eax, %eax
movq 0x28(%rsp), %rax
je 0x3966
incq %r12
cmpq %r12, %r14
seta %r13b
addq $0x48, %rbp
cmpq %r12, %rbx
jne 0x3927
jmp 0x39b3
leaq (%r15,%rbp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x20c0
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r12, %rdx
jbe 0x3a44
movl 0xc(%rsp), %ecx
movl %ecx, (%rax,%rbp)
testb $0x1, %r13b
jne 0x3a35
leaq 0x48(%rsp), %rbx
movq %rbx, -0x10(%rbx)
xorl %eax, %eax
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movq 0x10(%rsp), %rsi
callq 0x20c0
leaq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20c0
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
movq 0x18(%rsp), %rdi
callq 0x7b62
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a1e
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a35
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2170
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa6d6(%rip), %rdi      # 0xe121
movq %r12, %rsi
xorl %eax, %eax
callq 0x2210
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7b8c
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movl $0x1, %ebx
subq %r15, %rax
je 0x3d25
movq %rsi, %r14
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
imulq %rax, %r12
movq 0x8(%rsi), %r13
cmpq $0x1, %r12
adcq $0x0, %r12
addq $0x30, %r15
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0x3d16
testq %rdx, %rdx
je 0x3d21
movq (%r14), %rsi
movq -0x8(%r15), %rdi
callq 0x2180
testl %eax, %eax
je 0x3d21
addq $0x48, %r15
decq %r12
jne 0x3cf9
jmp 0x3d25
movl -0x30(%r15), %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rdi), %rsi
cmpq (%rdi), %rsi
je 0xa865
addq $-0x18, %rsi
movq %rsp, %rdi
callq 0xab02
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xaad6
movq %rsp, %rdi
callq 0xaf90
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xaf90
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x211f0
movq 0x1251b5(%rip), %rdi    # 0x14b938
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27e58
movl %ebp, 0x120219(%rip)    # 0x1469b0
movl %ebx, 0x12020f(%rip)    # 0x1469ac
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd3c54
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl 0x1201f9(%rip), %ebx    # 0x1469ac
subl %esi, %ebx
movl %edi, %r8d
subl 0x1251e1(%rip), %r8d    # 0x14b9a0
movl %ebx, %r9d
movl $0x58, %eax
subl 0x1251d6(%rip), %r9d    # 0x14b9a4
cmpl $0x0, 0x1251d3(%rip)    # 0x14b9a8
jne 0x267f3
movl $0x50, %eax
cmpl $0x0, 0x1251c9(%rip)    # 0x14b9ac
jne 0x267f3
movl $0x48, %eax
cmpl $0x0, 0x1251bf(%rip)    # 0x14b9b0
je 0x26814
movq 0x12513e(%rip), %rdi    # 0x14b938
movq (%rdi), %r10
leaq 0x12511c(%rip), %rsi    # 0x14b920
movsd 0xba814(%rip), %xmm0    # 0xe1020
movl %ebp, %edx
movl %ebx, %ecx
callq *(%r10,%rax)
cmpl $0x0, 0x12518d(%rip)    # 0x14b9a8
jne 0x2682f
cmpl $0x0, 0x125188(%rip)    # 0x14b9ac
jne 0x2682f
cmpl $0x0, 0x125183(%rip)    # 0x14b9b0
je 0x26834
callq 0xd3c54
movl %ebp, 0x125166(%rip)    # 0x14b9a0
movl %ebx, 0x125164(%rip)    # 0x14b9a4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMouse(int, int, int, int)
void GLUTMouse(int button, int state, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;
  
  // Process mouse button event
  // Process mouse button event
  if ((button == GLUT_LEFT) && (state == GLUT_UP)) {
    // Check for double click  
    static RNBoolean double_click = FALSE;
    static RNTime last_mouse_down_time;
    double_click = (!double_click) && (last_mouse_down_time.Elapsed() < 0.4);
    last_mouse_down_time.Read();

    // Set world origin
    if (double_click) {
      R3Ray ray = viewer->WorldRay(x, y);
      R3MeshIntersection intersection;
      if (mesh->Intersection(ray, &intersection)) {
        world_origin = intersection.point;
      }
    }
  }

  // Remember button state 
  int b = (button == GLUT_LEFT_BUTTON) ? 0 : ((button == GLUT_MIDDLE_BUTTON) ? 1 : 2);
  GLUTbutton[b] = (state == GLUT_DOWN) ? 1 : 0;

  // Remember modifiers 
  GLUTmodifiers = glutGetModifiers();

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

  // Redraw
  glutPostRedisplay();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
movl 0x120149(%rip), %r13d   # 0x1469ac
subl %ecx, %r13d
movl %esi, %eax
xorl $0x1, %eax
orl %edi, %eax
jne 0x26921
movb 0x12514f(%rip), %al     # 0x14b9c8
testb %al, %al
je 0x26968
xorl %eax, %eax
cmpl $0x0, 0x12512a(%rip)    # 0x14b9b4
jne 0x268a9
leaq 0x125125(%rip), %rdi    # 0x14b9b8
callq 0x8c9c2
movsd 0xba7e0(%rip), %xmm1    # 0xe1080
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
movl %eax, 0x125105(%rip)    # 0x14b9b4
leaq 0x125102(%rip), %rdi    # 0x14b9b8
xorl %esi, %esi
callq 0x21fa0
cmpl $0x0, 0x1250f0(%rip)    # 0x14b9b4
je 0x26921
movq 0x12506b(%rip), %rsi    # 0x14b938
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x28b36
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x7aaf8
movq 0x12504b(%rip), %rdi    # 0x14b948
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq *0x170(%rax)
testl %eax, %eax
je 0x26921
leaq 0x125007(%rip), %rdi    # 0x14b920
movq %r15, %rsi
callq 0x7ae68
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
incl %eax
xorl %ecx, %ecx
testl %r14d, %r14d
sete %cl
testl %ebp, %ebp
cmovel %ebp, %eax
leaq 0x125069(%rip), %rdx    # 0x14b9a8
movl %ecx, (%rdx,%rax,4)
callq 0xd8b9c
movl %ebx, 0x125053(%rip)    # 0x14b9a0
movl %r13d, 0x125050(%rip)   # 0x14b9a4
callq 0xd3c54
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x125059(%rip), %rdi    # 0x14b9c8
callq 0x22120
testl %eax, %eax
je 0x26881
leaq 0x125035(%rip), %rdi    # 0x14b9b8
callq 0x8c960
leaq 0x125039(%rip), %rdi    # 0x14b9c8
callq 0x215b0
jmp 0x26881
movq %rax, %rbx
leaq 0x125025(%rip), %rdi    # 0x14b9c8
callq 0x21590
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %edx, %edx
testl %edi, %edi
cmovgl %edi, %edx
movl %edx, 0x124e71(%rip)    # 0x14b9d0
movq 0x124e2a(%rip), %rax    # 0x14b990
movl 0x14(%rax), %ecx
cmpl %ecx, %edx
jl 0x26b75
decl %ecx
movl %ecx, 0x124e5b(%rip)    # 0x14b9d0
movslq 0x124e54(%rip), %rcx    # 0x14b9d0
movq 0x8(%rax), %rax
movq (%rax,%rcx,8), %rdi
movq %rdi, 0x124df5(%rip)    # 0x14b980
movsd 0x124d4d(%rip), %xmm0   # 0x14b8e0
ucomisd 0x124d3d(%rip), %xmm0   # 0x14b8d8
jbe 0x26bac
movups 0x124d34(%rip), %xmm0   # 0x14b8d8
movups %xmm0, 0x124d65(%rip)   # 0x14b910
retq
pushq %rax
movaps 0xba5dc(%rip), %xmm0    # 0xe1190
movaps %xmm0, 0x124d45(%rip)   # 0x14b900
movsd 0xba48d(%rip), %xmm0    # 0xe1050
callq 0x49310
movsd %xmm0, (%rsp)
movq 0x124dac(%rip), %rdi    # 0x14b980
movsd 0x124d2c(%rip), %xmm0   # 0x14b908
callq 0x49310
movsd (%rsp), %xmm1
movsd %xmm1, 0x124d22(%rip)   # 0x14b910
movsd %xmm0, 0x124d22(%rip)   # 0x14b918
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
leaq 0x124a76(%rip), %rdi    # 0x14b8e8
leaq 0x128007(%rip), %rsi    # 0x14ee80
callq 0x7abf0
testl %eax, %eax
je 0x26e92
leaq 0x124a97(%rip), %rdi    # 0x14b920
leaq 0x124a58(%rip), %rsi    # 0x14b8e8
jmp 0x26ebc
movq 0x124aaf(%rip), %rsi    # 0x14b948
movq 0xf8(%rsi), %rax
addq $0xf8, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x124a67(%rip), %rdi    # 0x14b920
movq %rbx, %rsi
callq 0x7ae68
movl 0x124b0d(%rip), %edi    # 0x14b9d4
callq 0x26b52
callq 0xd6f13
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x8cefc
cmpl $0x0, 0x14(%r14)
jle 0x46df7
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %r13
movl $0x448, %edi            # imm = 0x448
callq 0x218b0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x488d0
movl 0x14(%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8cf92
incq %rbp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jl 0x46dbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x448, %esi            # imm = 0x448
movq %r12, %rdi
callq 0x218d0
jmp 0x46e1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x8cf66
movq %r14, %rdi
callq 0x220b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::PropertyIndex(char const*) const
int R3MeshPropertySet::
PropertyIndex(const char *property_name) const
{
  // Search through properties for matching name
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);
    if (!strcmp(property->Name(), property_name)) return i;
  }

  // Not found
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x14(%rdi), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0x46ee5
movq %rsi, %r14
movq 0x8(%rdi), %r12
xorl %r13d, %r13d
movl %ecx, %ebp
movq (%r12,%r13,8), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x21cf0
movl %r13d, %ecx
testl %eax, %eax
cmovnel %ebp, %ecx
je 0x46ee3
incq %r13
cmpq %r13, %r15
jne 0x46ebd
jmp 0x46ee5
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::SortByName()
void R3MeshPropertySet::
SortByName(void)
{
  // Sort properties
  for (int i = 0; i < properties.NEntries(); i++) {
    for (int j = i+1; j < properties.NEntries(); j++) {
      if (strcmp(properties[i]->Name(), properties[j]->Name()) > 0) {
        R3MeshProperty *swap = properties[i];
        properties.EntryContents(properties.KthEntry(i)) = properties[j];
        properties.EntryContents(properties.KthEntry(j)) = swap;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movslq 0x14(%rdi), %rbx
testq %rbx, %rbx
jle 0x46f7a
movl $0x1, %ecx
movq %rcx, (%rsp)
xorl %r13d, %r13d
leaq 0x1(%r13), %rcx
movq %rcx, 0x10(%rsp)
cmpq %rbx, %rcx
jae 0x46f6c
movq (%rsp), %rbp
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
movq (%r15,%r13,8), %r12
leaq 0x8(%r12), %rdi
movq (%r15,%rbp,8), %r14
leaq 0x8(%r14), %rsi
callq 0x21cf0
testl %eax, %eax
jle 0x46f64
movq %r14, (%r15,%r13,8)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %rbx
jne 0x46f30
incq (%rsp)
movq 0x10(%rsp), %r13
cmpq %rbx, %r13
jne 0x46f1e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::operator=(gaps::R3MeshPropertySet const&)
R3MeshPropertySet& R3MeshPropertySet::
operator=(const R3MeshPropertySet& set)
{
  // Delete everything
  Empty();

  // Copy mesh
  mesh = set.mesh;
  
  // Copy properties
  for (int i = 0; i < set.NProperties(); i++) {
    R3MeshProperty *property = set.Property(i);
    Insert(new R3MeshProperty(*property));
  }

  // Return this
  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x8d13c
movq (%r14), %rax
movq %rax, (%rbx)
cmpl $0x0, 0x14(%r14)
jle 0x47048
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %r13
movl $0x448, %edi            # imm = 0x448
callq 0x218b0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x488d0
movl 0x14(%rbx), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x8cf92
incq %rbp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jl 0x4700e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x448, %esi            # imm = 0x448
movq %r12, %rdi
callq 0x218d0
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::Read(char const*)
int R3MeshPropertySet::
Read(const char *filename)
{
  // Check mesh
  if (!mesh) {
    RNFail("Property set must be associated with mesh before file can be read: %s\n", filename);
    return 0;
  }
  
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .arff)\n", filename);
    return 0;
  }

  // Read file of appropriate type
  if (!strcmp(extension, ".arff")) return ReadARFF(filename);
  else if (!strcmp(extension, ".npy")) return ReadNumpy(filename);
  else if (!strcmp(extension, ".prp")) return ReadBinary(filename);
  else if (!strcmp(extension, ".trt")) return ReadToronto(filename);
  else return ReadProperty(filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x470f4
movq %rdi, %r14
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x47107
movq %rax, %r15
leaq 0x9be74(%rip), %rsi     # 0xe2f13
movq %rax, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x47120
leaq 0x9be67(%rip), %rsi     # 0xe2f19
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x47130
leaq 0x9be59(%rip), %rsi     # 0xe2f1e
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x47140
leaq 0x9be4b(%rip), %rsi     # 0xe2f23
movq %r15, %rdi
callq 0x21cf0
movq %r14, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x47150
popq %rbx
popq %r14
popq %r15
jmp 0x47f8a
leaq 0x9bda5(%rip), %rdi     # 0xe2ea0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8fd7a
jmp 0x47118
leaq 0x9bdd9(%rip), %rdi     # 0xe2ee7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4715a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x474ca
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47a54
popq %rbx
popq %r14
popq %r15
jmp 0x47c1a
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::ReadProperty(char const*)
int R3MeshPropertySet::
ReadProperty(const char *filename)
{
  // Create property name
  char name[1024];
  strcpy(name, filename);
  char *start = strrchr(name, '/');
  if (start) start++; 
  else start = name;
  char *end = strrchr(start, '.');
  if (end) *end = '\0';

  // Create mesh property
  R3MeshProperty *property = new R3MeshProperty(mesh, start);
  if (!property) {
    RNFail("Unable to create mesh property for %s\n", filename);
    return 0;
  }

  // Read data 
  if (!property->Read(filename)) {
    RNFail("Unable to read values from %s\n", filename);
    return 0;
  }

  // Add property to set
  Insert(property);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x217f0
movq %r15, %rdi
movl $0x2f, %esi
callq 0x219a0
leaq 0x1(%rax), %r12
testq %rax, %rax
cmoveq %r15, %r12
movq %r12, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x47fd7
movb $0x0, (%rax)
movl $0x448, %edi            # imm = 0x448
callq 0x218b0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x487c8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4af34
testl %eax, %eax
je 0x4801d
movl 0x14(%r14), %edx
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x8cf92
movl $0x1, %ebp
jmp 0x48030
leaq 0x9b1dc(%rip), %rdi     # 0xe3200
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8fd7a
movl %ebp, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x448, %esi            # imm = 0x448
movq %r15, %rdi
callq 0x218d0
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::Write(char const*) const
int R3MeshPropertySet::
Write(const char *filename) const
{
  // Check mesh
  if (!mesh) {
    RNFail("Property set must be associated with mesh before file can be written: %s\n", filename);
    return 0;
  }
  
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .arff)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  if (!strcmp(extension, ".arff")) return WriteARFF(filename);
  else if (!strcmp(extension, ".npy")) return WriteNumpy(filename);
  else if (!strcmp(extension, ".txt")) return WriteValues(filename);
  else if (!strcmp(extension, ".prp")) return WriteBinary(filename);
  else if (!strcmp(extension, ".val")) return WriteValues(filename);
  else if (!strcmp(extension, ".dat")) return WriteValues(filename);

  // None of the extensions matched
  RNFail("Unable to write file %s (unrecognized extension: %s)\n", filename, extension);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x48120
movq %rdi, %r14
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x48133
movq %rax, %r15
leaq 0x9ae84(%rip), %rsi     # 0xe2f13
movq %rax, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4814c
leaq 0x9ae73(%rip), %rsi     # 0xe2f19
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4816c
leaq 0x995e8(%rip), %rsi     # 0xe16a5
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4815c
leaq 0x9ae4a(%rip), %rsi     # 0xe2f1e
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4817c
leaq 0x9b17e(%rip), %rsi     # 0xe3269
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4815c
leaq 0x9b170(%rip), %rsi     # 0xe326e
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4815c
leaq 0x995e9(%rip), %rdi     # 0xe16fa
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8fd7a
jmp 0x48144
leaq 0x9b0f8(%rip), %rdi     # 0xe321f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8fd7a
jmp 0x48144
leaq 0x9adad(%rip), %rdi     # 0xe2ee7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4818c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x484a0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x482b0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x485e8
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::WriteARFF(char const*) const
int R3MeshPropertySet::
WriteARFF(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open ARFF file: %s\n", filename);
    return 0;
  }

  // Write header
  fprintf(fp, "@relation %s\n\n", mesh->Name());

  // Write names
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);
    fprintf(fp, "@attribute %s real\n", property->Name());
  }

  // Write values
  fprintf(fp, "\n@data\n\n");
  for (int i = 0; i < mesh->NVertices(); i++) {
    for (int j = 0; j < NProperties(); j++) {
      fprintf(fp, "%g ", properties[j]->VertexValue(i));
    }
    fprintf(fp, "\n");
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9d1da(%rip), %rsi     # 0xe537c
movq %r15, %rdi
callq 0x21aa0
testq %rax, %rax
je 0x48291
movq %rax, %r14
movq (%rbx), %rdx
addq $0x78, %rdx
leaq 0x9b0af(%rip), %rsi     # 0xe3273
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d70
cmpl $0x0, 0x14(%rbx)
jle 0x48203
leaq 0x9b0a7(%rip), %r15     # 0xe3282
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
addq $0x8, %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d70
incq %r12
movslq 0x14(%rbx), %rax
cmpq %rax, %r12
jl 0x481de
leaq 0x9b08c(%rip), %rdi     # 0xe3296
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22270
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x48282
xorl %r12d, %r12d
leaq 0x9b070(%rip), %r15     # 0xe329f
cmpl $0x0, 0x14(%rbx)
jle 0x48266
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x410(%rax), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21d70
incq %r13
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
jl 0x48238
movl $0xa, %edi
movq %r14, %rsi
callq 0x21ba0
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r12
jl 0x4822f
movq %r14, %rdi
callq 0x218a0
movl $0x1, %ebx
jmp 0x482a4
leaq 0x9ac90(%rip), %rdi     # 0xe2f28
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x8fd7a
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::WriteValues(char const*) const
int R3MeshPropertySet::
WriteValues(const char *filename) const
{
  // Check number of properties
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);

    // Determine file name
    char name[1024];
    strncpy(name, filename, 1023);
    if (NProperties() > 1) {
      char basename[512];
      strncpy(basename, filename, 511);
      char *extension = strrchr(basename, '.');
      if (extension) { *extension = '\0'; }
      else extension = (char *) ".val";
      sprintf(name, "%s_%d.%s", basename, i, extension);
    }

    // Open file
    FILE *fp = fopen(name, "w");
    if (!fp) {
      RNFail("Unable to open values file: %s\n", name);
      return 0;
    }

    // Write values
    for (int i = 0; i < mesh->NVertices(); i++) {
      fprintf(fp, "%g\n", property->VertexValue(i));
    }

    // Close file
    fclose(fp);
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp            # imm = 0x618
movq %rsi, 0x8(%rsp)
movl 0x14(%rdi), %r12d
testl %r12d, %r12d
setle 0x7(%rsp)
jle 0x485ce
movq %rdi, %r14
leaq 0x9a447(%rip), %r13     # 0xe2919
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rbx
movl $0x3ff, %edx            # imm = 0x3FF
leaq 0x210(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x21410
cmpl $0x2, %r12d
movq %r15, %r12
jl 0x4854d
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x21410
movq %r15, %rdi
movl $0x2e, %esi
callq 0x219a0
leaq 0x9ad3f(%rip), %r8      # 0xe3269
testq %rax, %rax
je 0x48535
movb $0x0, (%rax)
movq %rax, %r8
movq %r12, %rdi
leaq 0x9aec2(%rip), %rsi     # 0xe3401
leaq 0x10(%rsp), %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x21130
movq %r12, %rdi
leaq 0x9ce25(%rip), %rsi     # 0xe537c
callq 0x21aa0
movq %r12, %rsi
movq %rax, %r12
testq %rax, %rax
je 0x485a6
movq (%r14), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4859c
xorl %r15d, %r15d
movq 0x410(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r12, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x21d70
incq %r15
movq (%r14), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r15
jl 0x48573
movq %r12, %rdi
callq 0x218a0
jmp 0x485b4
leaq 0x9ae5d(%rip), %rdi     # 0xe340a
xorl %eax, %eax
callq 0x8fd7a
testq %r12, %r12
je 0x485ce
incq %rbp
movslq 0x14(%r14), %r12
cmpq %r12, %rbp
setge 0x7(%rsp)
jl 0x484d4
movzbl 0x7(%rsp), %eax
andl $0x1, %eax
addq $0x618, %rsp            # imm = 0x618
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::R3MeshProperty(gaps::R3Mesh*, char const*, double const*)
R3MeshProperty::
R3MeshProperty(R3Mesh *mesh, const char *name, const RNScalar *vertex_values)
  : mesh(mesh),
    nvalues(0),
    values(NULL)
{
  // Assign property name
  if (name) strncpy(this->name, name, 1023); 
  else sprintf(this->name, "Property%d", next_property_name++);
  this->name[1023] = '\0';
  
  // Assign vertex values
  this->nvalues = mesh->NVertices();
  this->values = new RNScalar [ this->nvalues ];
  if (vertex_values) {
    for (int i = 0; i < mesh->NVertices(); i++) {
      this->values[i] = vertex_values[i];
    }
  }
  else {
    for (int i = 0; i < mesh->NVertices(); i++) {
      this->values[i] = 0;
    }
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movl $0x0, 0x408(%rdi)
movq $0x0, 0x410(%rdi)
addq $0x8, %rdi
testq %rdx, %rdx
je 0x4880c
movq %rdx, %rax
movl $0x3ff, %edx            # imm = 0x3FF
movq %rax, %rsi
callq 0x21410
jmp 0x48829
movl 0xfe21e(%rip), %edx     # 0x146a30
leal 0x1(%rdx), %eax
movl %eax, 0xfe215(%rip)     # 0x146a30
leaq 0x9ac66(%rip), %rsi     # 0xe3488
xorl %eax, %eax
callq 0x21130
movb $0x0, 0x407(%rbx)
movslq 0x14(%r15), %r12
leaq (,%r12,8), %r15
testq %r12, %r12
movl %r12d, 0x408(%rbx)
movq $-0x1, %rdi
cmovnsq %r15, %rdi
callq 0x21040
movq %rax, 0x410(%rbx)
testq %r14, %r14
je 0x48877
testl %r12d, %r12d
jle 0x48889
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21710
jmp 0x48889
testl %r12d, %r12d
jle 0x48889
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x21470
movaps 0x9aba0(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::R3MeshProperty(gaps::R3MeshProperty const&)
R3MeshProperty::
R3MeshProperty(const R3MeshProperty& property)
  : mesh(property.mesh),
    nvalues(0),
    values(NULL),
    mean(property.mean),
    stddev(property.stddev),
    minimum(property.minimum),
    maximum(property.maximum),
    median(property.median),
    l2norm(property.l2norm)
{
  // Copy property name
  strcpy(this->name, property.name);
  
  // Copy vertex values
  this->nvalues = mesh->NVertices();
  this->values = new RNScalar [ this->nvalues ];
  for (int i = 0; i < mesh->NVertices(); i++) {
    this->values[i] = property.values[i];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq %r15, (%rdi)
movl $0x0, 0x408(%rdi)
movq $0x0, 0x410(%rdi)
movups 0x418(%rsi), %xmm0
movups %xmm0, 0x418(%rdi)
movups 0x428(%rsi), %xmm0
movups %xmm0, 0x428(%rdi)
movups 0x438(%rsi), %xmm0
movups %xmm0, 0x438(%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x217f0
movslq 0x14(%r15), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movl %eax, 0x408(%r14)
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x21040
movq %rax, 0x410(%r14)
movslq 0x14(%r15), %rcx
testq %rcx, %rcx
jle 0x4897e
movq 0x410(%rbx), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x4896c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Mean() const
RNScalar R3MeshProperty::
Mean(void) const
{
  // Compute mean of property values
  if (mean == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->mean = 0;
    if (nvalues > 0) {
      // Compute sum 
      int count = 0;
      RNScalar sum = 0;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        sum += values[i];
        count++;
      }

      // Compute mean
      if (count > 0) property->mean = sum / count;
    }
  }

  // Return mean
  return mean;
}

// Assembly:
movsd 0x418(%rdi), %xmm0
ucomisd 0x981bc(%rip), %xmm0    # 0xe1090
jne 0x48f4b
jp 0x48f4b
movq $0x0, 0x418(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48f4b
movq 0x410(%rdi), %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
movsd 0x9818c(%rip), %xmm1    # 0xe1090
xorl %esi, %esi
movapd %xmm0, %xmm3
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
addsd %xmm2, %xmm0
jne 0x48f1f
jp 0x48f1f
movapd %xmm3, %xmm0
cmpneqsd %xmm1, %xmm2
movq %xmm2, %r8
subl %r8d, %esi
incq %rdx
cmpq %rdx, %rax
jne 0x48f06
testl %esi, %esi
je 0x48f4b
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x418(%rdi)
movsd 0x418(%rdi), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Minimum() const
RNScalar R3MeshProperty::
Minimum(void) const
{
  // Compute minimum of property values
  if (minimum == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->minimum = 0;
    if (nvalues > 0) {
      property->minimum = FLT_MAX;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        if (values[i] < property->minimum) property->minimum = values[i];
      }
    }
  }

  // Return minimum
  return minimum;
}

// Assembly:
movsd 0x428(%rdi), %xmm0
ucomisd 0x9812c(%rip), %xmm0    # 0xe1090
jne 0x48fd0
jp 0x48fd0
movq $0x0, 0x428(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48fd0
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
movq %rcx, 0x428(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x99d01(%rip), %xmm0    # 0xe2ca0
xorl %edx, %edx
movsd 0x980e7(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x48fb6
jnp 0x48fc8
ucomisd %xmm2, %xmm0
jbe 0x48fc8
movsd %xmm2, 0x428(%rdi)
movapd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x48fa9
movsd 0x428(%rdi), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Maximum() const
RNScalar R3MeshProperty::
Maximum(void) const
{
  // Compute maximum of property values
  if (maximum == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->maximum = 0;
    if (nvalues > 0) {
      property->maximum = -FLT_MAX;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        if (values[i] > property->maximum) property->maximum = values[i];
      }
    }
  }

  // Return maximum
  return maximum;
}

// Assembly:
movsd 0x430(%rdi), %xmm0
ucomisd 0x980a6(%rip), %xmm0    # 0xe1090
jne 0x49056
jp 0x49056
movq $0x0, 0x430(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49056
movabsq $-0x3810000020000000, %rcx # imm = 0xC7EFFFFFE0000000
movq %rcx, 0x430(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x99c83(%rip), %xmm0    # 0xe2ca8
xorl %edx, %edx
movsd 0x98061(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4903c
jnp 0x4904e
ucomisd %xmm0, %xmm2
jbe 0x4904e
movsd %xmm2, 0x430(%rdi)
movapd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x4902f
movsd 0x430(%rdi), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::StandardDeviation() const
RNScalar R3MeshProperty::
StandardDeviation(void) const
{
  // Compute standard deviation of property values
  if (stddev == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->stddev = 0;
    if (nvalues > 0) {
      // Comute sum of squared residuals
      int count = 0;
      RNScalar ssd = 0;
      RNScalar avg = Mean();
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        RNScalar delta = values[i] - avg;
        ssd += delta * delta;
        count++;
      }

      // Compute standard deviation
      if (count > 0) property->stddev = sqrt(ssd / count);
    }
  }

  // Return standard deviation
  return stddev;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x420(%rdi), %xmm0
ucomisd 0x9801c(%rip), %xmm0    # 0xe1090
jne 0x49137
jp 0x49137
movq $0x0, 0x420(%rbx)
cmpl $0x0, 0x408(%rbx)
jle 0x49137
movq %rbx, %rdi
callq 0x48ec4
movslq 0x408(%rbx), %rcx
testq %rcx, %rcx
jle 0x490fe
movq 0x410(%rbx), %rdx
xorpd %xmm3, %xmm3
xorl %esi, %esi
movsd 0x97fcf(%rip), %xmm2    # 0xe1090
xorl %eax, %eax
movsd (%rdx,%rsi,8), %xmm4
ucomisd %xmm2, %xmm4
movapd %xmm4, %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
jne 0x490e4
jp 0x490e4
movapd %xmm3, %xmm1
cmpneqsd %xmm2, %xmm4
movq %xmm4, %rdi
subl %edi, %eax
incq %rsi
movapd %xmm1, %xmm3
cmpq %rsi, %rcx
jne 0x490c3
jmp 0x49104
xorl %eax, %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x49137
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x49126
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x4912f
movapd %xmm1, %xmm0
callq 0x216a0
movsd %xmm0, 0x420(%rbx)
movsd 0x420(%rbx), %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Percentile(double) const
RNScalar R3MeshProperty::
Percentile(RNScalar percentile) const
{
  // Compute value at given percentile (100=max, 0=min)
  if (nvalues == 0) return 0;

  // Copy values
  int count = 0;
  RNScalar *copy = new RNScalar [ nvalues ];
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    copy[count++] = values[i];
  }

  // Check count of values
  if (count == 0) return 0;

  // Compute value at given percentile
  qsort(copy, count, sizeof(RNScalar), RNCompareScalars);
  int index = (int) (count * percentile / 100.0);
  if (index >= count) index = count - 1;
  RNScalar result = copy[index];

  // Delete copy
  delete [] copy;

  // Return result
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movslq 0x408(%rdi), %r15
xorpd %xmm1, %xmm1
testq %r15, %r15
je 0x493f2
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x21040
movq %rax, %rbx
testl %r15d, %r15d
jle 0x4938f
movq 0x410(%r14), %rax
xorl %ecx, %ecx
movsd 0x97d26(%rip), %xmm0    # 0xe1090
xorl %r14d, %r14d
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4937a
jnp 0x49385
movslq %r14d, %rdx
incl %r14d
movsd %xmm1, (%rbx,%rdx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x4936d
jmp 0x49392
xorl %r14d, %r14d
testl %r14d, %r14d
xorpd %xmm1, %xmm1
je 0x493f2
movslq %r14d, %rsi
leaq 0x45bd4(%rip), %rcx     # 0x8ef79
movl $0x8, %edx
movq %rbx, %rdi
callq 0x22210
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x97cd8(%rip), %xmm0    # 0xe10a0
cvttsd2si %xmm0, %eax
leal -0x1(%r14), %ecx
cmpl %eax, %r14d
cmovgl %eax, %ecx
movslq %ecx, %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x21c10
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::LocalMinimumCount() const
int R3MeshProperty::
LocalMinimumCount(void) const
{
  // Count values that are minima
  int count = 0;
  for (int i = 0; i < mesh->NVertices(); i++) 
    if (IsLocalMinimum(i)) count++;
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movslq 0x14(%rax), %r14
testq %r14, %r14
jle 0x49476
movq %rdi, %rbx
movq 0x8(%rax), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
callq 0x48d84
cmpl $0x1, %eax
sbbl $-0x1, %ebp
incq %r12
cmpq %r12, %r14
jne 0x4945a
jmp 0x49478
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::LocalMaximumCount() const
int R3MeshProperty::
LocalMaximumCount(void) const
{
  // Count values that are maxima
  int count = 0;
  for (int i = 0; i < mesh->NVertices(); i++) 
    if (IsLocalMaximum(i)) count++;
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movslq 0x14(%rax), %r14
testq %r14, %r14
jle 0x494c0
movq %rdi, %rbx
movq 0x8(%rax), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
callq 0x48e24
cmpl $0x1, %eax
sbbl $-0x1, %ebp
incq %r12
cmpq %r12, %r14
jne 0x494a4
jmp 0x494c2
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop