LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::~RGBDConfiguration()
RGBDConfiguration::
~RGBDConfiguration(void)
{
  // Delete everything
  while (NImages() > 0) delete Image(NImages()-1);
  while (NSurfaces() > 0) delete Surface(NSurfaces()-1);

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

  // Delete directory names
  if (color_directory) free(color_directory);
  if (depth_directory) free(depth_directory);
  if (category_directory) free(category_directory);
  if (instance_directory) free(instance_directory);
  if (texture_directory) free(texture_directory);

  // Delete dataset format
  if (dataset_format) free(dataset_format);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x191b96(%rip), %rcx    # 0x1acc20
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x19c40
movl %eax, 0x24(%rsp)
jmp 0x1b0a1
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jle 0x1b0e9
movq 0x28(%rsp), %rdi
callq 0x19c40
movl %eax, 0x20(%rsp)
jmp 0x1b0ba
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
decl %esi
callq 0x19c90
movq %rax, 0x18(%rsp)
jmp 0x1b0d1
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x1b0e7
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1b091
jmp 0x1b0eb
movq 0x28(%rsp), %rdi
callq 0x19c60
movl %eax, 0x14(%rsp)
jmp 0x1b0fb
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jle 0x1b143
movq 0x28(%rsp), %rdi
callq 0x19c60
movl %eax, 0x10(%rsp)
jmp 0x1b114
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
decl %esi
callq 0x19f70
movq %rax, 0x8(%rsp)
jmp 0x1b12b
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x1b141
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1b0eb
movq 0x28(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1b15d
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1b177
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1b191
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1b1ab
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1b1c5
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1b1df
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1b1f9
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x12870
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x19b90
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x222f0
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x19e30
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x22300
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::WorldCentroid() const
R3Point RGBDConfiguration::
WorldCentroid(void) const
{
  // Compute weighed sum of surface centroids
  RNArea weight = 0;
  R3Point position = R3zero_point;
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    position += surface->WorldArea() * surface->WorldCentroid();
    weight += surface->WorldArea();
  }

  // Return weighted average
  if (RNIsZero(weight)) return R3zero_point;
  return position / weight;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x197bf7(%rip), %rsi    # 0x1b2ea0
callq 0x8a9e0
movl $0x0, 0x64(%rsp)
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x19c60
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x1b356
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x19f70
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x22350
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x223d0
movsd (%rsp), %xmm0
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x22310
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x8b670
movq 0x58(%rsp), %rdi
callq 0x22350
addsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x80(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x1b2b6
movsd 0x80(%rsp), %xmm0
leaq 0x196b5a(%rip), %rax    # 0x1b1ec0
movsd (%rax), %xmm1
callq 0x1a370
cmpl $0x0, %eax
je 0x1b387
movq 0x10(%rsp), %rdi
leaq 0x197b20(%rip), %rsi    # 0x1b2ea0
callq 0x8a9e0
jmp 0x1b39f
movq 0x10(%rsp), %rdi
movsd 0x80(%rsp), %xmm0
leaq 0x68(%rsp), %rsi
callq 0x8ba50
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::InsertImage(gaps::RGBDImage*)
void RGBDConfiguration::
InsertImage(RGBDImage *image)
{
  // Just checking
  assert(image);
  assert(image->configuration == NULL);
  assert(image->configuration_index == -1);

  // Insert image into configuration
  image->configuration = this;
  image->configuration_index = images.NEntries();
  images.Insert(image);

  // Update bounding box
  world_bbox.Union(image->WorldBBox());
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rdi, 0x8(%rax)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x19e00
movq (%rsp), %rdi
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x68(%rsp), %rsi
callq 0x19cc0
movq 0x8(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x28d70
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x771c0
jmp 0x1b429
leaq 0x30(%rsp), %rdi
callq 0x19b90
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19b90
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::RemoveImage(gaps::RGBDImage*)
void RGBDConfiguration::
RemoveImage(RGBDImage *image)
{
  // Just checking
  assert(image);
  assert(image->configuration == this);
  assert(image->configuration_index >= 0);
  assert(images.Kth(image->configuration_index) == image);

  // Remove image from configuration
  RNArrayEntry *entry = images.KthEntry(image->configuration_index);
  RGBDImage *tail = images.Tail();
  tail->configuration_index = image->configuration_index;
  images.EntryContents(entry) = tail;
  images.RemoveTail();
  image->configuration_index = -1;
  image->configuration = NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq 0x28(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x22460
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x22480
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 $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x22490
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x8, %rdi
callq 0x224a0
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::InsertSurface(gaps::RGBDSurface*)
void RGBDConfiguration::
InsertSurface(RGBDSurface *surface)
{
  // Just checking
  assert(surface);
  assert(surface->configuration == NULL);
  assert(surface->configuration_index == -1);

  // Insert surface into configuration
  surface->configuration = this;
  surface->configuration_index = surfaces.NEntries();
  surfaces.Insert(surface);

  // Update bounding box
  world_bbox.Union(surface->WorldBBox());
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rdi, 0x8(%rax)
addq $0x18, %rdi
movq %rdi, (%rsp)
callq 0x19e00
movq (%rsp), %rdi
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x68(%rsp), %rsi
callq 0x224c0
movq 0x8(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x224f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x771c0
jmp 0x1b589
leaq 0x30(%rsp), %rdi
callq 0x19b90
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19b90
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::RemoveSurface(gaps::RGBDSurface*)
void RGBDConfiguration::
RemoveSurface(RGBDSurface *surface)
{
  // Just checking
  assert(surface);
  assert(surface->configuration == this);
  assert(surface->configuration_index >= 0);
  assert(surfaces.Kth(surface->configuration_index) == surface);

  // Remove surface from configuration
  RNArrayEntry *entry = surfaces.KthEntry(surface->configuration_index);
  RGBDSurface *tail = surfaces.Tail();
  tail->configuration_index = surface->configuration_index;
  surfaces.EntryContents(entry) = tail;
  surfaces.RemoveTail();
  surface->configuration_index = -1;
  surface->configuration = NULL;
}

// 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 0x10(%rax), %esi
callq 0x22460
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0x22590
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 $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x225a0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x18, %rdi
callq 0x224a0
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::Transform(gaps::R3Transformation const&)
void RGBDConfiguration::
Transform(const R3Transformation& transformation)
{
  // Transform images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->Transform(transformation);
  }
  
  // Transform surfaces
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    surface->Transform(transformation);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x1b6df
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x19c90
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x88(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1b690
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x19c60
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x1b733
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x19f70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1b6e7
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetName(char const*)
void RGBDConfiguration::
SetName(const char *name)
{
  // Set directory name
  if (this->name) free(this->name);
  if (name && strcmp(name, "-")) this->name = RNStrdup(name);
  else this->name = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rax)
je 0x1b76b
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1b7a0
movq 0x8(%rsp), %rdi
leaq 0x14abce(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1b7a0
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1b7ac
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetColorDirectory(char const*)
void RGBDConfiguration::
SetColorDirectory(const char *directory)
{
  // Set directory name
  if (color_directory) free(color_directory);
  if (directory && strcmp(directory, "-")) color_directory = RNStrdup(directory);
  else color_directory = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x30(%rax)
je 0x1b7eb
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1b820
movq 0x8(%rsp), %rdi
leaq 0x14ab4e(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1b820
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x1b82c
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetDepthDirectory(char const*)
void RGBDConfiguration::
SetDepthDirectory(const char *directory)
{
  // Set directory name
  if (depth_directory) free(depth_directory);
  if (directory && strcmp(directory, "-")) depth_directory = RNStrdup(directory);
  else depth_directory = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x38(%rax)
je 0x1b86b
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1b8a0
movq 0x8(%rsp), %rdi
leaq 0x14aace(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1b8a0
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x1b8ac
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetCategoryDirectory(char const*)
void RGBDConfiguration::
SetCategoryDirectory(const char *directory)
{
  // Set directory name
  if (category_directory) free(category_directory);
  if (directory && strcmp(directory, "-")) category_directory = RNStrdup(directory);
  else category_directory = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x40(%rax)
je 0x1b8eb
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1b920
movq 0x8(%rsp), %rdi
leaq 0x14aa4e(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1b920
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
jmp 0x1b92c
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetInstanceDirectory(char const*)
void RGBDConfiguration::
SetInstanceDirectory(const char *directory)
{
  // Set directory name
  if (instance_directory) free(instance_directory);
  if (directory && strcmp(directory, "-")) instance_directory = RNStrdup(directory);
  else instance_directory = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x48(%rax)
je 0x1b96b
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1b9a0
movq 0x8(%rsp), %rdi
leaq 0x14a9ce(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1b9a0
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
jmp 0x1b9ac
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetTextureDirectory(char const*)
void RGBDConfiguration::
SetTextureDirectory(const char *directory)
{
  // Set directory name
  if (texture_directory) free(texture_directory);
  if (directory && strcmp(directory, "-")) texture_directory = RNStrdup(directory);
  else texture_directory = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x50(%rax)
je 0x1b9eb
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1ba20
movq 0x8(%rsp), %rdi
leaq 0x14a94e(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1ba20
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
jmp 0x1ba2c
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::SetDatasetFormat(char const*)
void RGBDConfiguration::
SetDatasetFormat(const char *format)
{
  // Set format name
  if (dataset_format) free(dataset_format);
  if (format && strcmp(format, "-")) dataset_format = RNStrdup(format);
  else dataset_format = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x58(%rax)
je 0x1ba6b
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x1baa0
movq 0x8(%rsp), %rdi
leaq 0x14a8ce(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x1baa0
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
jmp 0x1baac
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadFile(char const*, int)
int RGBDConfiguration::
ReadFile(const char *filename, int read_every_kth_image)
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .conf)\n", filename);
    return 0;
  }

  // Read file of appropriate type
  if (!strncmp(extension, ".conf", 5)) {
    if (!ReadConfigurationFile(filename, read_every_kth_image)) return 0;
  }
  else if (!strncmp(extension, ".json", 5)) {
    if (!ReadNeRFFile(filename, read_every_kth_image)) return 0;
  }
  else if (!strncmp(extension, ".seg", 4)) {
    if (!ReadSegmentationFile(filename)) return 0;
  }
  else if (!strncmp(extension, ".obb", 4)) {
    if (!ReadOrientedBoxFile(filename)) return 0;
  }
  else {
    RNFail("Unable to read file %s (unrecognized extension: %s)\n", filename, extension);
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1bb16
movq 0x20(%rsp), %rsi
leaq 0x14aa8e(%rip), %rdi    # 0x166590
movb $0x0, %al
callq 0x12090
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
movq 0x10(%rsp), %rdi
leaq 0x14aa9a(%rip), %rsi    # 0x1665bc
movl $0x5, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bb5c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0x78(%rax)
cmpl $0x0, %eax
jne 0x1bb57
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
jmp 0x1bc4b
movq 0x10(%rsp), %rdi
leaq 0x14aa5a(%rip), %rsi    # 0x1665c2
movl $0x5, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bba5
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0x80(%rax)
cmpl $0x0, %eax
jne 0x1bba0
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
jmp 0x1bc49
movq 0x10(%rsp), %rdi
leaq 0x14aa17(%rip), %rsi    # 0x1665c8
movl $0x4, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bbe4
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x88(%rax)
cmpl $0x0, %eax
jne 0x1bbe2
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
jmp 0x1bc47
movq 0x10(%rsp), %rdi
leaq 0x14a9dd(%rip), %rsi    # 0x1665cd
movl $0x4, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bc23
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x90(%rax)
cmpl $0x0, %eax
jne 0x1bc21
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
jmp 0x1bc45
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x14a99e(%rip), %rdi    # 0x1665d2
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x34(%rsp)
jmp 0x1bc53
jmp 0x1bc47
jmp 0x1bc49
jmp 0x1bc4b
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::WriteFile(char const*, int) const
int RGBDConfiguration::
WriteFile(const char *filename, int write_every_kth_image) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .conf)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  if (!strncmp(extension, ".conf", 5)) {
    if (!WriteConfigurationFile(filename, write_every_kth_image)) return 0;
  }
  else if (!strncmp(extension, ".json", 5)) {
    if (!WriteNeRFFile(filename, write_every_kth_image)) return 0;
  }
  else if (!strncmp(extension, ".cam", 4)) {
    if (!WriteCameraFile(filename)) return 0;
  }
  else if (!strncmp(extension, ".obj", 4)) {
    if (!WriteObjFile(filename)) return 0;
  }
  else {
    RNFail("Unable to write file %s (unrecognized extension: %s)\n", filename, extension);
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1bcb6
movq 0x20(%rsp), %rsi
leaq 0x14a8ee(%rip), %rdi    # 0x166590
movb $0x0, %al
callq 0x12090
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
movq 0x10(%rsp), %rdi
leaq 0x14a8fa(%rip), %rsi    # 0x1665bc
movl $0x5, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bcff
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0xa0(%rax)
cmpl $0x0, %eax
jne 0x1bcfa
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
jmp 0x1bdf3
movq 0x10(%rsp), %rdi
leaq 0x14a8b7(%rip), %rsi    # 0x1665c2
movl $0x5, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bd48
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0xa8(%rax)
cmpl $0x0, %eax
jne 0x1bd43
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
jmp 0x1bdf1
movq 0x10(%rsp), %rdi
leaq 0x14a8b3(%rip), %rsi    # 0x166607
movl $0x4, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bd8c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0xb0(%rax)
cmpl $0x0, %eax
jne 0x1bd8a
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
jmp 0x1bdef
movq 0x10(%rsp), %rdi
leaq 0x14a874(%rip), %rsi    # 0x16660c
movl $0x4, %edx
callq 0x12310
cmpl $0x0, %eax
jne 0x1bdcb
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0xb8(%rax)
cmpl $0x0, %eax
jne 0x1bdc9
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
jmp 0x1bded
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x14a835(%rip), %rdi    # 0x166611
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x34(%rsp)
jmp 0x1bdfb
jmp 0x1bdef
jmp 0x1bdf1
jmp 0x1bdf3
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadConfigurationFile(char const*, int)
int RGBDConfiguration::
ReadConfigurationFile(const char *filename, int read_every_kth_image)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open configuration file %s\n", filename);
    return 0;
  }

  // Read file
  if (!ReadConfigurationStream(fp, read_every_kth_image)) return 0;
  
  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x150d6b(%rip), %rsi    # 0x16cba3
callq 0x12860
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1be67
movq 0x20(%rsp), %rsi
leaq 0x14a7f1(%rip), %rdi    # 0x166647
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x34(%rsp)
jmp 0x1be9f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0xc0(%rax)
cmpl $0x0, %eax
jne 0x1be8d
movl $0x0, 0x34(%rsp)
jmp 0x1be9f
movq 0x10(%rsp), %rdi
callq 0x126c0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::WriteConfigurationFile(char const*, int) const
int RGBDConfiguration::
WriteConfigurationFile(const char *filename, int write_every_kth_image) const
{
#if 0
  // Create directories
  char cmd[4096];
  if (color_directory) { sprintf(cmd, "mkdir -p %s", color_directory); system(cmd); }
  if (depth_directory) { sprintf(cmd, "mkdir -p %s", depth_directory); system(cmd); }
  if (category_directory) { sprintf(cmd, "mkdir -p %s", category_directory); system(cmd); }
  if (instance_directory) { sprintf(cmd, "mkdir -p %s", instance_directory); system(cmd); }
  if (texture_directory) { sprintf(cmd, "mkdir -p %s", texture_directory); system(cmd); }
#endif

  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open configuration file %s\n", filename);
    return 0;
  }

  // Write file
  if (!WriteConfigurationStream(fp, write_every_kth_image)) return 0;

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x14c9d2(%rip), %rsi    # 0x1688aa
callq 0x12860
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1bf07
movq 0x20(%rsp), %rsi
leaq 0x14a751(%rip), %rdi    # 0x166647
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x34(%rsp)
jmp 0x1bf3f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0xc8(%rax)
cmpl $0x0, %eax
jne 0x1bf2d
movl $0x0, 0x34(%rsp)
jmp 0x1bf3f
movq 0x10(%rsp), %rdi
callq 0x126c0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::GetJsonObjectMember(Json::Value*&, Json::Value*, char const*, int)
static int
GetJsonObjectMember(Json::Value *&result, Json::Value *object, const char *str, int expected_type = 0)
{
  // Check object type
  if (object->type() != Json::objectValue) {
    // RNFail("JSON: not an object\n");
    return 0;
  }

  // Check object member
  if (!object->isMember(str)) {
    // RNFail("JSON object has no member named %s\n", str);
    return 0;
  }

  // Get object member
  result = &((*object)[str]);
  if (result->type() == Json::nullValue) {
    // RNFail("JSON object has null member named %s\n", str);
    return 0;
  }

  // Check member type
  if (expected_type > 0) {
    if (result->type() != expected_type) {
      // RNFail("JSON object member %s has unexpected type %d (rather than %d)\n", str, result->type(), expected_type);
      return 0;
    }
  }
  
  // Check for empty strings
  if (result->type() == Json::stringValue) {
    if (result->asString().length() == 0) {
      // RNFail("JSON object has zero length string named %s\n", str);
      return 0;
    }
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
callq 0xed7d0
cmpl $0x7, %eax
je 0x205d3
movl $0x0, 0x54(%rsp)
jmp 0x206ae
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1720
testb $0x1, %al
jne 0x205f3
movl $0x0, 0x54(%rsp)
jmp 0x206ae
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xeb850
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0xed7d0
cmpl $0x0, %eax
jne 0x2062c
movl $0x0, 0x54(%rsp)
jmp 0x206ae
cmpl $0x0, 0x34(%rsp)
jle 0x20652
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0xed7d0
cmpl 0x34(%rsp), %eax
je 0x20650
movl $0x0, 0x54(%rsp)
jmp 0x206ae
jmp 0x20652
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0xed7d0
cmpl $0x4, %eax
jne 0x206a6
movq 0x48(%rsp), %rax
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0xe2e90
leaq 0x10(%rsp), %rdi
callq 0x12a90
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x12430
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
jne 0x206a4
movl $0x0, 0x54(%rsp)
jmp 0x206ae
jmp 0x206a6
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::GetJsonArrayEntry(Json::Value*&, Json::Value*, unsigned int, int)
static int
GetJsonArrayEntry(Json::Value *&result, Json::Value *array, unsigned int k, int expected_type = -1)
{
  // Check array type
  if (array->type() != Json::arrayValue) {
    RNFail("JSON: not an array\n");
    return 0;
  }

  // Check array size
  if (array->size() <= k) {
    // RNFail("JSON array has no member %d\n", k);
    return 0;
  }

  // Get entry
  result = &((*array)[k]);
  if (result->type() == Json::nullValue) {
    // RNFail("JSON array has null member %d\n", k);
    return 0;
  }

  // Check entry type
  if (expected_type > 0) {
    if (result->type() != expected_type) {
      // RNFail("JSON array entry %d has unexpected type %d (rather than %d)\n", k, result->type(), expected_type);
      return 0;
    }
  }
  
  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xed7d0
cmpl $0x6, %eax
je 0x206fd
leaq 0x14670b(%rip), %rdi    # 0x166df7
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x24(%rsp)
jmp 0x2077a
movq 0x10(%rsp), %rdi
callq 0xeb340
cmpl 0xc(%rsp), %eax
ja 0x20717
movl $0x0, 0x24(%rsp)
jmp 0x2077a
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xefce0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xed7d0
cmpl $0x0, %eax
jne 0x2074c
movl $0x0, 0x24(%rsp)
jmp 0x2077a
cmpl $0x0, 0x8(%rsp)
jle 0x20772
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xed7d0
cmpl 0x8(%rsp), %eax
je 0x20770
movl $0x0, 0x24(%rsp)
jmp 0x2077a
jmp 0x20772
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::WriteMtlFile(gaps::RGBDConfiguration const*, char const*)
static int
WriteMtlFile(const RGBDConfiguration *configuration, const char *filename)
{
  // Check texture directory name
  if (!configuration->TextureDirectory()) return 1;

  // Open mtl file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open file %s", filename);
    return 0;
  }

  // Write materials
  for (int i = 0; i < configuration->NSurfaces(); i++) {
    RGBDSurface *surface = configuration->Surface(i);
    if (!surface->TextureFilename()) continue;
    fprintf(fp, "newmtl surface%d\n", i);
    fprintf(fp, "Kd 1 1 1\n");
    fprintf(fp, "map_Kd %s/%s\n", configuration->TextureDirectory(), surface->TextureFilename());
    fprintf(fp, "\n");
  }
  
  // Close mtl file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x19f60
cmpq $0x0, %rax
jne 0x214fb
movl $0x1, 0x44(%rsp)
jmp 0x21621
movq 0x30(%rsp), %rdi
leaq 0x1473a3(%rip), %rsi    # 0x1688aa
callq 0x12860
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x21539
movq 0x30(%rsp), %rsi
leaq 0x145866(%rip), %rdi    # 0x166d8b
movb $0x0, %al
callq 0xdf990
movl $0x0, 0x44(%rsp)
jmp 0x21621
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
callq 0x19c60
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x2160f
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x19f70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22650
cmpq $0x0, %rax
jne 0x21586
jmp 0x215ff
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
leaq 0x145875(%rip), %rsi    # 0x166e0b
movb $0x0, %al
callq 0x12a30
movq 0x28(%rsp), %rdi
leaq 0x145874(%rip), %rsi    # 0x166e1d
movb $0x0, %al
callq 0x12a30
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x19f60
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22650
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x145842(%rip), %rsi    # 0x166e27
movb $0x0, %al
callq 0x12a30
movq 0x28(%rsp), %rdi
leaq 0x14b94a(%rip), %rsi    # 0x16cf42
movb $0x0, %al
callq 0x12a30
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x21541
movq 0x28(%rsp), %rdi
callq 0x126c0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadChannels()
int RGBDConfiguration::
ReadChannels(void)
{
  // Read images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReadChannels();
  }

  // Read surfaces
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    surface->ReadChannels();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21695
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x19c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0xf8(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2164b
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
callq 0x19c60
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x216e5
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2169d
movl $0x1, %eax
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReleaseChannels()
int RGBDConfiguration::
ReleaseChannels(void)
{
  // Release images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReleaseChannels();
  }

  // Release surfaces
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    surface->ReleaseChannels();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21755
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x19c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x148(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2170b
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
callq 0x19c60
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x217a5
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2175d
movl $0x1, %eax
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadColorChannels()
int RGBDConfiguration::
ReadColorChannels(void)
{
  // Read images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReadColorChannels();
  }

  // Read surfaces
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    surface->ReadColorChannels();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21815
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x19c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x217cb
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
callq 0x19c60
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x21865
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2181d
movl $0x1, %eax
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReleaseColorChannels()
int RGBDConfiguration::
ReleaseColorChannels(void)
{
  // Release images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReleaseColorChannels();
  }

  // Release surfaces
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    surface->ReleaseColorChannels();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x218d5
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x19c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x150(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2188b
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
callq 0x19c60
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x21925
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19f70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0xb0(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x218dd
movl $0x1, %eax
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadDepthChannels()
int RGBDConfiguration::
ReadDepthChannels(void)
{
  // Read images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReadDepthChannel();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21995
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2194b
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReleaseDepthChannels()
int RGBDConfiguration::
ReleaseDepthChannels(void)
{
  // Release images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReleaseDepthChannel();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21a05
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x158(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x219bb
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadCategoryChannels()
int RGBDConfiguration::
ReadCategoryChannels(void)
{
  // Read images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReadCategoryChannel();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21a75
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x110(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21a2b
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReleaseCategoryChannels()
int RGBDConfiguration::
ReleaseCategoryChannels(void)
{
  // Release images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReleaseCategoryChannel();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21ae5
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x160(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21a9b
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::ReadInstanceChannels()
int RGBDConfiguration::
ReadInstanceChannels(void)
{
  // Read images
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    image->ReadInstanceChannel();
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21b55
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x118(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21b0b
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::UpdateWorldBBox()
void RGBDConfiguration::
UpdateWorldBBox(void)
{
  // Initialize bounding box
  world_bbox = R3null_box;

  // Union image bounding boxes
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    world_bbox.Union(image->WorldViewpoint());
    if (!image->world_bbox.IsEmpty()) {
      world_bbox.Union(image->world_bbox);
    }
  }

  // Union surface bounding boxes
  for (int i = 0; i < NSurfaces(); i++) {
    RGBDSurface *surface = Surface(i);
    world_bbox.Union(surface->WorldBBox());
  }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x60, %rdi
leaq 0x1908d1(%rip), %rsi    # 0x1b2528
callq 0x22c20
movl $0x0, 0xac(%rsp)
movq 0x28(%rsp), %rdi
movl 0xac(%rsp), %eax
movl %eax, 0x24(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x21d29
movq 0x28(%rsp), %rdi
movl 0xac(%rsp), %esi
callq 0x19c90
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xa0(%rsp)
addq $0x60, %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x19db0
movq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x76f60
movq 0xa0(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
callq 0x19cf0
cmpl $0x0, %eax
jne 0x21d11
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
movq 0xa0(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
callq 0x771c0
jmp 0x21d13
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x21c67
movl $0x0, 0x84(%rsp)
movq 0x28(%rsp), %rdi
movl 0x84(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x19c60
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x21ddb
movq 0x28(%rsp), %rdi
movl 0x84(%rsp), %esi
callq 0x19f70
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x78(%rsp)
addq $0x60, %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x771c0
jmp 0x21da1
leaq 0x40(%rsp), %rdi
callq 0x19b90
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x21d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19b90
jmp 0x21de3
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDConfiguration.cpp
// Function: gaps::RGBDConfiguration::FindImage(char const*) const
RGBDImage *RGBDConfiguration::
FindImage(const char *name) const
{
  // Find image with matching name
  for (int i = 0; i < NImages(); i++) {
    RGBDImage *image = Image(i);
    if (image->Name() && !strcmp(image->Name(), name)) return image;
  }

  // Image not found
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x19c40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x21ee6
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x19c90
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x22c80
cmpq $0x0, %rax
je 0x21ed7
movq 0x10(%rsp), %rdi
callq 0x22c80
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x12a00
cmpl $0x0, %eax
jne 0x21ed7
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x21eef
jmp 0x21ed9
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21e70
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::WorldArea() const
inline RNArea RGBDSurface::
WorldArea(void) const
{
  // Return area of surface
  if (rectangle) return rectangle->Area();
  else if (mesh) return mesh->Area();
  return 0.0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x80(%rax)
je 0x22385
movq (%rsp), %rax
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x223b6
movq (%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x223ab
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x45500
movsd %xmm0, 0x10(%rsp)
jmp 0x223b6
jmp 0x223ad
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::WorldCentroid() const
inline R3Point RGBDSurface::
WorldCentroid(void) const
{
  // Return centroid of surface
  if (rectangle) return rectangle->Centroid();
  else if (mesh) return mesh->Centroid();
  return R3zero_point;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x22416
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
movq (%rsi), %rax
callq *0x68(%rax)
jmp 0x2244e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x2243c
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rsi
callq 0x45280
jmp 0x2244e
jmp 0x2243e
movq (%rsp), %rdi
leaq 0x190a57(%rip), %rsi    # 0x1b2ea0
callq 0x8a9e0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::WorldBBox() const
inline R3Box RGBDSurface::
WorldBBox(void) const
{
  // Return bounding box
  if (rectangle) return rectangle->BBox();
  else if (mesh) return mesh->BBox();
  return R3null_box;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x22539
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
movq (%rsi), %rax
callq *0x88(%rax)
jmp 0x22579
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x22567
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x22ca0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x75370
jmp 0x22579
jmp 0x22569
movq (%rsp), %rdi
leaq 0x18ffb4(%rip), %rsi    # 0x1b2528
callq 0x75370
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)