LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::CreateColor(unsigned char*, double) const
void R3SurfelViewer::
CreateColor(unsigned char *color, double value) const
{
  // Compute rgb based on blue-green-red heatmap
  if (value <= 0) {
    color[0] = 0;
    color[1] = 0;
    color[2] = 255;
  }
  else if (value < 0.1) {
    value *= 10 * 255;
    color[0] = 0;
    color[1] = value;
    color[2] = 255;
  }
  else if (value < 0.5) {
    value = (value - 0.1) * 2.5 * 255;
    color[0] = 0;
    color[1] = 255;
    color[2] = 255 - value;
  }
  else if (value < 0.9) {
    value = (value - 0.5) * 2.5 * 255;
    color[0] = value;
    color[1] = 255;
    color[2] = 0;
  }
  else if (value < 1) {
    value = (value - 0.9) * 10 * 255;
    color[0] = 255;
    color[1] = 255 - value;
    color[2] = 0;
  }
  else {
    color[0] = 255;
    color[1] = 0;
    color[2] = 0;
  }
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2d3a6
movsd 0x10dfc4(%rip), %xmm1   # 0x13b350
ucomisd %xmm0, %xmm1
jbe 0x2d3b1
mulsd 0x10dffe(%rip), %xmm0   # 0x13b398
movb $0x0, (%rsi)
cvttsd2si %xmm0, %eax
movb %al, 0x1(%rsi)
jmp 0x2d3ab
movw $0x0, (%rsi)
movb $-0x1, %al
movb %al, 0x2(%rsi)
retq
movsd 0x10dc57(%rip), %xmm1   # 0x13b010
ucomisd %xmm0, %xmm1
jbe 0x2d3ea
addsd 0x10dfc1(%rip), %xmm0   # 0x13b388
mulsd 0x10dfc1(%rip), %xmm0   # 0x13b390
movsd 0x10df99(%rip), %xmm1   # 0x13b370
mulsd %xmm1, %xmm0
movw $0xff00, (%rsi)         # imm = 0xFF00
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
jmp 0x2d3ad
movsd 0x10df66(%rip), %xmm1   # 0x13b358
ucomisd %xmm0, %xmm1
jbe 0x2d41c
addsd 0x10df78(%rip), %xmm0   # 0x13b378
mulsd 0x10df78(%rip), %xmm0   # 0x13b380
mulsd 0x10df60(%rip), %xmm0   # 0x13b370
cvttsd2si %xmm0, %eax
movb %al, (%rsi)
movb $-0x1, 0x1(%rsi)
jmp 0x2d45b
movsd 0x10dbe4(%rip), %xmm1   # 0x13b008
ucomisd %xmm0, %xmm1
jbe 0x2d456
addsd 0x10df2e(%rip), %xmm0   # 0x13b360
mulsd 0x10df2e(%rip), %xmm0   # 0x13b368
movsd 0x10df2e(%rip), %xmm1   # 0x13b370
mulsd %xmm1, %xmm0
movb $-0x1, (%rsi)
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0x1(%rsi)
jmp 0x2d45b
movw $0xff, (%rsi)
xorl %eax, %eax
jmp 0x2d3ad
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawViewingExtent() const
void R3SurfelViewer::
DrawViewingExtent(void) const
{
  // Check extent visibility
  if (!viewing_extent_visibility) return;
  
  // Check extent
  const R3Box& bbox = scene->BBox();  
  const R3Box& extent = ViewingExtent();
  if (extent.IsEmpty() || R3Contains(extent, bbox)) return;

  // Draw extent
  glDisable(GL_LIGHTING);
  RNLoadRgb(0.5, 0.5, 0.5);
  extent.Outline();
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x338(%rdi)
je 0x2d905
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d8b2
callq 0x3ff5c
jmp 0x2d8b9
leaq 0x199c9f(%rip), %rax    # 0x1c7558
movsd 0x128(%rbx), %xmm0
ucomisd 0x140(%rbx), %xmm0
ja 0x2d905
movsd 0x130(%rbx), %xmm0
ucomisd 0x148(%rbx), %xmm0
ja 0x2d905
movsd 0x138(%rbx), %xmm0
ucomisd 0x150(%rbx), %xmm0
ja 0x2d905
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8b6b0
testl %eax, %eax
je 0x2d907
popq %rbx
retq
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x10d6f7(%rip), %xmm0   # 0x13b010
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x27ee0
movq (%rbx), %rax
movq 0xb0(%rax), %rax
movl $0x1, %esi
movq %rbx, %rdi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::EnableViewingExtent() const
void R3SurfelViewer::
EnableViewingExtent(void) const
{
  // Check clip planes extent
  const R3Box& bbox = scene->BBox();  
  const R3Box& extent = ViewingExtent();
  if (extent.IsEmpty() || R3Contains(extent, bbox)) {
    DisableViewingExtent();
    return;
  }

  // Load lo clip planes
  for (int dim = RN_X; dim <= RN_Z; dim++) {
    if (extent[RN_LO][dim] > bbox[RN_LO][dim]) {
      GLdouble plane_equation[4] = { 0, 0, 0, 0 };
      plane_equation[dim] = 1.0;
      plane_equation[3] = -extent[RN_LO][dim];
      glClipPlane(GL_CLIP_PLANE0 + dim, plane_equation);
      glEnable(GL_CLIP_PLANE0 + dim);
    }
  }

  // Load hi clip planes
  for (int dim = RN_X; dim <= RN_Z; dim++) {
    if (extent[RN_HI][dim] < bbox[RN_HI][dim]) {
      GLdouble plane_equation[4] = { 0, 0, 0, 0 };
      plane_equation[dim] = -1.0;
      plane_equation[3] = extent[RN_HI][dim];
      glClipPlane(GL_CLIP_PLANE0 + 3 + dim, plane_equation);
      glEnable(GL_CLIP_PLANE0 + 3 + dim);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d969
callq 0x3ff5c
movq %rax, %r14
jmp 0x2d970
leaq 0x199be8(%rip), %r14    # 0x1c7558
movsd 0x128(%rbx), %xmm0
ucomisd 0x140(%rbx), %xmm0
ja 0x2d9b9
movsd 0x130(%rbx), %xmm0
ucomisd 0x148(%rbx), %xmm0
ja 0x2d9b9
movsd 0x138(%rbx), %xmm0
ucomisd 0x150(%rbx), %xmm0
ja 0x2d9b9
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x8b6b0
testl %eax, %eax
je 0x2d9d3
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x238(%rax)
xorl %r12d, %r12d
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
movq %rsp, %r15
movsd 0x128(%rbx,%r12,8), %xmm0
ucomisd 0x8(%r14,%r12,8), %xmm0
jbe 0x2da30
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, (%rsp)
movq %r13, (%rsp,%r12,8)
xorpd 0x10da7f(%rip), %xmm0   # 0x13b490
movlpd %xmm0, 0x18(%rsp)
leal 0x3000(%r12), %ebp
movl %ebp, %edi
movq %r15, %rsi
callq 0x27390
movl %ebp, %edi
callq 0x27860
incq %r12
cmpq $0x3, %r12
jne 0x2d9e3
xorl %r12d, %r12d
movabsq $-0x4010000000000000, %r13 # imm = 0xBFF0000000000000
movq %rsp, %r15
movsd 0x140(%rbx,%r12,8), %xmm0
movsd 0x20(%r14,%r12,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2da92
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, (%rsp)
movq %r13, (%rsp,%r12,8)
movsd %xmm0, 0x18(%rsp)
leal 0x3003(%r12), %ebp
movl %ebp, %edi
movq %r15, %rsi
callq 0x27390
movl %ebp, %edi
callq 0x27860
incq %r12
cmpq $0x3, %r12
jne 0x2da49
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::UpdateViewingFrustum()
void R3SurfelViewer::
UpdateViewingFrustum(void)
{
  // Update viewing frustum
  const R3Camera& camera = viewer.Camera();
  viewing_frustum = R3Frustum(camera.Origin(), camera.Towards(), camera.Up(),
    camera.XFOV(), camera.YFOV(), camera.Near(), camera.Far());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
leaq 0x80(%rdi), %r15
leaq 0xc8(%rdi), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0xc6a4c
leaq 0xb0(%rbx), %rcx
movsd 0xe0(%rbx), %xmm0
movsd 0xe8(%rbx), %xmm1
movsd 0xf0(%rbx), %xmm2
movsd 0xf8(%rbx), %xmm3
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xab06c
leaq 0x170(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc568c
leaq 0x188(%rbx), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc6562
leaq 0x50(%rsp), %rsi
leaq 0x1a0(%rbx), %rdi
callq 0xc6562
leaq 0x68(%rsp), %rsi
leaq 0x1b8(%rbx), %rdi
callq 0xc6562
xorl %r15d, %r15d
movq %rbx, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
leaq (%r14,%r13), %rsi
addq $0x68, %rsi
callq 0xc6562
movsd 0x80(%r14,%r13), %xmm0
movsd %xmm0, 0x1e8(%r12,%r13)
addq $0x20, %r13
cmpq $0x60, %r13
jne 0x2db77
incq %r15
addq $0x60, %r14
addq $0x60, %r12
cmpq $0x2, %r15
jne 0x2db74
leaq 0x18(%rsp), %rdi
movups 0x128(%rdi), %xmm0
movups 0x138(%rdi), %xmm1
movups %xmm1, 0x2a0(%rbx)
movups %xmm0, 0x290(%rbx)
callq 0xaf380
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2dbf7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xaf380
movq %rbx, %rdi
callq 0x28130
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::UpdateSelectedImageColorPixels()
void R3SurfelViewer::
UpdateSelectedImageColorPixels(void)
{
  // Check stuff
  if (!selected_image) return;
  if (selected_image == previous_color_image) return;

  // Get color image
  selected_image_color_pixels = selected_image->ColorChannels();
  if ((selected_image_color_pixels.Width() <= 0) ||
      (selected_image_color_pixels.Height() <= 0) ||
      (selected_image_color_pixels.Depth() != 3)) {
    selected_image_color_pixels = R2Image();
  }

  // Remember last selected image
  previous_color_image = selected_image;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x2d0(%rdi), %rsi
testq %rsi, %rsi
je 0x2e0e1
movq %rdi, %rbx
cmpq 0x5e0(%rdi), %rsi
je 0x2e0e1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x440f2
leaq 0x5c8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xe08f0
leaq 0x8(%rsp), %rdi
callq 0xe0852
cmpl $0x0, 0x5c8(%rbx)
jle 0x2e0b1
cmpl $0x0, 0x5cc(%rbx)
jle 0x2e0b1
cmpl $0x3, 0x5d0(%rbx)
je 0x2e0d3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe02c8
movq %r14, %rdi
movq %r15, %rsi
callq 0xe08f0
leaq 0x8(%rsp), %rdi
callq 0xe0852
movq 0x2d0(%rbx), %rax
movq %rax, 0x5e0(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2e0ed
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe0852
movq %rbx, %rdi
callq 0x28130
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::AdaptWorkingSet()
void R3SurfelViewer::
AdaptWorkingSet(void)
{
  // Check if adapting automatically
  if (!adapt_working_set_automatically) return;

  // Adjust target resolution based on frame time
  if (frame_time > 0.05) {
    SetTargetResolution(0.9 * TargetResolution());
  }
  else if (frame_time < 0.025) {
    SetTargetResolution(1.1 * TargetResolution());
  }

  // Make gross estimate of visible radius
  RNLength camera_height = viewer.Camera().Origin().Z();
  RNLength visible_radius = camera_height;

  // Adjust focus radius 
  SetFocusRadius(visible_radius);

  // Adjust surfel size based on visible radius
  if ((TargetResolution() > 0) && (visible_radius > 0)) {
    RNLength window_width = viewer.Viewport().Width();
    RNLength npixels = window_width / (visible_radius * TargetResolution());
    SetSurfelSize(npixels);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x460(%rdi)
je 0x2e2fc
movq %rdi, %rbx
movsd 0x4e8(%rdi), %xmm0
ucomisd 0x10d159(%rip), %xmm0   # 0x13b3c0
jbe 0x2e273
movsd 0x10d0e7(%rip), %xmm0   # 0x13b358
jmp 0x2e289
movsd 0x10d155(%rip), %xmm1   # 0x13b3d0
ucomisd %xmm0, %xmm1
jbe 0x2e29d
movsd 0x10d13f(%rip), %xmm0   # 0x13b3c8
mulsd 0x468(%rbx), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1c8(%rax)
movsd 0x90(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1d0(%rax)
movsd 0x8(%rsp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x2e2fc
movsd 0x468(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2e2fc
xorps %xmm0, %xmm0
cvtsi2sdl 0x118(%rbx), %xmm0
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmpq *%rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawSurfels(gaps::R3SurfelNode*, gaps::RNFlags) const
void R3SurfelViewer::
DrawSurfels(R3SurfelNode *node, RNFlags color_draw_flags) const
{
  // Check node
  if (!NodeVisibility(node)) return;

  // Draw all blocks
  for (int i = 0; i < node->NBlocks(); i++) {
    R3SurfelBlock *block = node->Block(i);
    block->Draw(shape_draw_flags | color_draw_flags, subsampling_factor);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2cf82
testl %eax, %eax
je 0x2e350
cmpl $0x0, 0x4c(%r14)
jle 0x2e350
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x458(%r15), %rsi
orq %rbx, %rsi
movl 0x48c(%r15), %edx
callq 0x37b06
incq %r12
movslq 0x4c(%r14), %rax
cmpq %rax, %r12
jl 0x2e326
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectProperties(int) const
void R3SurfelViewer::
DrawObjectProperties(int property_type) const
{
  // Check stuff
  if (!scene) return;
  
  // Draw object properties
  for (int i = 0; i < scene->NObjectProperties(); i++) {
    R3SurfelObjectProperty *property = scene->ObjectProperty(i);
    if (property->Type() != property_type) continue;
    R3SurfelObject *object = property->Object();
    if (!object->Parent()) continue;
    if (object->Parent() != scene->RootObject()) continue;
    if (!ObjectVisibility(object)) continue;
    if (!object->HasSurfels(TRUE)) continue;
    if ((surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_OBJECT) ||
        (surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_CURRENT_LABEL) ||
        (surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_OBJECT_ATTRIBUTES)) {
      unsigned char color[3];
      CreateColor(color, surfel_color_scheme, NULL, NULL, NULL, object, NULL);
      color[0] += 0.5 * (255 - color[0]);
      color[1] += 0.5 * (255 - color[1]);
      color[2] += 0.5 * (255 - color[2]);
      RNLoadRgb(color);
    }
    property->Draw(0);
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2eedd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpl $0x0, 0x3c(%rax)
jle 0x2eecf
movl %esi, %ebx
xorl %ebp, %ebp
leaq 0x5(%rsp), %r15
movq 0x30(%rax), %rcx
movq (%rcx,%rbp,8), %r12
cmpl %ebx, 0x2c(%r12)
jne 0x2edc4
movq 0x18(%r12), %r13
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0x2edc4
movq 0x10(%rax), %rax
cmpq (%rax), %rcx
je 0x2edd9
incq %rbp
movq 0x8(%r14), %rax
movslq 0x3c(%rax), %rcx
cmpq %rcx, %rbp
jl 0x2ed9e
jmp 0x2eecf
movq %r14, %rdi
movq %r13, %rsi
callq 0x2cece
testl %eax, %eax
je 0x2edc4
movq %r13, %rdi
movl $0x1, %esi
callq 0x46e36
testl %eax, %eax
je 0x2edc4
movl 0x360(%r14), %edx
cmpl $0xd, %edx
ja 0x2eebe
movl $0x2120, %eax           # imm = 0x2120
btl %edx, %eax
jae 0x2eebe
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq %r13
callq *0x210(%rax)
addq $0x10, %rsp
movzbl 0x5(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x10c1ba(%rip), %xmm2   # 0x13b010
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x5(%rsp)
movzbl 0x6(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x7(%rsp)
movq %r15, %rdi
callq 0x27c10
movq (%r12), %rax
movq %r12, %rdi
xorl %esi, %esi
callq *0x10(%rax)
jmp 0x2edc4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectPrincipalAxes() const
void R3SurfelViewer::
DrawObjectPrincipalAxes(void) const
{
  // Check stuff
  if (!object_principal_axes_visibility) return;
  
  // Draw object principal axes
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_principal_axes_color);
  DrawObjectProperties(R3_SURFEL_OBJECT_PCA_PROPERTY);
}

// Assembly:
cmpl $0x0, 0x308(%rdi)
je 0x2ef27
pushq %rbx
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x398(%rbx), %xmm0
movsd 0x3a0(%rbx), %xmm1
movsd 0x3a8(%rbx), %xmm2
callq 0x27ee0
movq (%rbx), %rax
movq 0x368(%rax), %rax
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmpq *%rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectOrientedBBoxes() const
void R3SurfelViewer::
DrawObjectOrientedBBoxes(void) const
{
  // Check stuff
  if (!object_oriented_bbox_visibility) return;

  // Draw object oriented boxes
  glLineWidth(2);
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_oriented_bbox_color);
  DrawObjectProperties(R3_SURFEL_OBJECT_AMODAL_OBB_PROPERTY);
  glLineWidth(1);
}

// Assembly:
cmpl $0x0, 0x30c(%rdi)
je 0x2ef88
pushq %rbx
movq %rdi, %rbx
movss 0x10c5a7(%rip), %xmm0   # 0x13b4e4
callq 0x281b0
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3b0(%rbx), %xmm0
movsd 0x3b8(%rbx), %xmm1
movsd 0x3c0(%rbx), %xmm2
callq 0x27ee0
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x2, %esi
callq *0x368(%rax)
movss 0x10c0be(%rip), %xmm0   # 0x13b040
popq %rbx
jmp 0x281b0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectRelationships() const
void R3SurfelViewer::
DrawObjectRelationships(void) const
{
  // Check stuff
  if (!scene) return;
  if (!object_relationship_visibility) return;
  
  // Draw object relationships
  glDisable(GL_LIGHTING);
  RNLoadRgb(1.0, 1.0, 1.0);
  for (int i = 0; i < scene->NObjectRelationships(); i++) {
    R3SurfelObjectRelationship *relationship = scene->ObjectRelationship(i);
    relationship->Draw();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2eff5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x310(%rdi)
je 0x2efee
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x10c055(%rip), %xmm0   # 0x13b008
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x27ee0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x5c(%rax)
jle 0x2efee
xorl %r14d, %r14d
movq 0x50(%rax), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x10(%rax)
incq %r14
movq 0x8(%rbx), %rax
movslq 0x5c(%rax), %rcx
cmpq %rcx, %r14
jl 0x2efcb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectBBoxes() const
void R3SurfelViewer::
DrawObjectBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!object_bbox_visibility) return;
  
  // Draw node bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_bbox_color);
  for (int i = 0; i < scene->NObjects(); i++) {
    R3SurfelObject *object = scene->Object(i);
    if (!object->Parent()) continue;
    if (object->Parent() != scene->RootObject()) continue;
    if ((object->NParts() == 0) && (object->NNodes() == 0)) continue;    
    object->BBox().Outline();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f094
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x314(%rdi)
je 0x2f08d
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3c8(%rbx), %xmm0
movsd 0x3d0(%rbx), %xmm1
movsd 0x3d8(%rbx), %xmm2
callq 0x27ee0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x2f08d
xorl %r14d, %r14d
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rdi
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x2f07d
cmpq (%rax), %rcx
jne 0x2f07d
cmpl $0x0, 0x2c(%rdi)
jne 0x2f067
cmpl $0x0, 0x6c(%rdi)
je 0x2f07d
callq 0x46926
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
incq %r14
movq 0x8(%rbx), %rax
movslq 0x1c(%rax), %rcx
cmpq %rcx, %r14
jl 0x2f045
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawNodeBBoxes() const
void R3SurfelViewer::
DrawNodeBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!node_bbox_visibility) return;
  
  // Draw node bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(node_bbox_color);
  for (int i = 0; i < resident_nodes.NNodes(); i++) {
    R3SurfelNode *node = resident_nodes.Node(i);
    if (node->NParts() > 0) RNLoadRgb(0, 1, 0);
    else RNLoadRgb(1, 0, 0);
    node->BBox().Outline();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f142
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x318(%rdi)
je 0x2f13d
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3e0(%rbx), %xmm0
movsd 0x3e8(%rbx), %xmm1
movsd 0x3f0(%rbx), %xmm2
callq 0x27ee0
cmpl $0x0, 0x24(%rbx)
jle 0x2f13d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %r14
cmpl $0x0, 0x3c(%r14)
jle 0x2f105
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
movss 0x10bf3d(%rip), %xmm1   # 0x13b040
jmp 0x2f113
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movss 0x10bf2d(%rip), %xmm0   # 0x13b040
callq 0x28360
movq %r14, %rdi
callq 0x3ff5c
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x2f0e6
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawBlockBBoxes() const
void R3SurfelViewer::
DrawBlockBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!block_bbox_visibility) return;

  // Draw block bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(block_bbox_color);
  for (int i = 0; i < resident_nodes.NNodes(); i++) {
    R3SurfelNode *node = resident_nodes.Node(i);
    for (int j = 0; j < node->NBlocks(); j++) {
      R3SurfelBlock *block = node->Block(j);
      block->BBox().Outline();
    }
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f1e6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x31c(%rdi)
je 0x2f1db
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3f8(%rbx), %xmm0
movsd 0x400(%rbx), %xmm1
movsd 0x408(%rbx), %xmm2
callq 0x27ee0
cmpl $0x0, 0x24(%rbx)
jle 0x2f1db
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %r15
cmpl $0x0, 0x4c(%r15)
jle 0x2f1cf
xorl %r12d, %r12d
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x36572
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
incq %r12
movslq 0x4c(%r15), %rax
cmpq %rax, %r12
jl 0x2f1a5
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x2f193
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawCenterPoint() const
void R3SurfelViewer::
DrawCenterPoint(void) const
{
  // Check stuff
  if (!center_point_visibility) return;
  
  // Draw center point
  glEnable(GL_LIGHTING);
  RNLoadRgb(center_point_color);
  R3Sphere(center_point, 0.1).Draw();
  glDisable(GL_LIGHTING);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x334(%rdi)
je 0x2f25e
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
movsd 0x440(%rbx), %xmm0
movsd 0x448(%rbx), %xmm1
movsd 0x450(%rbx), %xmm2
callq 0x27ee0
addq $0x2b0, %rbx            # imm = 0x2B0
movq %rsp, %r14
movsd 0x10c11c(%rip), %xmm0   # 0x13b350
movq %r14, %rdi
movq %rbx, %rsi
callq 0xabf72
movl $0x772, %esi            # imm = 0x772
movq %r14, %rdi
callq 0x818b4
movq %rsp, %rdi
callq 0xaf380
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xaf380
movq %rbx, %rdi
callq 0x28130
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawSelectedPoint() const
void R3SurfelViewer::
DrawSelectedPoint(void) const
{
  // Check stuff
  if (!selected_point) return;
  // if (!selected_point_visibility) return;

  // Draw selected point
  glEnable(GL_LIGHTING);
  RNLoadRgb(RNred_rgb);
  R3Sphere(selected_point->Position(), 0.05).Draw();
  glDisable(GL_LIGHTING);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x2c8(%rdi)
je 0x2f330
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
leaq 0x190e35(%rip), %rax    # 0x1c00d8
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
callq 0x27ee0
movq 0x2c8(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
addsd 0x10(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax), %xmm1
addsd 0x18(%rcx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rax), %xmm2
addsd 0x20(%rcx), %xmm2
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xc531e
leaq 0x8(%rsp), %r14
movsd 0x10c0bc(%rip), %xmm0   # 0x13b3c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xabf72
movl $0x772, %esi            # imm = 0x772
movq %r14, %rdi
callq 0x818b4
leaq 0x8(%rsp), %rdi
callq 0xaf380
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xaf380
movq %rbx, %rdi
callq 0x28130
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawScanViewpoints() const
void R3SurfelViewer::
DrawScanViewpoints(void) const
{
  // Check stuff
  if (!scene) return;
  if (!scan_viewpoint_visibility) return;
  
  // Draw scan viewpoints
  glDisable(GL_LIGHTING);
  RNLoadRgb(scan_viewpoint_color);
  RNGrfxBegin(RN_GRFX_LINES);
  for (int i = 0; i < scene->NScans(); i++) {
    R3SurfelScan *scan = scene->Scan(i);
    const R3Point& viewpoint = scan->Viewpoint();
    const R3Vector towards = scan->Towards();
    const R3Vector up = scan->Up();
    R3LoadPoint(viewpoint);
    R3LoadPoint(viewpoint + towards);
    R3LoadPoint(viewpoint);
    R3LoadPoint(viewpoint + 0.5 * up);
  }
  RNGrfxEnd();
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f47b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r12
cmpl $0x0, 0x320(%rdi)
je 0x2f46d
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x410(%r12), %xmm0
movsd 0x418(%r12), %xmm1
movsd 0x420(%r12), %xmm2
callq 0x27ee0
movl $0x1, %edi
callq 0x271a0
movq 0x8(%r12), %rax
cmpl $0x0, 0x8c(%rax)
jle 0x2f468
xorl %r15d, %r15d
movq 0x80(%rax), %rax
movq (%rax,%r15,8), %r14
leaq 0x28(%r14), %rbp
leaq 0x70(%r14), %rsi
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0xc6a4c
addq $0x58, %r14
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc5dc6
movq %rbp, %rdi
callq 0x271c0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xc5669
movq %r14, %rdi
callq 0x271c0
movq %rbp, %rdi
callq 0x271c0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movsd 0x10bbdb(%rip), %xmm0   # 0x13b010
callq 0xc6786
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xc5669
movq %r14, %rdi
callq 0x271c0
incq %r15
movq 0x8(%r12), %rax
movslq 0x8c(%rax), %rcx
cmpq %rcx, %r15
jl 0x2f3c3
callq 0x27cc0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawImageViewpoints() const
void R3SurfelViewer::
DrawImageViewpoints(void) const
{
  // Check stuff
  if (!scene) return;
  if (!image_viewpoint_visibility) return;
  
  // Draw image viewpoints
  glDisable(GL_LIGHTING);
  RNLoadRgb(image_viewpoint_color);
  for (int i = 0; i < scene->NImages(); i++) {
    R3SurfelImage *image = scene->Image(i);
    if (image == selected_image) glLineWidth(5);
    image->Draw();
    if (image == selected_image) glLineWidth(1);
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f53b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x324(%rdi)
je 0x2f536
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x428(%rbx), %xmm0
movsd 0x430(%rbx), %xmm1
movsd 0x438(%rbx), %xmm2
callq 0x27ee0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x9c(%rax)
jle 0x2f536
xorl %r15d, %r15d
movq 0x90(%rax), %rax
movq (%rax,%r15,8), %r14
cmpq 0x2d0(%rbx), %r14
jne 0x2f4f4
movss 0x10bff9(%rip), %xmm0   # 0x13b4e8
callq 0x281b0
movq (%r14), %rax
movl $0x1, %esi
movq %r14, %rdi
movsd 0x10bb01(%rip), %xmm0   # 0x13b008
callq *0xf0(%rax)
cmpq 0x2d0(%rbx), %r14
jne 0x2f523
movss 0x10bb22(%rip), %xmm0   # 0x13b040
callq 0x281b0
incq %r15
movq 0x8(%rbx), %rax
movslq 0x9c(%rax), %rcx
cmpq %rcx, %r15
jl 0x2f4d3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawAxes() const
void R3SurfelViewer::
DrawAxes(void) const
{
  // Check stuff
  if (!axes_visibility) return;

  // Draw axes
  RNScalar d = 1.0;
  glDisable(GL_LIGHTING);
  glLineWidth(3);
  R3BeginLine();
  RNLoadRgb(1, 0, 0);
  R3LoadPoint(R3zero_point);
  R3LoadPoint(R3zero_point + d * R3posx_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 1, 0);
  R3LoadPoint(R3zero_point);
  R3LoadPoint(R3zero_point + d * R3posy_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 0, 1);
  R3LoadPoint(R3zero_point);
  R3LoadPoint(R3zero_point + d * R3posz_vector);
  R3EndLine();
  glLineWidth(1);
}

// Assembly:
cmpl $0x0, 0x33c(%rdi)
je 0x30153
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movss 0x10b4d8(%rip), %xmm0   # 0x13b4ec
callq 0x281b0
movl $0x3, %edi
callq 0x271a0
movss 0x10b015(%rip), %xmm0   # 0x13b040
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x28360
leaq 0x5981c3(%rip), %rbx    # 0x5c8200
movq %rbx, %rdi
callq 0x271c0
leaq 0x115244(%rip), %rsi    # 0x145290
movq %rsp, %r14
movsd 0x10afb1(%rip), %xmm0   # 0x13b008
movq %r14, %rdi
callq 0xc6786
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc5669
movq %r15, %rdi
callq 0x271c0
callq 0x27cc0
movl $0x3, %edi
callq 0x271a0
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
movss 0x10afa9(%rip), %xmm1   # 0x13b040
callq 0x28360
movq %rbx, %rdi
callq 0x271c0
leaq 0x1151fd(%rip), %rsi    # 0x1452a8
movq %rsp, %r14
movq %r14, %rdi
movsd 0x10af4f(%rip), %xmm0   # 0x13b008
callq 0xc6786
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc5669
movq %r15, %rdi
callq 0x271c0
callq 0x27cc0
movl $0x3, %edi
callq 0x271a0
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movss 0x10af4a(%rip), %xmm2   # 0x13b040
callq 0x28360
movq %rbx, %rdi
callq 0x271c0
leaq 0x1151b6(%rip), %rsi    # 0x1452c0
movq %rsp, %r14
movq %r14, %rdi
movsd 0x10aef0(%rip), %xmm0   # 0x13b008
callq 0xc6786
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc5669
movq %r15, %rdi
callq 0x271c0
callq 0x27cc0
movss 0x10aefb(%rip), %xmm0   # 0x13b040
callq 0x281b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::CaptureImage(char const*) const
void R3SurfelViewer::
CaptureImage(const char *filename) const
{
  // Check stuff
  if (!filename) return;

  // Capture iamge
  R2Image image(viewer.Viewport().Width(), viewer.Viewport().Height(), 3);
  image.Capture();

  // Wrimte to file
  image.Write(filename);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x3019a
movq %rsi, %rbx
movl 0x118(%rdi), %esi
movl 0x11c(%rdi), %edx
movq %rsp, %r14
movq %r14, %rdi
movl $0x3, %ecx
callq 0xe05ea
movq %r14, %rdi
callq 0xe1074
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xe2424
movq %rsp, %rdi
callq 0xe0852
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe0852
movq %rbx, %rdi
callq 0x28130
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::Resize(int, int)
int R3SurfelViewer::
Resize(int w, int h)
{
  // Resize window
  glViewport(0, 0, w, h);

  // Resize viewer viewport
  viewer.ResizeViewport(0, 0, w, h);

  // Remember window size
  window_width = w;
  window_height = h;

  // Return whether need redraw
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x27210
leaq 0x78(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x78f18
movl %ebp, 0x498(%r14)
movl %ebx, 0x494(%r14)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::Initialize()
void R3SurfelViewer::
Initialize(void)
{
  // Initialize lights
  static GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
  static GLfloat light0_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
  static GLfloat light0_position[] = { 0.0, 0.0, -1.0, 0.0 };
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
  glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
  glEnable(GL_LIGHT0);
  static GLfloat light1_diffuse[] = { 0.5, 0.5, 0.5, 1.0 };
  static GLfloat light1_position[] = { 0.0, -1.0, 0.0, 0.0 };
  glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
  glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
  glEnable(GL_LIGHT1);
  glEnable(GL_NORMALIZE);

  // Initialize color settings
  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

  // Initialize graphics modes
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);

  // Initialize shaders
  CompileShaders();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x18e34b(%rip), %rsi    # 0x1bfa30
movl $0xb53, %edi            # imm = 0xB53
callq 0x28270
movl $0xb51, %edi            # imm = 0xB51
movl $0x1, %esi
callq 0x27150
leaq 0x18e33b(%rip), %rdx    # 0x1bfa40
movl $0x4000, %edi           # imm = 0x4000
movl $0x1201, %esi           # imm = 0x1201
callq 0x28110
leaq 0x18e335(%rip), %rdx    # 0x1bfa50
movl $0x4000, %edi           # imm = 0x4000
movl $0x1203, %esi           # imm = 0x1203
callq 0x28110
movl $0x4000, %edi           # imm = 0x4000
callq 0x27860
leaq 0x18e325(%rip), %rdx    # 0x1bfa60
movl $0x4001, %edi           # imm = 0x4001
movl $0x1201, %esi           # imm = 0x1201
callq 0x28110
leaq 0x18e31f(%rip), %rdx    # 0x1bfa70
movl $0x4001, %edi           # imm = 0x4001
movl $0x1203, %esi           # imm = 0x1203
callq 0x28110
movl $0x4001, %edi           # imm = 0x4001
callq 0x27860
movl $0xba1, %edi            # imm = 0xBA1
callq 0x27860
movl $0xb57, %edi            # imm = 0xB57
callq 0x27860
movl $0x404, %edi            # imm = 0x404
movl $0x1602, %esi           # imm = 0x1602
callq 0x275b0
movl $0xb71, %edi            # imm = 0xB71
callq 0x27860
movl $0xb44, %edi            # imm = 0xB44
callq 0x27860
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x388(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::ResetCamera()
void R3SurfelViewer::
ResetCamera(void)
{
  // Move center point to scene centroid
  if (!scene) return;
  SetCenterPoint(scene->Centroid());
  R3Point eye = CenterPoint() + 2 * scene->BBox().DiagonalRadius() * R3posz_vector;
  viewer.RepositionCamera(eye);
  viewer.ReorientCamera(R3negz_vector, R3posy_vector);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x318a0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x195d73(%rip), %r14    # 0x1c7558
movq %r14, %rsi
testq %rdi, %rdi
je 0x317f5
callq 0x3ff5c
movq %rax, %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *0x68(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x80(%rax)
leaq 0x2b0(%rbx), %r15
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x31835
callq 0x3ff5c
movq %rax, %r14
movq %r14, %rdi
callq 0xaeba8
mulsd 0x1097cb(%rip), %xmm0   # 0x13b010
addsd %xmm0, %xmm0
leaq 0x113a70(%rip), %rsi    # 0x1452c0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xc6786
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc5669
subq $-0x80, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7adec
leaq 0x113a82(%rip), %rsi    # 0x145308
leaq 0x113a1b(%rip), %rdx    # 0x1452a8
movq %rbx, %rdi
callq 0x7adf2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::ZoomCamera(double)
void R3SurfelViewer::
ZoomCamera(RNScalar scale)
{
  // Zoom into center point so that an area of radius scale is visible
  if (!scene) return;
  R3Point eye = center_point - scale * scene->BBox().DiagonalRadius() * viewer.Camera().Towards();
  viewer.RepositionCamera(eye);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x31961
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
leaq 0x2b0(%rdi), %rbx
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x318e4
callq 0x3ff5c
movq %rax, %rdi
jmp 0x318eb
leaq 0x195c6d(%rip), %rdi    # 0x1c7558
callq 0xaeba8
mulsd 0x109718(%rip), %xmm0   # 0x13b010
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x80(%r14), %r15
addq $0xc8, %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xc6a4c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
callq 0xc6786
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc5d45
movq %r15, %rdi
movq %r12, %rsi
callq 0x7adec
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::SelectPoint(gaps::R3SurfelObject*)
void R3SurfelViewer::
SelectPoint(R3SurfelObject *object)
{
  // Create pointset
  R3SurfelPointSet *pointset = object->PointSet(TRUE);
  if (!pointset) {
    SelectPoint(NULL, -1);
    return;
  }

  // Get object centroid
  R3Point centroid = object->Centroid();

  // Find point nearest object centroid
  RNLength best_dd = FLT_MAX;
  R3SurfelPoint *best_point = NULL;
  for (int i = 0; i < pointset->NPoints(); i++) {
    R3SurfelPoint *point = pointset->Point(i);
    RNLength dd = R3SquaredDistance(centroid, point->Position());
    if (dd < best_dd) {
      best_point = point;
      best_dd = dd;
    }
  }

  // Select point 
  R3SurfelBlock *block = (best_point) ? best_point->Block() : NULL;
  int surfel_index = (best_point) ? best_point->BlockIndex() : -1;
  SelectPoint(block, surfel_index);

  // Delete pointset
  delete pointset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movq %rsi, %rdi
movl $0x1, %esi
callq 0x46d4e
testq %rax, %rax
je 0x31a43
movq %rax, %r14
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
callq 0x46926
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq *0x68(%rcx)
cmpl $0x0, 0x10(%r14)
jle 0x31a67
movsd 0x109977(%rip), %xmm0   # 0x13b338
xorl %ebp, %ebp
leaq 0x30(%rsp), %r15
xorl %ebx, %ebx
xorl %r13d, %r13d
movsd %xmm0, 0x10(%rsp)
movq 0x8(%r14), %rax
leaq (%rax,%rbp), %r12
movq (%rax,%rbp), %rcx
movq 0x8(%rax,%rbp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
addsd 0x10(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax), %xmm1
addsd 0x18(%rcx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rax), %xmm2
addsd 0x20(%rcx), %xmm2
movq %r15, %rdi
callq 0xc531e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x8ca4f
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %r12, %r13
minsd %xmm1, %xmm0
incq %rbx
movslq 0x10(%r14), %rax
addq $0x10, %rbp
cmpq %rax, %rbx
jl 0x319cd
jmp 0x31a6a
movq (%rbx), %rax
movq 0x1b8(%rax), %rax
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %r13d, %r13d
testq %r13, %r13
je 0x31a75
movq (%r13), %rsi
jmp 0x31a77
xorl %esi, %esi
movq 0x8(%rsp), %rdi
testq %r13, %r13
je 0x31a98
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq (%rax), %rcx
shrq $0x4, %rcx
imull $0xaaaaaaab, %ecx, %edx # imm = 0xAAAAAAAB
jmp 0x31a9d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq (%rdi), %rax
callq *0x1b8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::SelectPoint(gaps::R3SurfelBlock*, int)
void R3SurfelViewer::
SelectPoint(R3SurfelBlock *block, int surfel_index)
{
  // Remember previously selected point
  R3SurfelPoint *previous_selected_point = selected_point;

  // Select point
  selected_point = NULL;
  if (block && (surfel_index >= 0) && (surfel_index < block->NSurfels())) {
    selected_point = new R3SurfelPoint(block, surfel_index);
  }

  // Delete previously selected point
  if (previous_selected_point) delete previous_selected_point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2c8(%rdi), %rbx
movq $0x0, 0x2c8(%rdi)
testq %rsi, %rsi
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x31b15
movl %edx, %ebp
movq %rsi, %r15
cmpl %edx, 0x8(%rsi)
jle 0x31b15
movq %rdi, %r14
movl $0x10, %edi
callq 0x27910
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x3b9b4
movq %r12, 0x2c8(%r14)
testq %rbx, %rbx
je 0x31b37
movq %rbx, %rdi
callq 0x3ba1c
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27930
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
callq 0x27930
movq %rbx, %rdi
callq 0x28130
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::SelectImage(gaps::R3SurfelImage*, int, int)
void R3SurfelViewer::
SelectImage(R3SurfelImage *image, RNBoolean update_working_set, RNBoolean jump_to_viewpoint)
{
  // Jump to viewpoint
  if (image && jump_to_viewpoint) {
    R3Camera camera(image->Viewpoint(), image->Towards(), image->Up(),
      image->XFOV(), image->YFOV(), viewer.Camera().Near(), viewer.Camera().Far());
    viewer.SetCamera(camera);
  }

  // Update working set
  if (image && update_working_set) {
    R3SurfelScan *scan = image->Scan();
    R3SurfelNode *node = (scan) ? scan->Node() : NULL;
    if (!node) {
      SetCenterPoint(image->Viewpoint() + 2.0 * image->Towards());
    }
    else {
      EmptyWorkingSet();
      center_point = node->Centroid();
      InsertIntoWorkingSet(node, TRUE);
    }
  }

  // Remember selected image
  selected_image = image;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
sete %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x31c49
movl %edx, 0xc(%rsp)
leaq 0x78(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0xc6a4c
movsd 0xb0(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
xorpd %xmm0, %xmm0
jae 0x31bca
xorps %xmm0, %xmm0
cvtsi2sdl 0x98(%rbx), %xmm0
mulsd 0x109453(%rip), %xmm0   # 0x13b010
divsd %xmm2, %xmm0
callq 0x27780
xorpd %xmm1, %xmm1
leaq 0x30(%rbx), %r12
leaq 0x60(%rbx), %r15
movsd 0xb8(%rbx), %xmm2
ucomisd %xmm2, %xmm1
jae 0x31c0c
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x9c(%rbx), %xmm0
mulsd 0x109417(%rip), %xmm0   # 0x13b010
divsd %xmm2, %xmm0
callq 0x27780
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0x78(%r14), %r13
movsd 0xf0(%r14), %xmm2
movsd 0xf8(%r14), %xmm3
leaq 0x48(%rsp), %rbp
leaq 0x18(%rsp), %rdx
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x7a6e4
movq %r13, %rdi
movq %rbp, %rsi
callq 0x78e18
movl 0xc(%rsp), %edx
testq %rbx, %rbx
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x31d0c
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x31c6b
movq 0x18(%rax), %r15
jmp 0x31c6e
xorl %r15d, %r15d
testq %r15, %r15
je 0x31cbd
movq (%r14), %rax
movq %r14, %rdi
callq *0x308(%rax)
movq %r15, %rdi
callq 0x3ff5c
movq (%rax), %rcx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq *0x68(%rcx)
leaq 0x2b0(%r14), %rdi
movq %r12, %rsi
callq 0xc568c
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq *0x328(%rax)
jmp 0x31d0c
leaq 0x30(%rbx), %r15
leaq 0x78(%rbx), %rsi
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0xc6a4c
leaq 0x18(%rsp), %r13
movsd 0x109731(%rip), %xmm0   # 0x13b410
movq %r13, %rdi
movq %r12, %rsi
callq 0xc6786
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc5669
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x80(%rax)
movq %rbx, 0x2d0(%r14)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::WriteImage(char const*)
int R3SurfelViewer::
WriteImage(const char *filename)
{
  // Check if can write file
  FILE *fp = fopen(filename, "w");
  if (!fp) return 0;
  else fclose(fp);

  // Remember screenshot image name -- capture image next redraw
  if (screenshot_name) free(screenshot_name);
  if (!filename) screenshot_name = NULL;
  else screenshot_name = RNStrdup(filename);

  // Return success
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x112681(%rip), %rsi    # 0x1443b8
movq %r14, %rdi
callq 0x27b10
testq %rax, %rax
je 0x31d6c
movq %rax, %rdi
callq 0x27900
movq 0x4f0(%rbx), %rdi
testq %rdi, %rdi
je 0x31d5d
callq 0x27b30
testq %r14, %r14
je 0x31d70
movq %r14, %rdi
callq 0xe9edf
jmp 0x31d72
xorl %eax, %eax
jmp 0x31d7e
xorl %eax, %eax
movq %rax, 0x4f0(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::ReadCoarsestBlocks(double)
void R3SurfelViewer::
ReadCoarsestBlocks(RNScalar max_complexity)
{
  // Just checking
  if (!scene) return;

  // Get convenient variables
  R3SurfelTree *tree = scene->Tree();
  if (!tree) return;

  // Seed breadth first search with root node
  RNQueue<R3SurfelNode *> queue;
  queue.Insert(tree->RootNode());

  // Visit nodes in breadth first search reading blocks
  RNScalar total_complexity = 0;
  while (!queue.IsEmpty()) {
    R3SurfelNode *node = queue.Pop();
    if (total_complexity + node->Complexity() > max_complexity) break;
    total_complexity += node->Complexity();
    node->ReadBlocks();
    for (int i = 0; i < node->NParts(); i++) {
      R3SurfelNode *part = node->Part(i);
      queue.Push(part);
    }
  }

  // Invalidate VBO buffers
  InvalidateVBO();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x32183
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x32183
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xe6ec8
movq 0x18(%r15), %rax
movq (%rax), %rsi
movl 0x10(%r14), %edx
movq %r14, %rdi
callq 0xe6f36
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %r14
cmpl $0x0, 0x20(%rsp)
je 0x3216d
movl 0x24(%rsp), %eax
cltd
idivl 0x18(%rsp)
movq 0x10(%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xe70e4
movq %r15, %rdi
callq 0x3fe32
addsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
ucomisd 0x8(%rsp), %xmm0
ja 0x3215b
movq %r15, %rdi
callq 0x3fe32
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x406ca
movsd (%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
cmpl $0x0, 0x3c(%r15)
jle 0x3215b
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rsi
movl 0x20(%rsp), %edx
movq %r14, %rdi
callq 0xe6f36
incq %r12
movslq 0x3c(%r15), %rax
cmpq %rax, %r12
jl 0x3213b
movsd 0x30(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x320c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x378(%rax)
leaq 0x10(%rsp), %rdi
callq 0xe726e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x32195
jmp 0x32195
jmp 0x32195
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe726e
movq %rbx, %rdi
callq 0x28130