LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x3b04
movq %rsi, %rbx
movq 0x8(%rsp), %rdx
movq (%rdx), %rbp
movq 0x8(%rdx), %r8
xorl %r15d, %r15d
movabsq $-0x71c71c71c71c71c7, %rdi # imm = 0x8E38E38E38E38E39
movq %r8, %rdx
cmpq %rbp, %rdx
je 0x3ae7
movl $0x30, %r13d
xorl %r14d, %r14d
movq %r15, 0x10(%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
cmpq %r15, %rdx
jbe 0x3b13
leaq (%r15,%r15,8), %rcx
movq (%rbp,%r13), %rdx
cmpq 0x30(%rax,%rcx,8), %rdx
jne 0x3abd
leaq (%rax,%rcx,8), %r12
testq %rdx, %rdx
je 0x3a89
movq 0x28(%r12), %rsi
movq -0x8(%rbp,%r13), %rdi
movq %rbx, %r15
movq %r8, %rbx
callq 0x2180
movq %rbx, %r8
movq %r15, %rbx
movq 0x10(%rsp), %r15
movabsq $-0x71c71c71c71c71c7, %rdi # imm = 0x8E38E38E38E38E39
testl %eax, %eax
jne 0x3abd
movl (%r12), %eax
leaq -0x28(,%r13), %rdi
addq %rbp, %rdi
movl %eax, -0x8(%rdi)
addq $0x8, %r12
movq %r12, %rsi
callq 0x20c0
movabsq $-0x71c71c71c71c71c7, %rdi # imm = 0x8E38E38E38E38E39
movq 0x8(%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rax), %r8
incq %r14
movq %r8, %rax
subq %rbp, %rax
sarq $0x3, %rax
imulq %rdi, %rax
addq $0x48, %r13
cmpq %r14, %rax
ja 0x3a27
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %r8, %rdx
jmp 0x3aea
movq %rbp, %rdx
incq %r15
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
imulq %rdi, %rsi
cmpq %r15, %rsi
ja 0x3a10
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa607(%rip), %rdi      # 0xe121
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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), %r12
movq 0x8(%rdi), %rax
movl $0x1, %ebx
subq %r12, %rax
je 0x3b92
movq %rsi, %r14
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
imulq %rax, %r13
movq 0x8(%rsi), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
addq $0x30, %r12
cmpq %r15, (%r12)
jne 0x3b82
testq %r15, %r15
je 0x3b8d
movq (%r14), %rsi
movq -0x8(%r12), %rdi
movq %r15, %rdx
callq 0x2180
testl %eax, %eax
je 0x3b8d
addq $0x48, %r12
decq %r13
jne 0x3b63
jmp 0x3b92
movl -0x30(%r12), %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa509
addq $-0x18, %rsi
movq %rsp, %rdi
callq 0xa7a6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa77a
movq %rsp, %rdi
callq 0xac34
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xac34
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1231f4(%rip), %rdi    # 0x149938
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27df8
movl %ebp, 0x11e258(%rip)    # 0x1449b0
movl %ebx, 0x11e24e(%rip)    # 0x1449ac
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd1d20
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11e238(%rip), %ebx    # 0x1449ac
subl %esi, %ebx
movl %edi, %r8d
subl 0x123220(%rip), %r8d    # 0x1499a0
movl %ebx, %r9d
movl $0x58, %eax
subl 0x123215(%rip), %r9d    # 0x1499a4
cmpl $0x0, 0x123212(%rip)    # 0x1499a8
jne 0x267b4
movl $0x50, %eax
cmpl $0x0, 0x123208(%rip)    # 0x1499ac
jne 0x267b4
movl $0x48, %eax
cmpl $0x0, 0x1231fe(%rip)    # 0x1499b0
je 0x267d5
movq 0x12317d(%rip), %rdi    # 0x149938
movq (%rdi), %r10
leaq 0x12315b(%rip), %rsi    # 0x149920
movsd 0xb8853(%rip), %xmm0    # 0xdf020
movl %ebp, %edx
movl %ebx, %ecx
callq *(%r10,%rax)
cmpl $0x0, 0x1231cc(%rip)    # 0x1499a8
jne 0x267f0
cmpl $0x0, 0x1231c7(%rip)    # 0x1499ac
jne 0x267f0
cmpl $0x0, 0x1231c2(%rip)    # 0x1499b0
je 0x267f5
callq 0xd1d20
movl %ebp, 0x1231a5(%rip)    # 0x1499a0
movl %ebx, 0x1231a3(%rip)    # 0x1499a4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11e188(%rip), %r13d   # 0x1449ac
subl %ecx, %r13d
movl %esi, %eax
xorl $0x1, %eax
orl %edi, %eax
jne 0x268e2
movb 0x12318e(%rip), %al     # 0x1499c8
testb %al, %al
je 0x26929
xorl %eax, %eax
cmpl $0x0, 0x123169(%rip)    # 0x1499b4
jne 0x2686a
leaq 0x123164(%rip), %rdi    # 0x1499b8
callq 0x8b7e2
movsd 0xb881f(%rip), %xmm1    # 0xdf080
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
movl %eax, 0x123144(%rip)    # 0x1499b4
leaq 0x123141(%rip), %rdi    # 0x1499b8
xorl %esi, %esi
callq 0x21f90
cmpl $0x0, 0x12312f(%rip)    # 0x1499b4
je 0x268e2
movq 0x1230aa(%rip), %rsi    # 0x149938
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x28ae6
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x79b58
movq 0x12308a(%rip), %rdi    # 0x149948
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq *0x170(%rax)
testl %eax, %eax
je 0x268e2
leaq 0x123046(%rip), %rdi    # 0x149920
movq %r15, %rsi
callq 0x79ec2
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 0x1230a8(%rip), %rdx    # 0x1499a8
movl %ecx, (%rdx,%rax,4)
callq 0xd6bd9
movl %ebx, 0x123092(%rip)    # 0x1499a0
movl %r13d, 0x12308f(%rip)   # 0x1499a4
callq 0xd1d20
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x123098(%rip), %rdi    # 0x1499c8
callq 0x22110
testl %eax, %eax
je 0x26842
leaq 0x123074(%rip), %rdi    # 0x1499b8
callq 0x8b780
leaq 0x123078(%rip), %rdi    # 0x1499c8
callq 0x215b0
jmp 0x26842
movq %rax, %rbx
leaq 0x123064(%rip), %rdi    # 0x1499c8
callq 0x21590
movq %rbx, %rdi
callq 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %eax, %eax
testl %edi, %edi
cmovgl %edi, %eax
movl %eax, 0x122ebc(%rip)    # 0x1499d0
movq 0x122e75(%rip), %rcx    # 0x149990
movl 0x14(%rcx), %edx
cmpl %edx, %eax
jl 0x26b2c
decl %edx
movl %edx, 0x122ea6(%rip)    # 0x1499d0
movl %edx, %eax
movq 0x8(%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movq %rdi, 0x122e43(%rip)    # 0x149980
movsd 0x122d9b(%rip), %xmm0   # 0x1498e0
ucomisd 0x122d8b(%rip), %xmm0   # 0x1498d8
jbe 0x26b5e
movups 0x122d82(%rip), %xmm0   # 0x1498d8
movaps %xmm0, 0x122db3(%rip)   # 0x149910
retq
pushq %rax
movaps 0xb862a(%rip), %xmm0    # 0xdf190
movaps %xmm0, 0x122d93(%rip)   # 0x149900
movsd 0xb84db(%rip), %xmm0    # 0xdf050
callq 0x48c8a
movsd %xmm0, (%rsp)
movq 0x122dfa(%rip), %rdi    # 0x149980
movsd 0x122d7a(%rip), %xmm0   # 0x149908
callq 0x48c8a
movsd (%rsp), %xmm1
movsd %xmm1, 0x122d70(%rip)   # 0x149910
movsd %xmm0, 0x122d70(%rip)   # 0x149918
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x122ac4(%rip), %rdi    # 0x1498e8
leaq 0x126055(%rip), %rsi    # 0x14ce80
callq 0x79c50
testl %eax, %eax
je 0x26e44
leaq 0x122ae5(%rip), %rdi    # 0x149920
leaq 0x122aa6(%rip), %rsi    # 0x1498e8
jmp 0x26e6e
movq 0x122afd(%rip), %rsi    # 0x149948
movq 0xf8(%rsi), %rax
addq $0xf8, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x122ab5(%rip), %rdi    # 0x149920
movq %rbx, %rsi
callq 0x79ec2
movl 0x122b5b(%rip), %edi    # 0x1499d4
callq 0x26b07
callq 0xd4fdb
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bd1c
cmpl $0x0, 0x14(%r14)
jle 0x467cf
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 0x4823c
movl 0x14(%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8bdb2
incq %rbp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jl 0x46794
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 0x467f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x8bd86
movq %r14, %rdi
callq 0x220a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x14(%rdi), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0x468a9
movq %rsi, %r14
movq 0x8(%rdi), %r13
xorl %r12d, %r12d
movq (%r13,%r12,8), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x21ce0
testl %eax, %eax
je 0x468a6
incq %r12
cmpq %r12, %r15
jne 0x46887
jmp 0x468a9
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4693a
movl $0x1, %ecx
movq %rcx, (%rsp)
xorl %r13d, %r13d
leaq 0x1(%r13), %rcx
movq %rcx, 0x10(%rsp)
cmpq %rbx, %rcx
jae 0x4692c
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 0x21ce0
testl %eax, %eax
jle 0x46924
movq %r14, (%r15,%r13,8)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %rbx
jne 0x468f0
incq (%rsp)
movq 0x10(%rsp), %r13
cmpq %rbx, %r13
jne 0x468de
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bf7c
movq (%r14), %rax
movq %rax, (%rbx)
cmpl $0x0, 0x14(%r14)
jle 0x46a08
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 0x4823c
movl 0x14(%rbx), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x8bdb2
incq %rbp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jl 0x469ce
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 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x46ab4
movq %rdi, %r14
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x46ac7
movq %rax, %r15
leaq 0x9a4a4(%rip), %rsi     # 0xe0f03
movq %rax, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x46ae0
leaq 0x9a497(%rip), %rsi     # 0xe0f09
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x46af0
leaq 0x9a489(%rip), %rsi     # 0xe0f0e
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x46b00
leaq 0x9a47b(%rip), %rsi     # 0xe0f13
movq %r15, %rdi
callq 0x21ce0
movq %r14, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x46b10
popq %rbx
popq %r14
popq %r15
jmp 0x47938
leaq 0x9a3d5(%rip), %rdi     # 0xe0e90
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8e88e
jmp 0x46ad8
leaq 0x9a409(%rip), %rdi     # 0xe0ed7
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 0x46b1a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x46e7a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47414
popq %rbx
popq %r14
popq %r15
jmp 0x475da
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47985
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 0x48134
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4a876
testl %eax, %eax
je 0x479cb
movl 0x14(%r14), %edx
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x8bdb2
movl $0x1, %ebp
jmp 0x479de
leaq 0x9981e(%rip), %rdi     # 0xe11f0
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8e88e
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 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47ace
movq %rdi, %r14
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x47ae1
movq %rax, %r15
leaq 0x994c6(%rip), %rsi     # 0xe0f03
movq %rax, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47afa
leaq 0x994b5(%rip), %rsi     # 0xe0f09
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47b1a
leaq 0x97c3a(%rip), %rsi     # 0xdf6a5
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47b0a
leaq 0x9948c(%rip), %rsi     # 0xe0f0e
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47b2a
leaq 0x997c0(%rip), %rsi     # 0xe1259
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47b0a
leaq 0x997b2(%rip), %rsi     # 0xe125e
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x47b0a
leaq 0x97c3b(%rip), %rdi     # 0xdf6fa
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8e88e
jmp 0x47af2
leaq 0x9973a(%rip), %rdi     # 0xe120f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8e88e
jmp 0x47af2
leaq 0x993ef(%rip), %rdi     # 0xe0ed7
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 0x47b3a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47e2e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47c5e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47f78
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b83c(%rip), %rsi     # 0xe338c
movq %r15, %rdi
callq 0x21a90
testq %rax, %rax
je 0x47c3f
movq %rax, %r14
movq (%rbx), %rdx
addq $0x78, %rdx
leaq 0x996f1(%rip), %rsi     # 0xe1263
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d60
cmpl $0x0, 0x14(%rbx)
jle 0x47bb1
leaq 0x996e9(%rip), %r15     # 0xe1272
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 0x21d60
incq %r12
movslq 0x14(%rbx), %rax
cmpq %rax, %r12
jl 0x47b8c
leaq 0x996ce(%rip), %rdi     # 0xe1286
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22260
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x47c30
xorl %r12d, %r12d
leaq 0x996b2(%rip), %r15     # 0xe128f
cmpl $0x0, 0x14(%rbx)
jle 0x47c14
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 0x21d60
incq %r13
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
jl 0x47be6
movl $0xa, %edi
movq %r14, %rsi
callq 0x21b90
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r12
jl 0x47bdd
movq %r14, %rdi
callq 0x218a0
movl $0x1, %ebx
jmp 0x47c52
leaq 0x992d2(%rip), %rdi     # 0xe0f18
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r13d
movl $0x1, %ebx
testl %r13d, %r13d
jle 0x47f64
movq %rdi, %r15
leaq 0x210(%rsp), %r14
leaq 0x98ab1(%rip), %rbp     # 0xe0919
xorl %ebx, %ebx
movq 0x8(%r15), %rax
movq (%rax,%rbx,8), %r12
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x21410
cmpl $0x2, %r13d
jl 0x47ed8
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x21410
movq %r13, %rdi
movl $0x2e, %esi
callq 0x219a0
leaq 0x993a4(%rip), %r8      # 0xe1259
testq %rax, %rax
je 0x47ec0
movb $0x0, (%rax)
movq %rax, %r8
movq %r14, %rdi
leaq 0x99527(%rip), %rsi     # 0xe13f1
leaq 0x10(%rsp), %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x21130
movq %r14, %rdi
leaq 0x9b4aa(%rip), %rsi     # 0xe338c
callq 0x21a90
testq %rax, %rax
je 0x47f4c
movq %rax, %r13
movq (%r15), %rax
cmpl $0x0, 0x14(%rax)
jle 0x47f25
xorl %r14d, %r14d
movq 0x410(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %r13, %rdi
movq %rbp, %rsi
movb $0x1, %al
callq 0x21d60
incq %r14
movq (%r15), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r14
jl 0x47efb
movq %r13, %rdi
callq 0x218a0
incq %rbx
movslq 0x14(%r15), %r13
cmpq %r13, %rbx
leaq 0x210(%rsp), %r14
jl 0x47e6a
movl $0x1, %ebx
jmp 0x47f64
leaq 0x994a7(%rip), %rdi     # 0xe13fa
xorl %ebx, %ebx
leaq 0x210(%rsp), %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebx, %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_O3/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 0x48178
movq %rdx, %rax
movl $0x3ff, %edx            # imm = 0x3FF
movq %rax, %rsi
callq 0x21410
jmp 0x48195
movl 0xfc8b2(%rip), %edx     # 0x144a30
leal 0x1(%rdx), %eax
movl %eax, 0xfc8a9(%rip)     # 0x144a30
leaq 0x992ea(%rip), %rsi     # 0xe1478
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 0x481e3
testl %r12d, %r12d
jle 0x481f5
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21710
jmp 0x481f5
testl %r12d, %r12d
jle 0x481f5
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x21470
movaps 0x99224(%rip), %xmm0    # 0xe1420
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_O3/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), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x408(%r14)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x21040
movq %rax, 0x410(%r14)
testq %r15, %r15
jle 0x482e6
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x482d4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x96836(%rip), %xmm0    # 0xdf090
jne 0x488d1
jp 0x488d1
movq $0x0, 0x418(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x488d2
movq 0x410(%rdi), %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
movsd 0x96806(%rip), %xmm1    # 0xdf090
xorl %esi, %esi
movapd %xmm0, %xmm3
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
addsd %xmm2, %xmm0
jne 0x488a5
jp 0x488a5
movapd %xmm3, %xmm0
cmpneqsd %xmm1, %xmm2
movq %xmm2, %r8
subl %r8d, %esi
incq %rdx
cmpq %rdx, %rax
jne 0x4888c
testl %esi, %esi
je 0x488d2
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x418(%rdi)
retq
xorpd %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x967a8(%rip), %xmm0    # 0xdf090
jne 0x48954
jp 0x48954
movq $0x0, 0x428(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48955
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
movq %rcx, 0x428(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x9837d(%rip), %xmm0    # 0xe0ca0
xorl %edx, %edx
movsd 0x96763(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4893a
jnp 0x4894c
ucomisd %xmm2, %xmm0
jbe 0x4894c
movsd %xmm2, 0x428(%rdi)
movapd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x4892d
retq
xorpd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x96726(%rip), %xmm0    # 0xdf090
jne 0x489d6
jp 0x489d6
movq $0x0, 0x430(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x489d7
movabsq $-0x3810000020000000, %rcx # imm = 0xC7EFFFFFE0000000
movq %rcx, 0x430(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x98303(%rip), %xmm0    # 0xe0ca8
xorl %edx, %edx
movsd 0x966e1(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x489bc
jnp 0x489ce
ucomisd %xmm0, %xmm2
jbe 0x489ce
movsd %xmm2, 0x430(%rdi)
movapd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x489af
retq
xorpd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movsd 0x420(%rdi), %xmm0
ucomisd 0x966a3(%rip), %xmm0    # 0xdf090
jne 0x48ab8
jp 0x48ab8
movq %rdi, %rbx
movq $0x0, 0x420(%rdi)
cmpl $0x0, 0x408(%rdi)
jle 0x48aa5
movq %rbx, %rdi
callq 0x4884a
movslq 0x408(%rbx), %rax
testq %rax, %rax
jle 0x48a9b
movapd %xmm0, %xmm1
movq 0x410(%rbx), %rcx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd 0x9664f(%rip), %xmm2    # 0xdf090
xorl %edx, %edx
movapd %xmm0, %xmm4
movsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm2, %xmm3
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm4, %xmm0
jne 0x48a68
jp 0x48a68
movapd %xmm4, %xmm0
cmpneqsd %xmm2, %xmm3
movq %xmm3, %rdi
subl %edi, %edx
incq %rsi
cmpq %rsi, %rax
jne 0x48a43
testl %edx, %edx
je 0x48a9b
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x48aab
sqrtsd %xmm0, %xmm0
jmp 0x48ab0
movsd 0x420(%rbx), %xmm0
jmp 0x48ab8
xorpd %xmm0, %xmm0
jmp 0x48ab8
callq 0x216a0
movsd %xmm0, 0x420(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48d71
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x21040
testl %r15d, %r15d
jle 0x48d6d
movq %rax, %rbx
movq 0x410(%r14), %rax
xorl %ecx, %ecx
movsd 0x963a8(%rip), %xmm0    # 0xdf090
xorl %r14d, %r14d
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x48cf8
jnp 0x48d03
movslq %r14d, %rdx
incl %r14d
movsd %xmm1, (%rbx,%rdx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x48ceb
testl %r14d, %r14d
xorpd %xmm1, %xmm1
je 0x48d71
movslq %r14d, %rsi
leaq 0x44e13(%rip), %rcx     # 0x8db31
movl $0x8, %edx
movq %rbx, %rdi
callq 0x22200
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x9635f(%rip), %xmm0    # 0xdf0a0
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 0x21c00
movsd 0x8(%rsp), %xmm1
jmp 0x48d71
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48dec
movq %rdi, %rbx
movq 0x8(%rax), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
callq 0x486fa
cmpl $0x1, %eax
sbbl $-0x1, %ebp
incq %r12
cmpq %r12, %r14
jne 0x48dd0
jmp 0x48dee
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48e36
movq %rdi, %rbx
movq 0x8(%rax), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
callq 0x487a2
cmpl $0x1, %eax
sbbl $-0x1, %ebp
incq %r12
cmpq %r12, %r14
jne 0x48e1a
jmp 0x48e38
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::NonZeroCount() const
int R3MeshProperty::
NonZeroCount(void) const
{
  // Count values that are non-zero
  int count = 0;
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (values[i] == 0) continue;
    count++;
  }
  return count;
}

// Assembly:
movq (%rdi), %rax
movslq 0x14(%rax), %rcx
testq %rcx, %rcx
jle 0x48e8d
movq 0x410(%rdi), %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
movsd 0x9622b(%rip), %xmm1    # 0xdf090
xorl %eax, %eax
movsd (%rdx,%rsi,8), %xmm2
movapd %xmm2, %xmm3
cmpneqpd %xmm0, %xmm3
cmpneqpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %edi
subl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x48e67
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::L1Norm() const
RNScalar R3MeshProperty::
L1Norm(void) const
{
  // Compute sum 
  RNScalar sum = 0;
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    sum += fabs(values[i]);
  }

  // Return sum
  return sum;
}

// Assembly:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48eec
movq 0x410(%rdi), %rcx
xorpd %xmm3, %xmm3
xorl %edx, %edx
movapd 0x9659f(%rip), %xmm1    # 0xdf450
movsd 0x961d7(%rip), %xmm2    # 0xdf090
movsd (%rcx,%rdx,8), %xmm0
movapd %xmm0, %xmm4
andpd %xmm1, %xmm4
addsd %xmm3, %xmm4
cmpeqsd %xmm2, %xmm0
movapd %xmm0, %xmm5
andnpd %xmm4, %xmm5
andpd %xmm3, %xmm0
orpd %xmm5, %xmm0
incq %rdx
movapd %xmm0, %xmm3
cmpq %rdx, %rax
jne 0x48eb9
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::L2Norm() const
RNScalar R3MeshProperty::
L2Norm(void) const
{
  // Compute L2 norm of property values
  if (l2norm == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->l2norm = 0;
    if (nvalues > 0) {
      // Compute sum 
      RNScalar sum = 0;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        sum += values[i] * values[i];
      }

      // Compute l2norm
      property->l2norm = sqrt( sum );
    }
  }

  // Return l2norm
  return l2norm;
}

// Assembly:
pushq %rbx
movsd 0x440(%rdi), %xmm0
ucomisd 0x9618f(%rip), %xmm0    # 0xdf090
jne 0x48f91
jp 0x48f91
movq %rdi, %rbx
movq $0x0, 0x440(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48f7e
movq 0x410(%rbx), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x96154(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
cmpeqsd %xmm1, %xmm2
movapd %xmm2, %xmm4
andnpd %xmm3, %xmm4
andpd %xmm0, %xmm2
orpd %xmm4, %xmm2
movapd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x48f3c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x48f84
sqrtsd %xmm0, %xmm0
jmp 0x48f89
xorpd %xmm0, %xmm0
jmp 0x48f91
callq 0x216a0
movsd %xmm0, 0x440(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Abs()
void R3MeshProperty::
Abs(void)
{
  // Replace every value by its absolute value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] = fabs(values[i]);
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x48fd7
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x960df(%rip), %xmm0    # 0xdf090
movapd 0x96497(%rip), %xmm1    # 0xdf450
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x48fc6
jnp 0x48fcf
andpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x48fb9
movaps 0x98442(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Sqrt()
void R3MeshProperty::
Sqrt(void)
{
  // Replace every value by its sqrt
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (values[i] >= 0) values[i] = sqrt(values[i]);
    else values[i] = -1.0 * sqrt( -values[i] );
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x408(%rdi)
jle 0x490b2
movq 0x410(%rbx), %rax
xorl %r14d, %r14d
movsd 0x96076(%rip), %xmm1    # 0xdf090
xorpd %xmm2, %xmm2
movapd 0x9643a(%rip), %xmm3    # 0xdf460
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x49034
jnp 0x4909f
ucomisd %xmm2, %xmm0
jae 0x49052
movsd 0x9841e(%rip), %xmm4    # 0xe1460
ucomisd %xmm0, %xmm4
xorpd %xmm3, %xmm0
jb 0x4905a
sqrtsd %xmm0, %xmm0
jmp 0x49073
jb 0x49079
sqrtsd %xmm0, %xmm0
jmp 0x49092
callq 0x216a0
movapd 0x963f9(%rip), %xmm3    # 0xdf460
xorpd %xmm2, %xmm2
movsd 0x9601d(%rip), %xmm1    # 0xdf090
xorpd %xmm3, %xmm0
jmp 0x49092
callq 0x216a0
movapd 0x963da(%rip), %xmm3    # 0xdf460
xorpd %xmm2, %xmm2
movsd 0x95ffe(%rip), %xmm1    # 0xdf090
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movslq 0x408(%rbx), %rcx
cmpq %rcx, %r14
jl 0x49026
movaps 0x98367(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Square()
void R3MeshProperty::
Square(void)
{
  // Replace every value by its square
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] = values[i] * values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49111
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95f9d(%rip), %xmm0    # 0xdf090
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49100
jnp 0x49109
mulsd %xmm1, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x490f3
movaps 0x98308(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Negate()
void R3MeshProperty::
Negate(void)
{
  // Negate every value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] = -values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49171
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95f45(%rip), %xmm0    # 0xdf090
movapd 0x9630d(%rip), %xmm1    # 0xdf460
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49160
jnp 0x49169
xorpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49153
movaps 0x982a8(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq