LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49517
movq 0x410(%rdi), %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
movsd 0x97ba1(%rip), %xmm1    # 0xe1090
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 0x494f1
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49576
movq 0x410(%rdi), %rcx
xorpd %xmm3, %xmm3
xorl %edx, %edx
movapd 0x97f15(%rip), %xmm1    # 0xe1450
movsd 0x97b4d(%rip), %xmm2    # 0xe1090
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 0x49543
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movsd 0x440(%rdi), %xmm0
ucomisd 0x97b02(%rip), %xmm0    # 0xe1090
jne 0x4960d
jp 0x4960d
movq $0x0, 0x440(%rbx)
movslq 0x408(%rbx), %rax
testq %rax, %rax
jle 0x4960d
movq 0x410(%rbx), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x97ad2(%rip), %xmm1    # 0xe1090
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 0x495be
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x49600
sqrtsd %xmm0, %xmm0
jmp 0x49605
callq 0x216a0
movsd %xmm0, 0x440(%rbx)
movsd 0x440(%rbx), %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4965b
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97a5b(%rip), %xmm0    # 0xe1090
movapd 0x97e13(%rip), %xmm1    # 0xe1450
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x4964a
jnp 0x49653
andpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4963d
movaps 0x99dce(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49736
xorl %r14d, %r14d
movsd 0x979f9(%rip), %xmm1    # 0xe1090
xorpd %xmm2, %xmm2
movapd 0x97dbd(%rip), %xmm3    # 0xe1460
movq 0x410(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x496b8
jnp 0x49723
ucomisd %xmm2, %xmm0
jae 0x496d6
movsd 0x99daa(%rip), %xmm4    # 0xe3470
ucomisd %xmm0, %xmm4
xorpd %xmm3, %xmm0
jb 0x496de
sqrtsd %xmm0, %xmm0
jmp 0x496f7
jb 0x496fd
sqrtsd %xmm0, %xmm0
jmp 0x49716
callq 0x216a0
movapd 0x97d75(%rip), %xmm3    # 0xe1460
xorpd %xmm2, %xmm2
movsd 0x97999(%rip), %xmm1    # 0xe1090
xorpd %xmm3, %xmm0
jmp 0x49716
callq 0x216a0
movapd 0x97d56(%rip), %xmm3    # 0xe1460
xorpd %xmm2, %xmm2
movsd 0x9797a(%rip), %xmm1    # 0xe1090
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movslq 0x408(%rbx), %rax
cmpq %rax, %r14
jl 0x496a3
movaps 0x99cf3(%rip), %xmm0    # 0xe3430
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_O1/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 0x49795
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97919(%rip), %xmm0    # 0xe1090
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49784
jnp 0x4978d
mulsd %xmm1, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49777
movaps 0x99c94(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x497f5
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x978c1(%rip), %xmm0    # 0xe1090
movapd 0x97c89(%rip), %xmm1    # 0xe1460
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x497e4
jnp 0x497ed
xorpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x497d7
movaps 0x99c34(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49865
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97861(%rip), %xmm0    # 0xe1090
xorpd %xmm1, %xmm1
movsd 0x977e5(%rip), %xmm2    # 0xe1020
movsd (%rcx,%rdx,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x49848
jnp 0x4985d
ucomisd %xmm1, %xmm3
jne 0x49850
jnp 0x4985d
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4983b
movaps 0x99bc4(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rdx
testq %rdx, %rdx
jle 0x4992d
movq 0x410(%rdi), %rax
leal 0x1(%rdx), %ecx
decq %rdx
movq %rdx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
movdqa 0x99b89(%rip), %xmm2    # 0xe3440
xorl %edx, %edx
movdqa 0x9946f(%rip), %xmm3    # 0xe2d30
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x99b7f(%rip), %xmm5    # 0xe3450
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x4990b
movsd %xmm0, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x49920
movsd %xmm0, 0x8(%rax,%rdx)
paddq %xmm5, %xmm2
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x498d1
movaps 0x99afc(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49978
movq 0x410(%rsi), %rcx
movq 0x410(%rdi), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49966
movaps 0x99ab1(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x499f0
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x976d6(%rip), %xmm0    # 0xe1090
xorpd %xmm1, %xmm1
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x499cb
jnp 0x499e8
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x499d8
jnp 0x499e8
ucomisd %xmm1, %xmm2
jne 0x499e8
jp 0x499e8
movq $0x0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x499be
movaps 0x99a39(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49a3d
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49a35
jp 0x49a35
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49a23
movaps 0x999ec(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49a95
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97619(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49a84
jnp 0x49a8d
addsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49a77
movaps 0x99994(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49b01
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x975ba(%rip), %xmm0    # 0xe1090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49ae3
jnp 0x49af9
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49af0
jnp 0x49af9
addsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49ad6
movaps 0x99928(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49b59
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97555(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49b48
jnp 0x49b51
subsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49b3b
movaps 0x998d0(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49bc5
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x974f6(%rip), %xmm0    # 0xe1090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49ba7
jnp 0x49bbd
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49bb4
jnp 0x49bbd
subsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49b9a
movaps 0x99864(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49c1d
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x97491(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49c0c
jnp 0x49c15
mulsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49bff
movaps 0x9980c(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49c89
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x97432(%rip), %xmm0    # 0xe1090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49c6b
jnp 0x49c81
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49c78
jnp 0x49c81
mulsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49c5e
movaps 0x997a0(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x49cb3
jp 0x49cb3
retq
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49cee
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x973c0(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49cdd
jnp 0x49ce6
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49cd0
movaps 0x9973b(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x49d67
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x97360(%rip), %xmm0    # 0xe1090
xorpd %xmm1, %xmm1
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49d41
jnp 0x49d5f
movsd (%rdx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x49d4e
jnp 0x49d5f
ucomisd %xmm1, %xmm3
jne 0x49d56
jnp 0x49d5f
divsd %xmm3, %xmm2
movsd %xmm2, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49d34
movaps 0x996c2(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
cmpl $0x0, 0x408(%rdi)
jle 0x49de7
xorl %r14d, %r14d
movsd 0x972ec(%rip), %xmm1    # 0xe1090
movq 0x410(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x49db9
jnp 0x49dd8
movsd (%rsp), %xmm1
callq 0x22080
movsd 0x972c5(%rip), %xmm1    # 0xe1090
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movslq 0x408(%rbx), %rax
cmpq %rax, %r14
jl 0x49da4
movaps 0x99642(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x408(%rdi)
jle 0x49e8a
movq %rsi, %r14
xorl %r15d, %r15d
movsd 0x97265(%rip), %xmm2    # 0xe1090
movq 0x410(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x49e40
jnp 0x49e7b
movq 0x410(%r14), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x49e55
jnp 0x49e7b
ucomisd 0x9721b(%rip), %xmm1    # 0xe1078
jne 0x49e61
jnp 0x49e7b
callq 0x22080
movsd 0x97222(%rip), %xmm2    # 0xe1090
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movslq 0x408(%rbx), %rax
cmpq %rax, %r15
jl 0x49e2b
movaps 0x9959f(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x8cefc
movq (%rbx), %rdi
cmpl $0x0, 0x14(%rdi)
jle 0x49f1b
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movq %rsp, %r14
movq 0x410(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x49ee8
jnp 0x49f0c
ucomisd 0x971a0(%rip), %xmm0    # 0xe1090
jne 0x49ef4
jnp 0x49f0c
movq 0x8(%rdi), %rax
movq (%rax,%r15,8), %rsi
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x8cf92
xorpd %xmm1, %xmm1
incq %r15
movq (%rbx), %rdi
movslq 0x14(%rdi), %rax
cmpq %rax, %r15
jl 0x49ed3
movq %rsp, %rsi
xorpd %xmm0, %xmm0
xorl %edx, %edx
callq 0x61134
movq (%rbx), %rcx
movslq 0x14(%rcx), %rcx
testq %rcx, %rcx
jle 0x49f65
movq 0x410(%rbx), %rdx
xorl %esi, %esi
movsd 0x9714a(%rip), %xmm0    # 0xe1090
movsd (%rdx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49f53
jnp 0x49f5d
movsd (%rax,%rsi,8), %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x49f46
testq %rax, %rax
je 0x49f72
movq %rax, %rdi
callq 0x21c10
movaps 0x994b7(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq %rsp, %rdi
callq 0x8cf66
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x49fa2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8cf66
movq %rbx, %rdi
callq 0x220b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::SetVertexValue(int, double)
void R3MeshProperty::
SetVertexValue(int vertex_index, RNScalar value)
{
  // Set vertex value
  values[vertex_index] = value;

  // Reset statistics
  ResetStatistics();
}

// Assembly:
movq 0x410(%rdi), %rax
movslq %esi, %rcx
movsd %xmm0, (%rax,%rcx,8)
movaps 0x9920e(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x4a2ab
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x96e23(%rip), %xmm3    # 0xe1090
movsd 0x99203(%rip), %xmm4    # 0xe3478
movsd (%rcx,%rdx,8), %xmm5
ucomisd %xmm3, %xmm5
jne 0x4a282
jnp 0x4a2a3
ucomisd %xmm5, %xmm0
jae 0x4a292
ucomisd %xmm4, %xmm2
movapd %xmm2, %xmm5
jmp 0x4a29a
ucomisd %xmm4, %xmm1
movapd %xmm1, %xmm5
jne 0x4a29e
jnp 0x4a2a3
movsd %xmm5, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4a275
movaps 0x9917e(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x410(%rdi), %rax
movslq %esi, %rcx
movsd (%rax,%rcx,8), %xmm1
movapd %xmm1, %xmm2
addsd %xmm0, %xmm2
cmpeqsd 0x96da8(%rip), %xmm1    # 0xe1090
movapd %xmm1, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movlpd %xmm1, (%rax,%rcx,8)
movaps 0x9912c(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x48ec4
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x49060
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0x408(%rbx), %eax
jne 0x4a415
jp 0x4a415
testl %eax, %eax
jle 0x4a452
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x96c9a(%rip), %xmm0    # 0xe1090
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4a403
jnp 0x4a40b
movq $0x0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4a3f6
jmp 0x4a452
testl %eax, %eax
movsd 0x8(%rsp), %xmm3
jle 0x4a452
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x96c60(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4a43d
jnp 0x4a44a
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4a430
movaps 0x98fd7(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $-0x1, 0x10(%rsp)
leaq -0x37(%rip), %rax       # 0x4a474
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
movq (%rdi), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4a519
xorl %r15d, %r15d
movsd 0x96bb6(%rip), %xmm1    # 0xe1090
movq %rsp, %r14
movq 0x410(%rbx), %rcx
movsd (%rcx,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x4a4f2
jnp 0x4a50a
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4b758
movsd 0x96b86(%rip), %xmm1    # 0xe1090
incq %r15
movq (%rbx), %rax
movslq 0x14(%rax), %rcx
cmpq %rcx, %r15
jl 0x4a4dd
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4a57f
cmpl $0x0, 0x8(%rsp)
je 0x4a57f
movl $0x1, %r15d
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b854
leal -0x1(%r15), %ecx
movslq 0x70(%rax), %rax
movq (%rbx), %rdx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x96b4c(%rip), %xmm0    # 0xe10a0
xorps %xmm1, %xmm1
cvtsi2sdl 0x14(%rdx), %xmm1
divsd %xmm1, %xmm0
movq 0x410(%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
movq (%rbx), %rax
cmpl 0x14(%rax), %r15d
jge 0x4a57f
incl %r15d
cmpl $0x0, 0x8(%rsp)
jne 0x4a532
movaps 0x98eaa(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4a5a9
callq 0x21c10
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4a5b5
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4a5c6
callq 0x21c10
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x488d0
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4a664
xorl %r12d, %r12d
movq %rsp, %r14
movq 0x410(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm0
ucomisd 0x96a82(%rip), %xmm0    # 0xe1090
jne 0x4a612
jnp 0x4a655
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x48b4c
movslq 0x70(%r15), %rax
movq 0x410(%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
movapd 0x98df3(%rip), %xmm0    # 0xe3430
movupd %xmm0, 0x418(%rbx)
movupd %xmm0, 0x428(%rbx)
movupd %xmm0, 0x438(%rbx)
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rcx
cmpq %rcx, %r12
jl 0x4a5f9
movaps 0x98dc5(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%rsp), %rdi
testq %rdi, %rdi
je 0x4a692
callq 0x21c10
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x410(%rsp), %rdi
testq %rdi, %rdi
je 0x4a6b6
callq 0x21c10
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Dilate(double)
void R3MeshProperty::
Dilate(RNScalar radius)
{
  // Copy property
  R3MeshProperty copy(*this);
  
  // Clear property
  Clear(0);
 
  // For every vertex with non-zero value
  for (int i = 0; i < mesh->NVertices(); i++) {
    if (copy.VertexValue(i) == 0) continue;
    if (copy.VertexValue(i) == RN_UNKNOWN) continue;
    R3MeshVertex *vertex = mesh->Vertex(i);

    // Find neighborhood of vertex
    RNArray<R3MeshVertex *> neighbor_vertices;
    RNLength *distances = mesh->DijkstraDistances(vertex, radius, neighbor_vertices);
    delete [] distances;

    // Set value of vertices within neighborhood
    for (int j = 0; j < neighbor_vertices.NEntries(); j++) {
      R3MeshVertex *neighbor_vertex = neighbor_vertices.Kth(j);
      if (VertexValue(neighbor_vertex) == RN_UNKNOWN) continue;
      SetVertexValue(neighbor_vertex, 1);
    }
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x460, %rsp            # imm = 0x460
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x488d0
movslq 0x408(%rbx), %rdx
testq %rdx, %rdx
jle 0x4a701
movq 0x410(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x21470
movaps 0x98d28(%rip), %xmm1    # 0xe3430
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4a82b
xorl %r12d, %r12d
xorpd %xmm2, %xmm2
movsd 0x96957(%rip), %xmm3    # 0xe1090
leaq 0x8(%rsp), %r14
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
movq 0x428(%rsp), %rcx
movsd (%rcx,%r12,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x4a762
jnp 0x4a818
ucomisd %xmm3, %xmm0
jne 0x4a76e
jnp 0x4a818
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r15
movq %r14, %rdi
callq 0x8cefc
movq (%rbx), %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x6139a
testq %rax, %rax
je 0x4a7a0
movq %rax, %rdi
callq 0x21c10
movslq 0x14(%rsp), %rax
testq %rax, %rax
movaps 0x98c81(%rip), %xmm1    # 0xe3430
movsd 0x968d9(%rip), %xmm2    # 0xe1090
jle 0x4a7fd
movq 0x8(%rsp), %rcx
movq 0x410(%rbx), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movslq 0x70(%rdi), %rdi
movsd (%rdx,%rdi,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x4a7dc
jnp 0x4a7f5
movq %r13, (%rdx,%rdi,8)
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
incq %rsi
cmpq %rsi, %rax
jne 0x4a7c7
movq %r14, %rdi
callq 0x8cf66
movsd 0x96883(%rip), %xmm3    # 0xe1090
movaps 0x98c1c(%rip), %xmm1    # 0xe3430
xorpd %xmm2, %xmm2
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rcx
cmpq %rcx, %r12
jl 0x4a748
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
movq 0x428(%rsp), %rdi
testq %rdi, %rdi
je 0x4a852
callq 0x21c10
addq $0x460, %rsp            # imm = 0x460
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x4a875
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8cf66
movq 0x428(%rsp), %rdi
testq %rdi, %rdi
je 0x4a887
callq 0x21c10
movq %rbx, %rdi
callq 0x220b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x14(%rax), %rax
movabsq $-0x4010000000000000, %r14 # imm = 0xBFF0000000000000
testq %rax, %rax
jle 0x4a917
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x967d2(%rip), %xmm1    # 0xe1090
xorpd %xmm2, %xmm2
movsd 0x96756(%rip), %xmm3    # 0xe1020
movsd (%rcx,%rdx,8), %xmm4
ucomisd %xmm1, %xmm4
jne 0x4a8d7
jnp 0x4a90f
cmpeqsd %xmm2, %xmm4
andpd %xmm3, %xmm4
movlpd %xmm4, (%rcx,%rdx,8)
movq %r14, 0x418(%rbx)
movq %r14, 0x420(%rbx)
movq %r14, 0x428(%rbx)
movq %r14, 0x430(%rbx)
movq %r14, 0x438(%rbx)
movq %r14, 0x440(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x4a8ca
movq %rbx, %rdi
callq 0x4a6be
movq (%rbx), %rax
movslq 0x14(%rax), %rax
testq %rax, %rax
jle 0x4a995
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x96754(%rip), %xmm0    # 0xe1090
xorpd %xmm1, %xmm1
movsd 0x966d8(%rip), %xmm2    # 0xe1020
movsd (%rcx,%rdx,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x4a955
jnp 0x4a98d
cmpeqsd %xmm1, %xmm3
andpd %xmm2, %xmm3
movlpd %xmm3, (%rcx,%rdx,8)
movq %r14, 0x418(%rbx)
movq %r14, 0x420(%rbx)
movq %r14, 0x428(%rbx)
movq %r14, 0x430(%rbx)
movq %r14, 0x438(%rbx)
movq %r14, 0x440(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x4a948
movaps 0x98a94(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x488d0
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4a9ba
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49b76
movaps 0x987e6(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%r14), %rdi
testq %rdi, %rdi
je 0x4ac70
callq 0x21c10
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x420(%rsp), %rdi
testq %rdi, %rdi
je 0x4ac90
callq 0x21c10
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x488d0
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4ac02
movslq 0x418(%rsp), %rax
testq %rax, %rax
jle 0x4ad0e
movq 0x420(%rsp), %rcx
xorl %edx, %edx
movsd 0x963a8(%rip), %xmm0    # 0xe1090
movapd 0x96760(%rip), %xmm1    # 0xe1450
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x4acfd
jnp 0x4ad06
andpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4acf0
movaps 0x9871b(%rip), %xmm0    # 0xe3430
leaq 0x10(%rsp), %r14
movups %xmm0, 0x418(%r14)
movups %xmm0, 0x428(%r14)
movups %xmm0, 0x438(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49c3a
movaps 0x986ec(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%r14), %rdi
testq %rdi, %rdi
je 0x4ad6a
callq 0x21c10
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x420(%rsp), %rdi
testq %rdi, %rdi
je 0x4ad8a
callq 0x21c10
movq %rbx, %rdi
callq 0x220b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq 0x410(%rdi), %rdi
testq %rdi, %rdi
je 0x4adb1
callq 0x21c10
movslq 0x14(%r14), %r15
leaq (,%r15,8), %r14
testq %r15, %r15
movl %r15d, 0x408(%rbx)
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x21040
movq %rax, 0x410(%rbx)
testq %r15, %r15
jle 0x4adf0
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x21470
movaps 0x98639(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x410(%rdi), %rdi
testq %rdi, %rdi
je 0x4ae2e
callq 0x21c10
movl $0x0, 0x408(%rbx)
movq $0x0, 0x410(%rbx)
leaq 0x8(%rbx), %rdi
movb $0x0, 0x8(%rbx)
movq (%r14), %r15
movq %r15, (%rbx)
movups 0x418(%r14), %xmm0
movups %xmm0, 0x418(%rbx)
movups 0x428(%r14), %xmm0
movups %xmm0, 0x428(%rbx)
movups 0x438(%r14), %xmm0
movups %xmm0, 0x438(%rbx)
leaq 0x8(%r14), %rsi
callq 0x217f0
movslq 0x14(%r15), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movl %eax, 0x408(%rbx)
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x21040
movq %rax, 0x410(%rbx)
movslq 0x14(%r15), %rcx
testq %rcx, %rcx
jle 0x4aed7
movq 0x410(%r14), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x4aec5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x408(%rdi), %eax
cmpl 0x408(%rsi), %eax
setne %cl
testl %eax, %eax
setle %dl
xorpd %xmm0, %xmm0
orb %cl, %dl
jne 0x4af32
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x9617c(%rip), %xmm1    # 0xe1090
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4af21
jnp 0x4af2a
mulsd (%rdx,%rsi,8), %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x4af14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x4aff4
movq %rax, %r15
leaq 0x97fb4(%rip), %rsi     # 0xe2f13
movq %rax, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4b01d
leaq 0x9672f(%rip), %rsi     # 0xe16a5
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4b00d
leaq 0x982dc(%rip), %rsi     # 0xe3269
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4b00d
leaq 0x982ce(%rip), %rsi     # 0xe326e
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4b00d
leaq 0x963f3(%rip), %rsi     # 0xe13a6
movq %r15, %rdi
callq 0x21cf0
testl %eax, %eax
je 0x4b02d
movaps 0x9846a(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%r14)
movups %xmm0, 0x428(%r14)
movups %xmm0, 0x438(%r14)
leaq 0x966e0(%rip), %rdi     # 0xe16c5
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8fd7a
jmp 0x4b005
leaq 0x97eec(%rip), %rdi     # 0xe2ee7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b2d2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b03e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b3fc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9d2b3(%rip), %rsi     # 0xe85a3
movq %rbx, %rdi
callq 0x21aa0
testq %rax, %rax
je 0x4b3cb
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x217f0
movq %r12, %rdi
movl $0x2f, %esi
callq 0x219a0
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %r12, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x4b33e
movb $0x0, (%rax)
leaq 0x98608(%rip), %rsi     # 0xe394d
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22180
cmpl $0x1, %eax
jne 0x4b3bc
leaq 0x985ed(%rip), %r12     # 0xe394d
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq (%r14), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %rbp
jge 0x4b3d4
movsd 0x8(%rsp), %xmm0
movq 0x410(%r14), %rax
movsd %xmm0, (%rax,%rbp,8)
movaps 0x980a4(%rip), %xmm0    # 0xe3430
movups %xmm0, 0x418(%r14)
movups %xmm0, 0x428(%r14)
movups %xmm0, 0x438(%r14)
incq %rbp
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x22180
cmpl $0x1, %eax
je 0x4b367
movq %r15, %rdi
callq 0x218a0
movl $0x1, %ebp
jmp 0x4b3e7
leaq 0x98103(%rip), %rdi     # 0xe34d5
jmp 0x4b3db
leaq 0x97bb0(%rip), %rdi     # 0xe2f8b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8fd7a
movl %ebp, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop