LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::SetPose(gaps::GSVPose const&, gaps::GSVPose const&)
void GSVImage::
SetPose(const GSVPose& pose0, const GSVPose& pose1)
{
  // Set pose parameters
  this->pose0 = pose0;
  this->pose1 = pose1;

  // Invalidate bounding boxes
  if (tapestry) tapestry->InvalidateBBox();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
addq $0x28, %rdi
callq 0x47d40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x68, %rdi
callq 0x47d40
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x50698
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x52420
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::DistortedPosition(gaps::R2Point const&) const
R2Point GSVImage::
DistortedPosition(const R2Point& undistorted_image_position) const
{
  // Return the position after distortion by the camera lens
  GSVCamera *camera = Camera();
  if (camera) return camera->DistortedPosition(undistorted_image_position);
  else return undistorted_image_position;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4f700
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5072d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4d380
jmp 0x5073c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1b9a60
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::UndistortedPosition(gaps::R2Point const&) const
R2Point GSVImage::
UndistortedPosition(const R2Point& distorted_image_position) const
{
  // Return the position after the inverse of distortion by the camera lens
  GSVCamera *camera = Camera();
  if (camera) return camera->UndistortedPosition(distorted_image_position);
  else return distorted_image_position;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4f700
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5079d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4d4f0
jmp 0x507ac
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1b9a60
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::DistortedPosition(gaps::R3Point const&) const
R2Point GSVImage::
DistortedPosition(const R3Point& world_position) const
{
  // Return position of 3D point in distorted image
  R2Point undistorted_position = UndistortedPosition(world_position);
  if (undistorted_position == R2Point(-1,-1)) return undistorted_position;
  return DistortedPosition(undistorted_position);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x40(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x50b30
leaq 0x20(%rsp), %rdi
movsd 0x214f32(%rip), %xmm1   # 0x266008
movaps %xmm1, %xmm0
callq 0x1b9a30
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1ba430
cmpl $0x0, %eax
je 0x51103
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1b9a60
jmp 0x51117
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x506e0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::RayThroughDistortedPosition(gaps::R2Point const&) const
R3Ray GSVImage::
RayThroughDistortedPosition(const R2Point& distorted_image_position) const
{
  // Return ray through distorted image point
  R2Point undistorted_position = UndistortedPosition(distorted_image_position);
  if (undistorted_position == R2Point(-1,-1)) return R3null_ray;
  return RayThroughUndistortedPosition(undistorted_position);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x40(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x50750
leaq 0x20(%rsp), %rdi
movsd 0x214a32(%rip), %xmm1   # 0x266008
movaps %xmm1, %xmm0
callq 0x1b9a30
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1ba430
cmpl $0x0, %eax
je 0x51605
movq 0x8(%rsp), %rdi
leaq 0x6b1a02(%rip), %rsi    # 0x703000
callq 0x17f650
jmp 0x51619
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x51130
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVImage.cpp
// Function: gaps::GSVImage::Print(_IO_FILE*, char const*, char const*) const
void GSVImage::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print image header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Image %d:", panorama_index);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

  // Add indentation to prefix
  char indented_prefix[1024];
  sprintf(indented_prefix, "%s  ", prefix);

  // Print image stuff
  // ???
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq %rdx, 0x420(%rsp)
movq %rcx, 0x418(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x428(%rsp)
jne 0x51691
movq 0x29d942(%rip), %rax    # 0x2eefc8
movq (%rax), %rax
movq %rax, 0x428(%rsp)
cmpq $0x0, 0x420(%rsp)
je 0x516ba
movq 0x428(%rsp), %rdi
movq 0x420(%rsp), %rdx
leaq 0x22eb74(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x8(%rsp), %rax
movq 0x428(%rsp), %rdi
movl 0x20(%rax), %edx
leaq 0x215b10(%rip), %rsi    # 0x2671e1
movb $0x0, %al
callq 0x293c0
cmpq $0x0, 0x418(%rsp)
je 0x51701
movq 0x428(%rsp), %rdi
movq 0x418(%rsp), %rdx
leaq 0x22eb2d(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x428(%rsp), %rdi
leaq 0x2156f6(%rip), %rsi    # 0x266e06
movb $0x0, %al
callq 0x293c0
leaq 0x10(%rsp), %rdi
movq 0x420(%rsp), %rdx
leaq 0x2153cb(%rip), %rsi    # 0x266af6
movb $0x0, %al
callq 0x2a280
addq $0x438, %rsp            # imm = 0x438
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::~GSVTapestry()
GSVTapestry::
~GSVTapestry(void)
{
  // Remove tapestry from segment
  if (segment) segment->RemoveTapestry(this);

  // Remove tapestry from camera
  if (camera) camera->RemoveTapestry(this);

  // Delete images
  while (NImages()) delete Image(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x294f4e(%rip), %rcx    # 0x2e6a08
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x51ada
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x490a0
jmp 0x51ad8
jmp 0x51ada
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x51af8
movq 0x18(%rsp), %rsi
movq 0x18(%rsi), %rdi
callq 0x4c7b0
jmp 0x51af6
jmp 0x51af8
jmp 0x51afa
movq 0x18(%rsp), %rdi
callq 0x44d20
movl %eax, 0x14(%rsp)
jmp 0x51b0a
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
je 0x51b3e
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x4a650
movq %rax, 0x8(%rsp)
jmp 0x51b26
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x51b3c
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x51afa
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x386c0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x4f370
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x44300
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::SceneIndex() const
int GSVTapestry::
SceneIndex(void) const
{
  // Get convenient variables
  GSVRun *run = Run();
  if (!run) return -1;
  GSVScene *scene = run->Scene();
  if (!scene) return -1;

  // Compute scene index
  int scene_index = RunIndex();
  for (int ir = 0; ir < run->SceneIndex(); ir++) {
    GSVRun *r = scene->Run(ir);
    scene_index += r->NTapestries();
  }

  // Return scene index
  return scene_index;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51cb0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x51c12
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x51c9f
movq 0x30(%rsp), %rdi
callq 0x4a630
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x51c33
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x51c9f
movq 0x10(%rsp), %rdi
callq 0x51cf0
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0x443f0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x51c97
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x39fb0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x45430
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x51c49
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::RunIndex() const
int GSVTapestry::
RunIndex(void) const
{
  // Get convenient variables
  GSVSegment *segment = Segment();
  if (!segment) return -1;
  GSVRun *run = segment->Run();
  if (!run) return -1;

  // Compute run index
  int run_index = SegmentIndex();
  for (int i = 0; i < segment->RunIndex(); i++) {
    GSVSegment *s = run->Segment(i);
    run_index += s->NTapestries();
  }

  // Return run index
  return run_index;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51750
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x51d22
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x51daf
movq 0x30(%rsp), %rdi
callq 0x4f380
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x51d43
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x51daf
movq 0x10(%rsp), %rdi
callq 0x44e00
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4a640
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x51da7
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x3a000
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x44b60
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x51d59
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::FindImageBeforeTimestamp(double, int, int) const
GSVImage *GSVTapestry::
FindImageBeforeTimestamp(RNScalar timestamp, int imin, int imax) const
{
  // Binary search
  int i = (imin + imax) / 2;
  if (i == imin) return Image(imin);
  assert(i < imax);
  GSVImage *image = Image(i);
  RNScalar t = image->Timestamp();
  if (t > timestamp) return FindImageBeforeTimestamp(timestamp, imin, i);
  else if (t < timestamp) return FindImageBeforeTimestamp(timestamp, i, imax);
  else return image;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x51e17
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x4a650
movq %rax, 0x40(%rsp)
jmp 0x51ea7
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x4a650
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4fc90
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x51e6c
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movl 0x2c(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x51dc0
movq %rax, 0x40(%rsp)
jmp 0x51ea7
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x51e9d
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x51dc0
movq %rax, 0x40(%rsp)
jmp 0x51ea7
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::FindImageBeforeTimestamp(double) const
GSVImage *GSVTapestry::
FindImageBeforeTimestamp(RNScalar timestamp) const
{
  // Binary search
  if (NImages() == 0) return NULL;
  if (timestamp <= Image(0)->Timestamp()) return Image(0);
  if (timestamp >= Image(NImages()-1)->Timestamp()) return Image(NImages()-1);
  return FindImageBeforeTimestamp(timestamp, 0, NImages()-1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x44d20
cmpl $0x0, %eax
jne 0x51ef1
movq $0x0, 0x30(%rsp)
jmp 0x51fc9
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %esi, %esi
callq 0x4a650
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4fc90
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x51f38
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x4a650
movq %rax, 0x30(%rsp)
jmp 0x51fc9
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x44d20
movq 0x18(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x4a650
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4fc90
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x51f99
movq 0x18(%rsp), %rdi
callq 0x44d20
movq 0x18(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x4a650
movq %rax, 0x30(%rsp)
jmp 0x51fc9
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
callq 0x44d20
movq 0x18(%rsp), %rdi
movsd (%rsp), %xmm0
movl %eax, %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x51dc0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::InsertImage(gaps::GSVImage*)
void GSVTapestry::
InsertImage(GSVImage *image)
{
  // Just checking
  assert(image->tapestry_index == -1);
  assert(image->tapestry == NULL);

  // Insert camera image
  image->tapestry = this;
  image->tapestry_index = images.NEntries();
  images.Insert(image);

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq %rdi, 0x8(%rax)
addq $0x28, %rdi
callq 0x38730
movq (%rsp), %rdi
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
addq $0x28, %rdi
movq 0x8(%rsp), %rsi
callq 0x4f390
movq (%rsp), %rdi
callq 0x52420
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::InvalidateBBox()
void GSVTapestry::
InvalidateBBox(void) 
{
  // Invalidate bounding box
  if (bbox.XMin() != FLT_MAX) {
    bbox = R3Box(FLT_MAX,FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX,-FLT_MAX);
    if (segment) segment->InvalidateBBox();
    if (camera) camera->InvalidateBBox();
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x38, %rdi
callq 0x38b90
movsd 0x213bd4(%rip), %xmm1   # 0x266018
ucomisd %xmm1, %xmm0
jne 0x52451
jp 0x52451
jmp 0x524ed
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movsd 0x213bb5(%rip), %xmm2   # 0x266018
movsd 0x213bb5(%rip), %xmm5   # 0x266020
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
movaps %xmm5, %xmm3
movaps %xmm5, %xmm4
callq 0x151b90
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rdi
callq 0x386d0
jmp 0x52491
leaq 0x28(%rsp), %rdi
callq 0x386c0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x524d1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x48ec0
jmp 0x524d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x386c0
jmp 0x524f2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x524eb
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x4c9e0
jmp 0x524ed
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x29c10
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::RemoveImage(gaps::GSVImage*)
void GSVTapestry::
RemoveImage(GSVImage *image)
{
  // Just checking
  assert(image->tapestry_index >= 0);
  assert(image->tapestry_index < images.NEntries());
  assert(image->tapestry == this);

  // Remove image
  RNArrayEntry *entry = images.KthEntry(image->tapestry_index);
  GSVImage *tail = images.Tail();
  tail->tapestry_index = image->tapestry_index;
  images.EntryContents(entry) = tail;
  images.RemoveTail();
  image->tapestry_index = -1;
  image->tapestry = NULL;

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq 0x28(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x44390
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x28, %rdi
callq 0x4f400
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x4f410
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x28, %rdi
callq 0x443d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0x52420
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::Print(_IO_FILE*, char const*, char const*) const
void GSVTapestry::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print tapestry header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Tapestry %d:", segment_index);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

  // Add indentation to prefix
  char indented_prefix[1024];
  sprintf(indented_prefix, "%s  ", prefix);

   // Print images
  for (int i = 0; i < NImages(); i++) {
    GSVImage *image = Image(i);
    image->Print(fp, indented_prefix, suffix);
  }
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movq %rdx, 0x430(%rsp)
movq %rcx, 0x428(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x438(%rsp)
jne 0x52681
movq 0x29c952(%rip), %rax    # 0x2eefc8
movq (%rax), %rax
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x430(%rsp)
je 0x526aa
movq 0x438(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x22db84(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x8(%rsp), %rax
movq 0x438(%rsp), %rdi
movl 0x10(%rax), %edx
leaq 0x214b3b(%rip), %rsi    # 0x2671fc
movb $0x0, %al
callq 0x293c0
cmpq $0x0, 0x428(%rsp)
je 0x526f1
movq 0x438(%rsp), %rdi
movq 0x428(%rsp), %rdx
leaq 0x22db3d(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x438(%rsp), %rdi
leaq 0x214706(%rip), %rsi    # 0x266e06
movb $0x0, %al
callq 0x293c0
leaq 0x20(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x2143db(%rip), %rsi    # 0x266af6
movb $0x0, %al
callq 0x2a280
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x44d20
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x52786
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x4a650
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x438(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x428(%rsp), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5272a
addq $0x448, %rsp            # imm = 0x448
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVTapestry.cpp
// Function: gaps::GSVTapestry::UpdateBBox()
void GSVTapestry::
UpdateBBox(void) 
{
  // Update bounding box
  bbox = R3null_box;
  for (int i = 0; i < NImages(); i++) {
    bbox.Union(Image(i)->Pose().Viewpoint());
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x38, %rdi
leaq 0x2afd41(%rip), %rsi    # 0x3024f8
callq 0x386d0
movl $0x0, 0x7c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x44d20
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x52869
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, (%rsp)
movl 0x7c(%rsp), %esi
callq 0x4a650
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4faf0
movq 0x8(%rsp), %rdi
callq 0x3a330
movq %rax, 0x10(%rsp)
jmp 0x52825
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
callq 0x153680
jmp 0x52835
leaq 0x38(%rsp), %rdi
callq 0x5e680
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x527c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5e680
jmp 0x52871
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x29c10
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::GSVLaser(int)
GSVLaser::
GSVLaser(int device_type)
  : run(NULL),
    run_index(-1),
    surveys(),
    device_type(device_type),
    max_sweep_index(0),
    max_beam_index(0),
    bbox(FLT_MAX,FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX,-FLT_MAX),
    data(NULL)
{
  // Set max sweep and beam indices
  if (device_type == GSV_SICK_LASER) {
    max_sweep_index = 0;
    max_beam_index = 179;
  }
  else if (device_type == GSV_VLP16_LASER) {
    max_sweep_index = 1799;
    max_beam_index = 15;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x2941ba(%rip), %rax    # 0x2e6a58
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0x4a5f0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movl $0x0, 0x30(%rdi)
addq $0x38, %rdi
movsd 0x213734(%rip), %xmm2   # 0x266018
movsd 0x213734(%rip), %xmm5   # 0x266020
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
movaps %xmm5, %xmm3
movaps %xmm5, %xmm4
callq 0x151b90
jmp 0x528ff
movq 0x10(%rsp), %rax
movq $0x0, 0x70(%rax)
cmpl $0x2, 0x2c(%rsp)
jne 0x52942
movq 0x10(%rsp), %rax
movl $0x0, 0x2c(%rax)
movl $0xb3, 0x30(%rax)
jmp 0x5295e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4a620
jmp 0x52963
cmpl $0x1, 0x2c(%rsp)
jne 0x5295c
movq 0x10(%rsp), %rax
movl $0x707, 0x2c(%rax)      # imm = 0x707
movl $0xf, 0x30(%rax)
jmp 0x5295e
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x29c10
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::~GSVLaser()
GSVLaser::
~GSVLaser(void)
{
  // Remove laser from run
  if (run) run->RemoveLaser(this);

  // Remove surveys from this laser
  while (NSurveys() > 0) RemoveSurvey(Survey(0));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x2940be(%rip), %rcx    # 0x2e6a48
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x529aa
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x45b00
jmp 0x529a8
jmp 0x529aa
jmp 0x529ac
movq 0x18(%rsp), %rdi
callq 0x44af0
movl %eax, 0x14(%rsp)
jmp 0x529bc
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jle 0x529eb
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x52f90
movq %rax, 0x8(%rsp)
jmp 0x529d8
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x52a20
jmp 0x529e9
jmp 0x529ac
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x386c0
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a620
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x44300
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::RemoveSurvey(gaps::GSVSurvey*)
void GSVLaser::
RemoveSurvey(GSVSurvey *survey)
{
  // Just checking
  assert(survey->laser_index >= 0);
  assert(survey->laser_index < surveys.NEntries());
  assert(survey->laser == this);

  // Remove survey
  RNArrayEntry *entry = surveys.KthEntry(survey->laser_index);
  GSVSurvey *tail = surveys.Tail();
  tail->laser_index = survey->laser_index;
  surveys.EntryContents(entry) = tail;
  surveys.RemoveTail();
  survey->laser_index = -1;
  survey->laser = NULL;

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
movq 0x28(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x44390
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0x4a7a0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x4a7b0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x18, %rdi
callq 0x443d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
callq 0x52c50
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::SceneIndex() const
int GSVLaser::
SceneIndex(void) const
{
  // Get convenient variables
  GSVScene *scene = Scene();
  if (!scene) return -1;

  // Compute scene index
  int scene_index = RunIndex();
  for (int i = 0; i < run->SceneIndex(); i++) {
    GSVRun *r = scene->Run(i);
    scene_index += r->NLasers();
  }

  // Return scene index
  return scene_index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x52b00
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x52b6f
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x52bdf
movq 0x8(%rsp), %rdi
callq 0x44c00
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rax), %rdi
callq 0x443f0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x52bd7
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44340
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x52b85
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::InsertSurvey(gaps::GSVSurvey*)
void GSVLaser::
InsertSurvey(GSVSurvey *survey)
{
  // Just checking
  assert(survey->laser_index == -1);
  assert(survey->laser == NULL);

  // Insert survey
  survey->laser = this;
  survey->laser_index = surveys.NEntries();
  surveys.Insert(survey);

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq %rdi, 0x18(%rax)
addq $0x18, %rdi
callq 0x38730
movq (%rsp), %rdi
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
callq 0x4a770
movq (%rsp), %rdi
callq 0x52c50
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::Draw(gaps::RNFlags) const
void GSVLaser::
Draw(RNFlags flags) const
{
  // Draw surveys
  for (int i = 0; i < NSurveys(); i++) {
    GSVSurvey *survey = Survey(i);
    survey->Draw(flags);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x44af0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x52d96
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x52f90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x52d40
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::Print(_IO_FILE*, char const*, char const*) const
void GSVLaser::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print laser header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Laser %d:", run_index);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

  // Add indentation to prefix
  char indented_prefix[1024];
  sprintf(indented_prefix, "%s  ", prefix);

 // Print surveys
  for (int i = 0; i < NSurveys(); i++) {
    GSVSurvey *survey = Survey(i);
    survey->Print(fp, indented_prefix, suffix);
  }
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movq %rdx, 0x430(%rsp)
movq %rcx, 0x428(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x438(%rsp)
jne 0x52df1
movq 0x29c1e2(%rip), %rax    # 0x2eefc8
movq (%rax), %rax
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x430(%rsp)
je 0x52e1a
movq 0x438(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x22d414(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x8(%rsp), %rax
movq 0x438(%rsp), %rdi
movl 0x10(%rax), %edx
leaq 0x2143ed(%rip), %rsi    # 0x26721e
movb $0x0, %al
callq 0x293c0
cmpq $0x0, 0x428(%rsp)
je 0x52e61
movq 0x438(%rsp), %rdi
movq 0x428(%rsp), %rdx
leaq 0x22d3cd(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x438(%rsp), %rdi
leaq 0x213f96(%rip), %rsi    # 0x266e06
movb $0x0, %al
callq 0x293c0
leaq 0x20(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x213c6b(%rip), %rsi    # 0x266af6
movb $0x0, %al
callq 0x2a280
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x44af0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x52ef6
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x52f90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x438(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x428(%rsp), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x52e9a
addq $0x448, %rsp            # imm = 0x448
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVLaser.cpp
// Function: gaps::GSVLaser::UpdateBBox()
void GSVLaser::
UpdateBBox(void) 
{
  // Update bounding box
  bbox = R3null_box;
  for (int i = 0; i < NSurveys(); i++) {
    bbox.Union(Survey(i)->BBox());
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x38, %rdi
leaq 0x2af5da(%rip), %rsi    # 0x3024f8
callq 0x386d0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x44af0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x52f81
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %esi
callq 0x52f90
movq %rax, %rdi
callq 0x4a830
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1538e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x52f2b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::~GSVSurvey()
GSVSurvey::
~GSVSurvey(void)
{
  // Remove survey from segment
  if (segment) segment->RemoveSurvey(this);

  // Remove survey from laser
  if (laser) laser->RemoveSurvey(this);

  // Delete scans
  while (NScans()) delete Scan(0);

  // Delete travel distances
  if (travel_distances) delete [] travel_distances;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x2939fe(%rip), %rcx    # 0x2e6a88
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x530aa
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rdi
callq 0x48f90
jmp 0x530a8
jmp 0x530aa
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x530c8
movq 0x18(%rsp), %rsi
movq 0x18(%rsi), %rdi
callq 0x52a20
jmp 0x530c6
jmp 0x530c8
jmp 0x530ca
movq 0x18(%rsp), %rdi
callq 0x3a080
movl %eax, 0x14(%rsp)
jmp 0x530da
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
je 0x5310e
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x3a0a0
movq %rax, 0x8(%rsp)
jmp 0x530f6
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x5310c
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x530ca
movq 0x18(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x53138
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x53136
movq (%rsp), %rdi
callq 0x296f0
jmp 0x53138
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0x386c0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x444c0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x44300
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::NScanlines() const
int GSVSurvey::
NScanlines(void) const
{
  // Return number of scanlines in survey
  int count = 0;
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    count += scan->NScanlines();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x53431
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a0d0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x533e3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::Scanline(int) const
GSVScanline *GSVSurvey::
Scanline(int scanline_index) const
{
  // Return scanline
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    if (scanline_index >= scan->NScanlines()) scanline_index -= scan->NScanlines();
    else return scan->Scanline(scanline_index);
  }

  // Index too high
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x534e9
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3a0d0
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jl 0x534c2
movq 0x18(%rsp), %rdi
callq 0x3a0d0
movl %eax, %ecx
movl 0x24(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x534d7
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3a0f0
movq %rax, 0x30(%rsp)
jmp 0x534f2
jmp 0x534d9
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x5345f
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::FindScanBeforeTimestamp(double) const
GSVScan *GSVSurvey::
FindScanBeforeTimestamp(RNScalar timestamp) const
{
  // Check number of scans
  if (NScans() == 0) return NULL;

  // Check all scans
  RNBoolean first = TRUE;
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    if (scan->NScanlines() == 0) continue;
    if (first && (timestamp < scan->Scanline(0)->Timestamp())) { first = FALSE; continue; }
    if (timestamp > scan->Scanline(scan->NScanlines()-1)->Timestamp()) continue;
    return scan;
  }

  // Otherwise not found
  return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3a080
cmpl $0x0, %eax
jne 0x53531
movq $0x0, 0x50(%rsp)
jmp 0x53632
movl $0x1, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movl 0x38(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x53629
movq 0x28(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3a0d0
cmpl $0x0, %eax
jne 0x53588
jmp 0x53619
cmpl $0x0, 0x3c(%rsp)
je 0x535c5
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3a0f0
movq %rax, %rdi
callq 0x44c80
movsd 0x18(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x535c5
movl $0x0, 0x3c(%rsp)
jmp 0x53619
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3a0d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x3a0f0
movq %rax, %rdi
callq 0x44c80
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5360d
jmp 0x53619
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x53632
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x53541
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::FindScanBeforeTravelDistance(double, int, int) const
GSVScan *GSVSurvey::
FindScanBeforeTravelDistance(RNScalar travel_distance, int imin, int imax) const
{
  // Binary search
  int i = (imin + imax) / 2;
  if (i == imin) return Scan(imin);
  assert(i < imax);
  GSVScan *scan = Scan(i);
  RNScalar t = TravelDistance(scan->SurveyIndex());
  if (t > travel_distance) return FindScanBeforeTravelDistance(travel_distance, imin, i);
  else if (t < travel_distance) return FindScanBeforeTravelDistance(travel_distance, i, imax);
  else return scan;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jne 0x53697
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x40(%rsp)
jmp 0x5372e
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x53fb0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x53f70
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x536f3
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movl 0x2c(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x53640
movq %rax, 0x40(%rsp)
jmp 0x5372e
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x53724
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x53640
movq %rax, 0x40(%rsp)
jmp 0x5372e
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::FindScanBeforeTravelDistance(double) const
GSVScan *GSVSurvey::
FindScanBeforeTravelDistance(RNScalar travel_distance) const
{
  // Binary search
  if (NScans() == 0) return NULL;
  if (travel_distance <= TravelDistance(0)) return Scan(0);
  if (travel_distance >= TravelDistance(NScans()-1)) return Scan(NScans()-1);
  return FindScanBeforeTravelDistance(travel_distance, 0, NScans()-1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3a080
cmpl $0x0, %eax
jne 0x53771
movq $0x0, 0x30(%rsp)
jmp 0x5382f
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %esi, %esi
callq 0x53f70
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x537ab
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x3a0a0
movq %rax, 0x30(%rsp)
jmp 0x5382f
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3a080
movq 0x18(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x53f70
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x537ff
movq 0x18(%rsp), %rdi
callq 0x3a080
movq 0x18(%rsp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x3a0a0
movq %rax, 0x30(%rsp)
jmp 0x5382f
movq 0x18(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
callq 0x3a080
movq 0x18(%rsp), %rdi
movsd (%rsp), %xmm0
movl %eax, %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x53640
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::NPoints() const
int GSVSurvey::
NPoints(void) const
{
  // Return number of points in all scans
  int npoints = 0;
  for (int i = 0; i < NScans(); i++) 
    npoints += Scan(i)->NPoints();
  return npoints;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x538aa
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x3a0a0
movq %rax, %rdi
callq 0x545e0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x53863
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::MaxBeamIndex() const
int GSVSurvey::
MaxBeamIndex(void) const
{
  // Initialize result
  int max_beam_index = -1;

  // Find maximum beam index of any point in any scan
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    int m = scan->MaxBeamIndex();
    if (m > max_beam_index) max_beam_index = m;
  }

  // Return result
  return max_beam_index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x53941
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x546f0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jle 0x53932
movl 0x1c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x53934
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x538e3
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::InsertScan(gaps::GSVScan*)
void GSVSurvey::
InsertScan(GSVScan *scan)
{
  // Just checking
  assert(scan->survey_index == -1);
  assert(scan->survey == NULL);

  // Insert laser scan
  scan->survey = this;
  scan->survey_index = scans.NEntries();
  scans.Insert(scan);

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq %rdi, 0x18(%rax)
addq $0x28, %rdi
callq 0x38730
movq (%rsp), %rdi
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x28, %rdi
movq 0x8(%rsp), %rsi
callq 0x47dc0
movq (%rsp), %rdi
callq 0x539b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::InvalidateBBox()
void GSVSurvey::
InvalidateBBox(void) 
{
  // Invalidate bounding box
  if (bbox.XMin() != FLT_MAX) {
    bbox = R3Box(FLT_MAX,FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX,-FLT_MAX);
    if (segment) segment->InvalidateBBox();
    if (laser) laser->InvalidateBBox();
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x40, %rdi
callq 0x38b90
movsd 0x212644(%rip), %xmm1   # 0x266018
ucomisd %xmm1, %xmm0
jne 0x539e1
jp 0x539e1
jmp 0x53a7d
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movsd 0x212625(%rip), %xmm2   # 0x266018
movsd 0x212625(%rip), %xmm5   # 0x266020
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
movaps %xmm5, %xmm3
movaps %xmm5, %xmm4
callq 0x151b90
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x40, %rdi
callq 0x386d0
jmp 0x53a21
leaq 0x28(%rsp), %rdi
callq 0x386c0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x53a61
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x48ec0
jmp 0x53a61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x386c0
jmp 0x53a82
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x53a7b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x52c50
jmp 0x53a7d
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x29c10
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::RemoveScan(gaps::GSVScan*)
void GSVSurvey::
RemoveScan(GSVScan *scan)
{
  // Just checking
  assert(scan->survey_index >= 0);
  assert(scan->survey_index < scans.NEntries());
  assert(scan->survey == this);

  // Remove scan
  RNArrayEntry *entry = scans.KthEntry(scan->survey_index);
  GSVScan *tail = scans.Tail();
  tail->survey_index = scan->survey_index;
  scans.EntryContents(entry) = tail;
  scans.RemoveTail();
  scan->survey_index = -1;
  scan->survey = NULL;

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq 0x28(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x44390
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x28, %rdi
callq 0x53fc0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
callq 0x53fd0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x28, %rdi
callq 0x443d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
callq 0x539b0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::Draw(gaps::RNFlags) const
void GSVSurvey::
Draw(RNFlags flags) const
{
  // Draw scans
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    scan->Draw(flags);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x53bb6
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x53b60
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVSurvey.cpp
// Function: gaps::GSVSurvey::Print(_IO_FILE*, char const*, char const*) const
void GSVSurvey::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print survey header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Survey %d:", segment_index);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

  // Add indentation to prefix
  char indented_prefix[1024];
  sprintf(indented_prefix, "%s  ", prefix);

   // Print scans
  for (int i = 0; i < NScans(); i++) {
    GSVScan *scan = Scan(i);
    scan->Print(fp, indented_prefix, suffix);
  }
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movq %rdx, 0x430(%rsp)
movq %rcx, 0x428(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x438(%rsp)
jne 0x53c11
movq 0x29b3c2(%rip), %rax    # 0x2eefc8
movq (%rax), %rax
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x430(%rsp)
je 0x53c3a
movq 0x438(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x22c5f4(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x8(%rsp), %rax
movq 0x438(%rsp), %rdi
movl 0x10(%rax), %edx
leaq 0x2135e8(%rip), %rsi    # 0x267239
movb $0x0, %al
callq 0x293c0
cmpq $0x0, 0x428(%rsp)
je 0x53c81
movq 0x438(%rsp), %rdi
movq 0x428(%rsp), %rdx
leaq 0x22c5ad(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x438(%rsp), %rdi
leaq 0x213176(%rip), %rsi    # 0x266e06
movb $0x0, %al
callq 0x293c0
leaq 0x20(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x212e4b(%rip), %rsi    # 0x266af6
movb $0x0, %al
callq 0x2a280
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3a080
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x53d16
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3a0a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x438(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x428(%rsp), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x53cba
addq $0x448, %rsp            # imm = 0x448
retq
nop