LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<gaps::R3SurfelPoint*>::FindClosest(gaps::R3SurfelPoint*, double, double, int, int (*)(gaps::R3SurfelPoint*, gaps::R3SurfelPoint*, void*), void*, gaps::RNArray<gaps::R3SurfelPoint*>&, double*) const
int R3Kdtree<PtrType>::
FindClosest(PtrType query_point, 
  RNScalar min_distance, RNScalar max_distance, int max_points, 
  int (*IsCompatible)(PtrType, PtrType, void *), void *compatible_data, 
  RNArray<PtrType>& points, RNLength *distances) const
{
  // Check root
  if (!root) return 0;

  // Use squared distances for efficiency
  if (max_distance < 0) return 0;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Allocate temporary array of squared distances to max_points closest points
  RNLength *distances_squared = new RNLength [ max_points ];

  // Search nodes recursively
  FindClosest(root, bbox, 
    query_point, Position(query_point),
    min_distance_squared, max_distance_squared, max_points, 
    IsCompatible, compatible_data,
    points, distances_squared);

  // Update return distances
  if (distances) {
    for (int i = 0; i < points.NEntries(); i++) {
      distances[i] = sqrt(distances_squared[i]);
    }
  }

  // Delete temporary array of squared distances
  delete [] distances_squared;

  // Return number of points
  return points.NEntries();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %rdi, %r15
movq 0x50(%rdi), %r12
testq %r12, %r12
sete %dil
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
seta %r9b
xorl %eax, %eax
orb %dil, %r9b
jne 0x35e07
movq 0x80(%rsp), %r13
maxsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movsd %xmm2, 0x10(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
movl %edx, %eax
shlq $0x3, %rax
testl %edx, %edx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rsi, %rbp
movl %edx, 0xc(%rsp)
callq 0x13030
movq %rax, %r14
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x35900
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
leaq 0x30(%rsp), %r8
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl 0xc(%rsp), %r9d
pushq %r14
pushq %rbx
pushq 0x30(%rsp)
pushq 0x40(%rsp)
callq 0x35e16
addq $0x20, %rsp
testq %r13, %r13
je 0x35dfc
cmpl $0x0, 0xc(%rbx)
jle 0x35dfc
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movsd (%r14,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x35de0
sqrtsd %xmm0, %xmm0
jmp 0x35de9
callq 0x133c0
xorpd %xmm1, %xmm1
movsd %xmm0, (%r13,%r15,8)
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x35dce
movq %r14, %rdi
callq 0x13680
movl 0xc(%rbx), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointGraph.cpp
// Function: gaps::R3SurfelPointGraph::R3SurfelPointGraph(gaps::R3SurfelPointGraph const&)
R3SurfelPointGraph::
R3SurfelPointGraph(const R3SurfelPointGraph& graph)
  : set(graph.set),
    neighbors(NULL),
    max_neighbors(graph.max_neighbors),
    max_distance(graph.max_distance)
{
  // Copy neighbors
  neighbors = new RNArray<R3SurfelPoint *> [ NPoints() ];
  for (int i = 0; i < NPoints(); i++) {
    neighbors[i].Resize(graph.neighbors[i].NEntries());
    for (int j = 0; j < graph.neighbors[i].NEntries(); j++) {
      neighbors[i].Insert(graph.neighbors[i][j]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xf8667(%rip), %rax     # 0x12e988
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
movq %rdi, 0x10(%rsp)
callq 0x32698
movq $0x0, 0x68(%r14)
movl 0x70(%r15), %eax
movl %eax, 0x70(%r14)
movsd 0x78(%r15), %xmm0
movsd %xmm0, 0x78(%r14)
movslq 0x18(%r14), %r13
movq %r13, %rbx
shlq $0x4, %rbx
leaq 0x8(%rbx), %rax
testq %r13, %r13
movq $-0x1, %rbp
cmovnsq %rax, %rbp
movq %rbp, %rdi
callq 0x13030
movq %r13, (%rax)
movq %rax, (%rsp)
leaq 0x8(%rax), %r12
testl %r13d, %r13d
je 0x36427
movq %rbp, 0x8(%rsp)
negq %rbx
xorl %r13d, %r13d
movq %r12, %rbp
movq %rbp, %rdi
callq 0xa9ca8
addq $-0x10, %r13
addq $0x10, %rbp
cmpq %r13, %rbx
jne 0x36399
cmpl $0x0, 0x18(%r14)
movq %r12, 0x68(%r14)
jle 0x3642b
movq 0x68(%r15), %rax
xorl %r12d, %r12d
movq %r12, %r13
shlq $0x4, %r13
movq 0x68(%r14), %rdi
addq %r13, %rdi
movl 0xc(%rax,%r13), %esi
callq 0xa9da2
movq 0x68(%r15), %rax
cmpl $0x0, 0xc(%rax,%r13)
jle 0x36419
addq %r13, %rax
xorl %ebx, %ebx
movq %rax, %rcx
movq 0x68(%r14), %rdi
movq (%rcx), %rax
movq (%rax,%rbx,8), %rsi
movl 0xc(%rdi,%r13), %edx
addq %r13, %rdi
callq 0xa9d3e
incq %rbx
movq 0x68(%r15), %rax
leaq (%rax,%r13), %rcx
movslq 0xc(%rax,%r13), %rdx
cmpq %rdx, %rbx
jl 0x363ec
incq %r12
movslq 0x18(%r14), %rcx
cmpq %rcx, %r12
jl 0x363c0
jmp 0x3642b
movq %r12, 0x68(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36470
jmp 0x36470
movq %rax, %r14
testq %r13, %r13
je 0x36460
negq %r13
movq (%rsp), %rbx
addq $-0x8, %rbx
leaq (%rbx,%r13), %rdi
callq 0xa9d12
addq $-0x10, %r13
jne 0x36451
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x139b0
jmp 0x36473
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x3279c
movq %r14, %rdi
callq 0x138b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointGraph.cpp
// Function: gaps::R3SurfelPointGraph::R3SurfelPointGraph(gaps::R3SurfelPointSet const&, int, double)
R3SurfelPointGraph::
R3SurfelPointGraph(const R3SurfelPointSet& set, int max_neighbors, RNLength max_distance)
  : set(set),
    neighbors(NULL),
    max_neighbors(max_neighbors),
    max_distance(max_distance)
{
  // Allocate neighbors
  neighbors = new RNArray<R3SurfelPoint *> [ NPoints() ];

  // Find neighbors with kdtree
  RNArray<R3SurfelPoint *> points;
  for (int i = 0; i < NPoints(); i++) points.Insert(Point(i));
  R3Kdtree<R3SurfelPoint *> kdtree(points, SurfelPointPosition, NULL);
  for (int i = 0; i < NPoints(); i++) {
    kdtree.FindClosest(Point(i), 0, max_distance, max_neighbors, neighbors[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movsd %xmm0, 0x10(%rsp)
movl %edx, %ebp
movq %rdi, %r14
leaq 0xf84df(%rip), %rax     # 0x12e988
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x30(%rsp)
callq 0x32698
movq $0x0, 0x68(%r14)
movl %ebp, 0x70(%r14)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x78(%r14)
movslq 0x18(%r14), %r12
movq %r12, %rbx
shlq $0x4, %rbx
leaq 0x8(%rbx), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x28(%rsp)
callq 0x13030
movq %r12, (%rax)
movq %rax, 0x8(%rsp)
leaq 0x8(%rax), %r15
testl %r12d, %r12d
je 0x36528
negq %rbx
xorl %r12d, %r12d
movq %r15, %r13
movq %r13, %rdi
callq 0xa9ca8
addq $-0x10, %r12
addq $0x10, %r13
cmpq %r12, %rbx
jne 0x36513
movq %r15, 0x68(%r14)
leaq 0x18(%rsp), %rdi
callq 0xa9ca8
cmpl $0x0, 0x18(%r14)
jle 0x3656a
xorl %ebx, %ebx
leaq 0x18(%rsp), %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
addq %rbx, %rsi
movl 0x24(%rsp), %edx
movq %r15, %rdi
callq 0xa9d3e
incq %r12
movslq 0x18(%r14), %rax
addq $0x10, %rbx
cmpq %rax, %r12
jl 0x36547
leaq -0x3f86(%rip), %rdx     # 0x325eb
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %ecx, %ecx
callq 0x3571a
cmpl $0x0, 0x18(%r14)
jle 0x365d1
xorl %ebx, %ebx
leaq 0x38(%rsp), %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
addq %rbx, %rsi
movq 0x68(%r14), %r9
addq %rbx, %r9
movq $0x0, (%rsp)
xorps %xmm0, %xmm0
movq %r15, %rdi
movsd 0x10(%rsp), %xmm1
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x35cf4
incq %r12
movslq 0x18(%r14), %rax
addq $0x10, %rbx
cmpq %rax, %r12
jl 0x36593
leaq 0x38(%rsp), %rdi
callq 0x35852
leaq 0x18(%rsp), %rdi
callq 0xa9d12
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3660f
jmp 0x365fb
movq %rax, %r14
jmp 0x36650
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x35852
jmp 0x36612
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xa9d12
jmp 0x36650
movq %rax, %r14
testq %r12, %r12
je 0x36641
negq %r12
movq 0x8(%rsp), %rbx
addq $-0x8, %rbx
leaq (%rbx,%r12), %rdi
callq 0xa9d12
addq $-0x10, %r12
jne 0x36632
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x139b0
movq 0x30(%rsp), %rdi
callq 0x3279c
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointGraph.cpp
// Function: gaps::R3SurfelPointGraph::Draw(gaps::RNFlags) const
void R3SurfelPointGraph::
Draw(RNFlags flags) const
{
  // Draw surfels
  set.Draw(flags);

  // Draw lines between neighbors
  RNGrfxBegin(RN_GRFX_LINES);
  for (int i = 0; i < NPoints(); i++) {
    R3SurfelPoint *point0 = Point(i);
    for (int j = 0; j < NNeighbors(i); j++) {
      R3SurfelPoint *point1 = Neighbor(i,j);
      R3LoadPoint(point0->Position());
      R3LoadPoint(point1->Position());
    }
  }
  RNGrfxEnd();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x34b6c
movl $0x1, %edi
callq 0x13130
movl 0x18(%rbx), %ecx
testl %ecx, %ecx
jle 0x36b86
movq 0x68(%rbx), %rax
xorl %esi, %esi
leaq 0x10(%rsp), %r14
movq %rsi, %r12
shlq $0x4, %r12
cmpl $0x0, 0xc(%rax,%r12)
jle 0x36b77
movq %rsi, 0x8(%rsp)
movq 0x10(%rbx), %r13
addq %r12, %r13
xorl %ebp, %ebp
movq (%rax,%r12), %rax
movq (%rax,%rbp,8), %r15
movq (%r13), %rax
movq 0x8(%r13), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%rcx), %xmm0
addsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rcx), %xmm1
addsd 0x18(%rax), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rcx), %xmm2
addsd 0x20(%rax), %xmm2
movq %r14, %rdi
callq 0x83dc2
movq %r14, %rdi
callq 0x13150
movq (%r15), %rax
movq 0x8(%r15), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%rcx), %xmm0
addsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rcx), %xmm1
addsd 0x18(%rax), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rcx), %xmm2
addsd 0x20(%rax), %xmm2
movq %r14, %rdi
callq 0x83dc2
movq %r14, %rdi
callq 0x13150
incq %rbp
movq 0x68(%rbx), %rax
movslq 0xc(%rax,%r12), %rcx
cmpq %rcx, %rbp
jl 0x36ad7
movl 0x18(%rbx), %ecx
movq 0x8(%rsp), %rsi
incq %rsi
movslq %ecx, %rdx
cmpq %rdx, %rsi
jl 0x36ab6
callq 0x136a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::~R3SurfelNode()
R3SurfelNode::
~R3SurfelNode(void)
{
  // Remove blocks from node
  while (NBlocks() > 0) RemoveBlock(Block(NBlocks()-1));

  // Remove node from object
  if (object) object->RemoveNode(this);

  // Remove node from scan
  if (scan) scan->SetNode(NULL);

  // Delete parts
  while (NParts() > 0) delete (Part(NParts()-1));
  
  // Remove node from tree
  if (tree) tree->RemoveNode(this);

  // Delete name
  if (name) free(name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf7660(%rip), %rax     # 0x12e9c0
movq %rax, (%rdi)
leaq 0x40(%rdi), %r14
movslq 0x4c(%rbx), %rax
testq %rax, %rax
jle 0x37384
movq (%rbx), %rcx
movq 0x40(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
movq %rbx, %rdi
callq *0x30(%rcx)
jmp 0x37367
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x37395
movq %rbx, %rsi
callq 0x16f82
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x373a6
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
movl 0x3c(%rbx), %eax
testl %eax, %eax
jle 0x373c5
movq 0x30(%rbx), %rcx
movl %eax, %edx
movq -0x8(%rcx,%rdx,8), %rdi
testq %rdi, %rdi
je 0x373a9
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x373a6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x373d6
movq %rbx, %rsi
callq 0x3905c
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x373e7
callq 0x135e0
leaq 0x60(%rbx), %rdi
callq 0x6e174
movq %r14, %rdi
callq 0xa9d12
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa9d12
jmp 0x3740d
movq %rax, %rdi
callq 0x183c3
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::AverageRadius() const
RNLength R3SurfelNode::
AverageRadius(void) const
{
  // Sum average radius of surfels 
  RNLength total_radius = 0;
  RNLength total_weight = 0;
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    RNScalar weight = block->NSurfels();
    total_radius += weight * block->AverageRadius();
    total_weight += weight;
  }

  // Return weighted average
  return (total_weight > 0) ? total_radius / total_weight : 0;
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
jle 0x37545
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xaf33f(%rip), %rax     # 0xe67d8
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, 0x20(%rsp)
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x2d0ea
movapd %xmm0, %xmm1
ucomisd 0xa5ea7(%rip), %xmm0    # 0xdd388
xorpd %xmm0, %xmm0
jne 0x374e9
jnp 0x37510
mulsd 0x8(%rsp), %xmm1
movsd 0xa5c51(%rip), %xmm0    # 0xdd148
divsd %xmm1, %xmm0
ucomisd 0xa5e85(%rip), %xmm0    # 0xdd388
jb 0x3750b
sqrtsd %xmm0, %xmm0
jmp 0x37510
callq 0x133c0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movapd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm2, %xmm0
incq %r14
movslq 0x4c(%rbx), %rax
cmpq %rax, %r14
jl 0x374ae
addq $0x38, %rsp
popq %rbx
popq %r14
divsd %xmm0, %xmm1
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
cmpltsd %xmm2, %xmm0
andpd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::BBox() const
const R3Box& R3SurfelNode::
BBox(void) const
{
  // Return bounding box of node
  if (bbox[0][0] == FLT_MAX) 
    ((R3SurfelNode *) this)->UpdateBBox();
  return bbox;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x68(%rdi), %xmm0
ucomisd 0xa5bfb(%rip), %xmm0    # 0xdd168
jne 0x3757a
jp 0x3757a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
addq $0x60, %rbx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::ElevationRange() const
const RNInterval& R3SurfelNode::
ElevationRange(void) const
{
  // Return elevation interval of node
  if (elevation_range.Min() == FLT_MAX) 
    ((R3SurfelNode *) this)->UpdateElevationRange();
  return elevation_range;
}

// Assembly:
pushq %rbx
leaq 0x98(%rdi), %rbx
movsd 0x98(%rdi), %xmm0
ucomisd 0xa5bcc(%rip), %xmm0    # 0xdd168
jne 0x375a6
jp 0x375a6
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::TimestampRange() const
const RNInterval& R3SurfelNode::
TimestampRange(void) const
{
  // Return timestamp interval of node
  if (timestamp_range.Min() == FLT_MAX) 
    ((R3SurfelNode *) this)->UpdateTimestampRange();
  return timestamp_range;
}

// Assembly:
pushq %rbx
leaq 0xa8(%rdi), %rbx
movsd 0xa8(%rdi), %xmm0
ucomisd 0xa5ba4(%rip), %xmm0    # 0xdd168
jne 0x375ce
jp 0x375ce
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::HasSurfels(int) const
RNBoolean R3SurfelNode::
HasSurfels(RNBoolean leaf_level) const
{
  // Check blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    if (block->NSurfels() > 0) return TRUE;
  }

  // Check parts
  if (leaf_level) {
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      if (part->HasSurfels(leaf_level)) return TRUE;
    }
  }

  // Did not find anything
  return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq 0x4c(%rdi), %rax
testq %rax, %rax
jle 0x375ff
movq 0x40(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpl $0x0, 0x8(%rsi)
jg 0x37630
incq %rdx
cmpq %rdx, %rax
jne 0x375ed
xorl %eax, %eax
testl %ebx, %ebx
je 0x37635
movslq 0x3c(%rdi), %r14
testq %r14, %r14
jle 0x37635
movq 0x30(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movl %ebx, %esi
callq 0x375d4
testl %eax, %eax
jne 0x37630
incq %r12
cmpq %r12, %r14
jne 0x37615
xorl %eax, %eax
jmp 0x37635
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::Object(int, int) const
R3SurfelObject *R3SurfelNode::
Object(RNBoolean search_ancestors, RNBoolean search_descendants) const
{
  // Return object, if there is one associated with this node
  if (object) return object;

  // Search descendants for object
  if (search_descendants) {
    RNScalar best_complexity = 0;
    R3SurfelObject *best_object = NULL;
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      R3SurfelObject *object = part->Object(FALSE, TRUE);
      if (object) {
        RNScalar complexity = object->Complexity();
        if (complexity > best_complexity) {
          best_complexity = complexity;
          best_object = object;
        }
      }
    }
    if (best_object) return best_object;
  }

  // Search ancestors for object
  if (search_ancestors) {
    const R3SurfelNode *node = this;
    while (node) {
      R3SurfelObject *object = node->Object(FALSE, FALSE);
      if (object) return object;
      node = node->Parent();
    }
  }

  // Object not found
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
jne 0x37786
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0x3776d
movslq 0x3c(%rbx), %r15
testq %r15, %r15
jle 0x3776d
movq 0x30(%rbx), %r12
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x376f4
testq %rax, %rax
je 0x37760
movsd 0x98(%rax), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmovaq %rax, %r14
maxsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incq %r13
cmpq %r13, %r15
jne 0x3772d
testq %r14, %r14
jne 0x37786
testl %ebp, %ebp
je 0x37783
movq 0x8(%rbx), %r14
testq %r14, %r14
jne 0x37786
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x37771
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_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::InsertIntoPointSet(gaps::R3SurfelPointSet*, int, double) const
void R3SurfelNode::
InsertIntoPointSet(R3SurfelPointSet *pointset, RNBoolean leaf_level, RNScalar max_resolution) const
{
  // Insert points
  if (leaf_level && (NParts() > 0)) {
    // Insert points from all decendent parts at leaf level
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      part->InsertIntoPointSet(pointset, leaf_level, max_resolution);
    }
  }
  else {
    // Insert points from all blocks in this node
    for (int i = 0; i < NBlocks(); i++) {
      R3SurfelBlock *block = Block(i);
      pointset->InsertPoints(block, max_resolution);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x3785d
cmpl $0x0, 0x3c(%r14)
jle 0x3785d
movl %edx, %ebp
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movsd (%rsp), %xmm0
callq 0x37816
incq %r15
movslq 0x3c(%r14), %rax
cmpq %rax, %r15
jl 0x37838
jmp 0x37889
cmpl $0x0, 0x4c(%r14)
jle 0x37889
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq *0x38(%rax)
incq %r15
movslq 0x4c(%r14), %rax
cmpq %rax, %r15
jl 0x37867
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::SetName(char const*)
void R3SurfelNode::
SetName(const char *name)
{
  // Delete previous name
  if (this->name) free(this->name);
  this->name = (name) ? RNStrdup(name) : NULL;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
testq %rdi, %rdi
je 0x378af
callq 0x135e0
testq %r14, %r14
je 0x378be
movq %r14, %rdi
callq 0xac67b
jmp 0x378c0
xorl %eax, %eax
movq %rax, 0xb8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x378e0
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x378e0
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::SetParent(gaps::R3SurfelNode*)
void R3SurfelNode::
SetParent(R3SurfelNode *parent)
{
  // Just checking
  assert(parent);
  assert(this->parent);
  assert(tree);
  assert(tree == this->parent->tree);
  assert(tree == parent->tree);
  if (parent == this->parent) return;

  // Find least common ancestor
  R3SurfelNode *least_common_ancestor = NULL;

  // Invalidate properties starting at current parent
  R3SurfelNode *ancestor = this->parent;
  while (ancestor && (ancestor != least_common_ancestor)) {
    if (ancestor->complexity == -1) break;
    ancestor->complexity = -1;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Invalidate properties starting at new parent
  ancestor = parent;
  while (ancestor && (ancestor != least_common_ancestor)) {
    if (ancestor->complexity == -1) break;
    ancestor->complexity = -1;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r12
cmpq %rsi, %r12
je 0x379d9
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
testq %r12, %r12
je 0x37954
movsd 0xa5834(%rip), %xmm0    # 0xdd160
movq %r12, %rdx
movsd 0x50(%rdx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3793c
jnp 0x37954
movq %rax, 0x50(%rdx)
movq %rcx, 0x68(%rdx)
movq %rcx, 0xa8(%rdx)
movq 0x28(%rdx), %rdx
testq %rdx, %rdx
jne 0x3792f
testq %r14, %r14
je 0x37989
movsd 0xa57ff(%rip), %xmm0    # 0xdd160
movq %r14, %rdx
movsd 0x50(%rdx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x37971
jnp 0x37989
movq %rax, 0x50(%rdx)
movq %rcx, 0x68(%rdx)
movq %rcx, 0xa8(%rdx)
movq 0x28(%rdx), %rdx
testq %rdx, %rdx
jne 0x37964
leaq 0x30(%r12), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa9d20
subq 0x30(%r12), %rax
shrq $0x3, %rax
movq %r15, %rdi
movl %eax, %esi
callq 0xa9ec8
leaq 0x30(%r14), %rdi
movl 0x3c(%r14), %edx
movq %rbx, %rsi
callq 0xa9d3e
movq %r14, 0x28(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x379d9
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x379d9
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::InsertBlock(gaps::R3SurfelBlock*)
void R3SurfelNode::
InsertBlock(R3SurfelBlock *block)
{
  // Just checking
  assert(block->node == NULL);
  assert(!blocks.FindEntry(block));

  // Insert block
  blocks.Insert(block);

  // Update properties
  R3SurfelNode *ancestor = this;
  while (ancestor) {
    if (ancestor->complexity == -1) break;
    ancestor->complexity = -1;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Mark resolution out of date
  resolution = -1;

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

  // Update object
  if (object) object->UpdateAfterInsertBlock(this, block);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rdi
movl 0x4c(%rbx), %edx
callq 0xa9d3e
movsd 0xa575c(%rip), %xmm0    # 0xdd160
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
movq %rbx, %rdx
movsd 0x50(%rdx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x37a28
jnp 0x37a40
movq %rax, 0x50(%rdx)
movq %rcx, 0x68(%rdx)
movq %rcx, 0xa8(%rdx)
movq 0x28(%rdx), %rdx
testq %rdx, %rdx
jne 0x37a1b
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fee4
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x37a63
movq %rbx, %rsi
movq %r14, %rdx
callq 0x18208
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x37a7c
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x37a7c
orb $0x1, 0x1e8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::RemoveBlock(gaps::R3SurfelBlock*)
void R3SurfelNode::
RemoveBlock(R3SurfelBlock *block)
{
  // Just checking
  assert(block->node == this);
  assert(blocks.FindEntry(block));

  // Update object
  if (object) object->UpdateBeforeRemoveBlock(this, block);

  // Update block
  block->UpdateBeforeRemove(this);

  // Remove block
  blocks.Remove(block);

  // Mark resolution out of date
  resolution = -1;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x37aa3
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1827a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2feec
leaq 0x40(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa9d20
subq 0x40(%rbx), %rax
shrq $0x3, %rax
movq %r15, %rdi
movl %eax, %esi
callq 0xa9ec8
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x58(%rbx)
movsd 0xa567b(%rip), %xmm0    # 0xdd160
movabsq $0x47efffffe0000000, %rcx # imm = 0x47EFFFFFE0000000
movq %rbx, %rdx
movsd 0x50(%rdx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x37aff
jnp 0x37b17
movq %rax, 0x50(%rdx)
movq %rcx, 0x68(%rdx)
movq %rcx, 0xa8(%rdx)
movq 0x28(%rdx), %rdx
testq %rdx, %rdx
jne 0x37af2
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x37b30
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x37b30
orb $0x1, 0x1e8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::Transform(gaps::R3Affine const&)
void R3SurfelNode::
Transform(const R3Affine& transformation) 
{
  // Transform all blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    block->Transform(transformation);
  }

  // Update resolution
  RNScalar scale = transformation.ScaleFactor();
  if ((resolution > 0) && (RNIsNotEqual(scale, 1.0))) resolution /= scale * scale;

  // Invalidate bounding boxes starting at this node
  R3SurfelNode *ancestor = this;
  while (ancestor) {
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    ancestor = ancestor->parent;
  }

  // Update object
  if (object) object->UpdateAfterTransform(this);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4c(%rdi)
jle 0x37b66
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x2db00
incq %r15
movslq 0x4c(%rbx), %rax
cmpq %rax, %r15
jl 0x37b4a
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
movsd 0x58(%rbx), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x37bb9
leaq 0xfc080(%rip), %rax     # 0x133c08
movsd (%rax), %xmm2
movsd 0xa55cc(%rip), %xmm3    # 0xdd160
addsd %xmm0, %xmm3
ucomisd %xmm2, %xmm3
ja 0x37bac
xorpd 0xa57fa(%rip), %xmm2    # 0xdd3a0
ucomisd %xmm3, %xmm2
jbe 0x37bb9
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x58(%rbx)
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rbx, %rcx
movq %rax, 0x68(%rcx)
movq %rax, 0xa8(%rcx)
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x37bc6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x37beb
movq %rbx, %rsi
callq 0x182f0
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x37c04
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x37c04
orb $0x1, 0x1e8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::SetMarks(int)
void R3SurfelNode::
SetMarks(RNBoolean mark)
{
  // Set mark for all blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    block->SetMarks(mark);
  }
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0x37c3d
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x2dab8
incq %r15
movslq 0x4c(%r14), %rax
cmpq %rax, %r15
jl 0x37c1d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::ReadBlocks(int)
void R3SurfelNode::
ReadBlocks(RNBoolean entire_subtree)
{
  // Read blocks in node
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    R3SurfelDatabase *database = block->Database();
    if (database) database->ReadBlock(block);
  }

  // Read blocks in parts
  if (entire_subtree) {
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      part->ReadBlocks(entire_subtree);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x4c(%rdi)
jle 0x37ca6
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %r15
movq 0x98(%r15), %rdi
testq %rdi, %rdi
je 0x37c9a
movl 0xb4(%r15), %eax
testl %eax, %eax
jne 0x37c91
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movl 0x28(%rdi), %ecx
movq %r15, %rsi
callq *0x88(%rax)
testl %eax, %eax
je 0x37c9a
movl 0xb4(%r15), %eax
incl %eax
movl %eax, 0xb4(%r15)
incq %r12
movslq 0x4c(%r14), %rax
cmpq %rax, %r12
jl 0x37c54
testl %ebx, %ebx
je 0x37ccf
cmpl $0x0, 0x3c(%r14)
jle 0x37ccf
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x37c3e
incq %r15
movslq 0x3c(%r14), %rax
cmpq %rax, %r15
jl 0x37cb4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::ReleaseBlocks(int)
void R3SurfelNode::
ReleaseBlocks(RNBoolean entire_subtree)
{
  // Release blocks in node
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    R3SurfelDatabase *database = block->Database();
    if (database) database->ReleaseBlock(block);
  }

  // Release blocks in parts
  if (entire_subtree) {
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      part->ReleaseBlocks(entire_subtree);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x4c(%rdi)
jle 0x37d83
xorl %r13d, %r13d
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %r15
movq 0x98(%r15), %r12
testq %r12, %r12
je 0x37d73
movl 0xb4(%r15), %eax
cmpl $0x1, %eax
jne 0x37d3c
movq (%r12), %rax
movq 0x8(%r12), %rdx
movl 0x28(%r12), %ecx
movq %r12, %rdi
movq %r15, %rsi
callq *0x90(%rax)
testl %eax, %eax
je 0x37d73
movl 0xb4(%r15), %eax
decl %eax
movl %eax, 0xb4(%r15)
jne 0x37d73
testb $0x2, 0x89(%r15)
je 0x37d73
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x2ca06
movl $0xc8, %esi
movq %r15, %rdi
callq 0x134f0
incq %r13
movslq 0x4c(%r14), %rax
cmpq %rax, %r13
jl 0x37cf7
testl %ebx, %ebx
je 0x37dac
cmpl $0x0, 0x3c(%r14)
jle 0x37dac
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x37cdc
incq %r15
movslq 0x3c(%r14), %rax
cmpq %rax, %r15
jl 0x37d91
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::AreBlocksResident() const
RNBoolean R3SurfelNode::
AreBlocksResident(void) const
{
  // Return whether blocks are in memory
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    R3SurfelDatabase *database = block->Database();
    if (!database->IsBlockResident(block)) return FALSE;
  }

  // All blocks are resident
  return TRUE;
}

// Assembly:
movslq 0x4c(%rdi), %rcx
testq %rcx, %rcx
jle 0x37df0
movq 0x40(%rdi), %rax
movq (%rax), %rdx
cmpq $0x0, (%rdx)
je 0x37df6
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rcx
je 0x37de7
movq (%rax,%rdx,8), %rdi
leaq 0x1(%rdx), %rsi
cmpq $0x0, (%rdi)
jne 0x37dd1
xorl %eax, %eax
cmpq %rcx, %rdx
setae %al
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::Print(_IO_FILE*, char const*, char const*) const
void R3SurfelNode::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

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

  // Print all surfel blocks
  if (prefix) fprintf(fp, "%s", prefix);
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    fprintf(fp, "%d ", block->DatabaseIndex());
  }
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
jne 0x37e1e
movq 0xfb155(%rip), %rax     # 0x132f70
movq (%rax), %rbx
testq %r12, %r12
je 0x37e2e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x135b0
movl 0x20(%r15), %edx
movq 0xb8(%r15), %rax
testq %rax, %rax
leaq 0xa5503(%rip), %rcx     # 0xdd346
cmovneq %rax, %rcx
leaq 0xa54f2(%rip), %rsi     # 0xdd340
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13740
testq %r14, %r14
je 0x37e68
movq %r14, %rdi
movq %rbx, %rsi
callq 0x135b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x13670
testq %r12, %r12
je 0x37e85
movq %r12, %rdi
movq %rbx, %rsi
callq 0x135b0
cmpl $0x0, 0x4c(%r15)
jle 0x37ebd
leaq 0xa5a10(%rip), %r12     # 0xdd8a3
xorl %r13d, %r13d
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rax
movl 0xa0(%rax), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x13740
incq %r13
movslq 0x4c(%r15), %rax
cmpq %rax, %r13
jl 0x37e96
testq %r14, %r14
je 0x37ecd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x135b0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13670
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::Draw(gaps::RNFlags) const
void R3SurfelNode::
Draw(RNFlags flags) const
{
  // Draw all blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    block->Draw(flags);
  }
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0x37f1e
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2e1d4
incq %r15
movslq 0x4c(%r14), %rax
cmpq %rax, %r15
jl 0x37ef8
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::DrawResidentDescendents(gaps::RNFlags) const
int R3SurfelNode::
DrawResidentDescendents(RNFlags draw_flags) const
{
  // Initialize return status
  int status = 0;

  // Draw parts
  if (NParts() > 0) {
    // Draw resident descendents of all parts
    status = 1;
    for (int i = 0; i < NParts(); i++) {
      R3SurfelNode *part = Part(i);
      status &= part->DrawResidentDescendents(draw_flags);
    }
  }

  // Draw node if resident
  if (status == 0) {
    if (AreBlocksResident()) {
      Draw(draw_flags);
      status = 1;
    }
  }

  // Return whether drew everything
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x3c(%rdi)
jle 0x37f63
movl $0x1, %ebp
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
andl %eax, %ebp
incq %r15
movslq 0x3c(%r14), %rax
cmpq %rax, %r15
jl 0x37f3b
movl $0x1, %eax
testl %ebp, %ebp
jne 0x37fac
movslq 0x4c(%r14), %rcx
testq %rcx, %rcx
jle 0x37f9b
movq 0x40(%r14), %rdx
movq (%rdx), %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
je 0x37fac
movl $0x1, %edi
movq %rdi, %rsi
cmpq %rdi, %rcx
je 0x37f96
movq (%rdx,%rsi,8), %r8
leaq 0x1(%rsi), %rdi
cmpq $0x0, (%r8)
jne 0x37f80
cmpq %rcx, %rsi
jb 0x37fac
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x48(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateAfterInsert(gaps::R3SurfelTree*)
void R3SurfelNode::
UpdateAfterInsert(R3SurfelTree *tree)
{
  // Invalidate properties
  R3SurfelNode *ancestor = parent;
  while (ancestor) {
    if (ancestor->complexity == -1) break;
    ancestor->complexity = -1;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    // while (ancestor->NBlocks()) { 
    //   R3SurfelBlock *block = ancestor->Block(0);
    //   ancestor->RemoveBlock(block);
    //   database->RemoveBlock(block);
    //   delete block;
    // }
    ancestor = ancestor->parent;
  }
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3813e
movsd 0xa505b(%rip), %xmm0    # 0xdd160
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movabsq $0x47efffffe0000000, %rdx # imm = 0x47EFFFFFE0000000
movsd 0x50(%rax), %xmm1
ucomisd %xmm0, %xmm1
jne 0x38126
jnp 0x3813e
movq %rcx, 0x50(%rax)
movq %rdx, 0x68(%rax)
movq %rdx, 0xa8(%rax)
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x38119
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateBeforeRemove(gaps::R3SurfelTree*)
void R3SurfelNode::
UpdateBeforeRemove(R3SurfelTree *tree)
{
  // Invalidate properties
  R3SurfelNode *ancestor = parent;
  while (ancestor) {
    if (ancestor->complexity == -1) break;
    ancestor->complexity = -1;
    ancestor->bbox[0][0] = FLT_MAX;
    ancestor->timestamp_range[0] = FLT_MAX;
    // while (ancestor->NBlocks()) { 
    //   R3SurfelBlock *block = ancestor->Block(0);
    //   ancestor->RemoveBlock(block);
    //   database->RemoveBlock(block);
    //   delete block;
    // }
    ancestor = ancestor->parent;
  }
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x3818a
movsd 0xa500f(%rip), %xmm0    # 0xdd160
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movabsq $0x47efffffe0000000, %rdx # imm = 0x47EFFFFFE0000000
movsd 0x50(%rax), %xmm1
ucomisd %xmm0, %xmm1
jne 0x38172
jnp 0x3818a
movq %rcx, 0x50(%rax)
movq %rdx, 0x68(%rax)
movq %rdx, 0xa8(%rax)
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x38165
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateProperties()
void R3SurfelNode::
UpdateProperties(void)
{
  // Update surfels
  UpdateSurfelNormals();

  // Update properties
  double dummy = 0;
  dummy += Complexity();
  dummy += Resolution();
  dummy += BBox().Min().X();
  dummy += ElevationRange().Min();
  dummy += TimestampRange().Min();
  if (dummy == 927612.21242) {
    printf("Amazing!\n");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x98(%rax)
movsd 0x50(%rbx), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x381c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
xorpd %xmm2, %xmm2
movsd 0x50(%rbx), %xmm1
addsd %xmm2, %xmm1
movsd 0x58(%rbx), %xmm0
ucomisd %xmm0, %xmm2
jbe 0x381ed
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq *0x88(%rax)
movsd 0x8(%rsp), %xmm1
movsd 0x58(%rbx), %xmm0
addsd %xmm0, %xmm1
movsd 0x68(%rbx), %xmm0
ucomisd 0xa4f6a(%rip), %xmm0    # 0xdd168
jne 0x3821c
jp 0x3821c
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq *0x68(%rax)
movsd 0x8(%rsp), %xmm1
movsd 0x68(%rbx), %xmm0
addsd %xmm0, %xmm1
movsd 0x98(%rbx), %xmm0
ucomisd 0xa4f38(%rip), %xmm0    # 0xdd168
jne 0x38251
jp 0x38251
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq *0x70(%rax)
movsd 0x8(%rsp), %xmm1
movsd 0x98(%rbx), %xmm0
addsd %xmm0, %xmm1
movsd 0xa8(%rbx), %xmm0
ucomisd 0xa4f03(%rip), %xmm0    # 0xdd168
jne 0x38286
jp 0x38286
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq *0x78(%rax)
movsd 0x8(%rsp), %xmm1
movsd 0xa8(%rbx), %xmm0
addsd %xmm0, %xmm1
ucomisd 0xa508e(%rip), %xmm1    # 0xdd320
jne 0x382a7
jp 0x382a7
leaq 0xa50ab(%rip), %rdi     # 0xdd348
addq $0x10, %rsp
popq %rbx
jmp 0x137c0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateBBox()
void R3SurfelNode::
UpdateBBox(void)
{
  // Check if bounding box is uptodate
  if (bbox[0][0] != FLT_MAX) return;

  // Initialize bounding box
  bbox = R3null_box;

  // Union bounding boxes of blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    bbox.Union(block->BBox());
  }

  // Union bounding boxes of parts
  for (int i = 0; i < NParts(); i++) {
    R3SurfelNode *part = Part(i);
    bbox.Union(part->BBox());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd 0x68(%rdi), %xmm0
ucomisd 0xa4ea5(%rip), %xmm0    # 0xdd168
jne 0x38371
jp 0x38371
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
addq $0x68, %rdi
leaq 0xfc6e7(%rip), %r15     # 0x1349c8
leaq 0x8(%r15), %rsi
callq 0x8412a
leaq 0x80(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x8412a
cmpl $0x0, 0x4c(%rbx)
jle 0x3832a
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2cb9e
movq %r14, %rdi
movq %rax, %rsi
callq 0x6de0c
incq %r15
movslq 0x4c(%rbx), %rax
cmpq %rax, %r15
jl 0x38306
cmpl $0x0, 0x3c(%rbx)
jle 0x38371
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %r15
movsd 0x68(%r15), %xmm0
ucomisd 0xa4e1f(%rip), %xmm0    # 0xdd168
jne 0x38356
jp 0x38356
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
addq $0x60, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6de0c
incq %r12
movslq 0x3c(%rbx), %rax
cmpq %rax, %r12
jl 0x38333
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateElevationRange()
void R3SurfelNode::
UpdateElevationRange(void)
{
  // Check if range is uptodate
  if (elevation_range[0] != FLT_MAX) return;

  // Initialize elevation range
  elevation_range.Reset(FLT_MAX,-FLT_MAX);

  // Compute elevation range
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    RNInterval block_range = block->ElevationRange();
    elevation_range.Union(block_range);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd 0x98(%rdi), %xmm0
ucomisd 0xa4dd1(%rip), %xmm0    # 0xdd168
jne 0x38409
jp 0x38409
movq %rdi, %rbx
movapd 0xa4f8a(%rip), %xmm0    # 0xdd330
movupd %xmm0, 0x98(%rdi)
cmpl $0x0, 0x4c(%rdi)
jle 0x38409
xorl %r15d, %r15d
movq %rsp, %r14
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2cd2e
movsd (%rsp), %xmm0
movsd 0x98(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x383e5
movsd %xmm0, 0x98(%rbx)
movsd 0x8(%rsp), %xmm0
ucomisd 0xa0(%rbx), %xmm0
jbe 0x383fd
movsd %xmm0, 0xa0(%rbx)
incq %r15
movslq 0x4c(%rbx), %rax
cmpq %rax, %r15
jl 0x383ba
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateTimestampRange()
void R3SurfelNode::
UpdateTimestampRange(void)
{
  // Check if range is uptodate
  if (timestamp_range[0] != FLT_MAX) return;

  // Initialize timestamp range
  timestamp_range.Reset(FLT_MAX,-FLT_MAX);

  // Union timestamp ranges of blocks
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    timestamp_range.Union(block->TimestampRange());
  }

  // Union timestamp ranges of parts
  for (int i = 0; i < NParts(); i++) {
    R3SurfelNode *part = Part(i);
    timestamp_range.Union(part->TimestampRange());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movsd 0xa8(%rdi), %xmm0
ucomisd 0xa4d3f(%rip), %xmm0    # 0xdd168
jne 0x38522
jp 0x38522
movq %rdi, %rbx
movapd 0xa4ef0(%rip), %xmm0    # 0xdd330
movupd %xmm0, 0xa8(%rdi)
cmpl $0x0, 0x4c(%rdi)
jle 0x384a1
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2ce62
movsd (%rax), %xmm1
movsd 0xa8(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3847c
movsd %xmm1, 0xa8(%rbx)
movapd %xmm1, %xmm0
movsd 0x8(%rax), %xmm1
ucomisd 0xb0(%rbx), %xmm1
jbe 0x38493
movsd %xmm1, 0xb0(%rbx)
incq %r14
movslq 0x4c(%rbx), %rax
cmpq %rax, %r14
jl 0x38451
jmp 0x384a9
movsd 0xa4cbf(%rip), %xmm0    # 0xdd168
cmpl $0x0, 0x3c(%rbx)
jle 0x38522
xorl %r15d, %r15d
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %r14
movsd 0xa8(%r14), %xmm1
ucomisd 0xa4c9d(%rip), %xmm1    # 0xdd168
jne 0x384e9
jp 0x384e9
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
movsd 0xa8(%r14), %xmm1
movsd 0xa8(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x384fb
movsd %xmm1, 0xa8(%rbx)
movapd %xmm1, %xmm0
movsd 0xb0(%r14), %xmm1
ucomisd 0xb0(%rbx), %xmm1
jbe 0x38516
movsd %xmm1, 0xb0(%rbx)
incq %r15
movslq 0x3c(%rbx), %rax
cmpq %rax, %r15
jl 0x384b2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateComplexity()
void R3SurfelNode::
UpdateComplexity(void)
{
  // Check if complexity is uptodate
  if (complexity >= 0) return;

  // Sum complexity of blocks
  complexity = 0;
  for (int i = 0; i < NBlocks(); i++) {
    R3SurfelBlock *block = Block(i);
    complexity += block->NSurfels();
  }
}

// Assembly:
movsd 0x50(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x3856f
movq $0x0, 0x50(%rdi)
movslq 0x4c(%rdi), %rax
testq %rax, %rax
jle 0x3856f
movq 0x40(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
xorps %xmm1, %xmm1
cvtsi2sdl 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x38552
movsd %xmm0, 0x50(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelNode.cpp
// Function: gaps::R3SurfelNode::UpdateResolution()
void R3SurfelNode::
UpdateResolution(void)
{
  // Check if resolution is uptodate
  if (resolution >= 0) return;

  // Initialize resolution
  resolution = 0;

  // Compute minimum of block resolutions
  if (Complexity() > 0) {
    resolution = FLT_MAX;
    assert(NBlocks() > 0);
    for (int i = 0; i < NBlocks(); i++) {
      R3SurfelBlock *block = Block(i);
      RNScalar block_resolution = block->Resolution();
      if (block_resolution < resolution) {
        resolution = block_resolution;
      }
    }
  }
}

// Assembly:
movsd 0x58(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x385fb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x58(%rdi)
movsd 0x50(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x385aa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
movsd 0x50(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x385f4
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rax, 0x58(%rbx)
cmpl $0x0, 0x4c(%rbx)
jle 0x385f4
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2d0ea
movsd 0x58(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x385e8
movsd %xmm0, 0x58(%rbx)
incq %r14
movslq 0x4c(%rbx), %rax
cmpq %rax, %r14
jl 0x385cb
addq $0x8, %rsp
popq %rbx
popq %r14
retq