LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::GroundTruthLabel() const
R3SurfelLabel *R3SurfelObject::
GroundTruthLabel(void) const
{
  // Return ground truth label
  R3SurfelLabelAssignment *assignment = GroundTruthLabelAssignment();
  if (assignment) return assignment->Label();
  return NULL;
}

// Assembly:
movslq 0x5c(%rdi), %rax
testq %rax, %rax
jle 0x17866
movq 0x50(%rdi), %rdx
movsd 0xc693f(%rip), %xmm0    # 0xde178
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rdx,%rsi,8), %rdi
cmpl $0x2, 0x40(%rdi)
jne 0x1785c
movsd 0x38(%rdi), %xmm1
ucomisd %xmm0, %xmm1
maxsd %xmm0, %xmm1
cmovaq %rdi, %rcx
movapd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x1783d
jmp 0x17868
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x17872
movq 0x28(%rcx), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::HumanLabel() const
R3SurfelLabel *R3SurfelObject::
HumanLabel(void) const
{
  // Return human generated label
  R3SurfelLabelAssignment *assignment = HumanLabelAssignment();
  if (assignment) return assignment->Label();
  return NULL;
}

// Assembly:
movslq 0x5c(%rdi), %rax
testq %rax, %rax
jle 0x178b8
movq 0x50(%rdi), %rdx
movsd 0xc68ed(%rip), %xmm0    # 0xde178
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rdx,%rsi,8), %rdi
cmpl $0x0, 0x40(%rdi)
jne 0x178ae
movsd 0x38(%rdi), %xmm1
ucomisd %xmm0, %xmm1
maxsd %xmm0, %xmm1
cmovaq %rdi, %rcx
movapd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x1788f
jmp 0x178ba
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x178c4
movq 0x28(%rcx), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::PredictedLabel() const
R3SurfelLabel *R3SurfelObject::
PredictedLabel(void) const
{
  // Return predicted label
  R3SurfelLabelAssignment *assignment = PredictedLabelAssignment();
  if (assignment) return assignment->Label();
  return NULL;
}

// Assembly:
movslq 0x5c(%rdi), %rax
testq %rax, %rax
jle 0x1790a
movq 0x50(%rdi), %rdx
movsd 0xc689b(%rip), %xmm0    # 0xde178
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rdx,%rsi,8), %rdi
cmpl $0x1, 0x40(%rdi)
jne 0x17900
movsd 0x38(%rdi), %xmm1
ucomisd %xmm0, %xmm1
maxsd %xmm0, %xmm1
cmovaq %rdi, %rcx
movapd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x178e1
jmp 0x1790c
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x17916
movq 0x28(%rcx), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::BestLabel(int) const
R3SurfelLabel *R3SurfelObject::
BestLabel(int originator) const
{
  // Return best label with given origniator
  R3SurfelLabelAssignment *assignment = BestLabelAssignment(originator);
  if (assignment) return assignment->Label();
  return NULL;
}

// Assembly:
movslq 0x5c(%rdi), %rax
testq %rax, %rax
jle 0x17977
movq 0x50(%rdi), %rdx
movsd 0xc682f(%rip), %xmm0    # 0xde178
xorl %edi, %edi
xorl %ecx, %ecx
movq (%rdx,%rdi,8), %r8
cmpl %esi, 0x40(%r8)
jne 0x1796d
movsd 0x38(%r8), %xmm1
ucomisd %xmm0, %xmm1
maxsd %xmm0, %xmm1
cmovaq %r8, %rcx
movapd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x1794d
jmp 0x17979
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x17983
movq 0x28(%rcx), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::BestOrientedBBox(int) const
R3OrientedBox R3SurfelObject::
BestOrientedBBox(int originator) const
{
  // Return best OBB (or an empty box if there is none)
  RNScalar best_confidence = -FLT_MAX;
  R3OrientedBox best_obb = R3null_oriented_box;
  for (int i = 0; i < properties.NEntries(); i++) {
    R3SurfelObjectProperty *property = properties.Kth(i);
    if (property->Type() != R3_SURFEL_OBJECT_AMODAL_OBB_PROPERTY) continue;
    if (property->NOperands() != 20) continue;
    int orig = (int) (property->Operand(16) + 0.5);
    if (orig != originator) continue;
    RNScalar confidence = property->Operand(15);
    if (confidence > best_confidence) {
      R3Point centroid(property->Operand(0), property->Operand(1), property->Operand(2));
      R3Vector axis1(property->Operand(3), property->Operand(4), property->Operand(5));
      R3Vector axis2(property->Operand(6), property->Operand(7), property->Operand(8));
      // R3Vector axis3(property->Operand(9), property->Operand(10), property->Operand(11));
      RNScalar radius1 = property->Operand(12);
      RNScalar radius2 = property->Operand(13);
      RNScalar radius3 = property->Operand(14);
      best_obb.Reset(centroid, axis1, axis2, radius1, radius2, radius3);
      best_confidence = confidence;
    }
  }

  // Return best obb
  return best_obb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11dded(%rip), %rsi    # 0x135790
callq 0x6cb2e
cmpl $0x0, 0x3c(%r14)
jle 0x17ab6
movsd 0xc67bd(%rip), %xmm0    # 0xde178
xorl %r15d, %r15d
movsd 0xc677a(%rip), %xmm2    # 0xde140
leaq 0x40(%rsp), %r13
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %r12
cmpl $0x2, 0x2c(%r12)
jne 0x17aa6
cmpl $0x14, 0x28(%r12)
jne 0x17aa6
movq 0x20(%r12), %rax
movsd 0x80(%rax), %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
cmpl %ebp, %ecx
jne 0x17aa6
movsd 0x78(%rax), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x17aa6
movsd %xmm1, 0x8(%rsp)
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0x28(%rsp), %rdi
callq 0x84d7e
movq 0x20(%r12), %rax
movsd 0x18(%rax), %xmm0
movsd 0x20(%rax), %xmm1
movsd 0x28(%rax), %xmm2
leaq 0x10(%rsp), %rdi
callq 0x85816
movq 0x20(%r12), %rax
movsd 0x30(%rax), %xmm0
movsd 0x38(%rax), %xmm1
movsd 0x40(%rax), %xmm2
movq %r13, %rdi
callq 0x85816
movq 0x20(%r12), %rax
movsd 0x60(%rax), %xmm0
movsd 0x68(%rax), %xmm1
movsd 0x70(%rax), %xmm2
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
callq 0x6ddac
movsd 0x8(%rsp), %xmm0
movsd 0xc669a(%rip), %xmm2    # 0xde140
incq %r15
movslq 0x3c(%r14), %rax
cmpq %rax, %r15
jl 0x179cb
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17ace
jmp 0x17ace
jmp 0x17ace
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ede0
movq %r14, %rdi
callq 0x138b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::CurrentOrientedBBox() const
R3OrientedBox R3SurfelObject::
CurrentOrientedBBox(void) const
{
  // Return best obb (either human or predicted)
  R3OrientedBox human_obb = HumanOrientedBBox();
  if (!human_obb.IsEmpty()) return human_obb;
  R3OrientedBox predicted_obb = PredictedOrientedBBox();
  if (!predicted_obb.IsEmpty()) return predicted_obb;
  return EstimateOrientedBBox((R3SurfelObject *) this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x17986
movsd 0x70(%r15), %xmm0
movsd 0x78(%r15), %xmm1
minsd 0x68(%r15), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x17b70
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x6cb2e
jmp 0x17bc0
movq %rsp, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x17986
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
minsd 0x68(%rsp), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x17bad
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cb2e
jmp 0x17bb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2839a
movq %rsp, %rdi
callq 0x6ede0
leaq 0x80(%rsp), %rdi
callq 0x6ede0
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6ede0
jmp 0x17bef
jmp 0x17bec
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x6ede0
movq %rbx, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::operator=(gaps::R3SurfelObject const&)
R3SurfelObject& R3SurfelObject::
operator=(const R3SurfelObject& object)
{
  // Copy properties
  this->feature_vector = object.feature_vector;
  this->name = (object.name) ? RNStrdup(object.name) : NULL;
  this->identifier = object.identifier;
  this->complexity = object.complexity;
  this->bbox = object.bbox;
  this->timestamp_range = object.timestamp_range;
  this->flags = 0;

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x70, %rsi
addq $0x70, %rdi
callq 0x3e6de
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x17c2e
callq 0xadc0f
jmp 0x17c30
xorl %eax, %eax
movq %rax, 0x88(%rbx)
movl 0x90(%r14), %eax
movl %eax, 0x90(%rbx)
movsd 0x98(%r14), %xmm0
movsd %xmm0, 0x98(%rbx)
movl $0xa8, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x850ec
movl $0xc0, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x850ec
movups 0xd8(%r14), %xmm0
movups %xmm0, 0xd8(%rbx)
movq $0x0, 0xe8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::SetParent(gaps::R3SurfelObject*)
void R3SurfelObject::
SetParent(R3SurfelObject *parent)
{
  // Just checking
  // assert(parent);
  // assert(this->parent);
  assert(!this->parent || (scene == this->parent->scene));
  assert(!parent || !this->parent || (parent->scene == this->parent->scene));
  if (parent == this->parent) return;

  // Invalidate bounding boxes starting at current parent
  R3SurfelObject *ancestor = this->parent;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamps starting at current parent
  ancestor = this->parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate bounding boxes starting at new parent
  ancestor = parent;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp ranges starting at new parent
  ancestor = parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Update hierarchy
  if (this->parent) this->parent->parts.Remove(this);
  if (parent) parent->parts.Insert(this);
  this->parent = parent;

  // Mark scene as dirty
  if (scene) scene->SetDirty();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r12
cmpq %rsi, %r12
je 0x17dc6
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
testq %r12, %r12
je 0x17cf1
movsd 0xc64a2(%rip), %xmm0    # 0xde170
movq %r12, %rcx
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17ce1
jnp 0x17cf1
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17cd1
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x17d22
movsd 0xc646e(%rip), %xmm0    # 0xde170
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17d12
jnp 0x17d22
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17d02
testq %r14, %r14
je 0x17d75
movsd 0xc6441(%rip), %xmm0    # 0xde170
movq %r14, %rcx
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17d42
jnp 0x17d52
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17d32
movq %r14, %rcx
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17d65
jnp 0x17d75
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17d55
testq %r12, %r12
je 0x17d9d
leaq 0x20(%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xaafac
subq 0x20(%r12), %rax
shrq $0x3, %rax
movq %r15, %rdi
movl %eax, %esi
callq 0xab13e
testq %r14, %r14
je 0x17db2
leaq 0x20(%r14), %rdi
movl 0x2c(%r14), %edx
movq %rbx, %rsi
callq 0xaafca
movq %r14, 0x18(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x17dc6
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::SetName(char const*)
void R3SurfelObject::
SetName(const char *name)
{
  // Delete previous name
  if (this->name) free(this->name);
  this->name = (name) ? RNStrdup(name) : NULL;

  // Mark scene as dirty
  if (scene) scene->SetDirty();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x17ded
callq 0x135e0
testq %r14, %r14
je 0x17dfc
movq %r14, %rdi
callq 0xadc0f
jmp 0x17dfe
xorl %eax, %eax
movq %rax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x17e15
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::InsertNode(gaps::R3SurfelNode*)
void R3SurfelObject::
InsertNode(R3SurfelNode *node)
{
  // Just checking
  assert(node);
  assert(!nodes.FindEntry(node));
  assert(node->object == NULL);

  // Update node
  node->object = this;

  // Insert node
  nodes.Insert(node);

  // Update complexity
  complexity += node->Complexity();

  // Invalidate bounding box
  R3SurfelObject *ancestor = this;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp range
  ancestor = this;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Update node
  node->UpdateAfterInsert(this);

  // Mark scene as dirty
  if (scene) scene->SetDirty();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsi)
addq $0x60, %rdi
movl 0x6c(%rbx), %edx
callq 0xaafca
movq %r14, %rdi
callq 0x3770e
addsd 0x98(%rbx), %xmm0
movsd %xmm0, 0x98(%rbx)
movsd 0xc62b0(%rip), %xmm0    # 0xde170
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rbx, %rcx
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17edd
jnp 0x17eed
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17ecd
movq %rbx, %rcx
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17f00
jnp 0x17f10
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x17ef0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x17f20
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::SetMarks(int)
void R3SurfelObject::
SetMarks(RNBoolean mark)
{
  // Set mark for all nodes
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->SetMarks(mark);
  }
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x17f5c
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x60(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x40(%rax)
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0x17f3b
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::ReadBlocks(int)
void R3SurfelObject::
ReadBlocks(RNBoolean entire_subtree)
{
  // Read blocks in object
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->ReadBlocks(entire_subtree);
  }
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x17f91
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x60(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x37fa6
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0x17f71
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::ReleaseBlocks(int)
void R3SurfelObject::
ReleaseBlocks(RNBoolean entire_subtree)
{
  // Release blocks in object
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->ReleaseBlocks(entire_subtree);
  }
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x17fc5
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x60(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x3803a
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0x17fa5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::AreBlocksResident() const
RNBoolean R3SurfelObject::
AreBlocksResident(void) const
{
  // Return whether blocks are in memory
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    if (!node->AreBlocksResident()) return FALSE;
  }

  // All blocks are resident
  return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x6c(%rdi)
setle %bpl
jle 0x1800e
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0x3810e
testl %eax, %eax
je 0x1800e
movl $0x1, %r14d
movslq 0x6c(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jge 0x1800e
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3810e
incq %r14
testl %eax, %eax
jne 0x17fed
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::Draw(gaps::RNFlags) const
void R3SurfelObject::
Draw(RNFlags flags) const
{
  // Draw all nodes
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->Draw(flags);
  }
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x1804e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x60(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0x1802c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::DrawResidentDescendents(gaps::RNFlags) const
void R3SurfelObject::
DrawResidentDescendents(RNFlags flags) const
{
  // Draw all nodes
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->DrawResidentDescendents(flags);
  }
}

// Assembly:
cmpl $0x0, 0x6c(%rdi)
jle 0x18086
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x60(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
incq %r15
movslq 0x6c(%r14), %rax
cmpq %rax, %r15
jl 0x18064
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::Print(_IO_FILE*, char const*, char const*) const
void R3SurfelObject::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print object
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "%d %s", SceneIndex(), (Name()) ? Name() : "-");
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

  // Print all nodes
  for (int i = 0; i < NNodes(); i++) {
    R3SurfelNode *node = Node(i);
    node->Print(fp, prefix, suffix);
  }
  fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rsi, %rsi
jne 0x180ac
movq 0x11bec7(%rip), %rax    # 0x133f70
movq (%rax), %r15
testq %r14, %r14
je 0x180bc
movq %r14, %rdi
movq %r15, %rsi
callq 0x135b0
movl 0x10(%r12), %edx
movq 0x88(%r12), %rax
testq %rax, %rax
leaq 0xc6273(%rip), %rcx     # 0xde346
cmovneq %rax, %rcx
leaq 0xc6262(%rip), %rsi     # 0xde340
movq %r15, %rdi
xorl %eax, %eax
callq 0x13740
testq %rbx, %rbx
je 0x180f8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x135b0
movl $0xa, %edi
movq %r15, %rsi
callq 0x13670
cmpl $0x0, 0x6c(%r12)
jle 0x18135
xorl %r13d, %r13d
movq 0x60(%r12), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x60(%rax)
incq %r13
movslq 0x6c(%r12), %rax
cmpq %rax, %r13
jl 0x18110
movl $0xa, %edi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateAfterInsert(gaps::R3SurfelScene*)
void R3SurfelObject::
UpdateAfterInsert(R3SurfelScene *scene)
{
  // Invalidate bounding boxes
  R3SurfelObject *ancestor = parent;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp ranges
  ancestor = parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }
}

// Assembly:
movq 0x18(%rdi), %rcx
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
testq %rcx, %rcx
je 0x18187
movsd 0xc6009(%rip), %xmm0    # 0xde170
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x18177
jnp 0x18187
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x18167
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x181b8
movsd 0xc5fd8(%rip), %xmm0    # 0xde170
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x181a8
jnp 0x181b8
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x18198
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateBeforeRemove(gaps::R3SurfelScene*)
void R3SurfelObject::
UpdateBeforeRemove(R3SurfelScene *scene)
{
  // Invalidate bounding boxes
  R3SurfelObject *ancestor = parent;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp ranges
  ancestor = parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }
}

// Assembly:
movq 0x18(%rdi), %rcx
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
testq %rcx, %rcx
je 0x181f5
movsd 0xc5f9b(%rip), %xmm0    # 0xde170
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x181e5
jnp 0x181f5
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x181d5
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x18226
movsd 0xc5f6a(%rip), %xmm0    # 0xde170
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x18216
jnp 0x18226
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x18206
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateBeforeRemoveObjectProperty(gaps::R3SurfelObjectProperty*)
void R3SurfelObject::
UpdateBeforeRemoveObjectProperty(R3SurfelObjectProperty *property)
{
  // Just checking
  assert(property->Scene());
  assert(property->Scene() == scene);

  // Remove property
  properties.Remove(property);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0xaafac
subq 0x30(%rbx), %rax
shrq $0x3, %rax
movq %r14, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xab13e
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateBeforeRemoveObjectRelationship(gaps::R3SurfelObjectRelationship*)
void R3SurfelObject::
UpdateBeforeRemoveObjectRelationship(R3SurfelObjectRelationship *relationship)
{
  // Just checking
  assert(relationship->Scene());
  assert(relationship->Scene() == scene);

  // Remove relationship
  relationships.Remove(relationship);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0xaafac
subq 0x40(%rbx), %rax
shrq $0x3, %rax
movq %r14, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xab13e
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateBeforeRemoveLabelAssignment(gaps::R3SurfelLabelAssignment*)
void R3SurfelObject::
UpdateBeforeRemoveLabelAssignment(R3SurfelLabelAssignment *assignment)
{
  // Check assignment
  assert(assignment->Scene());
  assert(assignment->Scene() == scene);
  assert(assignment->Object() == this);

  // Remove assignment
  RNArrayEntry *entry = assignments.KthEntry(assignment->object_index);
  R3SurfelLabelAssignment *tail = assignments.Tail();
  tail->object_index = assignment->object_index;
  assignments.EntryContents(entry) = tail;
  assignments.RemoveTail();
  assignment->object_index = -1;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x50(%rdi), %rax
movslq 0x20(%rsi), %rcx
movq 0x50(%rdi), %rdx
movslq 0x5c(%rdi), %rsi
movq -0x8(%rdx,%rsi,8), %rdi
movl %ecx, 0x20(%rdi)
movq %rdi, (%rdx,%rcx,8)
decl %esi
movq %rax, %rdi
callq 0xab13e
movl $0xffffffff, 0x20(%rbx) # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateAfterInsertBlock(gaps::R3SurfelNode*, gaps::R3SurfelBlock*)
void R3SurfelObject::
UpdateAfterInsertBlock(R3SurfelNode *node, R3SurfelBlock *block)
{
  // Update complexity
  complexity += block->NSurfels();

  // Invalidate bounding boxes
  R3SurfelObject *ancestor = this;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp ranges
  ancestor = parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }
}

// Assembly:
cvtsi2sdl 0x8(%rdx), %xmm0
addsd 0x98(%rdi), %xmm0
movsd %xmm0, 0x98(%rdi)
movsd 0xc5e77(%rip), %xmm0    # 0xde170
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rdi, %rcx
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x18316
jnp 0x18326
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x18306
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1834c
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1833f
jnp 0x1834c
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
jmp 0x1832a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateBeforeRemoveBlock(gaps::R3SurfelNode*, gaps::R3SurfelBlock*)
void R3SurfelObject::
UpdateBeforeRemoveBlock(R3SurfelNode *node, R3SurfelBlock *block)
{
  // Update complexity
  complexity -= block->NSurfels();

  // Invalidate properties
  R3SurfelObject *ancestor = this;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate timestamp ranges
  ancestor = parent;
  while (ancestor) {
    if (ancestor->timestamp_range[0] == FLT_MAX) break;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }
}

// Assembly:
cvtsi2sdl 0x8(%rdx), %xmm0
movsd 0x98(%rdi), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x98(%rdi)
movsd 0xc5e01(%rip), %xmm0    # 0xde170
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rdi, %rcx
movsd 0xa8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1838c
jnp 0x1839c
movq %rax, 0xa8(%rcx)
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x1837c
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x183c2
movsd 0xd8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x183b5
jnp 0x183c2
movq %rax, 0xd8(%rcx)
movq 0x18(%rcx), %rcx
jmp 0x183a0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateAfterTransform(gaps::R3SurfelNode*)
void R3SurfelObject::
UpdateAfterTransform(R3SurfelNode *node)
{
  // Invalidate bboxes
  R3SurfelObject *ancestor = this;
  while (ancestor) {
    if (ancestor->bbox[0][0] == FLT_MAX) break;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor = ancestor->parent;
  }
}

// Assembly:
movsd 0xc5da4(%rip), %xmm0    # 0xde170
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movsd 0xa8(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0x183e6
jnp 0x183f6
movq %rax, 0xa8(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x183d6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObject.cpp
// Function: gaps::R3SurfelObject::UpdateProperties()
void R3SurfelObject::
UpdateProperties(void)
{
  // Update properties
  double dummy = 0;
  dummy += Complexity();
  dummy += BBox().Min().X();
  dummy += TimestampRange().Min();
  if (dummy == 927612.21242) {
    printf("Amazing!\n");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
addsd 0x98(%rdi), %xmm1
movsd 0xa8(%rdi), %xmm0
ucomisd 0xc5d54(%rip), %xmm0    # 0xde170
jne 0x18434
jp 0x18434
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x170ea
movsd 0x8(%rsp), %xmm1
addsd 0xa8(%rbx), %xmm1
movsd 0xd8(%rbx), %xmm0
ucomisd 0xc5d24(%rip), %xmm0    # 0xde170
jne 0x18464
jp 0x18464
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x17274
movsd 0x8(%rsp), %xmm1
addsd 0xd8(%rbx), %xmm1
ucomisd 0xc5eb4(%rip), %xmm1    # 0xde328
jne 0x18489
jp 0x18489
leaq 0xc5ec9(%rip), %rdi     # 0xde348
addq $0x10, %rsp
popq %rbx
jmp 0x137c0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindObjectByName(char const*) const
R3SurfelObject *R3SurfelScene::
FindObjectByName(const char *object_name) const
{
  // Search for object
  for (int i = 0; i < NObjects(); i++) {
    R3SurfelObject *object = Object(i);
    if (!object->Name()) continue;
    if (strcmp(object->Name(), object_name)) continue;
    return object;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x1c(%rdi), %r15
testq %r15, %r15
jle 0x18bd7
movq %rsi, %rbx
movq 0x10(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x88(%rbp), %rdi
testq %rdi, %rdi
je 0x18bc9
movq %rbx, %rsi
callq 0x13710
testl %eax, %eax
setne %al
cmoveq %rbp, %r14
jmp 0x18bcb
movb $0x1, %al
testb %al, %al
je 0x18bda
incq %r13
cmpq %r13, %r15
jne 0x18ba6
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindObjectByIdentifier(int) const
R3SurfelObject *R3SurfelScene::
FindObjectByIdentifier(int identifier) const
{
  // Search for object
  for (int i = 0; i < NObjects(); i++) {
    R3SurfelObject *object = Object(i);
    if (object->Identifier() < 0) continue;
    if (object->Identifier() != identifier) continue;
    return object;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x1c(%rdi)
jle 0x18c3b
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r15
movq %r15, %rdi
callq 0x17098
testl %eax, %eax
js 0x18c29
movq %r15, %rdi
callq 0x17098
cmpl %ebp, %eax
setne %al
cmoveq %r15, %rbx
jmp 0x18c2b
movb $0x1, %al
testb %al, %al
je 0x18c3d
incq %r12
movslq 0x1c(%r14), %rax
cmpq %rax, %r12
jl 0x18c02
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindLabelByName(char const*) const
R3SurfelLabel *R3SurfelScene::
FindLabelByName(const char *label_name) const
{
  // Search for label
  for (int i = 0; i < NLabels(); i++) {
    R3SurfelLabel *label = Label(i);
    if (!label->Name()) continue;
    if (strcmp(label->Name(), label_name)) continue;
    return label;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x2c(%rdi), %r15
testq %r15, %r15
jle 0x18c96
movq %rsi, %rbx
movq 0x20(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x18c88
movq %rbx, %rsi
callq 0x13710
testl %eax, %eax
setne %al
cmoveq %rbp, %r14
jmp 0x18c8a
movb $0x1, %al
testb %al, %al
je 0x18c99
incq %r13
cmpq %r13, %r15
jne 0x18c68
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindLabelByIdentifier(int) const
R3SurfelLabel *R3SurfelScene::
FindLabelByIdentifier(int identifier) const
{
  // Search for label
  for (int i = 0; i < NLabels(); i++) {
    R3SurfelLabel *label = Label(i);
    if (label->Identifier() < 0) continue;
    if (label->Identifier() != identifier) continue;
    return label;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x2c(%rdi)
jle 0x18cfb
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %r15
movq %r15, %rdi
callq 0x40828
testl %eax, %eax
js 0x18ce9
movq %r15, %rdi
callq 0x40828
cmpl %ebp, %eax
setne %al
cmoveq %r15, %rbx
jmp 0x18ceb
movb $0x1, %al
testb %al, %al
je 0x18cfd
incq %r12
movslq 0x2c(%r14), %rax
cmpq %rax, %r12
jl 0x18cc2
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindLabelByAssignmentKeystroke(int) const
R3SurfelLabel *R3SurfelScene::
FindLabelByAssignmentKeystroke(int key) const
{
  // Search for label
  for (int i = 0; i < NLabels(); i++) {
    R3SurfelLabel *label = Label(i);
    if (label->AssignmentKeystroke() < 0) continue;
    if (label->AssignmentKeystroke() != key) continue;
    return label;
  }

  // Not found
  return NULL;
}

// Assembly:
movslq 0x2c(%rdi), %rcx
testq %rcx, %rcx
jle 0x18d40
movq 0x20(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x6c(%r8), %r9d
testl %r9d, %r9d
sets %r10b
cmpl %esi, %r9d
setne %r9b
orb %r10b, %r9b
cmoveq %r8, %rax
je 0x18d42
incq %rdi
cmpq %rdi, %rcx
jne 0x18d19
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindLabelAssignment(gaps::R3SurfelObject*, gaps::R3SurfelLabel*, double, int) const
R3SurfelLabelAssignment *R3SurfelScene::
FindLabelAssignment(R3SurfelObject *object, R3SurfelLabel *label, RNScalar confidence, int originator) const
{
  // Search for label assignment
  for (int i = 0; i < object->NLabelAssignments(); i++) {
    R3SurfelLabelAssignment *assignment = object->LabelAssignment(i);
    if (assignment->Label() != label) continue;
    if (assignment->Confidence() != confidence) continue;
    if (assignment->Originator() != originator) continue;
    return assignment;
  }

  // Not found
  return NULL;
}

// Assembly:
movslq 0x5c(%rsi), %rdi
testq %rdi, %rdi
jle 0x18d88
movq 0x50(%rsi), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r10
movb $0x1, %r9b
cmpq %rdx, 0x28(%r10)
jne 0x18d7b
movsd 0x38(%r10), %xmm1
ucomisd %xmm0, %xmm1
jne 0x18d7b
jp 0x18d7b
cmpl %ecx, 0x40(%r10)
setne %r9b
cmoveq %r10, %rax
testb %r9b, %r9b
je 0x18d8a
incq %r8
cmpq %r8, %rdi
jne 0x18d54
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindScanByName(char const*) const
R3SurfelScan *R3SurfelScene::
FindScanByName(const char *scan_name) const
{
  // Search for scan
  for (int i = 0; i < NScans(); i++) {
    R3SurfelScan *scan = Scan(i);
    if (!scan->Name()) continue;
    if (strcmp(scan->Name(), scan_name)) continue;
    return scan;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x8c(%rdi), %r15
testq %r15, %r15
jle 0x18de1
movq %rsi, %rbx
movq 0x80(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0xb8(%rbp), %rdi
testq %rdi, %rdi
je 0x18dd3
movq %rbx, %rsi
callq 0x13710
testl %eax, %eax
setne %al
cmoveq %rbp, %r14
jmp 0x18dd5
movb $0x1, %al
testb %al, %al
je 0x18de4
incq %r13
cmpq %r13, %r15
jne 0x18db0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindImageByName(char const*) const
R3SurfelImage *R3SurfelScene::
FindImageByName(const char *image_name) const
{
  // Search for image
  for (int i = 0; i < NImages(); i++) {
    R3SurfelImage *image = Image(i);
    if (!image->Name()) continue;
    if (strcmp(image->Name(), image_name)) continue;
    return image;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x9c(%rdi), %r15
testq %r15, %r15
jle 0x18e4b
movq %rsi, %rbx
movq 0x90(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x1c0(%rbp), %rdi
testq %rdi, %rdi
je 0x18e3d
movq %rbx, %rsi
callq 0x13710
testl %eax, %eax
setne %al
cmoveq %rbp, %r14
jmp 0x18e3f
movb $0x1, %al
testb %al, %al
je 0x18e4e
incq %r13
cmpq %r13, %r15
jne 0x18e1a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::FindFeatureByName(char const*) const
R3SurfelFeature *R3SurfelScene::
FindFeatureByName(const char *feature_name) const
{
  // Search for feature
  for (int i = 0; i < NFeatures(); i++) {
    R3SurfelFeature *feature = Feature(i);
    if (!feature->Name()) continue;
    if (strcmp(feature->Name(), feature_name)) continue;
    return feature;
  }

  // Not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0xac(%rdi), %r15
testq %r15, %r15
jle 0x19050
movq %rsi, %rbx
movq 0xa0(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq 0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x19042
movq %rbx, %rsi
callq 0x13710
testl %eax, %eax
setne %al
cmoveq %rbp, %r14
jmp 0x19044
movb $0x1, %al
testb %al, %al
je 0x19053
incq %r13
cmpq %r13, %r15
jne 0x19022
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::SetName(char const*)
void R3SurfelScene::
SetName(const char *name)
{
  // Delete previous name
  if (this->name) free(this->name);

  // Set new name
  this->name = (name) ? RNStrdup(name) : NULL;

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1d0(%rdi), %rdi
testq %rdi, %rdi
je 0x19081
callq 0x135e0
testq %r14, %r14
je 0x19090
movq %r14, %rdi
callq 0xadc0f
jmp 0x19092
xorl %eax, %eax
movq %rax, 0x1d0(%rbx)
orb $0x1, 0x1e8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::InsertObject(gaps::R3SurfelObject*, gaps::R3SurfelObject*)
void R3SurfelScene::
InsertObject(R3SurfelObject *object, R3SurfelObject *parent)
{
  // Just checking
  assert(object);
  assert(object->scene == NULL);
  assert(object->scene_index == -1);

  // Insert object into scene
  object->scene = this;
  object->scene_index = objects.NEntries();
  objects.Insert(object);

  // Insert object into parent
  object->parent = parent;
  if (parent) parent->parts.Insert(object);

  // Update object
  object->UpdateAfterInsert(this);

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsi)
addq $0x10, %rdi
movl 0x1c(%rbx), %edx
movl %edx, 0x10(%rsi)
callq 0xaafca
movq %r15, 0x18(%r14)
testq %r15, %r15
je 0x1935f
movl 0x2c(%r15), %edx
addq $0x20, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xaafca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1814c
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::InsertLabel(gaps::R3SurfelLabel*, gaps::R3SurfelLabel*)
void R3SurfelScene::
InsertLabel(R3SurfelLabel *label, R3SurfelLabel *parent)
{
  // Just checking
  assert(label);
  assert(label->scene == NULL);
  assert(label->scene_index == -1);

  // Insert label 
  label->scene = this;
  label->scene_index = labels.NEntries();
  labels.Insert(label);

  // Insert label into parent
  label->parent = parent;
  if (parent) parent->parts.Insert(label);

  // Update label
  label->UpdateAfterInsert(this);

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsi)
addq $0x20, %rdi
movl 0x2c(%rbx), %edx
movl %edx, 0x10(%rsi)
callq 0xaafca
movq %r15, 0x18(%r14)
testq %r15, %r15
je 0x1961b
movl 0x2c(%r15), %edx
addq $0x20, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xaafca
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::InsertObjectRelationship(gaps::R3SurfelObjectRelationship*)
void R3SurfelScene::
InsertObjectRelationship(R3SurfelObjectRelationship *relationship)
{
  // Just checking
  assert(relationship);
  assert(relationship->scene == NULL);
  assert(relationship->scene_index == -1);

  // Insert relationship into scene
  relationship->scene = this;
  relationship->scene_index = object_relationships.NEntries();
  object_relationships.Insert(relationship);

  // Update objects
  for (int i = 0; i < relationship->NObjects(); i++) {
    R3SurfelObject *object = relationship->Object(i);
    object->UpdateAfterInsertObjectRelationship(relationship);
  }

  // Update object relationship
  relationship->UpdateAfterInsert(this);

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsi)
addq $0x50, %rdi
movl 0x5c(%rbx), %edx
movl %edx, 0x10(%rsi)
callq 0xaafca
cmpl $0x0, 0x24(%r14)
jle 0x198a2
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x18260
incq %r15
movslq 0x24(%r14), %rax
cmpq %rax, %r15
jl 0x19886
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::RemoveObjectRelationship(gaps::R3SurfelObjectRelationship*)
void R3SurfelScene::
RemoveObjectRelationship(R3SurfelObjectRelationship *relationship)
{
  // Just checking
  assert(relationship);
  assert(relationship->scene == this);
  assert(relationship->scene_index >= 0);
  assert(object_relationships.Kth(relationship->scene_index) == relationship);

  // Update object relationship
  relationship->UpdateBeforeRemove(this);

  // Update objects
  for (int i = 0; i < relationship->NObjects(); i++) {
    R3SurfelObject *object = relationship->Object(i);
    object->UpdateBeforeRemoveObjectRelationship(relationship);
  }

  // Remove relationship from scene
  RNArrayEntry *entry = object_relationships.KthEntry(relationship->scene_index);
  R3SurfelObjectRelationship *tail = object_relationships.Tail();
  tail->scene_index = relationship->scene_index;
  object_relationships.EntryContents(entry) = tail;
  object_relationships.RemoveTail();
  relationship->scene_index = -1;
  relationship->scene = NULL;

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x24(%rsi)
jle 0x198e0
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x1826c
incq %r15
movslq 0x24(%r14), %rax
cmpq %rax, %r15
jl 0x198c4
leaq 0x50(%rbx), %rdi
movslq 0x10(%r14), %rax
movq 0x50(%rbx), %rcx
movslq 0x5c(%rbx), %rdx
movq -0x8(%rcx,%rdx,8), %rsi
movl %eax, 0x10(%rsi)
movq %rsi, (%rcx,%rax,8)
leal -0x1(%rdx), %esi
callq 0xab13e
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%r14)
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::InsertLabelRelationship(gaps::R3SurfelLabelRelationship*)
void R3SurfelScene::
InsertLabelRelationship(R3SurfelLabelRelationship *relationship)
{
  // Just checking
  assert(relationship);
  assert(relationship->scene == this);
  assert(relationship->scene_index == -1);

  // Insert relationship into scene
  relationship->scene = this;
  relationship->scene_index = label_relationships.NEntries();
  label_relationships.Insert(relationship);

  // Update labels
  for (int i = 0; i < relationship->NLabels(); i++) {
    R3SurfelLabel *label = relationship->Label(i);
    label->UpdateAfterInsertLabelRelationship(relationship);
  }

  // Update label relationship
  relationship->UpdateAfterInsert(this);

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsi)
addq $0x60, %rdi
movl 0x6c(%rbx), %edx
movl %edx, 0x10(%rsi)
callq 0xaafca
cmpl $0x0, 0x24(%r14)
jle 0x19966
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x40ae6
incq %r15
movslq 0x24(%r14), %rax
cmpq %rax, %r15
jl 0x1994a
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::RemoveLabelRelationship(gaps::R3SurfelLabelRelationship*)
void R3SurfelScene::
RemoveLabelRelationship(R3SurfelLabelRelationship *relationship)
{
  // Just checking
  assert(relationship);
  assert(relationship->scene == this);
  assert(relationship->scene_index >= 0);
  assert(label_relationships.Kth(relationship->scene_index) == relationship);

  // Update label relationship
  relationship->UpdateAfterInsert(this);

  // Update labels
  for (int i = 0; i < relationship->NLabels(); i++) {
    R3SurfelLabel *label = relationship->Label(i);
    label->UpdateBeforeRemoveLabelRelationship(relationship);
  }

  // Remove relationship from scene
  RNArrayEntry *entry = label_relationships.KthEntry(relationship->scene_index);
  R3SurfelLabelRelationship *tail = label_relationships.Tail();
  tail->scene_index = relationship->scene_index;
  label_relationships.EntryContents(entry) = tail;
  label_relationships.RemoveTail();
  relationship->scene_index = -1;
  relationship->scene = NULL;

  // Mark scene as dirty
  flags.Add(R3_SURFEL_SCENE_DIRTY_FLAG);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x24(%rsi)
jle 0x199a4
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x40af2
incq %r15
movslq 0x24(%r14), %rax
cmpq %rax, %r15
jl 0x19988
leaq 0x60(%rbx), %rdi
movslq 0x10(%r14), %rax
movq 0x60(%rbx), %rcx
movslq 0x6c(%rbx), %rdx
movq -0x8(%rcx,%rdx,8), %rsi
movl %eax, 0x10(%rsi)
movq %rsi, (%rcx,%rax,8)
leal -0x1(%rdx), %esi
callq 0xab13e
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%r14)
orb $0x1, 0x1e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop