LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::~RGBDSurface()
RGBDSurface::
~RGBDSurface(void)
{
  // Delete opengl texture
  InvalidateOpenGL();
  
  // Remove from configuration
  if (configuration) {
    configuration->RemoveSurface(this);
  }

  // Delete channels
  for (int i = 0; i < channels.NEntries(); i++) {
    if (channels[i]) delete channels[i];
  }

  // Delete filenames
  if (texture_filename) free(texture_filename);
  if (mesh_filename) free(mesh_filename);

  // Delete mesh face index
  if (mesh_face_index) delete mesh_face_index;

  // Delete geometry stuff
  if (rectangle) delete rectangle;
  if (mesh) delete mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0x188a7e(%rip), %rax    # 0x1acd88
movq %rax, (%rdi)
movq (%rdi), %rax
movq 0xd8(%rax), %rax
callq *%rax
jmp 0x2431b
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2433d
movq 0x40(%rsp), %rsi
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x2433b
jmp 0x2433d
movl $0x0, 0x4c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0x38(%rsp)
addq $0x18, %rdi
callq 0x19e00
movl %eax, 0x3c(%rsp)
jmp 0x24361
movl 0x38(%rsp), %eax
movl 0x3c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x243ea
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl 0x4c(%rsp), %esi
callq 0x277c0
movq %rax, 0x30(%rsp)
jmp 0x24386
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x243d8
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl 0x4c(%rsp), %esi
callq 0x277c0
movq %rax, 0x28(%rsp)
jmp 0x243aa
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x243d6
movq 0x20(%rsp), %rdi
callq 0xb3390
movq 0x20(%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
jmp 0x243d8
jmp 0x243da
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x24345
movq 0x40(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x24404
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x12870
movq 0x40(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2441e
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12870
movq 0x40(%rsp), %rax
cmpq $0x0, 0x90(%rax)
je 0x2445f
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x2445d
movq 0x18(%rsp), %rdi
callq 0xb3390
movq 0x18(%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
jmp 0x2445f
movq 0x40(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x24492
movq 0x40(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x24490
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x24492
movq 0x40(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x244c5
movq 0x40(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x244c3
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x244c5
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0x1a200
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x27790
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x22300
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TexelColor(int, int) const
RNRgb RGBDSurface::
TexelColor(int ix, int iy) const
{
  // Return color of pixel
  if (NChannels() < 3) return RNblack_rgb;
  RNScalar r = TexelChannelValue(ix, iy, RGBD_RED_CHANNEL);
  RNScalar g = TexelChannelValue(ix, iy, RGBD_GREEN_CHANNEL);
  RNScalar b = TexelChannelValue(ix, iy, RGBD_BLUE_CHANNEL);
  return RNRgb(r, g, b);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x277e0
cmpl $0x3, %eax
jge 0x24568
movq (%rsp), %rdi
leaq 0x19046f(%rip), %rsi    # 0x1b49d0
callq 0xdb190
jmp 0x245d7
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
xorl %ecx, %ecx
callq 0x27800
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x28(%rsp)
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl $0x1, %ecx
callq 0x27800
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movl $0x2, %ecx
callq 0x27800
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0xdb1d0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TexelWorldNormal(gaps::R2Point const&) const
R3Vector RGBDSurface::
TexelWorldNormal(const R2Point& texture_position) const
{
  // Return surface normal
  if (rectangle) {
    return rectangle->Normal();
  }
  else if (mesh) {
    double barycentrics[3];
    R3MeshFace *face = SearchMeshFaceIndex(texture_position, barycentrics);
    if (!face) return R3zero_vector;
    else return mesh->FaceNormal(face);
  }
  else {
    return R3zero_vector;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x247a2
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x225d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x8bb40
jmp 0x2481c
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x2480c
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0xe8(%rax)
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x247e8
movq (%rsp), %rdi
leaq 0x18e7af(%rip), %rsi    # 0x1b2f90
callq 0x8bb40
jmp 0x2481c
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x27910
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x8bb40
jmp 0x2481c
movq (%rsp), %rdi
leaq 0x18e779(%rip), %rsi    # 0x1b2f90
callq 0x8bb40
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TexelColor(gaps::R2Point const&) const
RNRgb RGBDSurface::
TexelColor(const R2Point& texture_position) const
{
  // Return color of pixel
  if (NChannels() < 3) return RNblack_rgb;
  RNScalar r = TexelChannelValue(texture_position, RGBD_RED_CHANNEL);
  RNScalar g = TexelChannelValue(texture_position, RGBD_GREEN_CHANNEL);
  RNScalar b = TexelChannelValue(texture_position, RGBD_BLUE_CHANNEL);
  return RNRgb(r, g, b);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x277e0
cmpl $0x3, %eax
jge 0x24875
movq (%rsp), %rdi
leaq 0x190162(%rip), %rsi    # 0x1b49d0
callq 0xdb190
jmp 0x248db
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x27890
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x27890
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rsi
movl $0x2, %edx
callq 0x27890
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0xdb1d0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SurfelColor(gaps::R2Point const&) const
RNRgb RGBDSurface::
SurfelColor(const R2Point& surface_position) const
{
  // Return color of texture at surface point
  R2Point texture_position;
  if (!TransformSurfaceToTexture(surface_position, texture_position)) return RNblack_rgb;
  return TexelColor(texture_position);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xcfd70
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
leaq 0x20(%rsp), %rdx
callq *0x40(%rax)
cmpl $0x0, %eax
jne 0x24951
movq 0x8(%rsp), %rdi
leaq 0x190086(%rip), %rsi    # 0x1b49d0
callq 0xdb190
jmp 0x24965
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x24830
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SurfelWorldPosition(gaps::R2Point const&) const
R3Point RGBDSurface::
SurfelWorldPosition(const R2Point& surface_position) const
{
  // Return world position at surface point
  R3Point world_position;
  if (!TransformSurfaceToWorld(surface_position, world_position)) return R3zero_point;
  return world_position;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x8a990
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
leaq 0x18(%rsp), %rdx
callq *0x48(%rax)
cmpl $0x0, %eax
jne 0x249cf
movq (%rsp), %rdi
leaq 0x18e4d8(%rip), %rsi    # 0x1b2ea0
callq 0x8a9e0
jmp 0x249dd
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8a9e0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SurfelWorldNormal(gaps::R2Point const&) const
R3Vector RGBDSurface::
SurfelWorldNormal(const R2Point& surface_position) const
{
  // Return normal at surface point
  if (rectangle) return rectangle->Normal();
  else if (mesh) return R3negy_vector; 
  return R3zero_vector;
}

// 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), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x24a44
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x225d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8bb40
jmp 0x24a79
movq 0x18(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x24a66
movq 0x8(%rsp), %rdi
leaq 0x18e5c1(%rip), %rsi    # 0x1b3020
callq 0x8bb40
jmp 0x24a79
jmp 0x24a68
movq 0x8(%rsp), %rdi
leaq 0x18e51c(%rip), %rsi    # 0x1b2f90
callq 0x8bb40
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetTexelColor(int, int, gaps::RNRgb const&)
void RGBDSurface::
SetTexelColor(int ix, int iy, const RNRgb& color)
{
  // Set pixel red, green, and blue
  SetTexelChannelValue(ix, iy, RGBD_RED_CHANNEL, color.R());
  SetTexelChannelValue(ix, iy, RGBD_GREEN_CHANNEL, color.G());
  SetTexelChannelValue(ix, iy, RGBD_BLUE_CHANNEL, color.B());

  // Invalidate opengl
  InvalidateOpenGL();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1a180
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x18(%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1a190
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %ecx
callq *0x18(%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1a1a0
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movl $0x2, %ecx
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0xd8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetTexelChannelValue(int, int, int, double)
void RGBDSurface::
SetTexelChannelValue(int ix, int iy, int channel_index, RNScalar value)
{
  // Check channel
  if (!channels[channel_index]) {
    RNFail("RGBD Channel is not resident in memory -- cannot get value\n");
    return;
  }
  
  // Set channel value at pixel
  if ((channel_index < 0) || (channel_index >= channels.NEntries())) return;
  if ((ix < 0) || (ix >= channels[channel_index]->XResolution())) return;
  if ((iy < 0) || (ix >= channels[channel_index]->YResolution())) return;
  channels[channel_index]->SetGridValue(ix, iy, value);

  // Invalidate opengl
  if ((channel_index >= RGBD_RED_CHANNEL) && (channel_index <= RGBD_BLUE_CHANNEL)) InvalidateOpenGL();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
movl 0x24(%rsp), %esi
callq 0x277c0
cmpq $0x0, (%rax)
jne 0x24c1b
leaq 0x1422aa(%rip), %rdi    # 0x166eb9
movb $0x0, %al
callq 0xdf990
jmp 0x24cf5
cmpl $0x0, 0x24(%rsp)
jl 0x24c42
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x19e00
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jl 0x24c47
jmp 0x24cf5
cmpl $0x0, 0x2c(%rsp)
jl 0x24c7a
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x24(%rsp), %esi
callq 0x277c0
movq (%rax), %rdi
callq 0x27940
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jl 0x24c7c
jmp 0x24cf5
cmpl $0x0, 0x28(%rsp)
jl 0x24caf
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movl 0x24(%rsp), %esi
callq 0x277c0
movq (%rax), %rdi
callq 0x27960
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x24cb1
jmp 0x24cf5
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x24(%rsp), %esi
callq 0x277c0
movq (%rax), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movsd 0x18(%rsp), %xmm0
callq 0x1a1b0
cmpl $0x0, 0x24(%rsp)
jl 0x24cf5
cmpl $0x2, 0x24(%rsp)
jg 0x24cf5
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0xd8(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetChannel(int, gaps::R2Grid const&)
void RGBDSurface::
SetChannel(int channel_index, const R2Grid& image)
{
  // Check if color channels are resident
  if ((channel_index >= RGBD_RED_CHANNEL) && (channel_index <= RGBD_BLUE_CHANNEL)) {
    if (color_resident_count == 0) {
      RNFail("Unable to set channel -- it has not been created\n");
      return;
    }
  }

  // Set channel
  *(channels[channel_index]) = image;

  // Set width and height
  this->width = image.XResolution();
  this->height = image.YResolution();

  // Invalidate opengl
  if ((channel_index >= RGBD_RED_CHANNEL) && (channel_index <= RGBD_BLUE_CHANNEL)) InvalidateOpenGL();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jl 0x24d47
cmpl $0x2, 0x1c(%rsp)
jg 0x24d47
movq 0x8(%rsp), %rax
cmpl $0x0, 0x70(%rax)
jne 0x24d45
leaq 0x1421b9(%rip), %rdi    # 0x166ef5
movb $0x0, %al
callq 0xdf990
jmp 0x24db2
jmp 0x24d47
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movl 0x1c(%rsp), %esi
callq 0x277c0
movq (%rsp), %rsi
movq (%rax), %rdi
callq 0xb2f20
movq 0x10(%rsp), %rdi
callq 0x27940
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rdi
callq 0x27960
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x2c(%rax)
cmpl $0x0, 0x1c(%rsp)
jl 0x24db2
cmpl $0x2, 0x1c(%rsp)
jg 0x24db2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xd8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetColorChannels(gaps::R2Image const&)
void RGBDSurface::
SetColorChannels(const R2Image& image)
{
  // Check if color channels are resident
  if (color_resident_count == 0) {
    RNFail("Unable to set color channels -- they have not been created\n");
    return;
  }

  // Copy color values
  for (int iy = 0; iy < image.Height(); iy++) {
    for (int ix = 0; ix < image.Width(); ix++) {
      RNRgb color = image.PixelRGB(ix, iy);
      channels[RGBD_RED_CHANNEL]->SetGridValue(ix, iy, color.R());      
      channels[RGBD_GREEN_CHANNEL]->SetGridValue(ix, iy, color.G());      
      channels[RGBD_BLUE_CHANNEL]->SetGridValue(ix, iy, color.B());
    }
  }

  // Set width and height
  this->width = image.Width();
  this->height = image.Height();

  // Invalidate opengl
  InvalidateOpenGL();
  
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpl $0x0, 0x70(%rax)
jne 0x24df1
leaq 0x142142(%rip), %rdi    # 0x166f27
movb $0x0, %al
callq 0xdf990
jmp 0x24f7b
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x68(%rsp), %rdi
callq 0x22950
movl %eax, %ecx
movl 0x3c(%rsp), %eax
cmpl %ecx, %eax
jge 0x24f4c
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x22940
movl %eax, %ecx
movl 0x38(%rsp), %eax
cmpl %ecx, %eax
jge 0x24f3a
movq 0x68(%rsp), %rsi
movl 0x60(%rsp), %edx
movl 0x64(%rsp), %ecx
leaq 0x48(%rsp), %rdi
callq 0xd21a0
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1a180
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x1a1b0
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1a190
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x1a1b0
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl $0x2, %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1a1a0
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
movl 0x34(%rsp), %edx
callq 0x1a1b0
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x24e21
jmp 0x24f3c
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x24df9
movq 0x68(%rsp), %rdi
callq 0x22940
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x68(%rsp), %rdi
callq 0x22950
movq 0x40(%rsp), %rdi
movl %eax, 0x2c(%rdi)
movq (%rdi), %rax
callq *0xd8(%rax)
addq $0x78, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetTextureFilename(char const*)
void RGBDSurface::
SetTextureFilename(const char *filename)
{
  // Set filename
  if (texture_filename) free(texture_filename);
  if (filename && strcmp(filename, "-")) texture_filename = RNStrdup(filename);
  else texture_filename = 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 0x24fab
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x24fe0
movq 0x8(%rsp), %rdi
leaq 0x14138e(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x24fe0
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
jmp 0x24fec
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetMeshFilename(char const*)
void RGBDSurface::
SetMeshFilename(const char *filename)
{
  // Set filename
  if (mesh_filename) free(mesh_filename);
  if (filename && strcmp(filename, "-")) mesh_filename = RNStrdup(filename);
  else mesh_filename = 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 0x2502b
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x25060
movq 0x8(%rsp), %rdi
leaq 0x14130e(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x25060
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
jmp 0x2506c
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SetWorldTexelSpacing(double)
void RGBDSurface::
SetWorldTexelSpacing(RNLength texel_spacing)
{
  // Compute new width and height
  if (texel_spacing > 0) {
    width = surface_bbox.XLength() / texel_spacing;
    height = surface_bbox.YLength() / texel_spacing;
  }
  
  // Resample channels
  for (int i = 0; i < NChannels(); i++) {
    R2Grid *channel = Channel(i);
    if (channel) channel->Resample(width, height);
  }

  // Invalidate mesh face index
  InvalidateMeshFaceIndex();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x250e3
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x1a210
movq 0x10(%rsp), %rdi
divsd 0x28(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rdi)
addq $0x48, %rdi
callq 0x277a0
movq 0x10(%rsp), %rax
divsd 0x28(%rsp), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x2c(%rax)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x277e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x25148
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x27980
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x25139
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
xorl %ecx, %ecx
callq 0xbbe00
jmp 0x2513b
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x250eb
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::Transform(gaps::R3Transformation const&)
void RGBDSurface::
Transform(const R3Transformation& transformation)
{
  // Update rectangle
  if (rectangle) rectangle->Transform(transformation);
  else if (mesh) mesh->Transform(transformation);

  // Invalidate the configuration's bounding box
  if (configuration) configuration->InvalidateWorldBBox();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x80(%rax)
je 0x2519c
movq (%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0xa0(%rax)
jmp 0x251c5
movq (%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x251c3
movq (%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x118(%rax)
jmp 0x251c5
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x251e1
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x128(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TransformTextureToSurface(gaps::R2Point const&, gaps::R2Point&) const
int RGBDSurface::
TransformTextureToSurface(const R2Point& texture_position, R2Point& surface_position) const
{
  // Transform from position in texture coordinates to surface coordinates
  if ((width == 0) || (height == 0)) return 0;
  RNScalar xlength = surface_bbox.XLength();
  RNScalar ylength = surface_bbox.YLength();
  surface_position[0] = surface_bbox[0][0] + xlength * texture_position[0] / width;
  surface_position[1] = surface_bbox[0][1] + ylength * texture_position[1] / height;
  return 1;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x28(%rax)
je 0x2521e
movq 0x30(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2522b
movl $0x0, 0x64(%rsp)
jmp 0x25354
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
callq 0x1a210
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
addq $0x48, %rdi
callq 0x277a0
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x38(%rsp)
addq $0x48, %rdi
xorl %esi, %esi
callq 0x279f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x1a280
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movsd (%rsp), %xmm1
movq 0x30(%rsp), %rax
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm1
cvtsi2sdl 0x28(%rax), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x27a30
movsd 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rdi
movsd %xmm0, (%rax)
addq $0x48, %rdi
xorl %esi, %esi
callq 0x279f0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1a280
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movsd 0x18(%rsp), %xmm1
movq 0x30(%rsp), %rax
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
mulsd %xmm2, %xmm1
cvtsi2sdl 0x2c(%rax), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x27a30
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TransformSurfaceToTexture(gaps::R2Point const&, gaps::R2Point&) const
int RGBDSurface::
TransformSurfaceToTexture(const R2Point& surface_position, R2Point& texture_position) const
{
  // Transform from position in surface coordinates to texture coordinates
  RNScalar xlength = surface_bbox.XLength();
  RNScalar ylength = surface_bbox.YLength();
  if ((xlength == 0) || (ylength == 0)) return 0;
  texture_position[0] = width  * (surface_position[0] - surface_bbox[0][0]) / xlength;
  texture_position[1] = height * (surface_position[1] - surface_bbox[0][1]) / ylength;
  return 1;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x48, %rdi
callq 0x1a210
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
addq $0x48, %rdi
callq 0x277a0
movsd %xmm0, 0x38(%rsp)
movsd 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x253b3
jp 0x253b3
jmp 0x253c4
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x253d1
jp 0x253d1
movl $0x0, 0x64(%rsp)
jmp 0x254cd
movq 0x30(%rsp), %rax
cvtsi2sdl 0x28(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movq 0x30(%rsp), %rdi
movsd %xmm0, (%rsp)
addq $0x48, %rdi
xorl %esi, %esi
callq 0x279f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x1a280
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x27a30
movsd 0x10(%rsp), %xmm0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movsd %xmm0, (%rcx)
cvtsi2sdl 0x2c(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
addq $0x48, %rdi
xorl %esi, %esi
callq 0x279f0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1a280
movsd 0x18(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
divsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x27a30
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TransformSurfaceToWorld(gaps::R2Point const&, gaps::R3Point&) const
int RGBDSurface::
TransformSurfaceToWorld(const R2Point& surface_position, R3Point& world_position) const
{
  // Transform from position in surface coordinates to world coordinates
  if (rectangle) {
    world_position = rectangle->Corner(0,0);
    world_position += surface_position[0] * rectangle->Axis(0);
    world_position += surface_position[1] * rectangle->Axis(1);
  }
  else if (mesh) {
    R2Point texture_position;
    double barycentrics[3];
    if (!TransformSurfaceToTexture(surface_position, texture_position)) return 0;
    R3MeshFace *face = SearchMeshFaceIndex(texture_position, barycentrics);
    if (face) world_position = mesh->FacePoint(face, barycentrics);
    else return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x255f7
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rsi
leaq 0xa0(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x27a50
movq 0xb8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x8b030
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movq 0x80(%rax), %rdi
xorl %esi, %esi
callq 0x22600
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x227f0
movq 0xb8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x8b0e0
movq 0xc0(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movq 0x18(%rsp), %rax
movsd %xmm0, 0x10(%rsp)
movq 0x80(%rax), %rdi
movl $0x1, %esi
callq 0x22600
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x227f0
movq 0xb8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x8b0e0
jmp 0x256a8
movq 0x18(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x256a6
leaq 0x60(%rsp), %rdi
callq 0xcfd70
movq 0x18(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq (%rdi), %rax
leaq 0x60(%rsp), %rdx
callq *0x40(%rax)
cmpl $0x0, %eax
jne 0x2563e
movl $0x0, 0xd4(%rsp)
jmp 0x256b3
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq (%rdi), %rax
leaq 0x60(%rsp), %rsi
callq *0xe8(%rax)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x25697
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rsi
movq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %rdi
callq 0x47e80
movq 0xb8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x8b030
jmp 0x256a4
movl $0x0, 0xd4(%rsp)
jmp 0x256b3
jmp 0x256a6
jmp 0x256a8
movl $0x1, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::TransformWorldToSurface(gaps::R3Point const&, gaps::R2Point&) const
int RGBDSurface::
TransformWorldToSurface(const R3Point& world_position, R2Point& surface_position) const
{
  // Transform from position in world coordinates to surface coordinates
  if (rectangle) {
    R3Point origin = rectangle->Corner(0,0);
    surface_position[0] = (world_position - origin).Dot(rectangle->Axis(0));;
    surface_position[1] = (world_position - origin).Dot(rectangle->Axis(1));;
  }
  else {
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x80(%rax)
je 0x257c0
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rsi
leaq 0x50(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x27a50
movq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x8ad00
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rdi
xorl %esi, %esi
callq 0x22600
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x8c110
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x27a30
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x70(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x8ad00
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rdi
movl $0x1, %esi
callq 0x22600
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x8c110
movsd %xmm0, 0x10(%rsp)
movq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x27a30
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x257cd
movl $0x0, 0x84(%rsp)
jmp 0x257d8
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::DrawEdges(int) const
void RGBDSurface::
DrawEdges(int color_scheme) const
{
  // Load color
  if (color_scheme == RGBD_NO_COLOR_SCHEME) LoadColor(color_scheme);
  else if (color_scheme == RGBD_HIGHLIGHT_COLOR_SCHEME) LoadColor(color_scheme);
  else LoadColor(RGBD_INDEX_COLOR_SCHEME);

  // Draw rectangle
  if (rectangle) rectangle->Outline();
  else if (mesh) mesh->DrawEdges();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x25b92
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0x25bc2
cmpl $0x4, 0x2c(%rsp)
jne 0x25bad
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0x25bc0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x80(%rax)
jmp 0x25bc2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x25c06
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1a6b0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0xb0(%rax)
jmp 0x25c48
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x25c46
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movl $0x772, %esi            # imm = 0x772
callq 0x1a6b0
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x130(%rax)
jmp 0x25c48
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::DrawVertices(int) const
void RGBDSurface::
DrawVertices(int color_scheme) const
{
  // Load color
  if (color_scheme == RGBD_NO_COLOR_SCHEME) LoadColor(color_scheme);
  else if (color_scheme == RGBD_HIGHLIGHT_COLOR_SCHEME) LoadColor(color_scheme);
  else LoadColor(RGBD_INDEX_COLOR_SCHEME);

  // Draw vertices
  if (rectangle) {
    RNGrfxBegin(RN_GRFX_POINTS);
    for (int i = 0; i < 4; i++) {
      R3Point position = rectangle->Corner(i);
      R3LoadPoint(position);
    }
    RNGrfxEnd();
  }
  else if (mesh) {
    RNGrfxBegin(RN_GRFX_POINTS);
    for (int i = 0; i < mesh->NVertices(); i++) {
      R3MeshVertex *vertex = mesh->Vertex(i);
      const R3Point& position = mesh->VertexPosition(vertex);
      R3LoadPoint(position);
    }
    RNGrfxEnd();
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x25c82
movq 0x10(%rsp), %rdi
movl 0x4c(%rsp), %esi
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0x25cb2
cmpl $0x4, 0x4c(%rsp)
jne 0x25c9d
movq 0x10(%rsp), %rdi
movl 0x4c(%rsp), %esi
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0x25cb0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x80(%rax)
jmp 0x25cb2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x80(%rax)
je 0x25d12
xorl %edi, %edi
callq 0x27c00
movl $0x0, 0x48(%rsp)
cmpl $0x4, 0x48(%rsp)
jge 0x25d08
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
movl 0x48(%rsp), %edx
leaq 0x30(%rsp), %rdi
callq 0x27ce0
leaq 0x30(%rsp), %rdi
callq 0x27c90
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x25cd0
callq 0x27cd0
jmp 0x25dad
movq 0x10(%rsp), %rax
cmpq $0x0, 0x88(%rax)
je 0x25dab
xorl %edi, %edi
callq 0x27c00
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movq 0x88(%rax), %rdi
callq 0x19f40
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x25da6
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
movl 0x2c(%rsp), %esi
callq 0x22b40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x88(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x22b70
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x27c90
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x25d34
callq 0x27cd0
jmp 0x25dad
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::LoadColor(int) const
void RGBDSurface::
LoadColor(int color_scheme) const
{
  // Check color scheme
  if (color_scheme == RGBD_INDEX_COLOR_SCHEME) {
    // Load color encoding index
    int k = 255.0 * (ConfigurationIndex()+1) / configuration->NSurfaces();
    unsigned char r = k;
    unsigned char g = 0;
    unsigned char b = 0;
    RNLoadRgb(r, g, b);
  }
  else if (color_scheme == RGBD_PHOTO_COLOR_SCHEME) {
    // Load white 
    RNLoadRgb(1.0, 1.0, 1.0);
  }
  else if (color_scheme == RGBD_RENDER_COLOR_SCHEME) {
    // Load white 
    RNLoadRgb(1.0, 1.0, 1.0);
  }
  else if (color_scheme == RGBD_HIGHLIGHT_COLOR_SCHEME) {
    // Load highlight color
    RNLoadRgb(1.0, 1.0, 0.0);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x3, 0x1c(%rsp)
jne 0x261e1
movq 0x8(%rsp), %rdi
callq 0x27ee0
movl %eax, %ecx
movq 0x8(%rsp), %rax
addl $0x1, %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x140cfa(%rip), %xmm0   # 0x166e88
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rax), %rdi
callq 0x19c60
movsd (%rsp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movb %al, 0x17(%rsp)
movb $0x0, 0x16(%rsp)
movb $0x0, 0x15(%rsp)
movb 0x17(%rsp), %cl
movb 0x16(%rsp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzbl 0x15(%rsp), %edx
callq 0x27ef0
jmp 0x26239
cmpl $0x1, 0x1c(%rsp)
jne 0x261fd
movsd 0x13fe40(%rip), %xmm2   # 0x166030
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x27f20
jmp 0x26237
cmpl $0x2, 0x1c(%rsp)
jne 0x26219
movsd 0x13fe24(%rip), %xmm2   # 0x166030
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x27f20
jmp 0x26235
cmpl $0x4, 0x1c(%rsp)
jne 0x26233
movsd 0x13fe08(%rip), %xmm1   # 0x166030
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq 0x27f20
jmp 0x26235
jmp 0x26237
jmp 0x26239
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::ReleaseColorChannels()
int RGBDSurface::
ReleaseColorChannels(void)
{
  // Check/update read count
  if (--color_resident_count > 0) return 1;

  // Write color channel before release???
  // WriteColorChannels();
  
  // Delete color channels
  for (int channel_index = RGBD_RED_CHANNEL; channel_index <= RGBD_BLUE_CHANNEL; channel_index++) {
    if (NChannels() <= channel_index) break;
    if (!channels[channel_index]) continue;
    delete channels[channel_index];
    channels[channel_index] = NULL;
  }

  // Return success;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x70(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x70(%rcx)
cmpl $0x0, %eax
jle 0x2679e
movl $0x1, 0x24(%rsp)
jmp 0x26844
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jg 0x2683c
movq 0x8(%rsp), %rdi
callq 0x277e0
cmpl 0x14(%rsp), %eax
jg 0x267c3
jmp 0x2683c
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x277c0
cmpq $0x0, (%rax)
jne 0x267dd
jmp 0x2682c
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x26813
movq (%rsp), %rdi
callq 0xb3390
movq (%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x277c0
movq $0x0, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x267a6
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::InvalidateOpenGL()
void RGBDSurface::
InvalidateOpenGL(void) 
{
  // Delete opengl texture
  if (opengl_texture_id > 0) {
    GLuint i = opengl_texture_id;
    glDeleteTextures(1, &i);
  }

  // Reset opengl identifier
  opengl_texture_id = -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x30(%rax)
jle 0x26b02
movq (%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x1, %edi
leaq 0xc(%rsp), %rsi
callq 0x12990
movq (%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::InvalidateMeshFaceIndex()
void RGBDSurface::
InvalidateMeshFaceIndex(void)
{
  // Delete mesh face index
  if (!mesh_face_index) return;
  delete mesh_face_index;
  mesh_face_index = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x90(%rax)
jne 0x2772f
jmp 0x2776c
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2775c
movq (%rsp), %rdi
callq 0xb3390
movq (%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
movq 0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::TexelChannelValue(int, int, int) const
inline RNScalar RGBDSurface::
TexelChannelValue(int ix, int iy, int channel_index) const
{
  // Check channel
  if (!channels[channel_index]) {
    RNFail("RGBD Channel is not resident in memory -- cannot get value\n");
    return R2_GRID_UNKNOWN_VALUE;
  }
  
  // Return value in channel at pixel position
  return channels[channel_index]->GridValue(ix, iy);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
cmpq $0x0, %rax
jne 0x2784f
leaq 0x13f681(%rip), %rdi    # 0x166eb9
movb $0x0, %al
callq 0xdf990
movsd 0x13e7d9(%rip), %xmm0   # 0x166020
movsd %xmm0, 0x20(%rsp)
jmp 0x27876
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
movq %rax, %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x1a060
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::TexelChannelValue(gaps::R2Point const&, int) const
inline RNScalar RGBDSurface::
TexelChannelValue(const R2Point& texture_position, int channel_index) const
{
  // Check channel
  if (!channels[channel_index]) {
    RNFail("RGBD Channel is not resident in memory -- cannot get value\n");
    return R2_GRID_UNKNOWN_VALUE;
  }
  
  // Return value in channel at pixel position
  return channels[channel_index]->GridValue(texture_position);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
cmpq $0x0, %rax
jne 0x278dc
leaq 0x13f5f4(%rip), %rdi    # 0x166eb9
movb $0x0, %al
callq 0xdf990
movsd 0x13e74c(%rip), %xmm0   # 0x166020
movsd %xmm0, 0x20(%rsp)
jmp 0x27900
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x1a2c0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDSurface.h
// Function: gaps::RGBDSurface::Channel(int) const
inline R2Grid *RGBDSurface::
Channel(int channel_index) const
{
  // Check channel
  if (!channels[channel_index]) {
    RNFail("RGBD Channel is not resident in memory -- cannot get it\n");
    return NULL;
  }
  
  // Return channel
  return channels[channel_index];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x1a2a0
cmpq $0x0, %rax
jne 0x279c3
leaq 0x13f5f9(%rip), %rdi    # 0x166faa
movb $0x0, %al
callq 0xdf990
movq $0x0, 0x20(%rsp)
jmp 0x279da
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x1a2a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/../../pkgs/R3Shapes/R3Rectangle.h
// Function: gaps::R3Rectangle::Corner(int, int) const
inline const R3Point R3Rectangle::
Corner(RNDirection dir0, RNDirection dir1) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3zero_point;

    // Return corner position
    R3Point corner = Center();
    corner += (dir0 == RN_HI) ? Radius(0)*Axis(0) : -Radius(0)*Axis(0);
    corner += (dir1 == RN_HI) ? Radius(1)*Axis(1) : -Radius(1)*Axis(1);
    return corner;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movl %ecx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x28190
cmpl $0x0, %eax
je 0x27aa3
movq 0x28(%rsp), %rdi
leaq 0x18b407(%rip), %rsi    # 0x1b2ea0
callq 0x8a9e0
jmp 0x27be8
movq 0x38(%rsp), %rdi
callq 0x281c0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x8a9e0
cmpl $0x1, 0x74(%rsp)
jne 0x27af4
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x22630
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x22600
movsd 0x20(%rsp), %xmm0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x227f0
jmp 0x27b3c
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x22630
movq 0x38(%rsp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %esi, %esi
callq 0x22600
movsd 0x18(%rsp), %xmm0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x227f0
movq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8b0e0
cmpl $0x1, 0x70(%rsp)
jne 0x27b8b
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x22630
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl $0x1, %esi
callq 0x22600
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x227f0
jmp 0x27bd9
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x22630
movq 0x38(%rsp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x1, %esi
callq 0x22600
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x227f0
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x8b0e0
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/../../pkgs/R2Shapes/R2Grid.h
// Function: gaps::R2Grid::RasterizeGridTriangle(gaps::R2Point const&, gaps::R2Point const&, gaps::R2Point const&, double, double, double, int)
inline void R2Grid::
RasterizeGridTriangle(const R2Point& p1, const R2Point& p2, const R2Point& p3, RNScalar value1, RNScalar value2, RNScalar value3, int operation)
{
  // Splat value everywhere inside grid triangle
  int i1[2] = { (int) (p1[0] + 0.5), (int) (p1[1] + 0.5) };
  int i2[2] = { (int) (p2[0] + 0.5), (int) (p2[1] + 0.5) };
  int i3[2] = { (int) (p3[0] + 0.5), (int) (p3[1] + 0.5) };
  RasterizeGridTriangle(i1, i2, i3, value1, value2, value3, operation);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm2, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movsd 0x13dd0b(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movsd 0x13dce8(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movsd 0x13dcc8(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movsd 0x13dca5(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x1a280
movsd 0x13dc85(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x1a280
movq 0x8(%rsp), %rdi
movsd 0x13dc5d(%rip), %xmm1   # 0x166028
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x18(%rsp)
leaq 0x24(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x14(%rsp), %rcx
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movl 0x2c(%rsp), %r8d
callq 0xbcb10
addq $0x68, %rsp
retq
nopw (%rax,%rax)