LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x10(%rsi)
je 0x33f13
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x6ea70
movsd 0x50(%rbx), %xmm0
movsd 0x50(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x33eaa
movsd %xmm0, 0x50(%r14)
movsd 0x58(%rbx), %xmm0
ucomisd 0x58(%r14), %xmm0
jbe 0x33ebd
movsd %xmm0, 0x58(%r14)
movl 0x10(%rbx), %esi
addl 0x10(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
cmpl $0x0, 0x10(%rbx)
jle 0x33f08
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movslq 0x10(%r14), %rdi
shlq $0x4, %rdi
addq 0x8(%r14), %rdi
callq 0x326a6
incl 0x10(%r14)
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x33edc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelPointSet const*, gaps::R2Box const&)
void R3SurfelPointSet::
InsertPoints(const R3SurfelPointSet *set, const R2Box& constraint_box)
{
  // Check set
  if (set->NPoints() == 0) return;

  // Check and update bounding box (conservatively)
  R3Box intersection_box(constraint_box[0][0], constraint_box[0][1], -FLT_MAX, constraint_box[1][0], constraint_box[1][1], FLT_MAX);
  intersection_box.Intersect(set->BBox());
  if (intersection_box.IsEmpty()) return;
  bbox.Union(intersection_box);

  // 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++) {
    const R3SurfelPoint *point = set->Point(i);
    R3Point position = point->Position();
    if (!R2Intersects(constraint_box, R2Point(position.X(), position.Y()))) continue;
    points[npoints] = *point;
    npoints++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x0, 0x10(%rsi)
je 0x340a2
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x8(%rdx), %xmm0
movsd 0x10(%rdx), %xmm1
movsd 0x18(%rdx), %xmm3
movq %rdx, (%rsp)
movsd 0x20(%rdx), %xmm4
leaq 0x8(%rsp), %r12
movsd 0xaa221(%rip), %xmm2    # 0xde178
movsd 0xaa211(%rip), %xmm5    # 0xde170
movq %r12, %rdi
callq 0x6e028
leaq 0x18(%r14), %rsi
movq %r12, %rdi
callq 0x6ebb4
movsd 0x10(%rsp), %xmm0
ucomisd 0x28(%rsp), %xmm0
ja 0x34098
movsd 0x18(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
ja 0x34098
movsd 0x20(%rsp), %xmm0
ucomisd 0x38(%rsp), %xmm0
ja 0x34098
leaq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6ea70
movsd 0x50(%r14), %xmm0
movsd 0x50(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x33fcd
movsd %xmm0, 0x50(%rbx)
movsd 0x58(%r14), %xmm0
ucomisd 0x58(%rbx), %xmm0
jbe 0x33fdf
movsd %xmm0, 0x58(%rbx)
movl 0x10(%r14), %esi
addl 0x10(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
cmpl $0x0, 0x10(%r14)
jle 0x34098
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rbp
movq (%rbp,%r12), %rax
movq 0x8(%rbp,%r12), %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
leaq 0x40(%rsp), %rdi
callq 0x84d7e
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0xa3776
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x90e13
testl %eax, %eax
je 0x34084
addq %r12, %rbp
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
addq 0x8(%rbx), %rdi
movq %rbp, %rsi
callq 0x326a6
incl 0x10(%rbx)
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x34003
leaq 0x8(%rsp), %rdi
callq 0x6ede0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x340b5
jmp 0x340b5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6ede0
movq %rbx, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::InsertPoints(gaps::R3SurfelPointSet const*, gaps::R3Box const&)
void R3SurfelPointSet::
InsertPoints(const R3SurfelPointSet *set, const R3Box& constraint_box)
{
  // Check set
  if (set->NPoints() == 0) return;

  // Check and update bounding box (conservatively)
  R3Box intersection_box = constraint_box;
  intersection_box.Intersect(set->BBox());
  if (intersection_box.IsEmpty()) return;
  bbox.Union(intersection_box);

  // 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++) {
    const R3SurfelPoint *point = set->Point(i);
    if (!R3Intersects(constraint_box, point->Position())) continue;
    points[npoints] = *point;
    npoints++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x0, 0x10(%rsi)
je 0x34222
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, (%rsp)
movq %rdx, %rsi
callq 0x6df88
leaq 0x18(%r14), %rsi
movq %r12, %rdi
callq 0x6ebb4
movsd 0x10(%rsp), %xmm0
ucomisd 0x28(%rsp), %xmm0
ja 0x34218
movsd 0x18(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
ja 0x34218
movsd 0x20(%rsp), %xmm0
ucomisd 0x38(%rsp), %xmm0
ja 0x34218
leaq 0x18(%r15), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6ea70
movsd 0x50(%r14), %xmm0
movsd 0x50(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x34164
movsd %xmm0, 0x50(%r15)
movsd 0x58(%r14), %xmm0
ucomisd 0x58(%r15), %xmm0
jbe 0x34178
movsd %xmm0, 0x58(%r15)
movl 0x10(%r14), %esi
addl 0x10(%r15), %esi
movq (%r15), %rax
movq %r15, %rdi
callq *0x80(%rax)
cmpl $0x0, 0x10(%r14)
jle 0x34218
xorl %ebp, %ebp
leaq 0x40(%rsp), %rbx
xorl %r12d, %r12d
movq 0x8(%r14), %r13
movq (%r13,%rbp), %rax
movq 0x8(%r13,%rbp), %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 %rbx, %rdi
callq 0x84d7e
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x49151
testl %eax, %eax
je 0x34208
addq %rbp, %r13
movslq 0x10(%r15), %rdi
shlq $0x4, %rdi
addq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0x326a6
incl 0x10(%r15)
incq %r12
movslq 0x10(%r14), %rax
addq $0x10, %rbp
cmpq %rax, %r12
jl 0x341a1
leaq 0x8(%rsp), %rdi
callq 0x6ede0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34235
jmp 0x34235
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6ede0
movq %rbx, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
cmpl $0x0, 0x10(%rsi)
je 0x345c6
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rsi
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testl %eax, %eax
je 0x345c6
movl 0x10(%r14), %esi
addl 0x10(%r15), %esi
movq (%r15), %rax
movq %r15, %rdi
callq *0x80(%rax)
cmpl $0x0, 0x10(%r14)
jle 0x345c6
leaq 0x18(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rbp
movq (%rbp,%r12), %rsi
movq 0x8(%rbp,%r12), %rdx
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x345b2
addq %r12, %rbp
movq (%rbp), %rax
movq 0x8(%rbp), %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
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x84d7e
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6e9a6
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rcx), %xmm0
addsd 0x60(%rax), %xmm0
movsd 0x50(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3458c
movsd %xmm0, 0x50(%r15)
ucomisd 0x58(%r15), %xmm0
jbe 0x3459a
movsd %xmm0, 0x58(%r15)
movslq 0x10(%r15), %rdi
shlq $0x4, %rdi
addq 0x8(%r15), %rdi
movq %rbp, %rsi
callq 0x326a6
incl 0x10(%r15)
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x344fa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpl 0x14(%rdi), %eax
jne 0x34608
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x4, %esi
cmovgl %ecx, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
movslq 0x10(%rbx), %rdi
leal 0x1(%rdi), %eax
movl %eax, 0x10(%rbx)
shlq $0x4, %rdi
addq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x326a6
leaq 0x18(%rbx), %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
cvtss2sd (%rcx), %xmm0
addsd 0x10(%rax), %xmm0
cvtss2sd 0x4(%rcx), %xmm1
addsd 0x18(%rax), %xmm1
cvtss2sd 0x8(%rcx), %xmm2
addsd 0x20(%rax), %xmm2
movq %rsp, %r12
movq %r12, %rdi
callq 0x84d7e
movq %r15, %rdi
movq %r12, %rsi
callq 0x6e9a6
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rcx), %xmm0
addsd 0x60(%rax), %xmm0
movsd 0x50(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x34684
movsd %xmm0, 0x50(%rbx)
ucomisd 0x58(%rbx), %xmm0
jbe 0x34690
movsd %xmm0, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::AllocatePoints(int)
void R3SurfelPointSet::
AllocatePoints(int n)
{
  // Check if already big enough
  if (n <= nallocated) return;

  // To avoid little increments to nallocated
  if (n < 2*npoints) n = 2*npoints;

  // Allocate enough memory to store n points
  R3SurfelPoint *next_points = new R3SurfelPoint [ n ];

  // Copy and delete old points
  if (points) {
    for (int i = 0; i < npoints; i++) next_points[i] = points[i];
    delete [] points;
  }

  // Update set
  points = next_points;
  nallocated = n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %esi, 0x14(%rdi)
jge 0x347db
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
addl %ebp, %ebp
cmpl %esi, %ebp
cmovlel %esi, %ebp
movslq %ebp, %r15
movq %r15, %r14
shlq $0x4, %r14
leaq 0x8(%r14), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x10(%rsp)
callq 0x13030
leaq 0x8(%rax), %r13
movq %rax, 0x8(%rsp)
movq %r15, (%rax)
testl %r15d, %r15d
je 0x34755
negq %r14
xorl %r15d, %r15d
movq %r13, %r12
movq %r12, %rdi
callq 0x32374
addq $-0x10, %r15
addq $0x10, %r12
cmpq %r15, %r14
jne 0x34740
cmpq $0x0, 0x8(%rbx)
je 0x347d4
cmpl $0x0, 0x10(%rbx)
jle 0x34788
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rsi
addq %r14, %rsi
leaq (%r14,%r13), %rdi
callq 0x326a6
incq %r15
movslq 0x10(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x34768
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x347d4
leaq -0x8(%r12), %rax
movq %rax, 0x8(%rsp)
movq -0x8(%r12), %r14
testq %r14, %r14
je 0x347bf
addq $-0x10, %r12
movq %r14, %r15
shlq $0x4, %r15
leaq (%r12,%r15), %rdi
callq 0x32470
addq $-0x10, %r15
jne 0x347b0
shlq $0x4, %r14
orq $0x8, %r14
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x139b0
movq %r13, 0x8(%rbx)
movl %ebp, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r15, %r15
je 0x3480d
negq %r15
movq 0x8(%rsp), %r14
addq $-0x8, %r14
leaq (%r14,%r15), %rdi
callq 0x32470
addq $-0x10, %r15
jne 0x347fe
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x139b0
movq %rbx, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0x3487b
leaq -0x8(%r13), %r14
movq -0x8(%r13), %r15
testq %r15, %r15
je 0x34868
addq $-0x10, %r13
movq %r15, %rbp
shlq $0x4, %rbp
movq %r13, %rdi
addq %rbp, %rdi
callq 0x32470
addq $-0x10, %rbp
jne 0x34857
shlq $0x4, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x139b0
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
leaq 0x10113a(%rip), %r14    # 0x1359c8
leaq 0x8(%r14), %rsi
callq 0x850ec
leaq 0x38(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0x850ec
leaq 0x502f22(%rip), %rax    # 0x5377d0
movups (%rax), %xmm0
movups %xmm0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x348fc
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x32902
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x348de
cmpl $0x0, 0x10(%r14)
jle 0x3492a
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movl $0x1, %esi
callq 0x32902
incq %r12
movslq 0x10(%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x34909
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x3496d
xorl %ebp, %ebp
movq 0x8(%rbx), %rcx
movslq %ebp, %rdi
shlq $0x4, %rdi
movq 0x8(%rcx,%rdi), %rdx
cmpb $0x0, 0x2f(%rdx)
jns 0x34964
addq %rcx, %rdi
cltq
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
callq 0x326a6
decl 0x10(%rbx)
decl %ebp
incl %ebp
movl 0x10(%rbx), %eax
cmpl %eax, %ebp
jl 0x34933
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x349b1
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movl $0x1, %esi
callq 0x32902
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x34990
cmpl $0x0, 0x10(%r14)
jle 0x349dc
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x32902
incq %r12
movslq 0x10(%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x349be
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x34a1f
xorl %ebp, %ebp
movq 0x8(%rbx), %rcx
movslq %ebp, %rdi
shlq $0x4, %rdi
movq 0x8(%rcx,%rdi), %rdx
cmpb $0x0, 0x2f(%rdx)
jns 0x34a16
addq %rcx, %rdi
cltq
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
callq 0x326a6
decl 0x10(%rbx)
decl %ebp
incl %ebp
movl 0x10(%rbx), %eax
cmpl %eax, %ebp
jl 0x349e5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelPointSet.cpp
// Function: gaps::R3SurfelPointSet::Union(gaps::R3SurfelPointSet const*)
void R3SurfelPointSet::
Union(const R3SurfelPointSet *set)
{
  // Set marks in other point set
  for (int i = 0; i < set->npoints; i++) {
    set->points[i].SetMark(TRUE);
  }

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

  // Count marked points from other point set
  int count = 0;
  for (int i = 0; i < set->npoints; i++) {
    if (!set->points[i].IsMarked()) continue;
    count++;
  }

  // Allocate space for points
  AllocatePoints(npoints + count);

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

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

  // Update timestamp range (conservatively)
  timestamp_range.Union(set->TimestampRange());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rsi)
jle 0x34a63
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
addq %r15, %rdi
movl $0x1, %esi
callq 0x32902
incq %r12
movslq 0x10(%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x34a42
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x34a8e
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
callq 0x32902
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x34a70
movslq 0x10(%r14), %rcx
testq %rcx, %rcx
jle 0x34abf
movq 0x8(%r14), %rdx
shlq $0x4, %rcx
xorl %edi, %edi
xorl %esi, %esi
movq 0x8(%rdx,%rdi), %r8
movzbl 0x2f(%r8), %r8d
shrl $0x7, %r8d
addl %r8d, %esi
addq $0x10, %rdi
cmpq %rdi, %rcx
jne 0x34aa3
jmp 0x34ac1
xorl %esi, %esi
addl %eax, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
cmpl $0x0, 0x10(%r14)
jle 0x34b12
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
movq 0x8(%rsi,%r15), %rax
cmpb $0x0, 0x2f(%rax)
jns 0x34b02
addq %r15, %rsi
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
addq 0x8(%rbx), %rdi
callq 0x326a6
incl 0x10(%rbx)
incq %r12
movslq 0x10(%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x34adc
leaq 0x18(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x6ea70
movsd 0x50(%r14), %xmm0
movsd 0x50(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x34b35
movsd %xmm0, 0x50(%rbx)
movsd 0x58(%r14), %xmm0
ucomisd 0x58(%rbx), %xmm0
jbe 0x34b47
movsd %xmm0, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
je 0x34c62
movq %rdi, %r14
movl $0x10, %edi
callq 0x134e0
movq %rax, %rbx
movq %rax, %rdi
callq 0xaaf34
cmpl $0x0, 0x10(%r14)
jle 0x34c47
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%r12), %r15
testq %r15, %r15
sete %al
cmpq %rbp, %r15
sete %cl
orb %al, %cl
jne 0x34c37
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafac
testq %rax, %rax
jne 0x34c37
movl 0xc(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafca
movq %r15, %rbp
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x34bfe
cmpl $0x0, 0xc(%rbx)
jne 0x34c64
movq %rbx, %rdi
callq 0xaaf9e
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
je 0x34d3a
movq %rdi, %r14
movl $0x10, %edi
callq 0x134e0
movq %rax, %rbx
movq %rax, %rdi
callq 0xaaf34
cmpl $0x0, 0x10(%r14)
jle 0x34d1f
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%r12), %rax
testq %rax, %rax
je 0x34d0f
movq 0xb8(%rax), %r15
testq %r15, %r15
sete %al
cmpq %rbp, %r15
sete %cl
orb %al, %cl
jne 0x34d0f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafac
testq %rax, %rax
jne 0x34d0f
movl 0xc(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafca
movq %r15, %rbp
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x34cca
cmpl $0x0, 0xc(%rbx)
jne 0x34d3c
movq %rbx, %rdi
callq 0xaaf9e
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
je 0x34e23
movq %rdi, %r14
movl $0x10, %edi
callq 0x134e0
movq %rax, %rbx
movq %rax, %rdi
callq 0xaaf34
cmpl $0x0, 0x10(%r14)
jle 0x34e08
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%r12), %rax
testq %rax, %rax
je 0x34df8
movq 0xb8(%rax), %rdi
testq %rdi, %rdi
je 0x34df8
xorl %esi, %esi
xorl %edx, %edx
callq 0x37a16
movq %rax, %r15
testq %rax, %rax
sete %al
cmpq %rbp, %r15
sete %cl
orb %al, %cl
jne 0x34df8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafac
testq %rax, %rax
jne 0x34df8
movl 0xc(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaafca
movq %r15, %rbp
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x34da2
cmpl $0x0, 0xc(%rbx)
jne 0x34e25
movq %rbx, %rdi
callq 0xaaf9e
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x134f0
movq %r14, %rdi
callq 0x138b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0xc8, %edi
callq 0x134e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2b96c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e9ea
testl %eax, %eax
je 0x352cc
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movl $0x1, %eax
jmp 0x352ce
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x134f0
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x13560
testq %rax, %rax
je 0x3533a
movq %rax, %r15
leaq 0xa9bbe(%rip), %rsi     # 0xdeed1
movl $0x4, %edx
movq %rax, %rdi
callq 0x13240
testl %eax, %eax
je 0x35353
leaq 0xa9171(%rip), %rdi     # 0xde49c
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xaddb2
jmp 0x3534b
leaq 0xa9b5b(%rip), %rdi     # 0xdee9c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x13070
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0xc8(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xaff73(%rip), %rsi     # 0xe52f8
movq %r15, %rdi
callq 0x135d0
testq %rax, %rax
je 0x35429
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x3541a
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rsp, %r15
leaq 0xab038(%rip), %r12     # 0xe03e9
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r13), %rcx
movq (%rax,%r13), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
addsd 0x10(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax), %xmm1
addsd 0x18(%rcx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rax), %xmm2
addsd 0x20(%rcx), %xmm2
movq %r15, %rdi
callq 0x84d7e
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq %r14, %rdi
movq %r12, %rsi
movb $0x3, %al
callq 0x13740
incq %rbp
movslq 0x10(%rbx), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x353b1
movq %r14, %rdi
callq 0x134d0
movl $0x1, %ebx
jmp 0x3543c
leaq 0xa90a2(%rip), %rdi     # 0xde4d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xaddb2
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<gaps::R3SurfelPoint*>::R3Kdtree(gaps::RNArray<gaps::R3SurfelPoint*> const&, gaps::R3Point (*)(gaps::R3SurfelPoint*, void*), void*)
R3Kdtree<PtrType>::
R3Kdtree(const RNArray<PtrType>& points, R3Point (*position_callback)(PtrType, void *), void *position_callback_data)
  : position_offset(-1),
    position_callback(position_callback),
    position_callback_data(position_callback_data),
    npoints(points.NEntries()),
    nnodes(1)
{
  // Create root node
  root = new R3KdtreeNode<PtrType>(NULL);
  assert(root);

  // Determine bounding box 
  bbox = R3null_box;
  for (int i = 0; i < points.NEntries(); i++) {
    bbox.Union(Position(points[i]));
  }

  // Allocate copy of points array (so that it can be sorted)
  PtrType *copy = new PtrType [ points.NEntries() ];
  assert(copy);

  // Copy points
  for (int i = 0; i < points.NEntries(); i++) 
    copy[i] = points[i];

  // Insert points into root
  InsertPoints(root, bbox, copy, points.NEntries());

  // Delete copy of points array
  delete [] copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6df44
movl $0xffffffff, 0x38(%rbx) # imm = 0xFFFFFFFF
movq %r12, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x58(%rbx)
movl $0x1, 0x5c(%rbx)
movl $0x130, %edi            # imm = 0x130
callq 0x134e0
xorl %ecx, %ecx
movl %ecx, 0x128(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl %ecx, 0x20(%rax)
movq %rax, 0x50(%rbx)
leaq 0x8(%rbx), %rdi
leaq 0xfff51(%rip), %r15     # 0x1359c8
leaq 0x8(%r15), %rsi
callq 0x850ec
leaq 0x20(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x850ec
movl 0xc(%r14), %r15d
testl %r15d, %r15d
jle 0x35aca
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq (%r14), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x35c02
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6e9a6
incq %r13
movslq 0xc(%r14), %r15
cmpq %r15, %r13
jl 0x35aa1
movslq %r15d, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x13030
movq %rax, %r12
testl %r15d, %r15d
jle 0x35b07
movq (%r14), %rax
movl %r15d, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%r12,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x35af7
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %r12, %rcx
movl %r15d, %r8d
callq 0x35c56
movq %r12, %rdi
callq 0x13680
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x35b36
jmp 0x35b36
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ede0
movq %r14, %rdi
callq 0x138b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/../../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 $0x38, %rsp
movq %r9, %rbx
movq %rdi, %rbp
movq 0x50(%rdi), %r15
testq %r15, %r15
sete %dil
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
seta %r9b
xorl %eax, %eax
orb %dil, %r9b
jne 0x360f7
maxsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movsd %xmm2, (%rsp)
mulsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movslq %edx, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rsi, %r13
callq 0x13030
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x35c02
movq %rbp, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
leaq 0x20(%rsp), %r8
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %r12d, %r9d
movq 0x70(%rsp), %r12
pushq %r14
pushq %rbx
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x36106
addq $0x20, %rsp
testq %r12, %r12
je 0x360ec
cmpl $0x0, 0xc(%rbx)
jle 0x360ec
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movsd (%r14,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x360d1
sqrtsd %xmm0, %xmm0
jmp 0x360da
callq 0x133c0
xorpd %xmm1, %xmm1
movsd %xmm0, (%r12,%r15,8)
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x360bf
movq %r14, %rdi
callq 0x13680
movl 0xc(%rbx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/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, %r14
movq %rdi, %r15
leaq 0xf9377(%rip), %rax     # 0x12f988
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
movq %rdi, 0x10(%rsp)
callq 0x32a30
movq $0x0, 0x68(%r15)
movl 0x70(%r14), %eax
movl %eax, 0x70(%r15)
movsd 0x78(%r14), %xmm0
movsd %xmm0, 0x78(%r15)
movslq 0x18(%r15), %r13
movq %r13, %rbx
shlq $0x4, %rbx
leaq 0x8(%rbx), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x13030
movq %r13, (%rax)
movq %rax, (%rsp)
leaq 0x8(%rax), %r12
testl %r13d, %r13d
je 0x36697
negq %rbx
xorl %r13d, %r13d
movq %r12, %rbp
movq %rbp, %rdi
callq 0xaaf34
addq $-0x10, %r13
addq $0x10, %rbp
cmpq %r13, %rbx
jne 0x36682
movq %r12, 0x68(%r15)
cmpl $0x0, 0x18(%r15)
jle 0x3670a
xorl %r12d, %r12d
movq %r12, %r13
shlq $0x4, %r13
movq 0x68(%r15), %rdi
addq %r13, %rdi
movq 0x68(%r14), %rax
movl 0xc(%rax,%r13), %esi
callq 0xab028
movq 0x68(%r14), %rax
cmpl $0x0, 0xc(%rax,%r13)
jle 0x366fe
addq %r13, %rax
xorl %ebx, %ebx
movq 0x68(%r15), %rdi
movq (%rax), %rax
movq (%rax,%rbx,8), %rsi
movl 0xc(%rdi,%r13), %edx
addq %r13, %rdi
callq 0xaafca
incq %rbx
movq 0x68(%r14), %rax
movslq 0xc(%rax,%r13), %rcx
addq %r13, %rax
cmpq %rcx, %rbx
jl 0x366d2
incq %r12
movslq 0x18(%r15), %rax
cmpq %rax, %r12
jl 0x366a5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3674f
jmp 0x3674f
movq %rax, %r14
testq %r13, %r13
je 0x3673f
negq %r13
movq (%rsp), %rbx
addq $-0x8, %rbx
leaq (%rbx,%r13), %rdi
callq 0xaaf9e
addq $-0x10, %r13
jne 0x36730
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x139b0
jmp 0x36752
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x32b34
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf9201(%rip), %rax     # 0x12f988
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x30(%rsp)
callq 0x32a30
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 0x36806
negq %rbx
xorl %r12d, %r12d
movq %r15, %r13
movq %r13, %rdi
callq 0xaaf34
addq $-0x10, %r12
addq $0x10, %r13
cmpq %r12, %rbx
jne 0x367f1
movq %r15, 0x68(%r14)
leaq 0x18(%rsp), %rdi
callq 0xaaf34
cmpl $0x0, 0x18(%r14)
jle 0x36848
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 0xaafca
incq %r12
movslq 0x18(%r14), %rax
addq $0x10, %rbx
cmpq %rax, %r12
jl 0x36825
leaq -0x3eca(%rip), %rdx     # 0x32985
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %ecx, %ecx
callq 0x35a0e
cmpl $0x0, 0x18(%r14)
jle 0x368af
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 0x35fea
incq %r12
movslq 0x18(%r14), %rax
addq $0x10, %rbx
cmpq %rax, %r12
jl 0x36871
leaq 0x38(%rsp), %rdi
callq 0x35b4a
leaq 0x18(%rsp), %rdi
callq 0xaaf9e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x368ed
jmp 0x368d9
movq %rax, %r14
jmp 0x3692e
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x35b4a
jmp 0x368f0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xaaf9e
jmp 0x3692e
movq %rax, %r14
testq %r12, %r12
je 0x3691f
negq %r12
movq 0x8(%rsp), %rbx
addq $-0x8, %rbx
leaq (%rbx,%r12), %rdi
callq 0xaaf9e
addq $-0x10, %r12
jne 0x36910
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x139b0
movq 0x30(%rsp), %rdi
callq 0x32b34
movq %r14, %rdi
callq 0x138b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34e50
movl $0x1, %edi
callq 0x13130
cmpl $0x0, 0x18(%rbx)
jle 0x36e5f
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movq %r12, 0x8(%rsp)
shlq $0x4, %r12
movq 0x68(%rbx), %rax
cmpl $0x0, 0xc(%rax,%r12)
jle 0x36e4a
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 0x84d7e
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 0x84d7e
movq %r14, %rdi
callq 0x13150
incq %rbp
movq 0x68(%rbx), %rax
movslq 0xc(%rax,%r12), %rcx
cmpq %rcx, %rbp
jl 0x36db2
movq 0x8(%rsp), %r12
incq %r12
movslq 0x18(%rbx), %rax
cmpq %rax, %r12
jl 0x36d90
callq 0x136a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/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 %rbx
movq %rdi, %rbx
leaq 0xf8377(%rip), %rax     # 0x12f9c0
movq %rax, (%rdi)
movslq 0x4c(%rbx), %rax
testq %rax, %rax
jle 0x37669
movq (%rbx), %rcx
movq 0x40(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
movq %rbx, %rdi
callq *0x30(%rcx)
jmp 0x3764c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3767a
movq %rbx, %rsi
callq 0x16fc4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x376a3
movq (%rdi), %rax
xorl %esi, %esi
callq *0x78(%rax)
jmp 0x376a3
movq 0x30(%rbx), %rcx
movl %eax, %eax
movq -0x8(%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x376a3
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x3c(%rbx), %eax
testl %eax, %eax
jg 0x3768d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x376bb
movq %rbx, %rsi
callq 0x393e0
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x376cc
callq 0x135e0
leaq 0x60(%rbx), %rdi
callq 0x6ede0
leaq 0x40(%rbx), %rdi
callq 0xaaf9e
addq $0x30, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xaaf9e
jmp 0x376ed
movq %rax, %rdi
callq 0x1848f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37821
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xb0073(%rip), %rax     # 0xe77e8
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 0x2d4ca
movapd %xmm0, %xmm1
ucomisd 0xa6bcb(%rip), %xmm0    # 0xde388
xorpd %xmm0, %xmm0
jne 0x377c5
jnp 0x377ec
mulsd 0x8(%rsp), %xmm1
movsd 0xa697d(%rip), %xmm0    # 0xde150
divsd %xmm1, %xmm0
ucomisd 0xa6ba9(%rip), %xmm0    # 0xde388
jb 0x377e7
sqrtsd %xmm0, %xmm0
jmp 0x377ec
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 0x3778a
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_O1/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 0xa6927(%rip), %xmm0    # 0xde170
jne 0x37856
jp 0x37856
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_O1/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 0xa68f8(%rip), %xmm0    # 0xde170
jne 0x37882
jp 0x37882
movq (%rdi), %rax
callq *0x70(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa68d0(%rip), %xmm0    # 0xde170
jne 0x378aa
jp 0x378aa
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
popq %rbx
retq
nop