LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromWorldToCamera(gaps::R3Point const&) const
R3Point R3SurfelImage::
TransformFromWorldToCamera(const R3Point& world_position) const
{
  // Initialize result
  R3Point camera_position = pose.InverseMatrix() * world_position;

  // Check if has rolling shutter
  if (HasRollingShutter()) {
    // Search for x coordinate (there is a different camera pose for every column)
    int column_index = ImageWidth() / 2;
    int last_column_index = column_index;
    for (int i = 0; i < ImageWidth()/2; i++) {
      // Transform world point into column's camera coordinate system
      R3CoordSystem cs = RollingShutterPoseAtImagePosition(R2Point(column_index, 0));
      R3Point camera_p = cs.InverseMatrix() * world_position;
      if (RNIsPositiveOrZero(camera_p.Z())) return camera_position;
      camera_position = camera_p;
      
      // Get/check column index
      R2Point distorted_position = TransformFromCameraToImage(camera_position);
      column_index = (int) (distorted_position.X() + 0.5);
      if (column_index < 0) column_index = 0;
      if (column_index >= ImageWidth()-1) column_index = ImageWidth()-1;
      if (column_index == last_column_index) break;
      last_column_index = column_index;
    }
  }

  // Return camera position
  return camera_position;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x30, %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x714b6
movq %r14, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdx
callq 0x7514e
testb $0x1, 0x1c8(%r15)
je 0x3d095
cmpl $0x2, 0x98(%r15)
jl 0x3d095
movl 0x98(%r15), %eax
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
leaq 0x28(%rsp), %r12
xorl %r13d, %r13d
movl %ebx, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
xorps %xmm1, %xmm1
movq %r12, %rdi
callq 0xa3776
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d0ac
movq %r12, %rdi
movq %r14, %rsi
callq 0x714b6
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x7514e
movsd 0x20(%rsp), %xmm0
leaq 0xf7bf7(%rip), %rax     # 0x134c08
movsd (%rax), %xmm1
xorpd 0xa1383(%rip), %xmm1    # 0xde3a0
ucomisd %xmm1, %xmm0
jae 0x3d073
movq %r14, %rsi
movq (%rsp), %r14
movq %r14, %rdi
callq 0x850ec
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3d128
movsd 0x28(%rsp), %xmm0
addsd 0xa10f2(%rip), %xmm0    # 0xde140
cvttsd2si %xmm0, %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
movl 0x98(%r15), %ebp
decl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl %ebx, %ebp
setne %al
movl %ebp, %ebx
jmp 0x3d075
xorl %eax, %eax
testb %al, %al
je 0x3d095
incl %r13d
movl 0x98(%r15), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %r13d
jl 0x3cfbc
movq (%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
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/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::RollingShutterPoseAtImagePosition(gaps::R2Point const&) const
R3CoordSystem R3SurfelImage::
RollingShutterPoseAtImagePosition(const R2Point& image_position) const
{
  // Check rolling shutter parameters
  if (!HasRollingShutter()) return pose;
  if (image_width <= 1) return rolling_shutter_poses[0];

  // Get interpolation parameter
  double u = (double) image_position.X() / (double) (image_width-1);
  if (u <= 0) return rolling_shutter_poses[0];
  if (u >= 1) return rolling_shutter_poses[1];

  // Return slerped pose
  return R3CoordSystemSlerp(rolling_shutter_poses[0], rolling_shutter_poses[1], u);
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
testb $0x1, 0x1c8(%rsi)
jne 0x3d0c2
addq $0x30, %rax
jmp 0x3d10f
movl 0x98(%rax), %ecx
cmpl $0x1, %ecx
jle 0x3d109
movsd (%rdx), %xmm0
decl %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x3d109
ucomisd 0xa1063(%rip), %xmm0    # 0xde150
jae 0x3d11f
leaq 0xf0(%rax), %rsi
addq $0x150, %rax            # imm = 0x150
movq %rbx, %rdi
movq %rax, %rdx
callq 0x71667
jmp 0x3d11a
addq $0xf0, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x713de
movq %rbx, %rax
popq %rbx
retq
addq $0x150, %rax            # imm = 0x150
jmp 0x3d10f
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromCameraToImage(gaps::R3Point const&) const
R2Point R3SurfelImage::
TransformFromCameraToImage(const R3Point& camera_position) const
{
  // Project 3D point in camera coordinates into pixels
  const R2Point c = ImageCenter();
  RNCoord x = c.X() + xfocal * camera_position.X() / -camera_position.Z();
  RNCoord y = c.Y() + yfocal * camera_position.Y() / -camera_position.Z();
  R2Point undistorted_image_position(x, y);
  
  // Distort image position
  return DistortImagePosition(undistorted_image_position);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0xa0, %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xa3780
movsd 0xb0(%r14), %xmm1
movsd 0xb8(%r14), %xmm2
mulsd (%r15), %xmm1
movsd 0x10(%r15), %xmm3
divsd %xmm3, %xmm1
movsd (%r12), %xmm0
subsd %xmm1, %xmm0
movsd 0x8(%r12), %xmm1
mulsd 0x8(%r15), %xmm2
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa3776
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3d224
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromWorldToImage(gaps::R3Point const&) const
R2Point R3SurfelImage::
TransformFromWorldToImage(const R3Point& world_position) const
{
  // Transform into camera coordinates
  R3Point camera_position = TransformFromWorldToCamera(world_position);
  if (RNIsPositiveOrZero(camera_position.Z())) return R2unknown_point;

  // Transform into image coordinates
  return TransformFromCameraToImage(camera_position);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3cf44
movsd 0x10(%r15), %xmm0
leaq 0xf7a25(%rip), %rax     # 0x134c08
movsd (%rax), %xmm1
xorpd 0xa11b1(%rip), %xmm1    # 0xde3a0
ucomisd %xmm1, %xmm0
jae 0x3d207
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d128
jmp 0x3d216
leaq 0x4fa172(%rip), %rsi    # 0x537380
movq %rbx, %rdi
callq 0xa3780
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromCameraToWorld(gaps::R3Point const&) const
R3Point R3SurfelImage::
TransformFromCameraToWorld(const R3Point& camera_position) const
{
  // Check if rolling shutter
  if (HasRollingShutter()) {
    // Get projected image position
    R2Point image_position = TransformFromCameraToImage(camera_position);

    // Get rolling shutter pose
    R3CoordSystem rs_pose = RollingShutterPoseAtImagePosition(image_position);

    // Transform 3D point from camera into world coordinate system
    return rs_pose.Matrix() * camera_position;
  }
  else {
    // Transform 3D point from camera into world coordinate system
    return CameraToWorld() * camera_position;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, 0x1c8(%rsi)
jne 0x3d50c
addq $0x30, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7142e
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x3d549
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3d128
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d0ac
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x7142e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7514e
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromImageToWorld(gaps::R2Point const&, double) const
R3Point R3SurfelImage::
TransformFromImageToWorld(const R2Point& image_position, RNLength depth) const
{
  // Transform from image to camera coordinates
  R3Point camera_position = TransformFromImageToCamera(image_position, depth);

  // Transform from camera to world coordinates
  if (HasRollingShutter()) {
    // Get rolling shutter pose
    R3CoordSystem rs_pose = RollingShutterPoseAtImagePosition(image_position);

    // Return position in world coordinates
    return rs_pose.Matrix() * camera_position;
  }
  else {
    // Return position in world coordinates
    return TransformFromCameraToWorld(camera_position);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3d5e2
testb $0x1, 0x1c8(%r14)
jne 0x3d59f
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d4ce
jmp 0x3d5d0
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3d0ac
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x7142e
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7514e
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::TransformFromImageToCamera(gaps::R2Point const&, double) const
R3Point R3SurfelImage::
TransformFromImageToCamera(const R2Point& image_position, RNLength depth) const
{
  // Check camera parameters
  if ((xfocal <= 0) || (yfocal <= 0)) return R3unknown_point;

  // Undistort image position
  R2Point undistorted_image_position = UndistortImagePosition(image_position);
  if (undistorted_image_position == R2unknown_point) return R3unknown_point;

  // Get depth
  if (depth < 0) {
    if (channels.NEntries() <= R3_SURFEL_DEPTH_CHANNEL) return R3unknown_point;
    if (!channels[R3_SURFEL_DEPTH_CHANNEL]) return R3unknown_point;
    int ix = image_position.X() + 0.5;
    int iy = image_position.Y() + 0.5;
    depth = channels[R3_SURFEL_DEPTH_CHANNEL]->GridValue(ix, iy);
  }

  // Backproject from pixels into camera coordinate system
  const R2Point c = ImageCenter();
  RNCoord x = (undistorted_image_position.X() - c.X()) * depth / xfocal;
  RNCoord y = (undistorted_image_position.Y() - c.Y()) * depth / yfocal;
  return R3Point(x, y, -depth);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd 0xb0(%rsi), %xmm1
jae 0x3d636
movq %rsi, %r14
ucomisd 0xb8(%rsi), %xmm1
jae 0x3d636
movq %rdx, %r15
movapd %xmm0, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3d712
leaq 0x4f9d56(%rip), %rsi    # 0x537380
movq %r12, %rdi
callq 0xa3a46
testl %eax, %eax
je 0x3d654
leaq 0x4f9123(%rip), %rsi    # 0x536760
movq %rbx, %rdi
callq 0x84d8e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3d6ae
cmpl $0x3, 0x2c(%r14)
jle 0x3d636
movq 0x20(%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x3d636
movsd 0xa0ac1(%rip), %xmm0    # 0xde140
movsd (%r15), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
addsd 0x8(%r15), %xmm0
cvttsd2si %xmm0, %edx
imull 0xc8(%rax), %edx
movq 0xb8(%rax), %rax
addl %ecx, %edx
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm1
movapd %xmm1, (%rsp)
leaq 0xa0(%r14), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xa3780
movsd 0x18(%rsp), %xmm0
subsd (%r15), %xmm0
movapd (%rsp), %xmm2
mulsd %xmm2, %xmm0
divsd 0xb0(%r14), %xmm0
movsd 0x20(%rsp), %xmm1
subsd 0x8(%r15), %xmm1
mulsd %xmm2, %xmm1
divsd 0xb8(%r14), %xmm1
xorpd 0xa0c9b(%rip), %xmm2    # 0xde3a0
movq %rbx, %rdi
callq 0x84d7e
jmp 0x3d645
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::UndistortImagePosition(gaps::R2Point const&) const
R2Point R3SurfelImage::
UndistortImagePosition(const R2Point& distorted_image_position) const
{
  // Check distortion type
  if (distortion_type == R3_SURFEL_NO_DISTORTION)
    return distorted_image_position;

  // Check distortion parameters
  if ((radial_distortion[0] == 0) && (radial_distortion[1] == 0) && (radial_distortion[2] == 0) &&
      (tangential_distortion[0] == 0) && (tangential_distortion[1] == 0))
    return distorted_image_position;

  // Check focal lengths
  if ((xfocal <= 0) || (yfocal <= 0))
    return distorted_image_position;
  
  // Not implemented yet
  RNWarning("R3SurfelImage::UndistortImagePosition not implemented");
  return distorted_image_position;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x0, 0xc0(%rsi)
je 0x3d787
movupd 0xc8(%rsi), %xmm0
movupd 0xd8(%rsi), %xmm1
xorpd %xmm2, %xmm2
cmpneqpd %xmm2, %xmm1
cmpneqpd %xmm2, %xmm0
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movmskps %xmm0, %eax
testl %eax, %eax
jne 0x3d762
movsd 0xe8(%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3d762
jnp 0x3d787
xorps %xmm0, %xmm0
ucomisd 0xb0(%rsi), %xmm0
jae 0x3d787
ucomisd 0xb8(%rsi), %xmm0
jae 0x3d787
leaq 0xa1f78(%rip), %rdi     # 0xdf6f8
xorl %eax, %eax
callq 0xade6d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa3780
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::RollingShutterPoseAtTimestamp(double) const
R3CoordSystem R3SurfelImage::
RollingShutterPoseAtTimestamp(RNScalar t) const
{
  // Check rolling shutter parameters
  if (!HasRollingShutter()) return pose;
  double dt = rolling_shutter_timestamps[1] - rolling_shutter_timestamps[0];
  if (RNIsZero(dt)) return rolling_shutter_poses[0];

  // Get interpolation parameter
  double u = (t - rolling_shutter_timestamps[0]) / dt;
  if (u <= 0) return rolling_shutter_poses[0];
  if (u >= 1) return rolling_shutter_poses[1];
  
  // Return slerped pose
  return R3CoordSystemSlerp(rolling_shutter_poses[0], rolling_shutter_poses[1], u);
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
testb $0x1, 0x1c8(%rsi)
jne 0x3d80a
addq $0x30, %rdx
jmp 0x3d87c
movsd 0x1b0(%rdx), %xmm2
movsd 0x1b8(%rdx), %xmm1
subsd %xmm2, %xmm1
leaq 0xf73e3(%rip), %rax     # 0x134c08
movsd (%rax), %xmm3
movapd 0xa0b6f(%rip), %xmm4    # 0xde3a0
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
jb 0x3d841
ucomisd %xmm1, %xmm3
jae 0x3d875
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x3d875
ucomisd 0xa08f5(%rip), %xmm0    # 0xde150
jae 0x3d88c
leaq 0xf0(%rdx), %rsi
addq $0x150, %rdx            # imm = 0x150
movq %rbx, %rdi
callq 0x71667
jmp 0x3d887
addq $0xf0, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x713de
movq %rbx, %rax
popq %rbx
retq
addq $0x150, %rdx            # imm = 0x150
jmp 0x3d87c
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::RollingShutterTimestampAtImagePosition(gaps::R2Point const&) const
RNScalar R3SurfelImage::
RollingShutterTimestampAtImagePosition(const R2Point& image_position) const
{
  // Check rolling shutter parameters
  if (!HasRollingShutter()) return timestamp;
  if (image_width <= 1) return rolling_shutter_timestamps[0];

  // Get interpolation parameter
  double u = (double) image_position.X() / (double) (image_width-1);
  if (u <= 0) return rolling_shutter_timestamps[0];
  if (u >= 1) return rolling_shutter_timestamps[1];

  // Return interpolated timestamp
  return (1-u)*rolling_shutter_timestamps[0] + u*rolling_shutter_timestamps[1];
}

// Assembly:
testb $0x1, 0x1c8(%rdi)
jne 0x3d8a8
movsd 0x90(%rdi), %xmm0
retq
movl 0x98(%rdi), %eax
cmpl $0x1, %eax
jle 0x3d8f6
movsd (%rsi), %xmm1
decl %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0x3d8f6
ucomisd 0xa087d(%rip), %xmm1    # 0xde150
jae 0x3d8ff
movsd 0xa0873(%rip), %xmm0    # 0xde150
subsd %xmm1, %xmm0
mulsd 0x1b8(%rdi), %xmm1
mulsd 0x1b0(%rdi), %xmm0
addsd %xmm1, %xmm0
retq
movsd 0x1b0(%rdi), %xmm0
retq
movsd 0x1b8(%rdi), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::Print(_IO_FILE*, char const*, char const*) const
void R3SurfelImage::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
jne 0x3d925
movq 0xf664e(%rip), %rax     # 0x133f70
movq (%rax), %rbx
testq %rdx, %rdx
je 0x3d935
movq %rdx, %rdi
movq %rbx, %rsi
callq 0x135b0
movl 0x10(%r15), %edx
movq 0x1c0(%r15), %rax
testq %rax, %rax
leaq 0xa09fc(%rip), %rcx     # 0xde346
cmovneq %rax, %rcx
leaq 0xa09eb(%rip), %rsi     # 0xde340
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13740
testq %r14, %r14
je 0x3d96f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x135b0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelImage.cpp
// Function: gaps::R3SurfelImage::Draw(gaps::RNFlags, double) const
void R3SurfelImage::
Draw(RNFlags flags, RNScalar scale) const
{
#if 1
  // Draw towards and up
  RNGrfxBegin(RN_GRFX_LINES);
  const R3Point& viewpoint = Viewpoint();
  const R3Vector towards = Towards();
  const R3Vector up = Up();
  R3LoadPoint(viewpoint);
  R3LoadPoint(viewpoint + scale * towards);
  R3LoadPoint(viewpoint);
  R3LoadPoint(viewpoint + 0.5 * scale * up);
  RNGrfxEnd();
#else
  // Draw R3Camera approximation
  Camera().Draw(scale);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %r15
movl $0x1, %edi
callq 0x13130
leaq 0x30(%r15), %rbx
leaq 0x78(%r15), %rsi
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x864ac
addq $0x60, %r15
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x85826
movq %rbx, %rdi
callq 0x13150
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movsd (%rsp), %xmm0
callq 0x861e6
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x850c9
movq %r12, %rdi
callq 0x13150
movq %rbx, %rdi
callq 0x13150
movsd (%rsp), %xmm0
mulsd 0xa072b(%rip), %xmm0    # 0xde140
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x861e6
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x850c9
movq %r14, %rdi
callq 0x13150
callq 0x136a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeature.cpp
// Function: gaps::R3SurfelFeature::operator=(gaps::R3SurfelFeature const&)
R3SurfelFeature& R3SurfelFeature::
operator=(const R3SurfelFeature& feature)
{
  // Assign properties
  this->name = (feature.name) ? RNStrdup(feature.name) : NULL;
  this->range = feature.range;
  this->weight = feature.weight;

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x3e46a
callq 0xadc0f
jmp 0x3e46c
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeature.cpp
// Function: gaps::R3SurfelFeature::Print(_IO_FILE*, char const*, char const*) const
void R3SurfelFeature::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print feature name
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "%s ", Name());
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
jne 0x3e51f
movq 0xf5a54(%rip), %rax     # 0x133f70
movq (%rax), %rbx
testq %rdx, %rdx
je 0x3e52f
movq %rdx, %rdi
movq %rbx, %rsi
callq 0x135b0
movq 0x18(%r15), %rdx
leaq 0xa0432(%rip), %rsi     # 0xde96c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13740
testq %r14, %r14
je 0x3e554
movq %r14, %rdi
movq %rbx, %rsi
callq 0x135b0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::R3SurfelFeatureVector(int)
R3SurfelFeatureVector::
R3SurfelFeatureVector(int nvalues)
  : values(NULL),
    nvalues(nvalues)
{
  // Allocate values
  if (nvalues > 0) {
    values = new RNScalar [ nvalues ];
    for (int i = 0; i < nvalues; i++) {
      values[i] = RN_UNKNOWN;
    }
  }
}

// Assembly:
leaq 0xf1889(%rip), %rax     # 0x12fdf8
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl %esi, 0x10(%rdi)
testl %esi, %esi
jle 0x3e640
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
leaq (,%r15,8), %rdi
callq 0x13030
movq %rax, 0x8(%r14)
incl %ebx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ebx
shlq $0x4, %rbx
movdqa 0xa11d0(%rip), %xmm1    # 0xdf790
xorl %ecx, %ecx
movdqa 0xa11d6(%rip), %xmm2    # 0xdf7a0
pxor %xmm2, %xmm0
movabsq $-0x4010000000000000, %rdx # imm = 0xBFF0000000000000
pcmpeqd %xmm3, %xmm3
movdqa 0xa11cc(%rip), %xmm4    # 0xdf7b0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x3e61a
movq %rdx, (%rax,%rcx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x3e62e
movq %rdx, 0x8(%rax,%rcx)
paddq %xmm4, %xmm1
addq $0x10, %rcx
cmpq %rcx, %rbx
jne 0x3e5e4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::R3SurfelFeatureVector(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector::
R3SurfelFeatureVector(const R3SurfelFeatureVector& vector)
  : values(NULL),
    nvalues(vector.nvalues)
{
  // Allocate values
  if (nvalues > 0) {
    values = new RNScalar [ nvalues ];
    for (int i = 0; i < nvalues; i++) {
      values[i] = vector.values[i];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xf17aa(%rip), %rax     # 0x12fdf8
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movslq 0x10(%rsi), %r15
movl %r15d, 0x10(%rdi)
testq %r15, %r15
jle 0x3e695
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%r15,8), %rdi
callq 0x13030
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x3e683
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator=(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator=(const R3SurfelFeatureVector& vector)
{
  // Reallocate values
  if (nvalues != vector.nvalues) {
    nvalues = vector.nvalues;
    if (values) delete [] values;
    if (nvalues > 0) values = new RNScalar [ nvalues ];
    else values = NULL;
  }

  // Copy values
  for (int i = 0; i < nvalues; i++) {
    values[i] = vector.values[i];
  }

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cmpl %eax, 0x10(%rdi)
je 0x3e71b
movl %eax, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3e701
callq 0x13680
movslq 0x10(%rbx), %rdi
testq %rdi, %rdi
jle 0x3e715
shlq $0x3, %rdi
callq 0x13030
jmp 0x3e717
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3e740
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3e72e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator+=(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator+=(const R3SurfelFeatureVector& vector)
{
  // Check number of values
  assert(nvalues == vector.nvalues);

  // Add values
  for (int i = 0; i < nvalues; i++) {
    values[i] += vector.values[i];
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e779
movq 0x8(%rsi), %rdx
movq 0x8(%rax), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
addsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3e762
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator-=(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator-=(const R3SurfelFeatureVector& vector)
{
  // Check number of values
  assert(nvalues == vector.nvalues);

  // Subtract values
  for (int i = 0; i < nvalues; i++) {
    values[i] -= vector.values[i];
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e7a7
movq 0x8(%rsi), %rdx
movq 0x8(%rax), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
subsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3e790
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator*=(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator*=(const R3SurfelFeatureVector& vector)
{
  // Check number of values
  assert(nvalues == vector.nvalues);

  // Multiply values
  for (int i = 0; i < nvalues; i++) {
    values[i] *= vector.values[i];
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e7d5
movq 0x8(%rsi), %rdx
movq 0x8(%rax), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
mulsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3e7be
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator/=(gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator/=(const R3SurfelFeatureVector& vector)
{
  // Check number of values
  assert(nvalues == vector.nvalues);

  // Divide values
  for (int i = 0; i < nvalues; i++) {
    if (RNIsNotZero(vector.values[i])) values[i] /= vector.values[i];
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e82b
movq 0x8(%rsi), %rdx
movq 0x8(%rax), %rsi
xorl %edi, %edi
leaq 0xf6415(%rip), %r8      # 0x134c08
movapd 0x9fba5(%rip), %xmm0    # 0xde3a0
movsd (%rdx,%rdi,8), %xmm1
movsd (%r8), %xmm2
ucomisd %xmm2, %xmm1
ja 0x3e815
xorpd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x3e823
movsd (%rsi,%rdi,8), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x3e7fb
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator+=(double)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator+=(RNScalar a)
{
  // Add values
  for (int i = 0; i < nvalues; i++) {
    values[i] += a;
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e854
movq 0x8(%rax), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3e83e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator-=(double)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator-=(RNScalar a)
{
  // Subtract values
  for (int i = 0; i < nvalues; i++) {
    values[i] -= a;
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e87e
movq 0x8(%rax), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3e868
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator*=(double)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator*=(RNScalar a)
{
  // Multiply values
  for (int i = 0; i < nvalues; i++) {
    values[i] *= a;
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
jle 0x3e8a8
movq 0x8(%rax), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3e892
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::operator/=(double)
R3SurfelFeatureVector& R3SurfelFeatureVector::
operator/=(RNScalar a)
{
  // Check a
  if (RNIsZero(a)) return *this;

  // Divide values
  for (int i = 0; i < nvalues; i++) {
    values[i] /= a;
  }

  // Return this
  return *this;
}

// Assembly:
movq %rdi, %rax
leaq 0xf6354(%rip), %rcx     # 0x134c08
movsd (%rcx), %xmm1
movapd 0x9fae0(%rip), %xmm2    # 0xde3a0
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x3e8d0
ucomisd %xmm0, %xmm1
jae 0x3e8f5
movslq 0x10(%rax), %rcx
testq %rcx, %rcx
jle 0x3e8f5
movq 0x8(%rax), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3e8df
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator+(gaps::R3SurfelFeatureVector const&, gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector 
operator+(const R3SurfelFeatureVector& vector1, const R3SurfelFeatureVector& vector2)
{
  // Add feature vectors
  R3SurfelFeatureVector vector = vector1;
  vector += vector2;
  return vector;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3e642
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3e92f
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3e918
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator-(gaps::R3SurfelFeatureVector const&, gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector 
operator-(const R3SurfelFeatureVector& vector1, const R3SurfelFeatureVector& vector2)
{
  // Subtract feature vectors
  R3SurfelFeatureVector vector = vector1;
  vector -= vector2;
  return vector;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3e642
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3e973
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
subsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3e95c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator*(gaps::R3SurfelFeatureVector const&, gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector 
operator*(const R3SurfelFeatureVector& vector1, const R3SurfelFeatureVector& vector2)
{
  // Multiply feature vectors
  R3SurfelFeatureVector vector = vector1;
  vector *= vector2;
  return vector;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3e642
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3e9b7
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
mulsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3e9a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator+(gaps::R3SurfelFeatureVector const&, double)
R3SurfelFeatureVector 
operator+(const R3SurfelFeatureVector& vector1, const RNScalar a)
{
  // Add scalar
  R3SurfelFeatureVector vector = vector1;
  vector += a;
  return vector;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3e642
movsd 0x8(%rsp), %xmm1
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3ea25
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3ea0f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator-(gaps::R3SurfelFeatureVector const&, double)
R3SurfelFeatureVector 
operator-(const R3SurfelFeatureVector& vector1, const RNScalar a)
{
  // Subtract scalar
  R3SurfelFeatureVector vector = vector1;
  vector -= a;
  return vector;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3e642
movsd 0x8(%rsp), %xmm1
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3eab3
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3ea9d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator*(gaps::R3SurfelFeatureVector const&, double)
R3SurfelFeatureVector 
operator*(const R3SurfelFeatureVector& vector1, const RNScalar a)
{
  // Multiply by scalar
  R3SurfelFeatureVector vector = vector1;
  vector *= a;
  return vector;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3e642
movsd 0x8(%rsp), %xmm1
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3eb17
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3eb01
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator*(double, gaps::R3SurfelFeatureVector const&)
R3SurfelFeatureVector 
operator*(const RNScalar a, const R3SurfelFeatureVector& vector1)
{
  // Multiply by scalar
  R3SurfelFeatureVector vector = vector1;
  vector *= a;
  return vector;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3e642
movsd 0x8(%rsp), %xmm1
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3eb5e
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3eb48
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::operator/(gaps::R3SurfelFeatureVector const&, double)
R3SurfelFeatureVector 
operator/(const R3SurfelFeatureVector& vector1, const RNScalar a)
{
  // Divide by scalar
  R3SurfelFeatureVector vector = vector1;
  vector /= a;
  return vector;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x3e642
leaq 0xf6087(%rip), %rax     # 0x134c08
movsd (%rax), %xmm0
movapd 0x9f813(%rip), %xmm1    # 0xde3a0
xorpd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
movapd %xmm2, %xmm1
jb 0x3eba7
ucomisd %xmm1, %xmm0
jae 0x3ebcc
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x3ebcc
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3ebb6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::Resize(int)
void R3SurfelFeatureVector::
Resize(int size)
{
  // Save old stuff
  RNScalar *old_values = values;
  int old_nvalues = nvalues;

  // Set new stuff
  nvalues = size;
  values = NULL;

  // Copy values
  if (nvalues > 0) {
    values = new RNScalar [ nvalues ];
    int overlap = (nvalues > old_nvalues) ? old_nvalues : nvalues;
    for (int i = 0; i < overlap; i++) values[i] = old_values[i];
    for (int i = overlap; i < nvalues; i++) values[i] = RN_UNKNOWN;
  }

  // Delete old values
  if (old_values) delete [] old_values;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rbx
movslq 0x10(%rdi), %r12
movl %esi, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
testl %esi, %esi
jle 0x3ece5
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
leaq (,%r15,8), %rdi
callq 0x13030
movq %rax, 0x8(%r14)
cmpl %ebp, %r12d
movl %ebp, %edx
cmovll %r12d, %edx
testl %r12d, %r12d
jle 0x3ec36
movl %edx, %ecx
xorl %esi, %esi
movq (%rbx,%rsi,8), %xmm0
movq %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3ec24
cmpl %ebp, %r12d
jge 0x3ece5
cmpq %r15, %r12
cmovlq %r12, %r15
notl %edx
addl %ebp, %edx
leaq 0x2(%rdx), %rcx
andq $-0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rax,%r15,8), %rax
addq $0x8, %rax
xorl %edx, %edx
movdqa 0xa0b22(%rip), %xmm1    # 0xdf790
movdqa 0xa0b2a(%rip), %xmm2    # 0xdf7a0
pxor %xmm2, %xmm0
movabsq $-0x4010000000000000, %rsi # imm = 0xBFF0000000000000
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x3ecc9
movq %rsi, -0x8(%rax,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x3ecdc
movq %rsi, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x3ec88
testq %rbx, %rbx
je 0x3ecfa
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13680
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::EuclideanDistanceSquared(gaps::R3SurfelFeatureVector const&) const
RNLength R3SurfelFeatureVector::
EuclideanDistanceSquared(const R3SurfelFeatureVector& vector) const
{
  // Compute sum of squared differences
  RNLength sum = 0;
  assert(NValues() == vector.NValues());
  for (int i = 0; i < NValues(); i++) {
    RNScalar delta = Value(i) - vector.Value(i);
    sum += delta * delta;
  }

  // Return squared Euclidean distance
  return sum;
}

// Assembly:
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0x3edea
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x3edcf
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::Correlation(gaps::R3SurfelFeatureVector const&) const
RNScalar R3SurfelFeatureVector::
Correlation(const R3SurfelFeatureVector& vector) const
{
  // Compute sum of products (dot product)
  RNLength sum = 0;
  assert(NValues() == vector.NValues());
  for (int i = 0; i < NValues(); i++) {
    sum += Value(i) * vector.Value(i);
  }

  // Return correlation
  return sum;
}

// Assembly:
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0x3ee1c
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x3ee05
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelFeatureVector.cpp
// Function: gaps::R3SurfelFeatureVector::Print(_IO_FILE*, char const*, char const*) const
void R3SurfelFeatureVector::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print feature values
  if (prefix) fprintf(fp, "%s", prefix);
  for (int i = 0; i < NValues(); i++) {
    fprintf(fp, "%g ", Value(i));
  }
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
jne 0x3ee41
movq 0xf5132(%rip), %rax     # 0x133f70
movq (%rax), %rbx
testq %rdx, %rdx
je 0x3ee51
movq %rdx, %rdi
movq %rbx, %rsi
callq 0x135b0
cmpl $0x0, 0x10(%r15)
jle 0x3ee85
xorl %r13d, %r13d
leaq 0x9fa4c(%rip), %r12     # 0xde8ae
movq 0x8(%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x13740
incq %r13
movslq 0x10(%r15), %rax
cmpq %rax, %r13
jl 0x3ee62
testq %r14, %r14
je 0x3ee95
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_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::BBox() const
const R3Box& R3SurfelObjectSet::
BBox(void) const
{
  // Update bounding box
  if (bbox[0][0] == FLT_MAX) {
    R3SurfelObjectSet *objectset = (R3SurfelObjectSet *) this;
    objectset->bbox = R3null_box;
    for (int i = 0; i < NObjects(); i++) {
      R3SurfelObject *object = Object(i);
      objectset->bbox.Union(object->BBox());
    }
  }

  // Return bounding box
  return bbox;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x18(%rdi), %rbx
movsd 0x20(%rdi), %xmm0
ucomisd 0x9f15c(%rip), %xmm0    # 0xde170
jne 0x3f06d
jp 0x3f06d
movq %rdi, %r14
addq $0x20, %rdi
leaq 0xf69a2(%rip), %r15     # 0x1359c8
leaq 0x8(%r15), %rsi
callq 0x850ec
leaq 0x38(%r14), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x850ec
cmpl $0x0, 0x14(%r14)
jle 0x3f06d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x170be
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6ea70
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x3f049
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::TimestampRange() const
const RNInterval& R3SurfelObjectSet::
TimestampRange(void) const
{
  // Update timestamp range
  if (timestamp_range.Min() == FLT_MAX) {
    R3SurfelObjectSet *objectset = (R3SurfelObjectSet *) this;
    objectset->timestamp_range.Reset(FLT_MAX,-FLT_MAX);
    for (int i = 0; i < NObjects(); i++) {
      R3SurfelObject *object = Object(i);
      objectset->timestamp_range.Union(object->TimestampRange());
    }
  }

  // Return timestamp range
  return timestamp_range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x50(%rdi), %rbx
movsd 0x50(%rdi), %xmm0
ucomisd 0x9f0e4(%rip), %xmm0    # 0xde170
jne 0x3f0e9
jp 0x3f0e9
movq %rdi, %r14
movapd 0x9f295(%rip), %xmm0    # 0xde330
movupd %xmm0, 0x50(%rdi)
cmpl $0x0, 0x14(%rdi)
jle 0x3f0e9
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1724e
movsd (%rax), %xmm0
movsd 0x50(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3f0ca
movsd %xmm0, (%rbx)
movsd 0x8(%rax), %xmm0
ucomisd 0x58(%r14), %xmm0
jbe 0x3f0dd
movsd %xmm0, 0x58(%r14)
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x3f0a9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::InsertObject(gaps::R3SurfelObject*)
void R3SurfelObjectSet::
InsertObject(R3SurfelObject *object)
{
  // Insert object
  objects.Insert(object);

  // Update bounding box
  bbox[0][0] = FLT_MAX;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
movl 0x14(%rbx), %edx
callq 0xaafca
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rax, 0x20(%rbx)
movaps 0x9f219(%rip), %xmm0    # 0xde330
movups %xmm0, 0x50(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::RemoveObject(int)
void R3SurfelObjectSet::
RemoveObject(int k)
{
  // Copy last object over object
  RNArrayEntry *entry = objects.KthEntry(k);
  assert(entry);
  R3SurfelObject *tail = objects.Tail();
  objects.EntryContents(entry) = tail;
  objects.RemoveTail();

  // Update bounding box
  bbox[0][0] = FLT_MAX;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %rax
movslq %esi, %rcx
movslq 0x14(%rbx), %rdx
movq -0x8(%rax,%rdx,8), %rsi
movq %rsi, (%rax,%rcx,8)
leal -0x1(%rdx), %esi
callq 0xab13e
movabsq $0x47efffffe0000000, %rax # imm = 0x47EFFFFFE0000000
movq %rax, 0x20(%rbx)
movaps 0x9f1ad(%rip), %xmm0    # 0xde330
movups %xmm0, 0x50(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::Empty()
void R3SurfelObjectSet::
Empty(void)
{
  // Remove objects
  objects.Empty();

  // Update bounding box
  bbox = R3Box(FLT_MAX, FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX, -FLT_MAX);

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

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
xorl %esi, %esi
callq 0xab174
leaq 0x8(%rsp), %rdi
movsd 0x9efc6(%rip), %xmm0    # 0xde170
movsd 0x9efc6(%rip), %xmm3    # 0xde178
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
callq 0x6e028
leaq 0x20(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x850ec
leaq 0x38(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x850ec
leaq 0x8(%rsp), %rdi
callq 0x6ede0
movaps 0x9f140(%rip), %xmm0    # 0xde330
movups %xmm0, 0x50(%rbx)
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6ede0
movq %rbx, %rdi
callq 0x138b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelObjectSet.cpp
// Function: gaps::R3SurfelObjectSet::Draw(gaps::RNFlags) const
void R3SurfelObjectSet::
Draw(RNFlags flags) const
{
  // Draw objects
  for (int i = 0; i < NObjects(); i++) {
    R3SurfelObject *object = Object(i);
    object->Draw(flags);
  }
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
jle 0x3f246
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x3f224
popq %rbx
popq %r14
popq %r15
retq
nop