LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::RGBDSurface(char const*, gaps::R3Rectangle*, double)
RGBDSurface::
RGBDSurface(const char *texture_filename, R3Rectangle *rectangle, RNLength texel_spacing)
  : configuration(NULL),
    configuration_index(-1),
    channels(),
    width(0), height(0),
    opengl_texture_id(-1),
    texture_filename(NULL),
    mesh_filename(NULL),
    surface_bbox(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX),
    color_resident_count(0),
    data(NULL),
    rectangle(rectangle),
    mesh(NULL),
    mesh_face_index(NULL),
    thickness(0)
{
  // Check rectangle
  if (!rectangle) return;
  
  // Set texture filename
  SetTextureFilename(texture_filename);

  // Compute coordinate stuff
  RNLength xlength = 2*rectangle->Radius(0);
  RNLength ylength = 2*rectangle->Radius(1);
  if (texel_spacing <= 0) texel_spacing = 0.01;
  width = (int) (xlength / texel_spacing + 0.5);
  height = (int) (ylength / texel_spacing + 0.5);
  if (width <= 0) width = 1;
  if (height <= 0) height = 1;

  // Compute bounding box of surface coordinates
  surface_bbox.Reset(R2zero_point, R2Point(xlength, ylength));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movaps %xmm0, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0xe53d8(%rip), %rax     # 0xffdb8
movq %rax, (%rdi)
xorl %r14d, %r14d
movq %r14, 0x8(%rdi)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x753d0
movq %r14, 0x28(%r15)
movl %ebp, 0x30(%r15)
leaq 0x48(%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r15)
movsd 0xa0616(%rip), %xmm0    # 0xbb030
movsd 0xa061e(%rip), %xmm2    # 0xbb040
movq %r14, %rdi
movapd %xmm0, %xmm1
movapd %xmm2, %xmm3
callq 0x6c3cc
movl $0x0, 0x70(%r15)
xorl %eax, %eax
movq %rax, 0x78(%r15)
movq %r12, 0x80(%r15)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x88(%r15)
movq %rax, 0x98(%r15)
testq %r12, %r12
je 0x1ab0d
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0xc0(%rax)
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm2
movapd %xmm2, %xmm1
cmpnlesd %xmm0, %xmm1
andpd %xmm1, %xmm2
movsd 0xa0a1f(%rip), %xmm0    # 0xbb4b0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movupd 0x68(%r12), %xmm0
addpd %xmm0, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm0, %xmm2
divpd %xmm1, %xmm2
addpd 0xa13e8(%rip), %xmm2    # 0xbbea0
cvttpd2dq %xmm2, %xmm1
movd %xmm1, %eax
movq %xmm1, 0x28(%r15)
testl %eax, %eax
jg 0x1aad2
movl $0x1, 0x28(%r15)
pshufd $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movd %xmm1, %eax
testl %eax, %eax
jg 0x1aae7
movl $0x1, 0x2c(%r15)
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
leaq 0x18(%rsp), %rdi
callq 0x6f0d6
leaq 0xec940(%rip), %rsi     # 0x107440
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x6cbec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ab23
movq %rax, %r15
jmp 0x1ab2e
movq %rax, %r15
movq %r14, %rdi
callq 0x6cc44
movq %rbx, %rdi
callq 0x7543a
movq %r15, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe505a(%rip), %rax     # 0xffdb8
movq %rax, (%rdi)
movl 0x30(%rdi), %eax
testl %eax, %eax
jle 0x1ad79
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, %edi
callq 0x11800
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad92
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
leaq 0x18(%rbx), %r14
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x1adcf
xorl %r12d, %r12d
movq (%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0x1adc4
movq %r15, %rdi
callq 0x60264
movl $0xd0, %esi
movq %r15, %rdi
callq 0x115c0
movl 0x24(%rbx), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x1ada0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1addd
callq 0x11710
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1adeb
callq 0x11710
movq 0x90(%rbx), %r15
testq %r15, %r15
je 0x1ae0c
movq %r15, %rdi
callq 0x60264
movl $0xd0, %esi
movq %r15, %rdi
callq 0x115c0
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x1ae1e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1ae30
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x6cc44
movq %r14, %rdi
callq 0x7543a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1a62b
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x24(%rsi)
jg 0x1ae97
leaq 0xec666(%rip), %rsi     # 0x1074f0
movq %rbx, %rdi
callq 0x75226
jmp 0x1af88
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq 0x18(%rsi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1aec8
movq 0xb8(%rcx), %rdx
movl 0xc8(%rcx), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
movsd (%rdx,%rcx,8), %xmm0
jmp 0x1aee2
leaq 0xa103f(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movq 0x18(%r15), %rax
movsd 0xa0136(%rip), %xmm0    # 0xbb018
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x1af08
movq 0xb8(%rcx), %rdx
movl 0xc8(%rcx), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
movsd (%rdx,%rcx,8), %xmm1
jmp 0x1af2e
leaq 0xa0fff(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x77f42
movsd 0x8(%rsp), %xmm0
movq 0x18(%r15), %rax
movsd 0xa00ea(%rip), %xmm1    # 0xbb018
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1af52
imull 0xc8(%rax), %ebp
movq 0xb8(%rax), %rax
addl %r14d, %ebp
movslq %ebp, %rcx
movsd (%rax,%rcx,8), %xmm2
jmp 0x1af80
leaq 0xa0fb5(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x77f42
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0xa0098(%rip), %xmm2    # 0xbb018
movq %rbx, %rdi
callq 0x75244
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rsi
testq %rsi, %rsi
je 0x1b09e
addq $0x50, %rsi
movq %rbx, %rdi
jmp 0x1b0fd
cmpq $0x0, 0x88(%r14)
je 0x1b0e7
movq (%r14), %rcx
movq %rsp, %rax
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq *0xe8(%rcx)
testq %rax, %rax
je 0x1b0f0
movq %rax, %r15
testb $0x4, 0xa8(%rax)
jne 0x1b0e1
movq 0x88(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x2c8(%rax)
addq $0x38, %r15
jmp 0x1b0f7
leaq 0xa1e52(%rip), %rsi     # 0xbcf40
jmp 0x1b099
leaq 0xa1e49(%rip), %r15     # 0xbcf40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c0a6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x24(%rsi)
jg 0x1b136
leaq 0xec3c7(%rip), %rsi     # 0x1074f0
movq %rbx, %rdi
callq 0x75226
jmp 0x1b1fb
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%rsi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1b15a
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
callq 0x609d4
jmp 0x1b170
leaq 0xa0dad(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movsd 0x9fea8(%rip), %xmm0    # 0xbb018
movsd %xmm0, 0x8(%rsp)
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x1b195
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
callq 0x609d4
jmp 0x1b1ab
leaq 0xa0d72(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movsd 0x9fe6d(%rip), %xmm0    # 0xbb018
movsd %xmm0, (%rsp)
movq 0x18(%r15), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1b1d2
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
callq 0x609d4
movaps %xmm0, %xmm2
jmp 0x1b1e8
leaq 0xa0d35(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movsd 0x9fe30(%rip), %xmm2    # 0xbb018
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x75244
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x6f0d4
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x1b24e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b110
jmp 0x1b25d
leaq 0xec29b(%rip), %rsi     # 0x1074f0
movq %rbx, %rdi
callq 0x75226
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::SurfelChannelValue(gaps::R2Point const&, int) const
RNScalar RGBDSurface::
SurfelChannelValue(const R2Point& surface_position, int channel_index) const
{
  // Return
  R2Point texture_position;
  if (!TransformSurfaceToTexture(surface_position, texture_position)) return 0;
  return TexelChannelValue(texture_position, channel_index);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x6f0d4
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x1b356
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x1b35b
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x609d4
jmp 0x1b371
xorps %xmm0, %xmm0
jmp 0x1b371
leaq 0xa0bac(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movsd 0x9fca7(%rip), %xmm0    # 0xbb018
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/../../pkgs/RNBasics/RNArray.hh
// Function: gaps::RGBDSurface::SetTexelChannelValue(int, int, int, double)
inline void *&RNVArray::
operator[](int k)
{
    // Return reference to kth data element
    assert(entries);
    assert(nentries >= 0);
    assert((k >= 0) && (k < nentries));
    return entries[k];
}

// Assembly:
movq 0x18(%rdi), %rax
movslq %ecx, %r8
movq (%rax,%r8,8), %rax
testq %rax, %rax
je 0x1b43d
testl %ecx, %ecx
js 0x1b43c
testl %esi, %esi
js 0x1b43c
cmpl %ecx, 0x24(%rdi)
jle 0x1b43c
testl %edx, %edx
js 0x1b43c
cmpl %esi, 0xc0(%rax)
jle 0x1b43c
cmpl %esi, 0xc4(%rax)
jle 0x1b43c
movq 0xb8(%rax), %r8
imull 0xc8(%rax), %edx
addl %esi, %edx
movslq %edx, %rax
movsd %xmm0, (%r8,%rax,8)
cmpl $0x2, %ecx
ja 0x1b43c
movq (%rdi), %rax
jmpq *0xd8(%rax)
retq
leaq 0xa0aca(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
jmp 0x77f42
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2, %esi
ja 0x1b475
cmpl $0x0, 0x70(%rbx)
jne 0x1b475
leaq 0xa0ae0(%rip), %rdi     # 0xbbf4a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x77f42
movq 0x18(%rbx), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x5ffa2
movl 0xc0(%r14), %eax
movl %eax, 0x28(%rbx)
movl 0xc4(%r14), %eax
movl %eax, 0x2c(%rbx)
cmpl $0x2, %ebp
ja 0x1b4b1
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0xd8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x70(%rdi)
je 0x1b5b1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
testl %ecx, %ecx
jle 0x1b590
xorl %ebp, %ebp
movq %rsp, %r15
testl %eax, %eax
jle 0x1b586
movslq %ebp, %r12
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x6fef2
movq 0x18(%rbx), %rax
movq (%rax), %rcx
movsd (%rsp), %xmm0
movq 0xb8(%rcx), %rdx
movslq 0xc8(%rcx), %rcx
imulq %r12, %rcx
addq %r13, %rcx
movsd %xmm0, (%rdx,%rcx,8)
movq 0x8(%rax), %rcx
movsd 0x8(%rsp), %xmm0
movq 0xb8(%rcx), %rdx
movslq 0xc8(%rcx), %rcx
imulq %r12, %rcx
addq %r13, %rcx
movsd %xmm0, (%rdx,%rcx,8)
movq 0x10(%rax), %rax
movsd 0x10(%rsp), %xmm0
movq 0xb8(%rax), %rcx
movslq 0xc8(%rax), %rax
imulq %r12, %rax
addq %r13, %rax
movsd %xmm0, (%rcx,%rax,8)
movl (%r14), %eax
incq %r13
cmpl %eax, %r13d
jl 0x1b4f4
movl 0x4(%r14), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x1b4e6
movl %eax, 0x28(%rbx)
movl %ecx, 0x2c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa09c4(%rip), %rdi     # 0xbbf7c
xorl %eax, %eax
jmp 0x77f42
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1b675
movupd 0x50(%rbx), %xmm1
movupd 0x60(%rbx), %xmm2
subpd %xmm1, %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm0
movlpd %xmm0, 0x28(%rbx)
cmpl $0x0, 0x24(%rbx)
jle 0x1b6b7
leaq 0xa097d(%rip), %r14     # 0xbbfff
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x1b6a1
movl 0x28(%rbx), %esi
movl 0x2c(%rbx), %edx
xorl %ecx, %ecx
callq 0x64f00
jmp 0x1b6ab
movq %r14, %rdi
xorl %eax, %eax
callq 0x77f42
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x1b685
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0xf0(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x28(%rdi), %r8d
xorl %eax, %eax
testl %r8d, %r8d
je 0x1b76c
movl 0x2c(%rdi), %ecx
testl %ecx, %ecx
je 0x1b76c
movsd 0x50(%rdi), %xmm0
movsd 0x60(%rdi), %xmm1
subsd %xmm0, %xmm1
movsd 0x68(%rdi), %xmm2
subsd 0x58(%rdi), %xmm2
mulsd (%rsi), %xmm1
cvtsi2sd %r8d, %xmm3
divsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
mulsd 0x8(%rsi), %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm2
addsd 0x58(%rdi), %xmm2
movsd %xmm2, 0x8(%rdx)
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x80(%rdi), %r12
testq %r12, %r12
je 0x1b883
movsd 0x68(%r12), %xmm0
minsd 0x70(%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x1b8fe
leaq 0x8(%r12), %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x4b612
movsd 0x68(%r12), %xmm0
xorps 0x9f819(%rip), %xmm0    # 0xbb050
leaq 0x20(%r12), %rsi
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x4ca32
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4b9e4
movsd 0x70(%r12), %xmm0
xorpd 0x9f7ef(%rip), %xmm0    # 0xbb050
addq $0x38, %r12
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4ca32
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4b9e4
jmp 0x1b90f
movl $0x1, %ebp
cmpq $0x0, 0x88(%r14)
je 0x1b96e
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x6f0d4
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x1b97f
movq (%r14), %rax
leaq 0x38(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq *0xe8(%rax)
testq %rax, %rax
je 0x1b97f
movq 0x88(%r14), %rsi
leaq 0x20(%rsp), %r14
movq %rsp, %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0x2d3ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b96a
jmp 0x1b96e
leaq 0xea29b(%rip), %rsi     # 0x105ba0
leaq 0x20(%rsp), %rdi
callq 0x4b612
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b96a
movsd (%r15), %xmm0
movq 0x80(%r14), %rsi
addq $0x20, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x4ca32
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b9e4
movsd 0x8(%r15), %xmm0
movq 0x80(%r14), %rsi
addq $0x38, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x4ca32
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b9e4
movl $0x1, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x1b96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x80(%rdi), %r12
testq %r12, %r12
je 0x1ba30
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0x68(%r12), %xmm0
minsd 0x70(%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x1ba34
leaq 0x8(%r12), %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x4b612
movsd 0x68(%r12), %xmm0
xorps 0x9f66d(%rip), %xmm0    # 0xbb050
leaq 0x20(%r12), %rsi
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x4ca32
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4b9e4
movsd 0x70(%r12), %xmm0
xorpd 0x9f641(%rip), %xmm0    # 0xbb050
addq $0x38, %r12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4ca32
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4b9e4
jmp 0x1ba45
xorl %eax, %eax
jmp 0x1baa4
leaq 0xea165(%rip), %rsi     # 0x105ba0
leaq 0x20(%rsp), %rdi
callq 0x4b612
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4b85e
movq 0x80(%r14), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0x4c322
movsd %xmm0, (%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4b85e
movq 0x80(%r14), %rsi
addq $0x38, %rsi
movq %r12, %rdi
callq 0x4c322
movsd %xmm0, 0x8(%rbx)
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
xorl %ecx, %ecx
cmpl $0x4, %esi
sete %cl
addl $0x3, %ecx
testl %esi, %esi
cmovnel %ecx, %esi
callq *0x80(%rax)
cmpq $0x0, 0x80(%rbx)
je 0x1bdd0
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x11150
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0xe9e84(%rip), %r12     # 0x105ba0
movq 0x80(%rbx), %r13
movsd 0x68(%r13), %xmm0
minsd 0x70(%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x1bd9e
leaq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x4b612
movsd 0x68(%r13), %xmm0
cmpl $0x2, %ebp
jae 0x1bd57
xorps 0x9f2f9(%rip), %xmm0    # 0xbb050
leaq 0x20(%r13), %rsi
movq %r15, %rdi
callq 0x4ca32
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b9e4
movsd 0x70(%r13), %xmm0
testb $0x1, %bpl
jne 0x1bd82
xorpd 0x9f2ce(%rip), %xmm0    # 0xbb050
addq $0x38, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4ca32
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b9e4
jmp 0x1bda9
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b612
movq %r14, %rdi
callq 0x11170
incl %ebp
cmpl $0x4, %ebp
jne 0x1bd1c
callq 0x117c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x88(%rbx)
je 0x1bdc1
xorl %edi, %edi
callq 0x11150
movq 0x88(%rbx), %rax
cmpl $0x0, 0x14(%rax)
jle 0x1be15
xorl %r14d, %r14d
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
addq $0x18, %rdi
callq 0x11170
incq %r14
movq 0x88(%rbx), %rax
movslq 0x14(%rax), %rcx
cmpq %rcx, %r14
jl 0x1bdf1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x117c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
decl %esi
cmpl $0x3, %esi
ja 0x1c2e7
leaq 0x9fc36(%rip), %rax     # 0xbbec0
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movsd 0x9ed8d(%rip), %xmm0    # 0xbb028
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
jmp 0x118f0
movl 0x10(%rdi), %eax
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x9fbe1(%rip), %xmm0    # 0xbbe98
movq 0x8(%rdi), %rax
cvtsi2sdl 0x24(%rax), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movzbl %al, %edi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x11580
movsd 0x9ed4c(%rip), %xmm0    # 0xbb028
xorps %xmm2, %xmm2
movaps %xmm0, %xmm1
jmp 0x118f0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::ReadColorChannels()
int RGBDSurface::
ReadColorChannels(void)
{
  // Initialize image
  R2Image rgb_image(width, height);

  // Check filename
  if (texture_filename) {
    // Get full filename
    char full_filename[4096];
    const char *dirname = (configuration) ? configuration->TextureDirectory() : NULL;
    if (dirname) sprintf(full_filename, "%s/%s", dirname, texture_filename);
    else sprintf(full_filename, "%s", texture_filename);
    if (!RNFileExists(full_filename)) return 0;
  
    // Read color image
    if (!rgb_image.Read(full_filename)) return 0;

    // Check image dimensions
    if ((rgb_image.Width() != width) || (rgb_image.Height() != height)) {
      RNFail("Mismatching image dimensions (%d,%d) vs (%d,%d) in %s\n",
        rgb_image.Width(), rgb_image.Height(), width, height, texture_filename);
      // return 0;
    }
  }

  // Create color channels
  return CreateColorChannels(rgb_image);
}

// Assembly:
pushq %rbx
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, %rbx
movl 0x28(%rdi), %esi
movl 0x2c(%rdi), %edx
leaq 0x8(%rsp), %rdi
movl $0x3, %ecx
callq 0x6fc8a
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0x1c3ae
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c352
movq 0x50(%rax), %rdx
testq %rdx, %rdx
je 0x1c352
leaq 0x9fc74(%rip), %rsi     # 0xbbfb8
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x11110
jmp 0x1c35f
leaq 0x20(%rsp), %rdi
movq %rcx, %rsi
callq 0x11530
leaq 0x20(%rsp), %rdi
callq 0x77314
testl %eax, %eax
je 0x1c3c3
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6f98c
testl %eax, %eax
je 0x1c3c3
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x28(%rbx), %ecx
movl 0x2c(%rbx), %r8d
movl %esi, %eax
xorl %ecx, %eax
movl %edx, %edi
xorl %r8d, %edi
orl %eax, %edi
je 0x1c3ae
movq 0x38(%rbx), %r9
leaq 0x9fc17(%rip), %rdi     # 0xbbfbe
xorl %eax, %eax
callq 0x77f42
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0xb8(%rax)
movl %eax, %ebx
jmp 0x1c3c5
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x6fee4
movl %ebx, %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbx
retq
jmp 0x1c3dc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6fee4
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::WriteColorChannels()
int RGBDSurface::
WriteColorChannels(void)
{
  // Check filename
  if (NChannels() <= RGBD_BLUE_CHANNEL) return 0;

  // Create texture filename, if there is none
  if (!texture_filename) {
    char buffer[4096];
    sprintf(buffer, "t%06d.jpg", ConfigurationIndex());
    SetTextureFilename(buffer);
  }

  // Get full filename
  char full_filename[4096];
  const char *dirname = (configuration) ? configuration->TextureDirectory() : NULL;
  if (dirname) sprintf(full_filename, "%s/%s", dirname, texture_filename);
  else sprintf(full_filename, "%s", texture_filename);

  // Compute color image
  R2Image rgb_image(width, height, 3);
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      RNRgb rgb = TexelColor(ix, iy);
      rgb_image.SetPixelRGB(ix, iy, rgb);
    }
  }

  // Write color image
  if (!rgb_image.Write(full_filename)) return 0;

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1030, %rsp           # imm = 0x1030
xorl %ebp, %ebp
cmpl $0x3, 0x24(%rdi)
jl 0x1c510
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x1c455
movl 0x10(%rbx), %edx
leaq 0x9fbbe(%rip), %rsi     # 0xbbff5
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x11110
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0xc0(%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c480
movq 0x50(%rax), %rdx
movq 0x38(%rbx), %rcx
testq %rdx, %rdx
je 0x1c484
leaq 0x9fb46(%rip), %rsi     # 0xbbfb8
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
callq 0x11110
jmp 0x1c491
movq 0x38(%rbx), %rcx
leaq 0x30(%rsp), %rdi
movq %rcx, %rsi
callq 0x11530
movl 0x28(%rbx), %esi
movl 0x2c(%rbx), %edx
movq %rsp, %rdi
movl $0x3, %ecx
callq 0x6fc8a
movl 0x2c(%rbx), %ecx
testl %ecx, %ecx
jle 0x1c4f3
movl 0x28(%rbx), %eax
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
movq %rsp, %r15
testl %eax, %eax
jle 0x1c4ed
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x1ae70
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %r14, %rcx
callq 0x7003a
incl %r12d
movl 0x28(%rbx), %eax
cmpl %eax, %r12d
jl 0x1c4bf
movl 0x2c(%rbx), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x1c4b8
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x71b08
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rsp, %rdi
callq 0x6fee4
movl %ebp, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c524
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6fee4
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x70(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
cmpl $0x1, %eax
jg 0x1c5b5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x1c5b0
xorl %r15d, %r15d
movq 0x18(%rbx), %rcx
movq (%rcx,%r15,8), %r14
testq %r14, %r14
je 0x1c59f
movq %r14, %rdi
callq 0x60264
movl $0xd0, %esi
movq %r14, %rdi
callq 0x115c0
movq 0x18(%rbx), %rax
movq $0x0, (%rax,%r15,8)
movl 0x24(%rbx), %eax
cmpq $0x1, %r15
ja 0x1c5b0
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x1c56e
popq %rbx
popq %r14
popq %r15
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDSurface.cpp
// Function: gaps::RGBDSurface::CreateColorChannels(gaps::R2Image const&)
int RGBDSurface::
CreateColorChannels(const R2Image& image)
{
  // Check/update read count
  if (color_resident_count++ > 0) return 1;

  // Create color channels
  while (channels.NEntries() <= RGBD_BLUE_CHANNEL) channels.Insert(NULL);
  if (!channels[RGBD_RED_CHANNEL]) channels[RGBD_RED_CHANNEL] = new R2Grid(image.Width(), image.Height());
  if (!channels[RGBD_GREEN_CHANNEL]) channels[RGBD_GREEN_CHANNEL] = new R2Grid(image.Width(), image.Height());
  if (!channels[RGBD_BLUE_CHANNEL]) channels[RGBD_BLUE_CHANNEL] = new R2Grid(image.Width(), image.Height());

  // Initialize color channels
  SetColorChannels(image);

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

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x70(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
testl %eax, %eax
jg 0x1c691
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movl 0x24(%rdi), %edx
cmpl $0x2, %edx
jg 0x1c5f9
movq %r15, %rdi
xorl %esi, %esi
callq 0x75466
movl 0x24(%rbx), %edx
cmpl $0x3, %edx
jl 0x1c5e7
movq (%r15), %rax
cmpq $0x0, (%rax)
jne 0x1c627
movl $0xd0, %edi
callq 0x115b0
movq %rax, %r12
movl (%r14), %esi
movl 0x4(%r14), %edx
movq %rax, %rdi
callq 0x5f630
movq (%r15), %rax
movq %r12, (%rax)
movq (%r15), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1c654
movl $0xd0, %edi
callq 0x115b0
movq %rax, %r12
movl (%r14), %esi
movl 0x4(%r14), %edx
movq %rax, %rdi
callq 0x5f630
movq (%r15), %rax
movq %r12, 0x8(%rax)
movq (%r15), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1c67e
movl $0xd0, %edi
callq 0x115b0
movq %rax, %r12
movl (%r14), %esi
movl 0x4(%r14), %edx
movq %rax, %rdi
callq 0x5f630
movq (%r15), %rax
movq %r12, 0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq (%r14), %rax
movq %rax, 0x28(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c6a6
jmp 0x1c6a6
movq %rax, %rbx
movl $0xd0, %esi
movq %r12, %rdi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %eax
testl %eax, %eax
jle 0x1c6de
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, %edi
callq 0x11800
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::~RGBDImage()
RGBDImage::
~RGBDImage(void)
{
  // Delete opengl texture
  if (opengl_texture_id >= 0) {
    GLuint i = opengl_texture_id;
    glDeleteTextures(1, &i);
  }
  
  // Remove from configuration
  if (configuration) {
    configuration->RemoveImage(this);
  }

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

  // Delete filenames
  if (name) free(name);
  if (color_filename) free(color_filename);
  if (depth_filename) free(depth_filename);
  if (category_filename) free(category_filename);
  if (instance_filename) free(instance_filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe2e8a(%rip), %rax     # 0xffed8
movq %rax, (%rdi)
movl 0x1c8(%rdi), %eax
testl %eax, %eax
js 0x1d06c
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, %edi
callq 0x11800
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d07e
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x18(%rbx), %r14
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x1d0bb
xorl %r12d, %r12d
movq (%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0x1d0b0
movq %r15, %rdi
callq 0x60264
movl $0xd0, %esi
movq %r15, %rdi
callq 0x115c0
movl 0x24(%rbx), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x1d08c
movq 0x1d0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d0cc
callq 0x11710
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d0dd
callq 0x11710
movq 0x1e0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d0ee
callq 0x11710
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d0ff
callq 0x11710
movq 0x1f0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d110
callq 0x11710
leaq 0x188(%rbx), %rdi
callq 0x43d34
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x45c68
movq %r14, %rdi
callq 0x7543a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1a62b
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::ProjectionMatrix(double, double) const
R4Matrix RGBDImage::
ProjectionMatrix(RNScalar neardist, RNScalar fardist) const
{
  // Return projection transformation from camera coordinates to normalized image coordinates
  RNScalar fx = Intrinsics()[0][0];
  RNScalar fy = Intrinsics()[1][1];
  RNScalar cx = Intrinsics()[0][2];
  RNScalar cy = Intrinsics()[1][2];
  RNScalar W = NPixels(RN_X);
  RNScalar H = NPixels(RN_Y);
  return R4Matrix(
    2*fx/W, 0, -2*(cx/W)+1, 0,
    0, 2*fy/H, -2*(cy/H)+1, 0,
    0, 0, -(fardist + neardist) / (fardist - neardist),  -2.0 * neardist * fardist / (fardist - neardist),
    0, 0, -1, 0 );
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movapd %xmm0, %xmm3
movq %rdi, %rbx
movsd 0x160(%rsi), %xmm5
movsd 0x140(%rsi), %xmm0
movsd 0x150(%rsi), %xmm4
cvtsi2sdl 0x28(%rsi), %xmm2
cvtsi2sdl 0x2c(%rsi), %xmm7
movsd 0x168(%rsi), %xmm8
addsd %xmm0, %xmm0
divsd %xmm2, %xmm0
divsd %xmm2, %xmm4
addsd %xmm4, %xmm4
movsd 0x9de6b(%rip), %xmm6    # 0xbb028
movapd %xmm6, %xmm2
subsd %xmm4, %xmm2
addsd %xmm5, %xmm5
divsd %xmm7, %xmm5
divsd %xmm7, %xmm8
addsd %xmm8, %xmm8
movapd %xmm3, %xmm4
addsd %xmm1, %xmm4
xorpd 0x9de69(%rip), %xmm4    # 0xbb050
subsd %xmm8, %xmm6
movapd %xmm1, %xmm7
subsd %xmm3, %xmm7
divsd %xmm7, %xmm4
mulsd 0x9ee38(%rip), %xmm3    # 0xbc038
mulsd %xmm1, %xmm3
divsd %xmm7, %xmm3
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x30(%rsp)
xorpd %xmm1, %xmm1
movupd %xmm1, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movupd %xmm1, (%rsp)
movsd %xmm4, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
xorpd %xmm1, %xmm1
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
xorpd %xmm7, %xmm7
callq 0x47f9e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::PixelColor(int, int) const
RNRgb RGBDImage::
PixelColor(int ix, int iy) const
{
  // Return color of pixel
  if (NChannels() < 3) return RNblack_rgb;
  RNScalar r = PixelChannelValue(ix, iy, RGBD_RED_CHANNEL);
  RNScalar g = PixelChannelValue(ix, iy, RGBD_GREEN_CHANNEL);
  RNScalar b = PixelChannelValue(ix, iy, RGBD_BLUE_CHANNEL);
  return RNRgb(r, g, b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x24(%rsi)
jg 0x1d755
leaq 0xe9da8(%rip), %rsi     # 0x1074f0
movq %rbx, %rdi
callq 0x75226
jmp 0x1d846
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq 0x18(%rsi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1d786
movq 0xb8(%rcx), %rdx
movl 0xc8(%rcx), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
movsd (%rdx,%rcx,8), %xmm0
jmp 0x1d7a0
leaq 0x9e781(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
callq 0x77f42
movq 0x18(%r15), %rax
movsd 0x9d878(%rip), %xmm0    # 0xbb018
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x1d7c6
movq 0xb8(%rcx), %rdx
movl 0xc8(%rcx), %ecx
imull %ebp, %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
movsd (%rdx,%rcx,8), %xmm1
jmp 0x1d7ec
leaq 0x9e741(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x77f42
movsd 0x8(%rsp), %xmm0
movq 0x18(%r15), %rax
movsd 0x9d82c(%rip), %xmm1    # 0xbb018
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1d810
imull 0xc8(%rax), %ebp
movq 0xb8(%rax), %rax
addl %r14d, %ebp
movslq %ebp, %rcx
movsd (%rax,%rcx,8), %xmm2
jmp 0x1d83e
leaq 0x9e6f7(%rip), %rdi     # 0xbbf0e
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x77f42
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x9d7da(%rip), %xmm2    # 0xbb018
movq %rbx, %rdi
callq 0x75244
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::PixelColor(gaps::R2Point const&) const
RNRgb RGBDImage::
PixelColor(const R2Point& image_position) const
{
  // Return color of pixel
  if (NChannels() < 3) return RNblack_rgb;
  RNScalar r = PixelChannelValue(image_position, RGBD_RED_CHANNEL);
  RNScalar g = PixelChannelValue(image_position, RGBD_GREEN_CHANNEL);
  RNScalar b = PixelChannelValue(image_position, RGBD_BLUE_CHANNEL);
  return RNRgb(r, g, b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x24(%rsi)
jg 0x1da57
leaq 0xe9aa3(%rip), %rsi     # 0x1074f0
movq %rbx, %rdi
callq 0x75226
jmp 0x1dac3
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%rsi), %rax
movq (%rax), %rdi
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
callq 0x609d4
movsd %xmm0, 0x8(%rsp)
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
callq 0x609d4
movsd %xmm0, (%rsp)
movq 0x18(%r15), %rax
movq 0x10(%rax), %rdi
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
callq 0x609d4
movaps %xmm0, %xmm2
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x75244
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::PixelWorldRay(gaps::R2Point const&) const
R3Ray RGBDImage::
PixelWorldRay(const R2Point& image_position) const
{
  // Get/check intrinsics matrix
  const R3Matrix& intrinsics_matrix = Intrinsics();
  if (RNIsZero(intrinsics_matrix[0][0])) return R3null_ray;
  if (RNIsZero(intrinsics_matrix[1][1])) return R3null_ray;

  // Get point at depth 1.0 along ray in camera coordinates
  R3Point camera_position;
  camera_position[0] = (image_position[0] - intrinsics_matrix[0][2]) / intrinsics_matrix[0][0];
  camera_position[1] = (image_position[1] - intrinsics_matrix[1][2]) / intrinsics_matrix[1][1];
  camera_position[2] = -1.0;

  // Create ray and transform into world coordinates
  R3Ray ray(R3zero_point, camera_position);
  ray.Transform(camera_to_world);

  // Return ray through pixel in world coordinates
  return ray;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x140(%rsi), %xmm2
leaq 0xe71b1(%rip), %rax     # 0x104cd8
movsd (%rax), %xmm0
movapd 0x9d51d(%rip), %xmm1    # 0xbb050
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x1db43
ucomisd %xmm2, %xmm0
jae 0x1db58
movsd 0x160(%r14), %xmm2
ucomisd %xmm1, %xmm2
jb 0x1db69
ucomisd %xmm2, %xmm0
jb 0x1db69
leaq 0xe7da1(%rip), %rsi     # 0x105900
movq %rbx, %rdi
callq 0x4b1ea
jmp 0x1dbdb
movq %rsp, %r12
movq %r12, %rdi
callq 0x4b600
movupd 0x140(%r14), %xmm0
movupd 0x150(%r14), %xmm1
movhpd 0x168(%r14), %xmm1      # xmm1 = xmm1[0],mem[0]
movupd (%r15), %xmm2
subpd %xmm1, %xmm2
movhpd 0x160(%r14), %xmm0      # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm2
movapd %xmm2, (%r12)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%r12)
leaq 0xe7fdf(%rip), %rsi     # 0x105ba0
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4b1f6
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b2c4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetNPixels(int, int)
void RGBDImage::
SetNPixels(int nx, int ny)
{
  // Resample color channels
  for (int i = RGBD_RED_CHANNEL; i <= RGBD_BLUE_CHANNEL; i++) {
    if (channels.NEntries() <= i) continue;
    if (channels[i]) channels[i]->Resample(nx, ny);
  }

  // Resample other channels (without interpolation)
  for (int i = RGBD_DEPTH_CHANNEL; i < channels.NEntries(); i++) {
    if (channels.NEntries() <= i) continue;
    R3Matrix tmp(R3identity_matrix);
    if (channels[i]) RGBDResampleDepthImage(*(channels[i]), tmp, nx, ny);
  }

  // Update intrinsics 
  double xscale = (nx > 0) ? (double) width / (double) nx : 1;
  double yscale = (ny > 0) ? (double) height / (double) ny : 1;
  this->intrinsics[0][0] /= xscale;
  this->intrinsics[0][2] /= xscale;
  this->intrinsics[1][1] /= yscale;
  this->intrinsics[1][2] /= yscale;

  // Update width and height of image
  this->width = nx;
  this->height = ny;

  // Invalidate opengl
  InvalidateOpenGL();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jge 0x1dc25
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x1dc25
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x64f00
incq %r15
cmpq $0x3, %r15
jne 0x1dc03
cmpl $0x4, 0x24(%rbx)
jl 0x1dc75
movl $0x3, %r13d
leaq 0xa067f(%rip), %r15     # 0xbe2c0
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6d1a2
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1dc69
movq %r12, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x23568
incq %r13
movslq 0x24(%rbx), %rax
cmpq %rax, %r13
jl 0x1dc44
movsd 0x9d3ab(%rip), %xmm0    # 0xbb028
testl %r14d, %r14d
jg 0x1dc88
movapd %xmm0, %xmm1
jmp 0x1dc96
cvtsi2sdl 0x28(%rbx), %xmm1
cvtsi2sd %r14d, %xmm2
divsd %xmm2, %xmm1
testl %ebp, %ebp
jle 0x1dcad
xorps %xmm0, %xmm0
cvtsi2sdl 0x2c(%rbx), %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
divsd %xmm2, %xmm0
movsd 0x140(%rbx), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x140(%rbx)
movsd 0x150(%rbx), %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x150(%rbx)
movupd 0x160(%rbx), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
movupd %xmm1, 0x160(%rbx)
movl %r14d, 0x28(%rbx)
movl %ebp, 0x2c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1c8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop