LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::SortByName()
void R3MeshPropertySet::
SortByName(void)
{
  // Sort properties
  for (int i = 0; i < properties.NEntries(); i++) {
    for (int j = i+1; j < properties.NEntries(); j++) {
      if (strcmp(properties[i]->Name(), properties[j]->Name()) > 0) {
        R3MeshProperty *swap = properties[i];
        properties.EntryContents(properties.KthEntry(i)) = properties[j];
        properties.EntryContents(properties.KthEntry(j)) = swap;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %eax
xorl %r14d, %r14d
testl %eax, %eax
movl $0x0, %ecx
movl %eax, 0x4(%rsp)
cmovgl %eax, %ecx
movq %rcx, 0x8(%rsp)
pushq $0x1
popq %r13
movq %r13, 0x10(%rsp)
cmpq 0x8(%rsp), %r14
jne 0x4143c
jmp 0x41450
movq 0x8(%rbx), %r12
movq (%r12,%r14,8), %r15
leaq 0x8(%r15), %rdi
movq (%r12,%r13,8), %rbp
leaq 0x8(%rbp), %rsi
callq 0x21d10
testl %eax, %eax
jle 0x41439
movq %rbp, (%r12,%r14,8)
movq 0x8(%rbx), %rax
movq %r15, (%rax,%r13,8)
incq %r13
cmpl %r13d, 0x4(%rsp)
jg 0x41410
incq %r14
movq 0x10(%rsp), %r13
incq %r13
jmp 0x41402
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::operator=(gaps::R3MeshPropertySet const&)
R3MeshPropertySet& R3MeshPropertySet::
operator=(const R3MeshPropertySet& set)
{
  // Delete everything
  Empty();

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

  // Return this
  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x41358
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
xorl %ebp, %ebp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jge 0x414ef
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %r13
movl $0x448, %edi            # imm = 0x448
callq 0x218c0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x42bdc
movq %r15, %rdi
movq %r12, %rsi
callq 0x26aa0
incq %rbp
jmp 0x414b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x448, %esi            # imm = 0x448
movq %r12, %rdi
callq 0x218e0
movq %rbx, %rdi
callq 0x220c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::Read(char const*)
int R3MeshPropertySet::
Read(const char *filename)
{
  // Check mesh
  if (!mesh) {
    RNFail("Property set must be associated with mesh before file can be read: %s\n", filename);
    return 0;
  }
  
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .arff)\n", filename);
    return 0;
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x4159a
movq %rdi, %r14
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x219b0
testq %rax, %rax
je 0x415ad
movq %rax, %r15
leaq 0x89996(%rip), %rsi     # 0xcaedb
movq %rax, %rdi
callq 0x21d10
testl %eax, %eax
je 0x415c6
leaq 0x89989(%rip), %rsi     # 0xcaee1
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x415d6
leaq 0x8997b(%rip), %rsi     # 0xcaee6
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x415e6
leaq 0x8996d(%rip), %rsi     # 0xcaeeb
movq %r15, %rdi
callq 0x21d10
movq %r14, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x415f6
popq %rbx
popq %r14
popq %r15
jmp 0x4230e
leaq 0x898c7(%rip), %rdi     # 0xcae68
movq %rbx, %rsi
xorl %eax, %eax
callq 0x82696
jmp 0x415be
leaq 0x898fb(%rip), %rdi     # 0xcaeaf
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 0x41600
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x418c2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x41e4e
popq %rbx
popq %r14
popq %r15
jmp 0x42002
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::ReadProperty(char const*)
int R3MeshPropertySet::
ReadProperty(const char *filename)
{
  // Create property name
  char name[1024];
  strcpy(name, filename);
  char *start = strrchr(name, '/');
  if (start) start++; 
  else start = name;
  char *end = strrchr(start, '.');
  if (end) *end = '\0';

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

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

  // Add property to set
  Insert(property);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x21800
pushq $0x2f
popq %rsi
movq %r15, %rdi
callq 0x219b0
leaq 0x1(%rax), %r12
testq %rax, %rax
cmoveq %r15, %r12
pushq $0x2e
popq %rsi
movq %r12, %rdi
callq 0x219b0
testq %rax, %rax
je 0x42357
movb $0x0, (%rax)
movl $0x448, %edi            # imm = 0x448
callq 0x218c0
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x42ae4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x44e9e
testl %eax, %eax
je 0x42397
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x26aa0
pushq $0x1
popq %rbp
jmp 0x423aa
leaq 0x88e2a(%rip), %rdi     # 0xcb1c8
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x82696
movl %ebp, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x448, %esi            # imm = 0x448
movq %r15, %rdi
callq 0x218e0
movq %rbx, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::Write(char const*) const
int R3MeshPropertySet::
Write(const char *filename) const
{
  // Check mesh
  if (!mesh) {
    RNFail("Property set must be associated with mesh before file can be written: %s\n", filename);
    return 0;
  }
  
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .arff)\n", filename);
    return 0;
  }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x42498
movq %rdi, %r14
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x219b0
testq %rax, %rax
je 0x424ab
movq %rax, %r15
leaq 0x88ad4(%rip), %rsi     # 0xcaedb
movq %rax, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424c4
leaq 0x88ac3(%rip), %rsi     # 0xcaee1
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424e4
leaq 0x87240(%rip), %rsi     # 0xc9675
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424d4
leaq 0x88a9a(%rip), %rsi     # 0xcaee6
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424f4
leaq 0x88dce(%rip), %rsi     # 0xcb231
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424d4
leaq 0x88dc0(%rip), %rsi     # 0xcb236
movq %r15, %rdi
callq 0x21d10
testl %eax, %eax
je 0x424d4
leaq 0x87241(%rip), %rdi     # 0xc96ca
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x82696
jmp 0x424bc
leaq 0x88d48(%rip), %rdi     # 0xcb1e7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x82696
jmp 0x424bc
leaq 0x889fd(%rip), %rdi     # 0xcaeaf
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 0x42504
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x427cc
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4261a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4290a
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::WriteARFF(char const*) const
int R3MeshPropertySet::
WriteARFF(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open ARFF file: %s\n", filename);
    return 0;
  }

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

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

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

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8ae10(%rip), %rsi     # 0xcd32c
movq %r15, %rdi
callq 0x21a90
testq %rax, %rax
je 0x425f6
movq %rax, %r14
movq (%rbx), %rdx
addq $0x78, %rdx
leaq 0x88cfd(%rip), %rsi     # 0xcb23b
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d80
leaq 0x88cfb(%rip), %r15     # 0xcb24a
xorl %r12d, %r12d
movslq 0x14(%rbx), %rax
cmpq %rax, %r12
jge 0x42579
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
addq $0x8, %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d80
incq %r12
jmp 0x42552
leaq 0x88cde(%rip), %rdi     # 0xcb25e
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x22290
xorl %r12d, %r12d
leaq 0x88ccf(%rip), %r15     # 0xcb267
pushq $0xa
popq %rbp
movq (%rbx), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r12
jge 0x425e9
xorl %r13d, %r13d
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
jge 0x425da
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x410(%rax), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21d80
incq %r13
jmp 0x425aa
movl %ebp, %edi
movq %r14, %rsi
callq 0x21b90
incq %r12
jmp 0x4259b
movq %r14, %rdi
callq 0x218b0
pushq $0x1
popq %rbx
jmp 0x42609
leaq 0x888f3(%rip), %rdi     # 0xcaef0
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x82696
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::WriteValues(char const*) const
int R3MeshPropertySet::
WriteValues(const char *filename) const
{
  // Check number of properties
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);

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

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

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

    // Close file
    fclose(fp);
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp            # imm = 0x618
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq 0x210(%rsp), %r13
leaq 0x880f5(%rip), %rbp     # 0xca8e9
xorl %ecx, %ecx
movslq 0x14(%r15), %r14
cmpq %r14, %rcx
jge 0x428ef
movq 0x8(%r15), %rax
movq %rcx, (%rsp)
movq (%rax,%rcx,8), %r12
movl $0x3ff, %edx            # imm = 0x3FF
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x21420
cmpl $0x2, %r14d
jl 0x42875
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x21420
movq %rbx, %rdi
pushq $0x2e
popq %rsi
callq 0x219b0
leaq 0x889e1(%rip), %r8      # 0xcb231
testq %rax, %rax
je 0x4285b
movb $0x0, (%rax)
movq %rax, %r8
movq %r13, %rdi
leaq 0x88b64(%rip), %rsi     # 0xcb3c9
leaq 0x10(%rsp), %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x21130
movq %r13, %rbx
movq %r13, %rdi
leaq 0x8aaaa(%rip), %rsi     # 0xcd32c
callq 0x21a90
testq %rax, %rax
je 0x428d5
movq %rax, %r13
xorl %r14d, %r14d
movq (%r15), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %r14
jge 0x428be
movq 0x410(%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %r13, %rdi
movq %rbp, %rsi
movb $0x1, %al
callq 0x21d80
incq %r14
jmp 0x42892
movq %r13, %rdi
callq 0x218b0
movq (%rsp), %rcx
incq %rcx
movq %rbx, %r13
jmp 0x427f6
leaq 0x88af6(%rip), %rdi     # 0xcb3d2
leaq 0x210(%rsp), %rsi
xorl %eax, %eax
callq 0x82696
movq (%rsp), %rcx
xorl %eax, %eax
cmpq %r14, %rcx
setge %al
addq $0x618, %rsp            # imm = 0x618
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::R3MeshProperty(gaps::R3Mesh*, char const*, double const*)
R3MeshProperty::
R3MeshProperty(R3Mesh *mesh, const char *name, const RNScalar *vertex_values)
  : mesh(mesh),
    nvalues(0),
    values(NULL)
{
  // Assign property name
  if (name) strncpy(this->name, name, 1023); 
  else sprintf(this->name, "Property%d", next_property_name++);
  this->name[1023] = '\0';
  
  // Assign vertex values
  this->nvalues = mesh->NVertices();
  this->values = new RNScalar [ this->nvalues ];
  if (vertex_values) {
    for (int i = 0; i < mesh->NVertices(); i++) {
      this->values[i] = vertex_values[i];
    }
  }
  else {
    for (int i = 0; i < mesh->NVertices(); i++) {
      this->values[i] = 0;
    }
  }

  // Reset statistics
  ResetStatistics();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
andl $0x0, 0x408(%rdi)
andq $0x0, 0x410(%rdi)
movq %rcx, %r14
addq $0x8, %rdi
testq %rdx, %rdx
je 0x42b1c
movq %rdx, %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x21420
jmp 0x42b39
movl 0xf1f2e(%rip), %edx     # 0x134a50
leal 0x1(%rdx), %eax
movl %eax, 0xf1f25(%rip)     # 0x134a50
leaq 0x88906(%rip), %rsi     # 0xcb438
xorl %eax, %eax
callq 0x21130
movb $0x0, 0x407(%rbx)
movslq 0x14(%r15), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x408(%rbx)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x21040
movq %rax, 0x410(%rbx)
xorl %ecx, %ecx
testl %r15d, %r15d
cmovgl %r15d, %ecx
xorl %edx, %edx
testq %r14, %r14
je 0x42b96
cmpq %rdx, %rcx
je 0x42b9b
movsd (%r14,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x42b79
andq $0x0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x42b8e
movaps 0x8885e(%rip), %xmm0    # 0xcb400
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_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::R3MeshProperty(gaps::R3MeshProperty const&)
R3MeshProperty::
R3MeshProperty(const R3MeshProperty& property)
  : mesh(property.mesh),
    nvalues(0),
    values(NULL),
    mean(property.mean),
    stddev(property.stddev),
    minimum(property.minimum),
    maximum(property.maximum),
    median(property.median),
    l2norm(property.l2norm)
{
  // Copy property name
  strcpy(this->name, property.name);
  
  // Copy vertex values
  this->nvalues = mesh->NVertices();
  this->values = new RNScalar [ this->nvalues ];
  for (int i = 0; i < mesh->NVertices(); i++) {
    this->values[i] = property.values[i];
  }
}

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

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

  // Return mean
  return mean;
}

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

  // Return minimum
  return minimum;
}

// Assembly:
movsd 0x428(%rdi), %xmm0
ucomisd 0x85e90(%rip), %xmm0    # 0xc9088
jne 0x43267
jp 0x43267
andq $0x0, 0x428(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x43263
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
movq %rcx, 0x428(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x87a40(%rip), %xmm0    # 0xcac70
xorl %edx, %edx
movsd 0x85e4e(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x43267
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x4324c
jnp 0x4325e
ucomisd %xmm2, %xmm0
jbe 0x4325e
movsd %xmm2, 0x428(%rdi)
movapd %xmm2, %xmm0
incq %rdx
jmp 0x4323a
xorpd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Maximum() const
RNScalar R3MeshProperty::
Maximum(void) const
{
  // Compute maximum of property values
  if (maximum == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->maximum = 0;
    if (nvalues > 0) {
      property->maximum = -FLT_MAX;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        if (values[i] > property->maximum) property->maximum = values[i];
      }
    }
  }

  // Return maximum
  return maximum;
}

// Assembly:
movsd 0x430(%rdi), %xmm0
ucomisd 0x85e10(%rip), %xmm0    # 0xc9088
jne 0x432e7
jp 0x432e7
andq $0x0, 0x430(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x432e3
movabsq $-0x3810000020000000, %rcx # imm = 0xC7EFFFFFE0000000
movq %rcx, 0x430(%rdi)
movq 0x410(%rdi), %rcx
movsd 0x879c8(%rip), %xmm0    # 0xcac78
xorl %edx, %edx
movsd 0x85dce(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x432e7
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x432cc
jnp 0x432de
ucomisd %xmm0, %xmm2
jbe 0x432de
movsd %xmm2, 0x430(%rdi)
movapd %xmm2, %xmm0
incq %rdx
jmp 0x432ba
xorpd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::StandardDeviation() const
RNScalar R3MeshProperty::
StandardDeviation(void) const
{
  // Compute standard deviation of property values
  if (stddev == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->stddev = 0;
    if (nvalues > 0) {
      // Comute sum of squared residuals
      int count = 0;
      RNScalar ssd = 0;
      RNScalar avg = Mean();
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        RNScalar delta = values[i] - avg;
        ssd += delta * delta;
        count++;
      }

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

  // Return standard deviation
  return stddev;
}

// Assembly:
pushq %rbx
movsd 0x420(%rdi), %xmm0
ucomisd 0x85d8f(%rip), %xmm0    # 0xc9088
jne 0x433bf
jp 0x433bf
movq %rdi, %rbx
andq $0x0, 0x420(%rdi)
cmpl $0x0, 0x408(%rdi)
jle 0x4339e
movq %rbx, %rdi
callq 0x4315a
movl 0x408(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq 0x410(%rbx), %rdx
xorpd %xmm1, %xmm1
movsd 0x85d43(%rip), %xmm2    # 0xc9088
xorl %esi, %esi
cmpq %rcx, %rax
je 0x43382
movsd (%rdx,%rcx,8), %xmm4
ucomisd %xmm2, %xmm4
movapd %xmm4, %xmm3
subsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
jne 0x4336d
jp 0x4336d
movapd %xmm1, %xmm3
cmpneqsd %xmm2, %xmm4
movq %xmm4, %rdi
subl %edi, %esi
incq %rcx
movapd %xmm3, %xmm1
jmp 0x43347
testl %esi, %esi
je 0x433a4
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x433ae
sqrtsd %xmm1, %xmm0
jmp 0x433b7
xorpd %xmm0, %xmm0
jmp 0x433bf
movsd 0x420(%rbx), %xmm0
jmp 0x433bf
movapd %xmm1, %xmm0
callq 0x216a0
movsd %xmm0, 0x420(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::Percentile(double) const
RNScalar R3MeshProperty::
Percentile(RNScalar percentile) const
{
  // Compute value at given percentile (100=max, 0=min)
  if (nvalues == 0) return 0;

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

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

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

  // Delete copy
  delete [] copy;

  // Return result
  return result;
}

// Assembly:
movslq 0x408(%rdi), %rax
xorpd %xmm1, %xmm1
testq %rax, %rax
je 0x43657
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movsd %xmm0, (%rsp)
movq %rax, %rcx
shlq $0x3, %rcx
xorl %r15d, %r15d
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
movl $0x0, %r12d
cmovgl %eax, %r12d
callq 0x21040
movq %rax, %rbx
movq 0x410(%r14), %rax
movsd 0x85ab8(%rip), %xmm0    # 0xc9088
xorl %r14d, %r14d
movslq %r14d, %rsi
cmpq %r15, %r12
je 0x435f7
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x435e9
jnp 0x435f2
leal 0x1(%rsi), %r14d
movsd %xmm1, (%rbx,%rsi,8)
incq %r15
jmp 0x435d3
testl %r14d, %r14d
xorpd %xmm1, %xmm1
je 0x4364c
leaq 0x3e542(%rip), %rcx     # 0x81b49
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x22220
cvtsi2sd %r14d, %xmm0
mulsd (%rsp), %xmm0
divsd 0x85a74(%rip), %xmm0    # 0xc9098
cvttsd2si %xmm0, %eax
leal -0x1(%r14), %ecx
cmpl %eax, %r14d
cmovgl %eax, %ecx
movslq %ecx, %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x21c00
movsd (%rsp), %xmm1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::LocalMinimumCount() const
int R3MeshProperty::
LocalMinimumCount(void) const
{
  // Count values that are minima
  int count = 0;
  for (int i = 0; i < mesh->NVertices(); i++) 
    if (IsLocalMinimum(i)) count++;
  return count;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movq (%r14), %rax
cmpl 0x14(%rax), %ebp
jge 0x436b3
movq %r14, %rdi
movl %ebp, %esi
callq 0x45616
cmpl $0x1, %eax
sbbl $-0x1, %ebx
incl %ebp
jmp 0x43697
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::LocalMaximumCount() const
int R3MeshProperty::
LocalMaximumCount(void) const
{
  // Count values that are maxima
  int count = 0;
  for (int i = 0; i < mesh->NVertices(); i++) 
    if (IsLocalMaximum(i)) count++;
  return count;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
movq (%r14), %rax
cmpl 0x14(%rax), %ebp
jge 0x436e1
movq %r14, %rdi
movl %ebp, %esi
callq 0x4562a
cmpl $0x1, %eax
sbbl $-0x1, %ebx
incl %ebp
jmp 0x436c5
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x14(%rax), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movq 0x410(%rdi), %rsi
xorpd %xmm0, %xmm0
movsd 0x85980(%rip), %xmm1    # 0xc9088
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x43731
movsd (%rsi,%rdx,8), %xmm2
movapd %xmm2, %xmm3
cmpneqpd %xmm0, %xmm3
cmpneqpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %edi
subl %edi, %eax
incq %rdx
jmp 0x4370a
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x408(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq 0x410(%rdi), %rdx
xorpd %xmm0, %xmm0
movapd 0x85cfe(%rip), %xmm1    # 0xc9450
movsd 0x8592e(%rip), %xmm2    # 0xc9088
cmpq %rcx, %rax
je 0x4378e
movsd (%rdx,%rcx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm1, %xmm4
addsd %xmm0, %xmm4
cmpeqsd %xmm2, %xmm3
movapd %xmm3, %xmm5
andnpd %xmm4, %xmm5
andpd %xmm0, %xmm3
orpd %xmm5, %xmm3
incq %rcx
movapd %xmm3, %xmm0
jmp 0x4375a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshProperty.cpp
// Function: gaps::R3MeshProperty::L2Norm() const
RNScalar R3MeshProperty::
L2Norm(void) const
{
  // Compute L2 norm of property values
  if (l2norm == RN_UNKNOWN) {
    R3MeshProperty *property = (R3MeshProperty *) this;
    property->l2norm = 0;
    if (nvalues > 0) {
      // Compute sum 
      RNScalar sum = 0;
      for (int i = 0; i < nvalues; i++) {
        if (values[i] == RN_UNKNOWN) continue;
        sum += values[i] * values[i];
      }

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

  // Return l2norm
  return l2norm;
}

// Assembly:
pushq %rbx
movsd 0x440(%rdi), %xmm0
ucomisd 0x858e7(%rip), %xmm0    # 0xc9088
jne 0x43830
jp 0x43830
movq %rdi, %rbx
andq $0x0, 0x440(%rdi)
movslq 0x408(%rdi), %rax
testq %rax, %rax
jle 0x4381d
movq 0x410(%rbx), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x858af(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x4380d
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
incq %rdx
movapd %xmm2, %xmm0
jmp 0x437d9
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x43823
sqrtsd %xmm0, %xmm0
jmp 0x43828
xorpd %xmm0, %xmm0
jmp 0x43830
callq 0x216a0
movsd %xmm0, 0x440(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x8583e(%rip), %xmm0    # 0xc9088
movapd 0x85bfe(%rip), %xmm1    # 0xc9450
cmpq %rax, %rdx
jge 0x43872
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43864
jnp 0x4386d
andpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x43852
movaps 0x87b87(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movsd 0x857e6(%rip), %xmm1    # 0xc9088
xorpd %xmm2, %xmm2
movapd 0x85bb2(%rip), %xmm3    # 0xc9460
movslq 0x408(%rbx), %rax
cmpq %rax, %r14
jge 0x43946
movq 0x410(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x438d3
jnp 0x4393e
ucomisd %xmm2, %xmm0
jae 0x438f1
movsd 0x87b3f(%rip), %xmm4    # 0xcb420
ucomisd %xmm0, %xmm4
xorpd %xmm3, %xmm0
jb 0x438f9
sqrtsd %xmm0, %xmm0
jmp 0x43912
jb 0x43918
sqrtsd %xmm0, %xmm0
jmp 0x43931
callq 0x216a0
movapd 0x85b5a(%rip), %xmm3    # 0xc9460
xorpd %xmm2, %xmm2
movsd 0x85776(%rip), %xmm1    # 0xc9088
xorpd %xmm3, %xmm0
jmp 0x43931
callq 0x216a0
movapd 0x85b3b(%rip), %xmm3    # 0xc9460
xorpd %xmm2, %xmm2
movsd 0x85757(%rip), %xmm1    # 0xc9088
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x438ae
movaps 0x87ab3(%rip), %xmm0    # 0xcb400
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_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x85706(%rip), %xmm0    # 0xc9088
cmpq %rax, %rdx
jge 0x439a2
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x43994
jnp 0x4399d
mulsd %xmm1, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
jmp 0x43982
movaps 0x87a57(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x856b0(%rip), %xmm0    # 0xc9088
movapd 0x85a80(%rip), %xmm1    # 0xc9460
cmpq %rax, %rdx
jge 0x43a00
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x439f2
jnp 0x439fb
xorpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x439e0
movaps 0x879f9(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x85652(%rip), %xmm0    # 0xc9088
xorpd %xmm1, %xmm1
movsd 0x855de(%rip), %xmm2    # 0xc9020
cmpq %rax, %rdx
jge 0x43a6e
movsd (%rcx,%rdx,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x43a54
jnp 0x43a69
ucomisd %xmm1, %xmm3
jne 0x43a5c
jnp 0x43a69
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rcx,%rdx,8)
incq %rdx
jmp 0x43a42
movaps 0x8798b(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq 0x410(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x43aab
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x43a9c
movaps 0x8794e(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rsi), %rcx
movq 0x410(%rdi), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x43af3
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x43adf
movaps 0x87906(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x85559(%rip), %xmm0    # 0xc9088
xorpd %xmm1, %xmm1
cmpq %rax, %rsi
jge 0x43b64
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43b45
jnp 0x43b5f
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43b52
jnp 0x43b5f
ucomisd %xmm1, %xmm2
jne 0x43b5f
jp 0x43b5f
andq $0x0, (%rcx,%rsi,8)
incq %rsi
jmp 0x43b33
movaps 0x87895(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x43bae
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43ba9
jp 0x43ba9
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
jmp 0x43b92
movaps 0x8784b(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x408(%rdi), %eax
movq 0x410(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x854a0(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x43c08
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x43bfa
jnp 0x43c03
addsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x43be8
movaps 0x877f1(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x85443(%rip), %xmm0    # 0xc9088
cmpq %rax, %rsi
jge 0x43c72
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x43c57
jnp 0x43c6d
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43c64
jnp 0x43c6d
addsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
jmp 0x43c45
movaps 0x87787(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
xorl %edx, %edx
movsd 0x853e0(%rip), %xmm1    # 0xc9088
cmpq %rax, %rdx
jge 0x43cc8
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x43cba
jnp 0x43cc3
subsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x43ca8
movaps 0x87731(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x85383(%rip), %xmm0    # 0xc9088
cmpq %rax, %rsi
jge 0x43d32
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x43d17
jnp 0x43d2d
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43d24
jnp 0x43d2d
subsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
jmp 0x43d05
movaps 0x876c7(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x408(%rdi), %eax
movq 0x410(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x8531c(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x43d8c
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x43d7e
jnp 0x43d87
mulsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x43d6c
movaps 0x8766d(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x852bf(%rip), %xmm0    # 0xc9088
cmpq %rax, %rsi
jge 0x43df6
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x43ddb
jnp 0x43df1
movsd (%rdx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43de8
jnp 0x43df1
mulsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rsi,8)
incq %rsi
jmp 0x43dc9
movaps 0x87603(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43e21
jp 0x43e21
retq
movl 0x408(%rdi), %eax
movq 0x410(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x8524b(%rip), %xmm1    # 0xc9088
cmpq %rdx, %rax
je 0x43e5d
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm1, %xmm2
jne 0x43e4f
jnp 0x43e58
divsd %xmm0, %xmm2
movsd %xmm2, (%rcx,%rdx,8)
incq %rdx
jmp 0x43e3d
movaps 0x8759c(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x410(%rdi), %rcx
movq 0x410(%rsi), %rdx
xorl %esi, %esi
movsd 0x851ef(%rip), %xmm0    # 0xc9088
xorpd %xmm1, %xmm1
cmpq %rax, %rsi
jge 0x43ed2
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x43eaf
jnp 0x43ecd
movsd (%rdx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jne 0x43ebc
jnp 0x43ecd
ucomisd %xmm1, %xmm3
jne 0x43ec4
jnp 0x43ecd
divsd %xmm3, %xmm2
movsd %xmm2, (%rcx,%rsi,8)
incq %rsi
jmp 0x43e9d
movaps 0x87527(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rdi)
movups %xmm0, 0x428(%rdi)
movups %xmm0, 0x438(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movsd 0x85181(%rip), %xmm1    # 0xc9088
movslq 0x408(%rbx), %rax
cmpq %rax, %r14
jge 0x43f4c
movq 0x410(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x43f28
jnp 0x43f47
movsd (%rsp), %xmm1
callq 0x22090
movsd 0x8514e(%rip), %xmm1    # 0xc9088
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x43f07
movaps 0x874ad(%rip), %xmm0    # 0xcb400
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_O2/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 %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movsd 0x85102(%rip), %xmm2    # 0xc9088
movslq 0x408(%rbx), %rax
cmpq %rax, %r15
jge 0x43fe7
movq 0x410(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x43fa7
jnp 0x43fe2
movq 0x410(%r14), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm2, %xmm1
jne 0x43fbc
jnp 0x43fe2
ucomisd 0x86e9c(%rip), %xmm1    # 0xcae60
jne 0x43fc8
jnp 0x43fe2
callq 0x22090
movsd 0x850b3(%rip), %xmm2    # 0xc9088
movq 0x410(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x43f86
movaps 0x87412(%rip), %xmm0    # 0xcb400
movups %xmm0, 0x418(%rbx)
movups %xmm0, 0x428(%rbx)
movups %xmm0, 0x438(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop