LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e035
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x128039(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6dff1
jp 0x6dff1
jmp 0x6e028
movq (%rsp), %rax
movq 0x410(%rax), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rcx
movslq 0xc(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6dfba
movq (%rsp), %rdi
callq 0x6c450
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e0ee
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127f89(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e0a1
jp 0x6e0a1
jmp 0x6e0de
movq (%rsp), %rax
movq 0x410(%rax), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6e06a
movq (%rsp), %rdi
callq 0x6c450
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Invert()
void R3MeshProperty::
Invert(void)
{
  // Invert every value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (values[i] == 0) continue;
    values[i] = 1.0 / values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e1b5
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127ed5(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e155
jp 0x6e155
jmp 0x6e1a5
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e177
jp 0x6e177
jmp 0x6e1a5
movq (%rsp), %rax
movq 0x410(%rax), %rcx
movslq 0xc(%rsp), %rdx
movsd 0x127ed9(%rip), %xmm0   # 0x196068
divsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6e11a
movq (%rsp), %rdi
callq 0x6c450
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Clear(double)
void R3MeshProperty::
Clear(RNScalar value)
{
  // Set every value
  for (int i = 0; i < nvalues; i++) {
    values[i] = value;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e22b
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e1f1
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Copy(gaps::R3MeshProperty const&)
void R3MeshProperty::
Copy(const R3MeshProperty& property)
{
  // Copy every value
  for (int i = 0; i < nvalues; i++) {
    values[i] = property.values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e2aa
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e260
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Mask(gaps::R3MeshProperty const&)
void R3MeshProperty::
Mask(const R3MeshProperty& property)
{
  // Zero values where property is zero
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == 0) values[i] = 0;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e391
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127d0d(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e31d
jp 0x6e31d
jmp 0x6e381
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127ce5(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e345
jp 0x6e345
jmp 0x6e381
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e37f
jp 0x6e37f
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x6e381
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e2e0
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Substitute(double, double)
void R3MeshProperty::
Substitute(RNScalar current, RNScalar replacement)
{
  // Substitute values that match
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == current) values[i] = replacement;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e41f
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x18(%rsp), %xmm0
jne 0x6e410
jp 0x6e410
movq (%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x6e412
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6e3c6
movq (%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Add(double)
void R3MeshProperty::
Add(RNScalar value)
{
  // Add scalar to every value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] += value;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e4b8
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127ba0(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e48a
jp 0x6e48a
jmp 0x6e4ab
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e451
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Add(gaps::R3MeshProperty const&)
void R3MeshProperty::
Add(const R3MeshProperty& property)
{
  // Add every value 
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    values[i] += property.values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e596
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127afd(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e52d
jp 0x6e52d
jmp 0x6e586
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127ad5(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e555
jp 0x6e555
jmp 0x6e586
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e4f0
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Subtract(double)
void R3MeshProperty::
Subtract(RNScalar value)
{
  // Subtract scalar from every value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] -= value;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e63c
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127a20(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e60a
jp 0x6e60a
jmp 0x6e62f
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm1
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e5d1
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Subtract(gaps::R3MeshProperty const&)
void R3MeshProperty::
Subtract(const R3MeshProperty& property)
{
  // Subtract every value 
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    values[i] -= property.values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e71a
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x12797d(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e6ad
jp 0x6e6ad
jmp 0x6e70a
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127955(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e6d5
jp 0x6e6d5
jmp 0x6e70a
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e670
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Multiply(double)
void R3MeshProperty::
Multiply(RNScalar value)
{
  // Multiply every value by a scalar
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] *= value;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e7b8
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1278a0(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e78a
jp 0x6e78a
jmp 0x6e7ab
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e751
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Multiply(gaps::R3MeshProperty const&)
void R3MeshProperty::
Multiply(const R3MeshProperty& property)
{
  // Multiply every value 
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    values[i] *= property.values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e896
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1277fd(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e82d
jp 0x6e82d
jmp 0x6e886
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1277d5(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e855
jp 0x6e855
jmp 0x6e886
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e7f0
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Divide(double)
void R3MeshProperty::
Divide(RNScalar value)
{
  // Check value
  if (value == 0) return;

  // Divide every value by a scalar
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] /= value;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6e8dc
jp 0x6e8dc
jmp 0x6e959
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6e94f
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x12770d(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e91d
jp 0x6e91d
jmp 0x6e942
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm1
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e8e4
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Divide(gaps::R3MeshProperty const&)
void R3MeshProperty::
Divide(const R3MeshProperty& property)
{
  // Divide every value 
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == 0) continue;
    values[i] /= property.values[i];
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6ea50
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x12766d(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e9c0
jp 0x6e9c0
jmp 0x6ea40
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127642(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6e9e8
jp 0x6e9e8
jmp 0x6ea40
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6ea0b
jp 0x6ea0b
jmp 0x6ea40
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6e980
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Pow(double)
void R3MeshProperty::
Pow(RNScalar exponent)
{
  // Raise every value to an exponent
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] = pow(values[i], exponent);
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6eafe
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127570(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6eaba
jp 0x6eaba
jmp 0x6eaf1
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x23240
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6ea81
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Pow(gaps::R3MeshProperty const&)
void R3MeshProperty::
Pow(const R3MeshProperty& property)
{
  // Raise every value to an exponent
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == RN_UNKNOWN) continue;
    if (property.values[i] == 0) continue;
    values[i] = pow(values[i], property.values[i]);
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6ec12
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1274bd(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6eb70
jp 0x6eb70
jmp 0x6ec02
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127492(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6eb98
jp 0x6eb98
jmp 0x6ec02
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6ebbb
jp 0x6ebbb
jmp 0x6ec02
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x23240
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6eb30
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::DistanceTransform()
void R3MeshProperty::
DistanceTransform(void)
{
  // Create array of source vertices
  RNArray<R3MeshVertex *> vertices;
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (values[i] == 0) continue;
    if (values[i] == RN_UNKNOWN) continue;
    R3MeshVertex *vertex = mesh->Vertex(i);
    vertices.Insert(vertex);
  }

  // Compute distances to those vertices
  RNLength *distances = mesh->DijkstraDistances(vertices);

  // Fill property
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (values[i] == RN_UNKNOWN) continue;
    values[i] = distances[i];
  }

  // Delete distances
  delete [] distances;

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x712b0
movl $0x0, 0x5c(%rsp)
movq 0x28(%rsp), %rax
movl 0x5c(%rsp), %ecx
movl %ecx, 0x20(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0x24(%rsp)
jmp 0x6ec70
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6ed2d
movq 0x28(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x5c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6ecc0
jp 0x6ecc0
jmp 0x6ed1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x712e0
jmp 0x6ee16
movq 0x28(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x5c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x127342(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6ece8
jp 0x6ece8
jmp 0x6ed1d
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x5c(%rsp), %esi
callq 0x2abf0
movq %rax, 0x18(%rsp)
jmp 0x6ed00
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x71490
jmp 0x6ed1b
jmp 0x6ed1d
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x6ec55
movq 0x28(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq 0x60(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x9a200
movq %rax, 0x10(%rsp)
jmp 0x6ed4d
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0xc(%rsp)
jmp 0x6ed7a
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6ede3
movq 0x28(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x34(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x12727c(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6edae
jp 0x6edae
jmp 0x6edd3
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movslq 0x34(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0x34(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x6ed5f
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x6edfb
movq (%rsp), %rdi
callq 0x22d80
movq 0x28(%rsp), %rdi
callq 0x6c450
jmp 0x6ee07
leaq 0x60(%rsp), %rdi
callq 0x712e0
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x23270
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Threshold(double, double, double)
void R3MeshProperty::
Threshold(RNScalar threshold, RNScalar low, RNScalar high)
{
  // Threshold every value
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    if (values[i] <= threshold) {
      if (low != R3_MESH_PROPERTY_KEEP_VALUE) values[i] = low;
    }
    else {
      if (high != R3_MESH_PROPERTY_KEEP_VALUE) values[i] = high;
    }
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6f3bd
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x126d10(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f31d
jp 0x6f31d
jmp 0x6f3ad
movq 0x8(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x6f375
movsd 0x20(%rsp), %xmm0
movsd 0x12917b(%rip), %xmm1   # 0x1984c8
ucomisd %xmm1, %xmm0
jne 0x6f357
jp 0x6f357
jmp 0x6f373
movq 0x8(%rsp), %rax
movsd 0x20(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x6f3ab
movsd 0x18(%rsp), %xmm0
movsd 0x129145(%rip), %xmm1   # 0x1984c8
ucomisd %xmm1, %xmm0
jne 0x6f38d
jp 0x6f38d
jmp 0x6f3a9
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x6f3ab
jmp 0x6f3ad
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6f2dd
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::AddVertexValue(int, double)
void R3MeshProperty::
AddVertexValue(int vertex_index, RNScalar value)
{
  // Add value to a vertex
  if (values[vertex_index] == RN_UNKNOWN) values[vertex_index] = value;
  else values[vertex_index] += value;

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x410(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x126c1a(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f42c
jp 0x6f42c
movq 0x8(%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x6f44d
movq 0x8(%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x1c(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Normalize()
void R3MeshProperty::
Normalize(void)
{
  // Get mean and stddev
  RNScalar m = Mean();
  RNScalar s = StandardDeviation();

  // Check stddev
  if (s == 0) {
    // Set everything to zero
    for (int i = 0; i < nvalues; i++) {
      if (values[i] == RN_UNKNOWN) continue;
      values[i] = 0;
    }
  }
  else {
    // Normalize by mean and stddev
    for (int i = 0; i < nvalues; i++) {
      if (values[i] == RN_UNKNOWN) continue;
      values[i] = (values[i] - m) / s;
    }
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6d010
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x6d370
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6f5e6
jp 0x6f5e6
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6f5e1
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x126a6e(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f5bc
jp 0x6f5bc
jmp 0x6f5d4
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6f585
jmp 0x6f666
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x6f664
movq (%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x126a05(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f625
jp 0x6f625
jmp 0x6f657
movq (%rsp), %rax
movq 0x410(%rax), %rcx
movslq 0x8(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd 0x18(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movq 0x410(%rax), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x6f5ee
jmp 0x6f666
movq (%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Percentilize()
void R3MeshProperty::
Percentilize(void)
{
  // Push vertices onto heap sorted by property value
  RNHeap<R3MeshVertex *> heap(VertexPropertyValueCallback, NULL, this);
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (values[i] == RN_UNKNOWN) continue;
    heap.Push(mesh->Vertex(i));
  }

  // Pop vertices in order, storing perecentiles
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (heap.IsEmpty()) break;
    R3MeshVertex *vertex = heap.Pop();
    int vertex_index = mesh->VertexID(vertex);
    values[vertex_index] = 100.0 * i / mesh->NVertices();
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rcx
movq %rcx, 0x38(%rsp)
leaq 0x68(%rsp), %rdi
leaq -0x58(%rip), %rsi       # 0x6f680
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r8d
callq 0x71530
movl $0x0, 0x64(%rsp)
movq 0x38(%rsp), %rax
movl 0x64(%rsp), %ecx
movl %ecx, 0x30(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0x34(%rsp)
jmp 0x6f70a
movl 0x30(%rsp), %eax
movl 0x34(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6f79a
movq 0x38(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x64(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1268e8(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f75f
jp 0x6f75f
jmp 0x6f78a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x718f0
jmp 0x6f8a5
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl 0x64(%rsp), %esi
callq 0x2abf0
movq %rax, 0x28(%rsp)
jmp 0x6f777
movq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x715a0
jmp 0x6f788
jmp 0x6f78a
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x6f6ef
movl $0x0, 0x50(%rsp)
movq 0x38(%rsp), %rax
movl 0x50(%rsp), %ecx
movl %ecx, 0x20(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0x24(%rsp)
jmp 0x6f7bd
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6f887
leaq 0x68(%rsp), %rdi
callq 0x717c0
movl %eax, 0x1c(%rsp)
jmp 0x6f7dd
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
je 0x6f7eb
jmp 0x6f887
leaq 0x68(%rsp), %rdi
callq 0x717e0
movq %rax, 0x10(%rsp)
jmp 0x6f7fc
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x2b080
movl %eax, 0xc(%rsp)
jmp 0x6f81e
movq 0x38(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x44(%rsp)
cvtsi2sdl 0x50(%rsp), %xmm0
movsd 0x12686f(%rip), %xmm1   # 0x1960a8
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0x8(%rsp)
jmp 0x6f850
movq 0x38(%rsp), %rax
movsd (%rsp), %xmm0
movl 0x8(%rsp), %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movq 0x410(%rax), %rax
movslq 0x44(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x6f7a2
movq 0x38(%rsp), %rdi
callq 0x6c450
jmp 0x6f893
leaq 0x68(%rsp), %rdi
callq 0x718f0
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x23270
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Laplace()
void R3MeshProperty::
Laplace(void)
{
  // Assign laplacian  at every vertex
  R3MeshProperty copy(*this);
  for (int i = 0; i < mesh->NVertices(); i++) {
    R3MeshVertex *vertex = mesh->Vertex(i);
    if (values[i] == RN_UNKNOWN) continue;
    SetVertexValue(vertex, copy.Laplacian(vertex));
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x498, %rsp            # imm = 0x498
movq %rdi, 0x490(%rsp)
movq 0x490(%rsp), %rsi
movq %rsi, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6c4c0
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, 0x1c(%rsp)
jmp 0x6f8f9
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6f9b0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x44(%rsp), %esi
callq 0x2abf0
movq %rax, 0x10(%rsp)
jmp 0x6f921
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x410(%rax), %rax
movslq 0x44(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1266d7(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6f96d
jp 0x6f96d
jmp 0x6f9a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6c640
jmp 0x6f9ce
movq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6c9d0
movsd %xmm0, 0x8(%rsp)
jmp 0x6f988
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x6f4b0
jmp 0x6f99e
jmp 0x6f9a0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x6f8de
movq 0x20(%rsp), %rdi
callq 0x6c450
jmp 0x6f9bc
leaq 0x48(%rsp), %rdi
callq 0x6c640
addq $0x498, %rsp            # imm = 0x498
retq
movq 0x38(%rsp), %rdi
callq 0x23270
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Erode(double)
void R3MeshProperty::
Erode(RNScalar radius)
{
  // Flip values
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (VertexValue(i) == RN_UNKNOWN) continue;
    if (VertexValue(i) == 0) SetVertexValue(i, 1);
    else SetVertexValue(i, 0);
  }

  // Dilate
  Dilate(radius);

  // Flip values
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (VertexValue(i) == RN_UNKNOWN) continue;
    if (VertexValue(i) == 0) SetVertexValue(i, 1);
    else SetVertexValue(i, 0);
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x6fd34
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2b0a0
movsd 0x12634a(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6fce0
jp 0x6fce0
jmp 0x6fd24
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2b0a0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6fd11
jp 0x6fd11
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movsd 0x12635e(%rip), %xmm0   # 0x196068
callq 0x6f210
jmp 0x6fd22
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
xorps %xmm0, %xmm0
callq 0x6f210
jmp 0x6fd24
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6fca1
movq 0x8(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x6f9e0
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, (%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x6fddd
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2b0a0
movsd 0x1262a1(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x6fd89
jp 0x6fd89
jmp 0x6fdcd
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2b0a0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6fdba
jp 0x6fdba
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movsd 0x1262b5(%rip), %xmm0   # 0x196068
callq 0x6f210
jmp 0x6fdcb
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
xorps %xmm0, %xmm0
callq 0x6f210
jmp 0x6fdcd
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6fd4c
movq 0x8(%rsp), %rdi
callq 0x6c450
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::DoG(double)
void R3MeshProperty::
DoG(RNScalar sigma)
{
  // Difference of Gaussians
  // Replace values with difference from blurred version
  R3MeshProperty blur(*this); 
  blur.Blur(sigma);
  Subtract(blur);

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x478, %rsp            # imm = 0x478
movq %rdi, 0x470(%rsp)
movsd %xmm0, 0x468(%rsp)
movq 0x470(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c4c0
movq 0x8(%rsp), %rdi
movsd 0x468(%rsp), %xmm0
callq 0x6fdf0
jmp 0x70278
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6e650
jmp 0x70288
movq (%rsp), %rdi
callq 0x6c450
jmp 0x70293
leaq 0x20(%rsp), %rdi
callq 0x6c640
addq $0x478, %rsp            # imm = 0x478
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6c640
movq 0x18(%rsp), %rdi
callq 0x23270
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Strength(double)
void R3MeshProperty::
Strength(RNScalar sigma)
{
  // Replace values with significance score
  // For now, compute product of value and DoG
  R3MeshProperty dog(*this); 
  dog.DoG(sigma);
  dog.Abs();
  Multiply(dog);

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x478, %rsp            # imm = 0x478
movq %rdi, 0x470(%rsp)
movsd %xmm0, 0x468(%rsp)
movq 0x470(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c4c0
movq 0x8(%rsp), %rdi
movsd 0x468(%rsp), %xmm0
callq 0x70230
jmp 0x70318
leaq 0x20(%rsp), %rdi
callq 0x6dde0
jmp 0x70324
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6e7d0
jmp 0x70334
movq (%rsp), %rdi
callq 0x6c450
jmp 0x7033f
leaq 0x20(%rsp), %rdi
callq 0x6c640
addq $0x478, %rsp            # imm = 0x478
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6c640
movq 0x18(%rsp), %rdi
callq 0x23270
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Reset(gaps::R3Mesh*)
void R3MeshProperty::
Reset(R3Mesh *mesh)
{
  // Set mesh
  this->mesh = mesh;

  // Assign vertex values
  if (values) delete [] values;
  this->nvalues = mesh->NVertices();
  this->values = new RNScalar [ this->nvalues ];
  for (int i = 0; i < mesh->NVertices(); i++) {
    this->values[i] = 0;
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x410(%rax)
je 0x703cd
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x703cb
movq 0x10(%rsp), %rdi
callq 0x22d80
jmp 0x703cd
movq 0x28(%rsp), %rdi
callq 0x2abd0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x408(%rax)
movslq 0x408(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x22040
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x410(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2abd0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x70465
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq 0x24(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x70423
movq 0x18(%rsp), %rdi
callq 0x6c450
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::operator=(gaps::R3MeshProperty const&)
R3MeshProperty& R3MeshProperty::
operator=(const R3MeshProperty& property)
{
  // Reset everything
  if (values) delete [] values;
  nvalues = 0;
  values = NULL;
  name[0] = '\0';

  // Copy stuff
  mesh = property.mesh;
  mean = property.mean;
  stddev = property.stddev;
  minimum = property.minimum;
  maximum = property.maximum;
  median = property.median;
  l2norm = property.l2norm;

  // Copy 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];
  }

  // Return this
  return *this;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x410(%rax)
je 0x704c5
movq 0x18(%rsp), %rax
movq 0x410(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x704c3
movq 0x10(%rsp), %rdi
callq 0x22d80
jmp 0x704c5
movq 0x18(%rsp), %rdi
movl $0x0, 0x408(%rdi)
movq $0x0, 0x410(%rdi)
movb $0x0, 0x8(%rdi)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq 0x28(%rsp), %rax
movsd 0x418(%rax), %xmm0
movsd %xmm0, 0x418(%rdi)
movq 0x28(%rsp), %rax
movsd 0x420(%rax), %xmm0
movsd %xmm0, 0x420(%rdi)
movq 0x28(%rsp), %rax
movsd 0x428(%rax), %xmm0
movsd %xmm0, 0x428(%rdi)
movq 0x28(%rsp), %rax
movsd 0x430(%rax), %xmm0
movsd %xmm0, 0x430(%rdi)
movq 0x28(%rsp), %rax
movsd 0x438(%rax), %xmm0
movsd %xmm0, 0x438(%rdi)
movq 0x28(%rsp), %rax
movsd 0x440(%rax), %xmm0
movsd %xmm0, 0x440(%rdi)
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
callq 0x228f0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x2abd0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x408(%rax)
movslq 0x408(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x22040
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x410(%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x7062f
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x410(%rcx), %rcx
movslq 0x24(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x410(%rax), %rax
movslq 0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x705d7
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Dot(gaps::R3MeshProperty const&) const
RNScalar R3MeshProperty::
Dot(const R3MeshProperty& property) const
{
  // Check if number of values is consistent
  if (nvalues != property.nvalues) return 0;

  // Compute dot product of property "vectors"
  RNScalar dot = 0;
  for (int i = 0; i < nvalues; i++) {
    if (values[i] == RN_UNKNOWN) continue;
    dot += values[i] * property.values[i];
  }

  // Return dot product
  return dot;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl 0x408(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x408(%rcx), %eax
je 0x70675
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x7071b
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %eax
cmpl 0x408(%rcx), %eax
jge 0x7070f
movq -0x30(%rsp), %rax
movq 0x410(%rax), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x12596b(%rip), %xmm1   # 0x196020
ucomisd %xmm1, %xmm0
jne 0x706bf
jp 0x706bf
jmp 0x706ff
movq -0x30(%rsp), %rax
movq 0x410(%rax), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq 0x410(%rax), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x70686
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Read(char const*)
int R3MeshProperty::
Read(const char *filename)
{
  // 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, ".txt")) return ReadValues(filename);
  else if (!strcmp(extension, ".val")) return ReadValues(filename);
  else if (!strcmp(extension, ".dat")) return ReadValues(filename);
  else if (!strcmp(extension, ".pid")) return ReadPoints(filename);

  // Reset statistics
  ResetStatistics();

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x22b00
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x70781
movq 0x10(%rsp), %rsi
leaq 0x12777a(%rip), %rdi    # 0x197ee7
movb $0x0, %al
callq 0x22090
movl $0x0, 0x24(%rsp)
jmp 0x7088d
movq 0x8(%rsp), %rdi
leaq 0x127786(%rip), %rsi    # 0x197f13
callq 0x22ea0
cmpl $0x0, %eax
jne 0x707ae
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x708a0
movl %eax, 0x24(%rsp)
jmp 0x7088d
movq 0x8(%rsp), %rdi
leaq 0x125f63(%rip), %rsi    # 0x19671d
callq 0x22ea0
cmpl $0x0, %eax
jne 0x707db
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x70c90
movl %eax, 0x24(%rsp)
jmp 0x7088d
movq 0x8(%rsp), %rdi
leaq 0x127b0a(%rip), %rsi    # 0x1982f1
callq 0x22ea0
cmpl $0x0, %eax
jne 0x70808
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x70c90
movl %eax, 0x24(%rsp)
jmp 0x7088d
movq 0x8(%rsp), %rdi
leaq 0x127ae2(%rip), %rsi    # 0x1982f6
callq 0x22ea0
cmpl $0x0, %eax
jne 0x70832
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x70c90
movl %eax, 0x24(%rsp)
jmp 0x7088d
movq 0x8(%rsp), %rdi
leaq 0x125c38(%rip), %rsi    # 0x196476
callq 0x22ea0
cmpl $0x0, %eax
jne 0x7085c
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x70e30
movl %eax, 0x24(%rsp)
jmp 0x7088d
jmp 0x7085e
jmp 0x70860
jmp 0x70862
jmp 0x70864
movq (%rsp), %rdi
callq 0x6c450
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x125ebf(%rip), %rdi    # 0x19673d
movb $0x0, %al
callq 0xfbc30
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::ReadValues(char const*)
int R3MeshProperty::
ReadValues(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open ASCII file: %s\n", filename);
    return 0;
  }

  // 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';

  // Read data 
  double value;
  int vertex_index = 0;
  while (fscanf(fp, "%lf", &value) == (unsigned int) 1) {
    if (vertex_index >= mesh->NVertices()) {
      RNFail("Too many data lines in %s\n", filename);
      return 0;
    }
    SetVertexValue(vertex_index, value);
    vertex_index++;
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x458, %rsp            # imm = 0x458
movq %rdi, 0x448(%rsp)
movq %rsi, 0x440(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x440(%rsp), %rdi
leaq 0x12cc20(%rip), %rsi    # 0x19d8e3
callq 0x22bf0
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x438(%rsp)
jne 0x70d01
movq 0x440(%rsp), %rsi
leaq 0x127861(%rip), %rdi    # 0x19854b
movb $0x0, %al
callq 0xfbc30
movl $0x0, 0x454(%rsp)
jmp 0x70e13
leaq 0x30(%rsp), %rdi
movq 0x440(%rsp), %rsi
callq 0x228f0
leaq 0x30(%rsp), %rdi
movl $0x2f, %esi
callq 0x22b00
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x70d3f
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x70d49
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2e, %esi
callq 0x22b00
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x70d6d
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, 0x14(%rsp)
movq 0x438(%rsp), %rdi
leaq 0x127c31(%rip), %rsi    # 0x1989b5
leaq 0x18(%rsp), %rdx
movb $0x0, %al
callq 0x23350
cmpl $0x1, %eax
jne 0x70dfb
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq (%rax), %rdi
callq 0x2abd0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x70dd7
movq 0x440(%rsp), %rsi
leaq 0x1271f9(%rip), %rdi    # 0x197fbc
movb $0x0, %al
callq 0xfbc30
movl $0x0, 0x454(%rsp)
jmp 0x70e13
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movsd 0x18(%rsp), %xmm0
callq 0x6f210
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x70d75
movq 0x438(%rsp), %rdi
callq 0x229c0
movl $0x1, 0x454(%rsp)
movl 0x454(%rsp), %eax
addq $0x458, %rsp            # imm = 0x458
retq
nopw %cs:(%rax,%rax)