LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMarkConstraint::Check(gaps::R3SurfelBlock const*, gaps::R3Surfel const*) const
int R3SurfelMarkConstraint::
Check(const R3SurfelBlock *block, const R3Surfel *surfel) const
{
  // Return whether surfel satisfies constraint
  if (surfel->IsMarked()) {
    if (include_marked) return R3_SURFEL_CONSTRAINT_PASS; 
  }
  else {
    if (include_unmarked) return R3_SURFEL_CONSTRAINT_PASS;
  }
  return R3_SURFEL_CONSTRAINT_FAIL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x45470
cmpl $0x0, %eax
je 0x53f61
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x53f5f
movl $0x2, 0x24(%rsp)
jmp 0x53f7f
jmp 0x53f77
movq (%rsp), %rax
cmpl $0x0, 0xc(%rax)
je 0x53f75
movl $0x2, 0x24(%rsp)
jmp 0x53f7f
jmp 0x53f77
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3SurfelObject const*) const
int R3SurfelMultiConstraint::
Check(const R3SurfelObject *object) const
{
  // Initialize return status 
  int status = R3_SURFEL_CONSTRAINT_PASS;

  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    int s = constraint->Check(object);
    if (s == R3_SURFEL_CONSTRAINT_FAIL) return R3_SURFEL_CONSTRAINT_FAIL;
    else if (s == R3_SURFEL_CONSTRAINT_MAYBE) status = R3_SURFEL_CONSTRAINT_MAYBE;
  }

  // Return how all constraints are met
  return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x540f4
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
callq 0x54da0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x540d4
movl $0x0, 0x44(%rsp)
jmp 0x540fc
cmpl $0x1, 0x1c(%rsp)
jne 0x540e3
movl $0x1, 0x2c(%rsp)
jmp 0x540e5
jmp 0x540e7
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x54078
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3SurfelNode const*) const
int R3SurfelMultiConstraint::
Check(const R3SurfelNode *node) const
{
  // Initialize return status 
  int status = R3_SURFEL_CONSTRAINT_PASS;

  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    int s = constraint->Check(node);
    if (s == R3_SURFEL_CONSTRAINT_FAIL) return R3_SURFEL_CONSTRAINT_FAIL;
    else if (s == R3_SURFEL_CONSTRAINT_MAYBE) status = R3_SURFEL_CONSTRAINT_MAYBE;
  }

  // Return how all constraints are met
  return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x541b4
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
callq 0x54da0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x54194
movl $0x0, 0x44(%rsp)
jmp 0x541bc
cmpl $0x1, 0x1c(%rsp)
jne 0x541a3
movl $0x1, 0x2c(%rsp)
jmp 0x541a5
jmp 0x541a7
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x54138
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3SurfelBlock const*) const
int R3SurfelMultiConstraint::
Check(const R3SurfelBlock *block) const
{
  // Initialize return status 
  int status = R3_SURFEL_CONSTRAINT_PASS;

  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    int s = constraint->Check(block);
    if (s == R3_SURFEL_CONSTRAINT_FAIL) return R3_SURFEL_CONSTRAINT_FAIL;
    else if (s == R3_SURFEL_CONSTRAINT_MAYBE) status = R3_SURFEL_CONSTRAINT_MAYBE;
  }

  // Return how all constraints are met
  return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x54274
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
callq 0x54da0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x54254
movl $0x0, 0x44(%rsp)
jmp 0x5427c
cmpl $0x1, 0x1c(%rsp)
jne 0x54263
movl $0x1, 0x2c(%rsp)
jmp 0x54265
jmp 0x54267
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x541f8
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3SurfelBlock const*, gaps::R3Surfel const*) const
int R3SurfelMultiConstraint::
Check(const R3SurfelBlock *block, const R3Surfel *surfel) const
{
  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    if (!constraint->Check(block, surfel)) return R3_SURFEL_CONSTRAINT_FAIL;
  }

  // Return how all constraints are met
  return R3_SURFEL_CONSTRAINT_PASS;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x5431f
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x24(%rsp), %esi
callq 0x54da0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
jne 0x54310
movl $0x0, 0x44(%rsp)
jmp 0x54327
jmp 0x54312
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x542b5
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3Box const&) const
int R3SurfelMultiConstraint::
Check(const R3Box& box) const
{
  // Initialize return status 
  int status = R3_SURFEL_CONSTRAINT_PASS;

  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    int s = constraint->Check(box);
    if (s == R3_SURFEL_CONSTRAINT_FAIL) return R3_SURFEL_CONSTRAINT_FAIL;
    else if (s == R3_SURFEL_CONSTRAINT_MAYBE) status = R3_SURFEL_CONSTRAINT_MAYBE;
  }

  // Return how all constraints are met
  return status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x543d4
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
callq 0x54da0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x543b4
movl $0x0, 0x44(%rsp)
jmp 0x543dc
cmpl $0x1, 0x1c(%rsp)
jne 0x543c3
movl $0x1, 0x2c(%rsp)
jmp 0x543c5
jmp 0x543c7
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x54358
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelConstraint.cpp
// Function: gaps::R3SurfelMultiConstraint::Check(gaps::R3Point const&) const
int R3SurfelMultiConstraint::
Check(const R3Point& point) const
{
  // Check whether all constraints are met
  for (int i = 0; i < constraints.NEntries(); i++) {
    const R3SurfelConstraint *constraint = constraints.Kth(i);
    if (!constraint->Check(point)) return R3_SURFEL_CONSTRAINT_FAIL;
  }

  // All constraints are met
  return R3_SURFEL_CONSTRAINT_PASS;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
callq 0x16d50
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x54475
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x1c(%rsp), %esi
callq 0x54da0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
cmpl $0x0, %eax
jne 0x54466
movl $0x0, 0x34(%rsp)
jmp 0x5447d
jmp 0x54468
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x54410
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPoint.cpp
// Function: gaps::R3SurfelPoint::R3SurfelPoint(gaps::R3SurfelBlock*, int)
R3SurfelPoint::
R3SurfelPoint(R3SurfelBlock *block, int surfel_index)
  : block(block),
    surfel(NULL)
{
  // Update block reference count
  if (block && block->Database()) block->Database()->ReadBlock(block);

  // Find surfel
  surfel = block->Surfel(surfel_index);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, 0x18(%rsp)
je 0x5577b
movq 0x18(%rsp), %rdi
callq 0x43610
cmpq $0x0, %rax
je 0x5577b
movq 0x18(%rsp), %rdi
callq 0x43610
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x31140
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x43660
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPoint.cpp
// Function: gaps::R3SurfelPoint::Copy(gaps::R3SurfelPoint const*)
void R3SurfelPoint::
Copy(const R3SurfelPoint *point)
{
  // Update block reference counts
  if (this->block != point->block) {
    if (this->block && this->block->Database()) this->block->Database()->ReleaseBlock(this->block);
    if (point->block && point->block->Database()) point->block->Database()->ReadBlock(point->block);
  }

  // Copy block and surfel
  this->block = point->block;
  this->surfel = point->surfel;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
je 0x558a8
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x5586b
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x43610
cmpq $0x0, %rax
je 0x5586b
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x43610
movq %rax, %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x311c0
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x558a6
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x43610
cmpq $0x0, %rax
je 0x558a6
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x43610
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x31140
jmp 0x558a8
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPoint.cpp
// Function: gaps::R3SurfelPoint::Reset(gaps::R3SurfelBlock*, gaps::R3Surfel const*)
void R3SurfelPoint::
Reset(R3SurfelBlock *block, const R3Surfel *surfel)
{
  // Update block reference counts
  if (this->block != block) {
    if (this->block && this->block->Database()) this->block->Database()->ReleaseBlock(this->block);
    if (block && block->Database()) block->Database()->ReadBlock(block);
  }

  // Copy block and surfel
  this->block = block;
  this->surfel = surfel;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
je 0x55963
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55932
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x43610
cmpq $0x0, %rax
je 0x55932
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x43610
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x311c0
cmpq $0x0, 0x18(%rsp)
je 0x55961
movq 0x18(%rsp), %rdi
callq 0x43610
cmpq $0x0, %rax
je 0x55961
movq 0x18(%rsp), %rdi
callq 0x43610
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x31140
jmp 0x55963
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPoint.cpp
// Function: gaps::R3SurfelPoint::Draw(gaps::RNFlags) const
void R3SurfelPoint::
Draw(RNFlags flags) const
{
  // Draw surfel
  RNGrfxBegin(RN_GRFX_POINTS);
  if (flags[R3_SURFEL_COLOR_DRAW_FLAG]) RNLoadRgb(Color());
  R3LoadPoint(Position().Coords());
  RNGrfxEnd();
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
xorl %edi, %edi
callq 0x4ff50
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1b970
movq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x31a20
cmpl $0x0, %eax
je 0x55d92
movq (%rsp), %rdi
callq 0x4fa20
movq %rax, %rdi
callq 0x4ff70
movq (%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x18730
leaq 0x8(%rsp), %rdi
callq 0x50440
movq %rax, %rdi
callq 0x50430
callq 0x50070
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Centroid() const
R3Point R3SurfelPointSet::
Centroid(void) const
{
  // Return centroid of set
  R3Point sum(0, 0, 0);
  if (npoints == 0) return sum;
  for (int i = 0; i < npoints; i++) {
    R3SurfelPoint& point = points[i];
    sum[0] += point.X();
    sum[1] += point.Y();
    sum[2] += point.Z();
  }
  return R3Point(sum[0]/npoints, sum[1]/npoints, sum[2]/npoints); 
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xf8350
movq 0x38(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x56117
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf8390
jmp 0x56268
movl $0x0, 0x4c(%rsp)
movq 0x38(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x561df
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5b1c0
movsd %xmm0, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1bde0
movsd 0x10(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x5b1d0
movsd %xmm0, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x1bde0
movsd 0x18(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x5b1e0
movsd %xmm0, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x2, %esi
callq 0x1bde0
movsd 0x20(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x5611f
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1bde0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movsd (%rcx), %xmm0
cvtsi2sdl 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x1bde0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movsd (%rcx), %xmm0
cvtsi2sdl 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x2, %esi
callq 0x1bde0
movq 0x28(%rsp), %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rax, %rcx
movq 0x38(%rsp), %rax
movsd (%rcx), %xmm2
cvtsi2sdl 0x10(%rax), %xmm3
divsd %xmm3, %xmm2
callq 0xf8350
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelBlock*)
void R3SurfelPointSet::
InsertPoints(R3SurfelBlock *block)
{
  // Check block
  if (block->NSurfels() == 0) return;

  // Update bounding box
  bbox.Union(block->BBox());

  // Update timestamp range
  timestamp_range.Union(block->TimestampRange());

  // Allocate space for points
  AllocatePoints(npoints + block->NSurfels());

  // Read block
  if (block->database) block->database->ReadBlock(block);

  // Copy surfels
  for (int i = 0; i < block->NSurfels(); i++) {
    const R3Surfel *surfel = block->Surfel(i);
    points[npoints].Reset(block, surfel);
    npoints++;
  }

  // Release block
  if (block->database) block->database->ReleaseBlock(block);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1c0e0
cmpl $0x0, %eax
jne 0x56a8c
jmp 0x56bc2
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4a500
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcbc30
movq 0x20(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4a780
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x1bbc0
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1c0e0
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdi
addl %eax, %esi
movq (%rdi), %rax
callq *0x80(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x56b25
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x31140
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1c0e0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x56b9d
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x43660
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x558d0
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x56b2d
movq 0x38(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x56bc2
movq 0x38(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x311c0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelBlock*, gaps::R3SurfelConstraint const&)
void R3SurfelPointSet::
InsertPoints(R3SurfelBlock *block, const R3SurfelConstraint& constraint)
{
  // Check block
  if (block->NSurfels() == 0) return;
  if (!constraint.Check(block->BBox())) return;

  // Allocate space for points
  AllocatePoints(npoints + block->NSurfels());

  // Read block
  if (block->database) block->database->ReadBlock(block);

  // Copy points
  for (int i = 0; i < block->NSurfels(); i++) {
    const R3Surfel *surfel = block->Surfel(i);
    if (!constraint.Check(block, surfel)) continue;
    points[npoints].Reset(block, surfel);
    bbox.Union(points[npoints].Position());
    timestamp_range.Union(points[npoints].Timestamp());
    npoints++;
  }

  // Release block
  if (block->database) block->database->ReleaseBlock(block);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1c0e0
cmpl $0x0, %eax
jne 0x57ee1
jmp 0x58082
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4a500
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x57f0d
jmp 0x58082
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1c0e0
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdi
addl %eax, %esi
movq (%rdi), %rax
callq *0x80(%rax)
movq 0x58(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x57f5c
movq 0x58(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x31140
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1c0e0
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x5805d
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x43660
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
jne 0x57fb6
jmp 0x5804d
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x58(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x558d0
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rsi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x18730
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xcb9d0
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x4fa60
movq 0x8(%rsp), %rdi
callq 0x4fbf0
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x57f64
movq 0x58(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x58082
movq 0x58(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x311c0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelPointSet const*)
void R3SurfelPointSet::
InsertPoints(const R3SurfelPointSet *set)
{
  // Check set
  if (set->NPoints() == 0) return;

  // Check and update bounding box (conservatively)
  bbox.Union(set->BBox());

  // Check and update timestamp range (conservatively)
  timestamp_range.Union(set->TimestampRange());

  // Allocate space for points
  AllocatePoints(npoints + set->NPoints());

  // Copy points
  for (int i = 0; i < set->NPoints(); i++) {
    points[npoints] = set->points[i];
    npoints++;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x18700
cmpl $0x0, %eax
jne 0x5834c
jmp 0x5842d
movq 0x28(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x435d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xcbc30
movq 0x28(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4f840
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x1bbc0
movq 0x28(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
callq 0x18700
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rdi
addl %eax, %esi
movq (%rdi), %rax
callq *0x80(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
callq 0x18700
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x5842d
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rsi
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x55980
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x583c8
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelPointSet const*, gaps::R3SurfelConstraint const&)
void R3SurfelPointSet::
InsertPoints(const R3SurfelPointSet *set, const R3SurfelConstraint& constraint)
{
  // Check set
  if (set->NPoints() == 0) return;
  if (!constraint.Check(set->BBox())) return;

  // Allocate space for points
  AllocatePoints(npoints + set->NPoints());

  // Insert surfels
  for (int i = 0; i < set->NPoints(); i++) {
    const R3SurfelPoint *point = set->Point(i);
    R3SurfelBlock *block = point->Block();
    const R3Surfel *surfel = point->Surfel();
    assert(block && surfel);
    if (!constraint.Check(block, surfel)) continue;
    bbox.Union(point->Position());
    timestamp_range.Union(point->Timestamp());
    points[npoints] = *point;
    npoints++;
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x18700
cmpl $0x0, %eax
jne 0x58f31
jmp 0x59084
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x435d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x58f5d
jmp 0x59084
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rdi
callq 0x18700
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdi
addl %eax, %esi
movq (%rdi), %rax
callq *0x80(%rax)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x18700
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x59084
movq 0x68(%rsp), %rdi
movl 0x5c(%rsp), %esi
callq 0x18710
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44cb0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44cc0
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
jne 0x58ffc
jmp 0x59074
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x18730
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xcb9d0
movq 0x20(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4fa60
movq 0x8(%rsp), %rdi
callq 0x4fbf0
movq 0x20(%rsp), %rax
movq 0x50(%rsp), %rsi
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x55980
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x58f8f
addq $0x78, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoint(gaps::R3SurfelPoint const&)
void R3SurfelPointSet::
InsertPoint(const R3SurfelPoint& point)
{
  // AllocatePoints points
  if (npoints == nallocated) {
    if (npoints > 0) AllocatePoints(2 * npoints);
    else AllocatePoints(4);
  }

  // Insert point
  points[npoints++] = point;;

  // Update bounding box
  bbox.Union(point.Position());

  // Update timestamp range
  timestamp_range.Union(point.Timestamp());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x590e5
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x590d0
movq 0x18(%rsp), %rdi
movl 0x10(%rdi), %esi
shll %esi
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0x590e3
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movl $0x4, %esi
callq *0x80(%rax)
jmp 0x590e5
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rsi
movq 0x8(%rcx), %rdi
movl 0x10(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x10(%rcx)
cltq
shlq $0x4, %rax
addq %rax, %rdi
callq 0x55980
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x18730
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xcb9d0
movq 0x18(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4fa60
movq 0x10(%rsp), %rdi
callq 0x4fbf0
addq $0x48, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Empty()
void R3SurfelPointSet::
Empty(void)
{
  // Delete points
  if (points) delete [] points;

  // Reset everything
  nallocated = 0;
  npoints = 0;
  points = NULL;
  bbox = R3null_box;
  timestamp_range = RNnull_interval;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x5953e
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x5953c
movq 0x20(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq -0x8(%rcx), %rdx
movq %rdx, 0x10(%rsp)
shlq $0x4, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x18(%rsp)
je 0x59525
movq 0x18(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, (%rsp)
callq 0x557a0
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x59500
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x4, %rsi
addq $0x8, %rsi
callq 0x13a90
jmp 0x5953e
movq 0x28(%rsp), %rdi
movl $0x0, 0x14(%rdi)
movl $0x0, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
addq $0x18, %rdi
leaq 0x1a3da4(%rip), %rsi    # 0x1fd308
callq 0x1bd40
movq 0x28(%rsp), %rax
leaq 0x5a5f3b(%rip), %rcx    # 0x5ff4b0
movq (%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x58(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Subtract(gaps::R3SurfelPointSet const*)
void R3SurfelPointSet::
Subtract(const R3SurfelPointSet *set)
{
  // Clear marks in this point set
  for (int i = 0; i < npoints; i++) {
    points[i].SetMark(FALSE);
  }

  // Set marks in other point set
  for (int i = 0; i < set->npoints; i++) {
    set->points[i].SetMark(TRUE);
  }

  // Remove marked points from this point set
  for (int i = 0; i < npoints; i++) {
    if (!points[i].IsMarked()) continue;
    points[i] = points[npoints-1];
    npoints--;
    i--;
  }

  // Update bounding box (conservatively)
  // Do nothing
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movq (%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x595e4
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x55d10
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x595af
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x59626
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x55d10
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x595ec
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x596ad
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x43f60
cmpl $0x0, %eax
jne 0x5965b
jmp 0x596a0
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x10(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x55980
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5962e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Intersect(gaps::R3SurfelPointSet const*)
void R3SurfelPointSet::
Intersect(const R3SurfelPointSet *set)
{
  // Set marks in this point set
  for (int i = 0; i < npoints; i++) {
    points[i].SetMark(TRUE);
  }

  // Clear marks in other point set
  for (int i = 0; i < set->npoints; i++) {
    set->points[i].SetMark(FALSE);
  }

  // Remove marked points from this point set
  for (int i = 0; i < npoints; i++) {
    if (!points[i].IsMarked()) continue;
    points[i] = points[npoints-1];
    npoints--;
    i--;
  }

  // Update bounding box (conservatively)
  // Do nothing
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movq (%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x59717
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x55d10
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x596df
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x59756
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x55d10
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5971f
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x597dd
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x43f60
cmpl $0x0, %eax
jne 0x5978b
jmp 0x597d0
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x10(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x55980
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5975e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Blocks() const
RNArray<R3SurfelBlock *> *R3SurfelPointSet::
Blocks(void) const
{
  // Check pointset 
  if (npoints == 0) return NULL;

  // Create array of blocks
  RNArray<R3SurfelBlock *> *blocks = new RNArray<R3SurfelBlock *>();
  if (!blocks) {
    RNFail("Unable to allocate array of blocks\n");
    return NULL;
  }

  // Fill array of blocks
  R3SurfelBlock *last_block = NULL;
  for (int i = 0; i < npoints; i++) {
    R3SurfelPoint *point = &points[i];
    R3SurfelBlock *block = point->Block();
    if (!block) continue;
    if (block == last_block) continue;
    if (blocks->FindEntry(block)) continue;
    blocks->Insert(block);
    last_block = block;
  }

  // Check array of blocks
  if (blocks->IsEmpty()) {
    delete blocks;
    return NULL;
  }

  // Return array of blocks
  return blocks;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x10(%rax)
jne 0x59a97
movq $0x0, 0x60(%rsp)
jmp 0x59bf4
movl $0x10, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x436b0
jmp 0x59ab3
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x59b03
leaq 0x14bc6c(%rip), %rdi    # 0x1a5738
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x60(%rsp)
jmp 0x59bf4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x10, %esi
callq 0x13580
jmp 0x59bfe
movq $0x0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x18(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x59ba7
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x44cb0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x59b59
jmp 0x59b97
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x59b67
jmp 0x59b97
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b260
cmpq $0x0, %rax
je 0x59b7e
jmp 0x59b97
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x436c0
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x59b14
movq 0x50(%rsp), %rdi
callq 0x31da0
cmpl $0x0, %eax
je 0x59bea
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x59bdf
movq 0x8(%rsp), %rdi
callq 0x43730
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x13580
movq $0x0, 0x60(%rsp)
jmp 0x59bf4
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x13970
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Nodes() const
RNArray<R3SurfelNode *> *R3SurfelPointSet::
Nodes(void) const
{
  // Check pointset 
  if (npoints == 0) return NULL;

  // Create array of nodes
  RNArray<R3SurfelNode *> *nodes = new RNArray<R3SurfelNode *>();
  if (!nodes) {
    RNFail("Unable to allocate array of nodes\n");
    return NULL;
  }

  // Fill array of nodes
  R3SurfelNode *last_node = NULL;
  for (int i = 0; i < npoints; i++) {
    R3SurfelPoint *point = &points[i];
    R3SurfelBlock *block = point->Block();
    if (!block) continue;
    R3SurfelNode *node = block->Node();
    if (!node) continue;
    if (node == last_node) continue;
    if (nodes->FindEntry(node)) continue;
    nodes->Insert(node);
    last_node = node;
  }    

  // Check array of nodes
  if (nodes->IsEmpty()) {
    delete nodes;
    return NULL;
  }

  // Return array of nodes
  return nodes;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x10(%rax)
jne 0x59c37
movq $0x0, 0x60(%rsp)
jmp 0x59daa
movl $0x10, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x1b960
jmp 0x59c53
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x59ca3
leaq 0x14baf0(%rip), %rdi    # 0x1a575c
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x60(%rsp)
jmp 0x59daa
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x10, %esi
callq 0x13580
jmp 0x59db4
movq $0x0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x10(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x59d60
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x44cb0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x59cf9
jmp 0x59d50
movq 0x20(%rsp), %rdi
callq 0x43710
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x59d12
jmp 0x59d50
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x59d20
jmp 0x59d50
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5b290
cmpq $0x0, %rax
je 0x59d37
jmp 0x59d50
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1bee0
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x59cb4
movq 0x50(%rsp), %rdi
callq 0x31da0
cmpl $0x0, %eax
je 0x59da0
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x59d95
movq (%rsp), %rdi
callq 0x1b9a0
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x13580
movq $0x0, 0x60(%rsp)
jmp 0x59daa
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x13970
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Objects() const
RNArray<R3SurfelObject *> *R3SurfelPointSet::
Objects(void) const
{
  // Check pointset 
  if (npoints == 0) return NULL;

  // Create array of objects
  RNArray<R3SurfelObject *> *objects = new RNArray<R3SurfelObject *>();
  if (!objects) {
    RNFail("Unable to allocate array of objects\n");
    return NULL;
  }

  // Fill array of objects
  R3SurfelObject *last_object = NULL;
  for (int i = 0; i < npoints; i++) {
    R3SurfelPoint *point = &points[i];
    R3SurfelBlock *block = point->Block();
    if (!block) continue;
    R3SurfelNode *node = block->Node();
    if (!node) continue;
    R3SurfelObject *object = node->Object();
    if (!object) continue;
    if (object == last_object) continue;
    if (objects->FindEntry(object)) continue;
    objects->Insert(object);
    last_object = object;
  }    

  // Check array of objects
  if (objects->IsEmpty()) {
    delete objects;
    return NULL;
  }

  // Return array of objects
  return objects;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x10(%rax)
jne 0x59de7
movq $0x0, 0x70(%rsp)
jmp 0x59f7a
movl $0x10, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x1b920
jmp 0x59e03
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x59e53
leaq 0x14af3e(%rip), %rdi    # 0x1a4d5a
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x70(%rsp)
jmp 0x59f7a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x10, %esi
callq 0x13580
jmp 0x59f84
movq $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x18(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x59f2d
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x44(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44cb0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x59ea9
jmp 0x59f1d
movq 0x30(%rsp), %rdi
callq 0x43710
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x59ec2
jmp 0x59f1d
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x5f2c0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x59edf
jmp 0x59f1d
movq 0x20(%rsp), %rax
cmpq 0x48(%rsp), %rax
jne 0x59eed
jmp 0x59f1d
movq 0x60(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5b2c0
cmpq $0x0, %rax
je 0x59f04
jmp 0x59f1d
movq 0x60(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1be70
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x59e64
movq 0x60(%rsp), %rdi
callq 0x31da0
cmpl $0x0, %eax
je 0x59f70
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x59f65
movq 0x8(%rsp), %rdi
callq 0x1b9e0
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x13580
movq $0x0, 0x70(%rsp)
jmp 0x59f7a
movq 0x60(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x13970
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::ReadFile(char const*)
int R3SurfelPointSet::
ReadFile(const char *filename)
{
  // Create block
  R3SurfelBlock *block = new R3SurfelBlock();
  if (!block) {
    RNFail("Unable to allocate block for %s\n", filename);
    return 0;
  }

  // Read block
  if (!block->ReadFile(filename)) return 0;

  // Insert points from block
  InsertPoints(block);

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xc8, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x47c30
jmp 0x5a504
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x5a552
movq 0x30(%rsp), %rsi
leaq 0x14b25d(%rip), %rdi    # 0x1a577f
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x44(%rsp)
jmp 0x5a588
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0xc8, %esi
callq 0x13580
jmp 0x5a591
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4cd40
cmpl $0x0, %eax
jne 0x5a570
movl $0x0, 0x44(%rsp)
jmp 0x5a588
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13970
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::WriteFile(char const*) const
int R3SurfelPointSet::
WriteFile(const char *filename) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .ply)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  if (!strncmp(extension, ".xyz", 4)) {
    return WriteXYZFile(filename);
  }
  else { 
    RNFail("Unable to write file %s (unrecognized extension: %s)\n", filename, extension); 
    return 0; 
  }

  // Should never get here
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x13630
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x5a5ee
movq 0x10(%rsp), %rsi
leaq 0x14a993(%rip), %rdi    # 0x1a4f70
movb $0x0, %al
callq 0x13070
movl $0x0, 0x24(%rsp)
jmp 0x5a641
movq 0x8(%rsp), %rdi
leaq 0x14a9ab(%rip), %rsi    # 0x1a4fa5
movl $0x4, %edx
callq 0x13260
cmpl $0x0, %eax
jne 0x5a621
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0xc8(%rax)
movl %eax, 0x24(%rsp)
jmp 0x5a641
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x149e3e(%rip), %rdi    # 0x1a4470
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::WriteXYZFile(char const*) const
int R3SurfelPointSet::
WriteXYZFile(const char *filename) const
{
  // Open file
  FILE *fp;
  if (!(fp = fopen(filename, "w"))) {
    RNFail("Unable to open file %s\n", filename);
    return 0;
  }

  // Write points
  for (int i = 0; i < NPoints(); i++) {
    const R3SurfelPoint *point = Point(i);
    R3Point position = point->Position();
    fprintf(fp, "%g %g %g\n", position.X(), position.Y(), position.Z());
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x14c88a(%rip), %rsi    # 0x1a6efe
callq 0x13690
movq %rax, 0x58(%rsp)
cmpq $0x0, %rax
jne 0x5a6a4
movq 0x60(%rsp), %rsi
leaq 0x149e16(%rip), %rdi    # 0x1a44a6
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x74(%rsp)
jmp 0x5a766
movl $0x0, 0x54(%rsp)
movq 0x28(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0x18700
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x5a754
movq 0x28(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x18710
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x18730
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x187b0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x187c0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x187a0
movq 0x8(%rsp), %rdi
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
leaq 0x14bda6(%rip), %rsi    # 0x1a64e3
movb $0x3, %al
callq 0x13810
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x5a6ac
movq 0x58(%rsp), %rdi
callq 0x13560
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointGraph.cpp
// Function: gaps::R3SurfelPointGraph::~R3SurfelPointGraph()
R3SurfelPointGraph::
~R3SurfelPointGraph(void)
{
  // Delete neighbors
  if (neighbors) {
    delete [] neighbors;
    neighbors = NULL;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x1912fe(%rip), %rcx    # 0x1ee988
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x68(%rax)
je 0x5d727
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x5d71a
movq 0x20(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq -0x8(%rcx), %rdx
movq %rdx, 0x10(%rsp)
shlq $0x4, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x18(%rsp)
je 0x5d703
movq 0x18(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, (%rsp)
callq 0x43fb0
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x5d6de
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x4, %rsi
addq $0x8, %rsi
callq 0x13a90
movq 0x28(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x56040
addq $0x38, %rsp
retq
nopw (%rax,%rax)