LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x491e1
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95ee5(%rip), %xmm0    # 0xdf090
xorpd %xmm1, %xmm1
movsd 0x95e69(%rip), %xmm2    # 0xdf020
movsd (%rcx,%rdx,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x491c4
jnp 0x491d9
ucomisd %xmm1, %xmm3
jne 0x491cc
jnp 0x491d9
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x491b7
movaps 0x98238(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x492a9
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 0x981fd(%rip), %xmm2    # 0xe1430
xorl %edx, %edx
movdqa 0x97ae3(%rip), %xmm3    # 0xe0d20
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x981f3(%rip), %xmm5    # 0xe1440
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 0x49287
movsd %xmm0, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x4929c
movsd %xmm0, 0x8(%rax,%rdx)
paddq %xmm5, %xmm2
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x4924d
movaps 0x98170(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x492f4
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 0x492e2
movaps 0x98125(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4936c
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x95d5a(%rip), %xmm0    # 0xdf090
xorpd %xmm1, %xmm1
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49347
jnp 0x49364
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49354
jnp 0x49364
ucomisd %xmm1, %xmm2
jne 0x49364
jp 0x49364
movq $0x0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x4933a
movaps 0x980ad(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x493b9
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x493b1
jp 0x493b1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4939f
movaps 0x98060(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x49411
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95c9d(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49400
jnp 0x49409
addsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x493f3
movaps 0x98008(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x4947d
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x95c3e(%rip), %xmm0    # 0xdf090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4945f
jnp 0x49475
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x4946c
jnp 0x49475
addsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49452
movaps 0x97f9c(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x494d5
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95bd9(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x494c4
jnp 0x494cd
subsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x494b7
movaps 0x97f44(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x49541
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x95b7a(%rip), %xmm0    # 0xdf090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49523
jnp 0x49539
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x49530
jnp 0x49539
subsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49516
movaps 0x97ed8(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x49599
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95b15(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49588
jnp 0x49591
mulsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4957b
movaps 0x97e80(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x49605
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x95ab6(%rip), %xmm0    # 0xdf090
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x495e7
jnp 0x495fd
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x495f4
jnp 0x495fd
mulsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x495da
movaps 0x97e14(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x4962f
jp 0x4962f
retq
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x4966a
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x95a44(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49659
jnp 0x49662
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4964c
movaps 0x97daf(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x496e3
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x959e4(%rip), %xmm0    # 0xdf090
xorpd %xmm1, %xmm1
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x496bd
jnp 0x496db
movsd (%rdx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x496ca
jnp 0x496db
ucomisd %xmm1, %xmm3
jne 0x496d2
jnp 0x496db
divsd %xmm3, %xmm2
movsd %xmm2, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x496b0
movaps 0x97d36(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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
movl 0x408(%rdi), %eax
testl %eax, %eax
jle 0x49766
movq 0x410(%rbx), %rcx
xorl %r14d, %r14d
movsd 0x95968(%rip), %xmm1    # 0xdf090
movsd (%rcx,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x49736
jnp 0x4975b
movsd (%rsp), %xmm1
callq 0x22070
movsd 0x95948(%rip), %xmm1    # 0xdf090
movq 0x410(%rbx), %rcx
movsd %xmm0, (%rcx,%r14,8)
movl 0x408(%rbx), %eax
incq %r14
movslq %eax, %rdx
cmpq %rdx, %r14
jl 0x49728
movaps 0x97cb3(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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
movl 0x408(%rdi), %eax
testl %eax, %eax
jle 0x4980b
movq %rsi, %r14
movq 0x410(%rbx), %rcx
xorl %r15d, %r15d
movsd 0x958df(%rip), %xmm2    # 0xdf090
movsd (%rcx,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x497bf
jnp 0x49800
movq 0x410(%r14), %rdx
movsd (%rdx,%r15,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x497d4
jnp 0x49800
ucomisd 0x9589c(%rip), %xmm1    # 0xdf078
jne 0x497e0
jnp 0x49800
callq 0x22070
movsd 0x958a3(%rip), %xmm2    # 0xdf090
movq 0x410(%rbx), %rcx
movsd %xmm0, (%rcx,%r15,8)
movl 0x408(%rbx), %eax
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0x497b1
movaps 0x97c0e(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x8bd1c
movq (%rbx), %rdi
cmpl $0x0, 0x14(%rdi)
jle 0x4989d
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movq %rsp, %r14
movq 0x410(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x4986a
jnp 0x49891
ucomisd 0x9581e(%rip), %xmm0    # 0xdf090
jne 0x49876
jnp 0x49891
movq 0x8(%rdi), %rax
movq (%rax,%r15,8), %rsi
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x8bdb2
movq (%rbx), %rdi
xorpd %xmm1, %xmm1
incq %r15
movslq 0x14(%rdi), %rax
cmpq %rax, %r15
jl 0x49855
movq %rsp, %rsi
xorpd %xmm0, %xmm0
xorl %edx, %edx
callq 0x6057e
movq (%rbx), %rcx
movslq 0x14(%rcx), %rcx
testq %rcx, %rcx
jle 0x498e7
movq 0x410(%rbx), %rdx
xorl %esi, %esi
movsd 0x957c8(%rip), %xmm0    # 0xdf090
movsd (%rdx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x498d5
jnp 0x498df
movsd (%rax,%rsi,8), %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x498c8
testq %rax, %rax
je 0x498f4
movq %rax, %rdi
callq 0x21c00
movaps 0x97b25(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq %rsp, %rdi
callq 0x8bd86
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x49924
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8bd86
movq %rbx, %rdi
callq 0x220a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9787c(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x49c2d
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x954a1(%rip), %xmm3    # 0xdf090
movsd 0x97871(%rip), %xmm4    # 0xe1468
movsd (%rcx,%rdx,8), %xmm5
ucomisd %xmm3, %xmm5
jne 0x49c04
jnp 0x49c25
ucomisd %xmm5, %xmm0
jae 0x49c14
ucomisd %xmm4, %xmm2
movapd %xmm2, %xmm5
jmp 0x49c1c
ucomisd %xmm4, %xmm1
movapd %xmm1, %xmm5
jne 0x49c20
jnp 0x49c25
movsd %xmm5, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49bf7
movaps 0x977ec(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x95426(%rip), %xmm1    # 0xdf090
movapd %xmm1, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movlpd %xmm1, (%rax,%rcx,8)
movaps 0x9779a(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x4884a
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x489dc
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0x408(%rbx), %eax
jne 0x49d97
jp 0x49d97
testl %eax, %eax
jle 0x49dd4
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x95318(%rip), %xmm0    # 0xdf090
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x49d85
jnp 0x49d8d
movq $0x0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49d78
jmp 0x49dd4
testl %eax, %eax
movsd 0x8(%rsp), %xmm3
jle 0x49dd4
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x952de(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x49dbf
jnp 0x49dcc
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x49db2
movaps 0x97645(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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       # 0x49df6
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
movq (%rdi), %rax
cmpl $0x0, 0x14(%rax)
jle 0x49efe
xorl %r15d, %r15d
movsd 0x95230(%rip), %xmm1    # 0xdf090
movq %rsp, %r14
movq 0x410(%rbx), %rcx
movsd (%rcx,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x49e78
jnp 0x49e93
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4b09a
movq (%rbx), %rax
movsd 0x951fd(%rip), %xmm1    # 0xdf090
incq %r15
movslq 0x14(%rax), %rcx
cmpq %rcx, %r15
jl 0x49e63
testl %ecx, %ecx
jle 0x49efe
cmpl $0x0, 0x8(%rsp)
je 0x49efe
movl $0x1, %r15d
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b1ae
leal -0x1(%r15), %ecx
movslq 0x70(%rax), %rax
movq (%rbx), %rdx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movl 0x14(%rdx), %ecx
mulsd 0x951c8(%rip), %xmm0    # 0xdf0a0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movq 0x410(%rbx), %rdx
movsd %xmm0, (%rdx,%rax,8)
cmpl %ecx, %r15d
jge 0x49efe
incl %r15d
cmpl $0x0, 0x8(%rsp)
jne 0x49eb3
movaps 0x9751b(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x49f28
callq 0x21c00
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x49f34
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x49f45
callq 0x21c00
movq %rbx, %rdi
callq 0x220a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4823c
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x49fe4
movq 0x410(%rbx), %rcx
xorl %r12d, %r12d
movq %rsp, %r14
movsd (%rcx,%r12,8), %xmm0
ucomisd 0x95102(%rip), %xmm0    # 0xdf090
jne 0x49f92
jnp 0x49fd8
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x484b6
movslq 0x70(%r15), %rax
movq 0x410(%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
movapd 0x97463(%rip), %xmm0    # 0xe1420
movupd %xmm0, 0x418(%rbx)
movupd %xmm0, 0x428(%rbx)
movupd %xmm0, 0x438(%rbx)
movq (%rbx), %rax
incq %r12
movslq 0x14(%rax), %rdx
cmpq %rdx, %r12
jl 0x49f80
movaps 0x97435(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%rsp), %rdi
testq %rdi, %rdi
je 0x4a012
callq 0x21c00
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 0x4a036
callq 0x21c00
movq %rbx, %rdi
callq 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4823c
movslq 0x408(%rbx), %rdx
testq %rdx, %rdx
jle 0x4a081
movq 0x410(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x21470
movaps 0x97398(%rip), %xmm1    # 0xe1420
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4a1ab
xorl %r12d, %r12d
xorpd %xmm2, %xmm2
movsd 0x94fd7(%rip), %xmm3    # 0xdf090
leaq 0x8(%rsp), %r14
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
movq 0x428(%rsp), %rcx
movsd (%rcx,%r12,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x4a0e2
jnp 0x4a19b
ucomisd %xmm3, %xmm0
jne 0x4a0ee
jnp 0x4a19b
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r15
movq %r14, %rdi
callq 0x8bd1c
movq (%rbx), %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x607cc
testq %rax, %rax
je 0x4a120
movq %rax, %rdi
callq 0x21c00
movslq 0x14(%rsp), %rax
testq %rax, %rax
movaps 0x972f1(%rip), %xmm1    # 0xe1420
movsd 0x94f59(%rip), %xmm2    # 0xdf090
jle 0x4a17d
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 0x4a15c
jnp 0x4a175
movq %r13, (%rdx,%rdi,8)
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
incq %rsi
cmpq %rsi, %rax
jne 0x4a147
movq %r14, %rdi
callq 0x8bd86
movsd 0x94f03(%rip), %xmm3    # 0xdf090
movaps 0x9728c(%rip), %xmm1    # 0xe1420
movq (%rbx), %rax
xorpd %xmm2, %xmm2
incq %r12
movslq 0x14(%rax), %rcx
cmpq %rcx, %r12
jl 0x4a0c8
movups %xmm1, 0x418(%rbx)
movups %xmm1, 0x428(%rbx)
movups %xmm1, 0x438(%rbx)
movq 0x428(%rsp), %rdi
testq %rdi, %rdi
je 0x4a1d2
callq 0x21c00
addq $0x460, %rsp            # imm = 0x460
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x4a1f5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8bd86
movq 0x428(%rsp), %rdi
testq %rdi, %rdi
je 0x4a207
callq 0x21c00
movq %rbx, %rdi
callq 0x220a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x14(%rax), %rax
testq %rax, %rax
jle 0x4a280
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x94e5f(%rip), %xmm1    # 0xdf090
xorpd %xmm2, %xmm2
movsd 0x94de3(%rip), %xmm3    # 0xdf020
movapd 0x971db(%rip), %xmm4    # 0xe1420
movsd (%rcx,%rdx,8), %xmm5
ucomisd %xmm1, %xmm5
jne 0x4a252
jnp 0x4a278
cmpeqsd %xmm2, %xmm5
andpd %xmm3, %xmm5
movlpd %xmm5, (%rcx,%rdx,8)
movupd %xmm4, 0x418(%rbx)
movupd %xmm4, 0x428(%rbx)
movupd %xmm4, 0x438(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x4a245
movq %rbx, %rdi
callq 0x4a03e
movq (%rbx), %rax
movslq 0x14(%rax), %rax
testq %rax, %rax
jle 0x4a2f4
movq 0x410(%rbx), %rcx
xorl %edx, %edx
movsd 0x94deb(%rip), %xmm0    # 0xdf090
xorpd %xmm1, %xmm1
movsd 0x94d6f(%rip), %xmm2    # 0xdf020
movapd 0x97167(%rip), %xmm3    # 0xe1420
movsd (%rcx,%rdx,8), %xmm4
ucomisd %xmm0, %xmm4
jne 0x4a2c6
jnp 0x4a2ec
cmpeqsd %xmm1, %xmm4
andpd %xmm2, %xmm4
movlpd %xmm4, (%rcx,%rdx,8)
movupd %xmm3, 0x418(%rbx)
movupd %xmm3, 0x428(%rbx)
movupd %xmm3, 0x438(%rbx)
incq %rdx
cmpq %rdx, %rax
jne 0x4a2b9
movaps 0x97125(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4823c
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4a312
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x494f2
movaps 0x96e92(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%r14), %rdi
testq %rdi, %rdi
je 0x4a5b4
callq 0x21c00
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x420(%rsp), %rdi
testq %rdi, %rdi
je 0x4a5d4
callq 0x21c00
movq %rbx, %rdi
callq 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4823c
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4a546
movslq 0x418(%rsp), %rax
testq %rax, %rax
jle 0x4a652
movq 0x420(%rsp), %rcx
xorl %edx, %edx
movsd 0x94a64(%rip), %xmm0    # 0xdf090
movapd 0x94e1c(%rip), %xmm1    # 0xdf450
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x4a641
jnp 0x4a64a
andpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4a634
movaps 0x96dc7(%rip), %xmm0    # 0xe1420
leaq 0x10(%rsp), %r14
movups %xmm0, 0x418(%r14)
movups %xmm0, 0x428(%r14)
movups %xmm0, 0x438(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x495b6
movaps 0x96d98(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq 0x410(%r14), %rdi
testq %rdi, %rdi
je 0x4a6ae
callq 0x21c00
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x420(%rsp), %rdi
testq %rdi, %rdi
je 0x4a6ce
callq 0x21c00
movq %rbx, %rdi
callq 0x220a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a6f5
callq 0x21c00
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 0x4a734
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x21470
movaps 0x96ce5(%rip), %xmm0    # 0xe1420
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_O3/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 0x4a772
callq 0x21c00
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), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x408(%rbx)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x21040
movq %rax, 0x410(%rbx)
testq %r15, %r15
jle 0x4a818
movq 0x410(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x4a806
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::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 0x4a874
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x9483a(%rip), %xmm1    # 0xdf090
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4a863
jnp 0x4a86c
mulsd (%rdx,%rsi,8), %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x4a856
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a936
movq %rax, %r15
leaq 0x96662(%rip), %rsi     # 0xe0f03
movq %rax, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4a95f
leaq 0x94ded(%rip), %rsi     # 0xdf6a5
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4a94f
leaq 0x9698a(%rip), %rsi     # 0xe1259
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4a94f
leaq 0x9697c(%rip), %rsi     # 0xe125e
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4a94f
leaq 0x94aae(%rip), %rsi     # 0xdf3a3
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4a96f
movaps 0x96b18(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%r14)
movups %xmm0, 0x428(%r14)
movups %xmm0, 0x438(%r14)
leaq 0x94d9e(%rip), %rdi     # 0xdf6c5
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8e88e
jmp 0x4a947
leaq 0x9659a(%rip), %rdi     # 0xe0ed7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4ac14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4a980
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4ad3e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b991(%rip), %rsi     # 0xe65c3
movq %rbx, %rdi
callq 0x21a90
testq %rax, %rax
je 0x4ad0d
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 0x4ac80
movb $0x0, (%rax)
leaq 0x96cb3(%rip), %rsi     # 0xe193a
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22170
cmpl $0x1, %eax
jne 0x4acfe
leaq 0x96c98(%rip), %r12     # 0xe193a
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq (%r14), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %rbp
jge 0x4ad16
movsd 0x8(%rsp), %xmm0
movq 0x410(%r14), %rax
movsd %xmm0, (%rax,%rbp,8)
movaps 0x96752(%rip), %xmm0    # 0xe1420
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 0x22170
cmpl $0x1, %eax
je 0x4aca9
movq %r15, %rdi
callq 0x218a0
movl $0x1, %ebp
jmp 0x4ad29
leaq 0x967b1(%rip), %rdi     # 0xe14c5
jmp 0x4ad1d
leaq 0x9625e(%rip), %rdi     # 0xe0f7b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebp, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::ReadPoints(char const*)
int R3MeshProperty::
ReadPoints(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
  SetName("Points");

  // Initialize all values to zero
  Clear(0);

  // Assign value 1 to vertices in pid file
  int vertex_index;
  while (fscanf(fp, "%d", &vertex_index) == (unsigned int) 1) {
    if ((vertex_index > 0) && (vertex_index < mesh->NVertices())) {
      SetVertexValue(vertex_index, 1);
    }
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9b86b(%rip), %rsi     # 0xe65c3
movq %r15, %rdi
callq 0x21a90
testq %rax, %rax
je 0x4ae4d
movq %rax, %r14
leaq 0x8(%rbx), %rdi
leaq 0x9676d(%rip), %rsi     # 0xe14e4
movl $0x400, %edx            # imm = 0x400
callq 0x21410
movb $0x0, 0x5b(%rbx)
movslq 0x408(%rbx), %rdx
testq %rdx, %rdx
jle 0x4ada3
movq 0x410(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x21470
movaps 0x96676(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
leaq 0x9b474(%rip), %rsi     # 0xe623a
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x22170
cmpl $0x1, %eax
jne 0x4ae3e
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
leaq 0x9b44f(%rip), %r15     # 0xe623a
leaq 0xc(%rsp), %r12
movslq 0xc(%rsp), %rax
testq %rax, %rax
jle 0x4ae29
movq (%rbx), %rcx
cmpl 0x14(%rcx), %eax
jge 0x4ae29
movq 0x410(%rbx), %rcx
movq %r13, (%rcx,%rax,8)
movaps 0x9660c(%rip), %xmm0    # 0xe1420
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x22170
cmpl $0x1, %eax
je 0x4adf0
movq %r14, %rdi
callq 0x218a0
movl $0x1, %ebx
jmp 0x4ae60
leaq 0x96671(%rip), %rdi     # 0xe14c5
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Write(char const*) const
int R3MeshProperty::
Write(const char *filename) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .arff)\n", filename);
    return 0;
  }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x219a0
testq %rax, %rax
je 0x4aef2
movq %rax, %r15
leaq 0x9606c(%rip), %rsi     # 0xe0f03
movq %rax, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4af1b
leaq 0x947fb(%rip), %rsi     # 0xdf6a5
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4af0b
leaq 0x9639c(%rip), %rsi     # 0xe1259
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4af0b
leaq 0x9638e(%rip), %rsi     # 0xe125e
movq %r15, %rdi
callq 0x21ce0
testl %eax, %eax
je 0x4af0b
leaq 0x94817(%rip), %rdi     # 0xdf6fa
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8e88e
jmp 0x4af03
leaq 0x95fde(%rip), %rdi     # 0xe0ed7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4b008
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4af2c
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::WriteARFF(char const*) const
int R3MeshProperty::
WriteARFF(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open ARFF file: %s\n", filename);
    return 0;
  }

  // Write header
  const char *mesh_name = (mesh->Name()) ? mesh->Name() : "Mesh";
  fprintf(fp, "@relation %s\n\n", mesh_name);

  // Write names
  const char *property_name = (Name()) ? Name() : "Property";
  fprintf(fp, "@attribute %s real\n", property_name);

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

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9844b(%rip), %rsi     # 0xe338c
movq %r15, %rdi
callq 0x21a90
testq %rax, %rax
je 0x4afe6
movq %rax, %r14
movq (%rbx), %rdx
addq $0x78, %rdx
leaq 0x96300(%rip), %rsi     # 0xe1263
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d60
leaq 0x8(%rbx), %rdx
leaq 0x962fa(%rip), %rsi     # 0xe1272
movq %r14, %rdi
xorl %eax, %eax
callq 0x21d60
leaq 0x962fd(%rip), %rdi     # 0xe1286
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22260
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4afd7
xorl %r12d, %r12d
leaq 0x9596b(%rip), %r15     # 0xe0919
movq 0x410(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21d60
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r12
jl 0x4afae
movq %r14, %rdi
callq 0x218a0
movl $0x1, %ebx
jmp 0x4aff9
leaq 0x95f2b(%rip), %rdi     # 0xe0f18
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::WriteValues(char const*) const
int R3MeshProperty::
WriteValues(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open values file: %s\n", filename);
    return 0;
  }

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

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9836f(%rip), %rsi     # 0xe338c
movq %r15, %rdi
callq 0x21a90
testq %rax, %rax
je 0x4b078
movq %rax, %r14
movq (%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x4b069
xorl %r12d, %r12d
leaq 0x958d9(%rip), %r15     # 0xe0919
movq 0x410(%rbx), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21d60
incq %r12
movq (%rbx), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r12
jl 0x4b040
movq %r14, %rdi
callq 0x218a0
movl $0x1, %ebx
jmp 0x4b08b
leaq 0x9637b(%rip), %rdi     # 0xe13fa
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x8e88e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop