LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: DrawAxes()
static void
DrawAxes(void)
{
  // Check if should draw axes
  if (!show_axes) return;

  // Draw axes
  RNScalar d = world_bbox.DiagonalRadius();
  glDisable(GL_LIGHTING);
  glLineWidth(3);
  R3BeginLine();
  RNLoadRgb(1, 0, 0);
  R3LoadPoint(R3zero_point + 0.5*d * R3negx_vector);
  R3LoadPoint(R3zero_point + d * R3posx_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 1, 0);
  R3LoadPoint(R3zero_point + 0.5*d * R3negy_vector);
  R3LoadPoint(R3zero_point + d * R3posy_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 0, 1);
  R3LoadPoint(R3zero_point + 0.5*d * R3negz_vector);
  R3LoadPoint(R3zero_point + d * R3posz_vector);
  R3EndLine();
  glLineWidth(1);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
cmpl $0x0, 0x2cdd92(%rip)    # 0x2fef00
jne 0x31175
jmp 0x3138a
leaq 0x2cd6bc(%rip), %rdi    # 0x2fe838
callq 0x38be0
movsd %xmm0, 0x120(%rsp)
movl $0xb50, %edi            # imm = 0xB50
callq 0x2a130
movss 0x234f7c(%rip), %xmm0   # 0x266118
callq 0x29310
callq 0x3a440
movl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x39820
movsd 0x234e94(%rip), %xmm0   # 0x266050
mulsd 0x120(%rsp), %xmm0
leaq 0xf0(%rsp), %rdi
leaq 0x6d2234(%rip), %rsi    # 0x703408
callq 0x38f20
leaq 0x108(%rsp), %rdi
leaq 0x6d20b8(%rip), %rsi    # 0x7032a0
leaq 0xf0(%rsp), %rdx
callq 0x180350
leaq 0x108(%rsp), %rdi
callq 0x38e20
movsd 0x120(%rsp), %xmm0
leaq 0xc0(%rsp), %rdi
leaq 0x6d21a6(%rip), %rsi    # 0x7033c0
callq 0x38f20
leaq 0xd8(%rsp), %rdi
leaq 0x6d2072(%rip), %rsi    # 0x7032a0
leaq 0xc0(%rsp), %rdx
callq 0x180350
leaq 0xd8(%rsp), %rdi
callq 0x38e20
callq 0x3a450
callq 0x3a440
xorl %edx, %edx
movl $0x1, %esi
movl %edx, %edi
callq 0x39820
movsd 0x234de8(%rip), %xmm0   # 0x266050
mulsd 0x120(%rsp), %xmm0
leaq 0x90(%rsp), %rdi
leaq 0x6d21a0(%rip), %rsi    # 0x703420
callq 0x38f20
leaq 0xa8(%rsp), %rdi
leaq 0x6d200c(%rip), %rsi    # 0x7032a0
leaq 0x90(%rsp), %rdx
callq 0x180350
leaq 0xa8(%rsp), %rdi
callq 0x38e20
movsd 0x120(%rsp), %xmm0
leaq 0x60(%rsp), %rdi
leaq 0x6d2115(%rip), %rsi    # 0x7033d8
callq 0x38f20
leaq 0x78(%rsp), %rdi
leaq 0x6d1fcc(%rip), %rsi    # 0x7032a0
leaq 0x60(%rsp), %rdx
callq 0x180350
leaq 0x78(%rsp), %rdi
callq 0x38e20
callq 0x3a450
callq 0x3a440
xorl %esi, %esi
movl $0x1, %edx
movl %esi, %edi
callq 0x39820
movsd 0x234d48(%rip), %xmm0   # 0x266050
mulsd 0x120(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
leaq 0x6d211b(%rip), %rsi    # 0x703438
callq 0x38f20
leaq 0x48(%rsp), %rdi
leaq 0x6d1f72(%rip), %rsi    # 0x7032a0
leaq 0x30(%rsp), %rdx
callq 0x180350
leaq 0x48(%rsp), %rdi
callq 0x38e20
movsd 0x120(%rsp), %xmm0
movq %rsp, %rdi
leaq 0x6d209b(%rip), %rsi    # 0x7033f0
callq 0x38f20
leaq 0x18(%rsp), %rdi
leaq 0x6d1f3a(%rip), %rsi    # 0x7032a0
movq %rsp, %rdx
callq 0x180350
leaq 0x18(%rsp), %rdi
callq 0x38e20
callq 0x3a450
movss 0x234d8f(%rip), %xmm0   # 0x266114
callq 0x29310
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: DrawScene(gaps::R3Scene*, int, int)
static void
DrawScene(R3Scene *scene,
  int model_index, int color_scheme)
{
  // Check if should draw scene
  if (!show_scenes) return;

  // Draw faces
  if (show_surfaces) {
    glEnable(GL_LIGHTING);
    scene->LoadLights(2);
    scene->Draw();
  }

  // Draw edges
  if (show_edges) {
    if (color_scheme != PICK_COLOR_SCHEME) {
      glDisable(GL_LIGHTING);
      RNLoadRgb(0.0, 1.0, 0.0);
      scene->Draw(R3_EDGES_DRAW_FLAG);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
cmpl $0x0, 0x2be554(%rip)    # 0x2efb7c
jne 0x3162f
jmp 0x316d5
cmpl $0x0, 0x2cd696(%rip)    # 0x2feccc
je 0x3167e
movl $0xb50, %edi            # imm = 0xB50
callq 0x29a50
movq 0x30(%rsp), %rdi
movl $0x2, %esi
movl $0x7, %edx
callq 0xbe8f0
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x772, %esi            # imm = 0x772
callq 0x38e50
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbefa0
cmpl $0x0, 0x2cd64b(%rip)    # 0x2fecd0
je 0x316d5
cmpl $0x5, 0x28(%rsp)
je 0x316d3
movl $0xb50, %edi            # imm = 0xB50
callq 0x2a130
xorps %xmm2, %xmm2
movsd 0x23496d(%rip), %xmm1   # 0x266010
movaps %xmm2, %xmm0
callq 0x38d60
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x38e50
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbefa0
jmp 0x316d5
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: LoadColorIndex(int, int, int)
static void
LoadColorIndex(int model_index, int element_type, int element_index)
{
  // Set color to represent an integer (24 bits)
  int k = element_index + 1;
  unsigned char color[4];
  color[0] = (k      ) & 0xFF;
  color[1] = (k >>  8) & 0xFF;
  color[2] = (k >> 16) & 0xFF;
  color[3] = ((model_index + 1) & 0x0F) << 4;
  color[3] |= (element_type + 1) & 0x0F;
  RNLoadRgba(color);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, 0x4(%rsp)
movl 0x8(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0x5(%rsp)
movl 0x8(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, 0x6(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
andl $0xf, %eax
shll $0x4, %eax
movb %al, 0x7(%rsp)
movl 0x10(%rsp), %ecx
addl $0x1, %ecx
andl $0xf, %ecx
movzbl 0x7(%rsp), %eax
orl %ecx, %eax
movb %al, 0x7(%rsp)
leaq 0x4(%rsp), %rdi
callq 0x38fb0
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: LoadColorValue(double)
static void 
LoadColorValue(double value) 
{
  // Initialize color
  unsigned char color[3];
  
  // 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;
  }

  // Load color
  RNLoadRgb(color);
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x10(%rsp), %xmm0
jb 0x34b19
movb $0x0, 0xd(%rsp)
movb $0x0, 0xe(%rsp)
movb $-0x1, 0xf(%rsp)
jmp 0x34c86
movsd 0x23157f(%rip), %xmm0   # 0x2660a0
ucomisd 0x10(%rsp), %xmm0
jbe 0x34b5a
movsd 0x10(%rsp), %xmm0
movsd 0x2315b1(%rip), %xmm1   # 0x2660e8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movb $0x0, 0xd(%rsp)
cvttsd2si 0x10(%rsp), %eax
movb %al, 0xe(%rsp)
movb $-0x1, 0xf(%rsp)
jmp 0x34c84
movsd 0x2314ee(%rip), %xmm0   # 0x266050
ucomisd 0x10(%rsp), %xmm0
jbe 0x34bbb
movsd 0x10(%rsp), %xmm1
movsd 0x231568(%rip), %xmm0   # 0x2660e0
addsd %xmm0, %xmm1
movsd 0x2314a4(%rip), %xmm0   # 0x266028
mulsd %xmm0, %xmm1
movsd 0x231540(%rip), %xmm0   # 0x2660d0
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movb $0x0, 0xd(%rsp)
movb $-0x1, 0xe(%rsp)
movsd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0xf(%rsp)
jmp 0x34c82
movsd 0x2314ad(%rip), %xmm0   # 0x266070
ucomisd 0x10(%rsp), %xmm0
jbe 0x34c11
movsd 0x10(%rsp), %xmm0
movsd 0x2314ff(%rip), %xmm1   # 0x2660d8
addsd %xmm1, %xmm0
movsd 0x231443(%rip), %xmm1   # 0x266028
mulsd %xmm1, %xmm0
movsd 0x2314df(%rip), %xmm1   # 0x2660d0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
cvttsd2si 0x10(%rsp), %eax
movb %al, 0xd(%rsp)
movb $-0x1, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
jmp 0x34c80
movsd 0x2313f7(%rip), %xmm0   # 0x266010
ucomisd 0x10(%rsp), %xmm0
jbe 0x34c6f
movsd 0x10(%rsp), %xmm1
movsd 0x231499(%rip), %xmm0   # 0x2660c8
addsd %xmm0, %xmm1
movsd 0x23145d(%rip), %xmm0   # 0x266098
mulsd %xmm0, %xmm1
movsd 0x231489(%rip), %xmm0   # 0x2660d0
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movb $-0x1, 0xd(%rsp)
movsd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
jmp 0x34c7e
movb $-0x1, 0xd(%rsp)
movb $0x0, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
jmp 0x34c80
jmp 0x34c82
jmp 0x34c84
jmp 0x34c86
leaq 0xd(%rsp), %rdi
callq 0x39b90
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: DrawDotOnImageInset(ImageData*, double, double, double, gaps::R2Point const&)
static void
DrawDotOnImageInset(ImageData *data,
  double x, double y, double scale,
  const R2Point& image_position)
{
  // Check if drawing image insets
  if (!show_image_insets) return;

  // Get convenient variables
  double w = scale * data->image_width;
  double h = scale * data->image_height;
  if ((w == 0) || (h == 0)) return;

  // Set viewport
  glViewport(x, y, w, h);

  // Set viewing transformation
  glMatrixMode(GL_PROJECTION);  
  glPushMatrix();
  glLoadIdentity();
  glOrtho(0, data->image_width, 0, data->image_height, 0, 1);
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  // Draw dot
  RNLoadRgb(1, 0, 0);
  glPointSize(5);
  RNGrfxBegin(RN_GRFX_POINTS);
  R3LoadPoint(image_position.X(), image_position.Y(), -0.25);
  RNGrfxEnd();
  glPointSize(1);

  // Restore viewing transformation
  glMatrixMode(GL_PROJECTION);  
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);  
  glPopMatrix();

  // Resore viewport
  viewer->Viewport().Load();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm2, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpl $0x0, 0x2ca015(%rip)    # 0x2feeec
jne 0x34ede
jmp 0x3504c
movsd 0x28(%rsp), %xmm0
movq 0x40(%rsp), %rax
cvtsi2sdl 0x768(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x40(%rsp), %rax
cvtsi2sdl 0x76c(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x34f2b
jp 0x34f2b
jmp 0x34f3c
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x34f41
jp 0x34f41
jmp 0x3504c
cvttsd2si 0x38(%rsp), %edi
cvttsd2si 0x30(%rsp), %esi
cvttsd2si 0x18(%rsp), %edx
cvttsd2si 0x10(%rsp), %ecx
callq 0x29790
movl $0x1701, %edi           # imm = 0x1701
callq 0x29190
callq 0x29d20
callq 0x294f0
movq 0x40(%rsp), %rax
cvtsi2sdl 0x768(%rax), %xmm1
movq 0x40(%rsp), %rax
cvtsi2sdl 0x76c(%rax), %xmm3
xorps %xmm4, %xmm4
movsd 0x231079(%rip), %xmm5   # 0x266010
movaps %xmm4, %xmm0
movaps %xmm4, %xmm2
callq 0x295d0
movl $0x1700, %edi           # imm = 0x1700
callq 0x29190
callq 0x29d20
callq 0x294f0
movl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x39820
movss 0x231150(%rip), %xmm0   # 0x26611c
callq 0x29700
xorl %edi, %edi
callq 0x38d90
movq 0x20(%rsp), %rdi
callq 0x39990
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x399a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd 0x2310ed(%rip), %xmm2   # 0x2660f0
callq 0x39ce0
callq 0x38e40
movss 0x2310ff(%rip), %xmm0   # 0x266114
callq 0x29700
movl $0x1701, %edi           # imm = 0x1701
callq 0x29190
callq 0x2a210
movl $0x1700, %edi           # imm = 0x1700
callq 0x29190
callq 0x2a210
movq 0x2c9c71(%rip), %rdi    # 0x2fecb0
callq 0x39d50
movq %rax, %rdi
callq 0x39d70
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: LoadTexture(ImageData*)
static void
LoadTexture(ImageData *data)
{
  // Check if already loaded
  if (data->texture_id > 0) return;

  // Check color image
  if (data->color_image.Width() <= 0) return;
  if (data->color_image.Height() <= 0) return;
  if (data->color_image.Depth() != 3) return;

  // Allocate texture id
  glGenTextures(1, &data->texture_id);
  assert(data->texture_id > 0);

  // Set texture parameters
  glBindTexture(GL_TEXTURE_2D, data->texture_id);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

  // Set texture pixels
  gluBuild2DMipmaps(GL_TEXTURE_2D, 3,
    data->color_image.Width(), data->color_image.Height(),
    GL_RGB, GL_UNSIGNED_BYTE, data->color_image.Pixels());
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x770(%rax)
jbe 0x3637c
jmp 0x36494
movq 0x10(%rsp), %rdi
callq 0x39d10
cmpl $0x0, %eax
jg 0x36390
jmp 0x36494
movq 0x10(%rsp), %rdi
callq 0x39d20
cmpl $0x0, %eax
jg 0x363a4
jmp 0x36494
movq 0x10(%rsp), %rdi
callq 0x39d30
cmpl $0x3, %eax
je 0x363b8
jmp 0x36494
movq 0x10(%rsp), %rsi
addq $0x770, %rsi            # imm = 0x770
movl $0x1, %edi
callq 0x29710
movq 0x10(%rsp), %rax
movl 0x770(%rax), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq 0x2a4b0
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2802, %esi           # imm = 0x2802
movl $0x2900, %edx           # imm = 0x2900
callq 0x29e30
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2803, %esi           # imm = 0x2803
movl $0x2900, %edx           # imm = 0x2900
callq 0x29e30
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2801, %esi           # imm = 0x2801
movl $0x2701, %edx           # imm = 0x2701
callq 0x29e30
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2800, %esi           # imm = 0x2800
movl $0x2601, %edx           # imm = 0x2601
callq 0x29e30
movl $0x2300, %edi           # imm = 0x2300
movl $0x2200, %esi           # imm = 0x2200
movl $0x2100, %edx           # imm = 0x2100
callq 0x29340
movq 0x10(%rsp), %rdi
callq 0x39d10
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39d20
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39d40
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
movl $0xde1, %edi            # imm = 0xDE1
movl $0x3, %esi
movl $0x1907, %r8d           # imm = 0x1907
movl $0x1401, %r9d           # imm = 0x1401
movq %rax, (%rsp)
callq 0x2a540
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: GLUTStop()
static void
GLUTStop(void)
{
  // Close sfl scenes
  for (int i = 0; i < sfls.NEntries(); i++) {
    if (sfls[i]) CloseSFLFiles(sfls[i]);
  }
  
  // Destroy window 
  glutDestroyWindow(GLUTwindow);

  // Exit
  exit(0);
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
leaq 0x2c8361(%rip), %rdi    # 0x2fe818
callq 0x38730
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x36502
movl 0x4(%rsp), %esi
leaq 0x2c8348(%rip), %rdi    # 0x2fe818
callq 0x388e0
cmpq $0x0, (%rax)
je 0x364f3
movl 0x4(%rsp), %esi
leaq 0x2c8332(%rip), %rdi    # 0x2fe818
callq 0x388e0
movq (%rax), %rdi
callq 0x36520
jmp 0x364f5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x364a9
movl 0x2c87b8(%rip), %edi    # 0x2fecc0
callq 0x1fe670
xorl %edi, %edi
callq 0x29c60
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: ReadPointSetFile(char const*)
static R3PointSet *
ReadPointSetFile(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate pointset
  R3PointSet *pointset = new R3PointSet();
  if (!pointset) {
    RNFail("Unable to allocate pointset for %s\n", filename);
    return NULL;
  }

  // Read pointset from file
  if (!pointset->ReadFile(filename)) {
    delete pointset;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read pointset from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Points = %d\n", pointset->NPoints());
    fflush(stdout);
  }

  // Return success
  return pointset;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1c7070
movq 0x10(%rsp), %rdi
callq 0x38bc0
movl $0x150, %edi            # imm = 0x150
callq 0x292e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x1825a0
jmp 0x369fe
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x36a53
movq 0x48(%rsp), %rsi
leaq 0x22fb75(%rip), %rdi    # 0x266591
movb $0x0, %al
callq 0x1cbff0
movq $0x0, 0x50(%rsp)
jmp 0x36b02
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x150, %esi            # imm = 0x150
callq 0x291f0
jmp 0x36b0c
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x184230
cmpl $0x0, %eax
jne 0x36a9b
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x36a90
movq 0x8(%rsp), %rdi
callq 0x182890
movq 0x8(%rsp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0x291f0
movq $0x0, 0x50(%rsp)
jmp 0x36b02
cmpl $0x0, 0x2c821a(%rip)    # 0x2fecbc
je 0x36af8
movq 0x48(%rsp), %rsi
leaq 0x22fb05(%rip), %rdi    # 0x2665b5
movb $0x0, %al
callq 0x290f0
leaq 0x38(%rsp), %rdi
callq 0x1c7130
leaq 0x22f900(%rip), %rdi    # 0x2663c8
movb $0x1, %al
callq 0x290f0
movq 0x30(%rsp), %rdi
callq 0x38db0
movl %eax, %esi
leaq 0x22faee(%rip), %rdi    # 0x2665d0
movb $0x0, %al
callq 0x290f0
movq 0x2b84d8(%rip), %rax    # 0x2eefc8
movq (%rax), %rdi
callq 0x29910
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x29c10
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/gapsview/gapsview.cpp
// Function: ReadMeshFile(char const*)
static R3Mesh *
ReadMeshFile(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  if (!mesh) {
    RNFail("Unable to allocate mesh for %s\n", filename);
    return NULL;
  }

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1c7070
movq 0x10(%rsp), %rdi
callq 0x38bc0
movl $0x138, %edi            # imm = 0x138
callq 0x292e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x117b50
jmp 0x36b5e
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x36bb3
movq 0x48(%rsp), %rsi
leaq 0x22fa65(%rip), %rdi    # 0x2665e1
movb $0x0, %al
callq 0x1cbff0
movq $0x0, 0x50(%rsp)
jmp 0x36c93
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0x291f0
jmp 0x36c9d
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x36bf4
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x36be6
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x36c93
cmpl $0x0, 0x2c80c1(%rip)    # 0x2fecbc
je 0x36c89
movq 0x48(%rsp), %rsi
leaq 0x22f9f4(%rip), %rdi    # 0x266601
movb $0x0, %al
callq 0x290f0
leaq 0x38(%rsp), %rdi
callq 0x1c7130
leaq 0x22f7a3(%rip), %rdi    # 0x2663c8
movb $0x1, %al
callq 0x290f0
movq 0x30(%rsp), %rdi
callq 0x39030
movl %eax, %esi
leaq 0x22f9d9(%rip), %rdi    # 0x266618
movb $0x0, %al
callq 0x290f0
movq 0x30(%rsp), %rdi
callq 0x3a740
movl %eax, %esi
leaq 0x22f9cf(%rip), %rdi    # 0x266628
movb $0x0, %al
callq 0x290f0
movq 0x30(%rsp), %rdi
callq 0x391c0
movl %eax, %esi
leaq 0x22f9c5(%rip), %rdi    # 0x266638
movb $0x0, %al
callq 0x290f0
movq 0x2b8347(%rip), %rax    # 0x2eefc8
movq (%rax), %rdi
callq 0x29910
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x29c10
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::~GSVScene()
GSVScene::
~GSVScene(void)
{
  // Delete runs
  while (NRuns() > 0) delete Run(0);

  // Delete filename
  if (filename) free(filename);

  // Delete raw data directory name
  if (raw_data_directory_name) free(raw_data_directory_name);

  // Delete cache data_directory name
  if (cache_data_directory_name) free(cache_data_directory_name);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x2ab7f6(%rip), %rcx    # 0x2e6840
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x39f90
movl %eax, 0x14(%rsp)
jmp 0x3b061
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jle 0x3b095
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x39fb0
movq %rax, 0x8(%rsp)
jmp 0x3b07d
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x3b093
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3b051
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3b0af
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x29350
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3b0c9
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x29350
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3b0e3
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x29350
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
callq 0x15c1b0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x386c0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x442f0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x44300
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::Run(char const*) const
GSVRun *GSVScene::
Run(const char *name) const
{
  // Return run with matching name
  for (int ir = 0; ir < NRuns(); ir++) {
    GSVRun *run = Run(ir);
    if (!run->Name()) continue;
    if (!strcmp(run->Name(), name)) return run;
  }

  // None found
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b1e8
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44310
cmpq $0x0, %rax
jne 0x3b1b1
jmp 0x3b1db
movq 0x10(%rsp), %rdi
callq 0x44310
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x29f00
cmpl $0x0, %eax
jne 0x3b1d9
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3b1f1
jmp 0x3b1db
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3b170
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NSegments() const
int GSVScene::
NSegments(void) const
{
  // Return number of segments in scene
  int count = 0;
  for (int ir = 0; ir < NRuns(); ir++) {
    GSVRun *run = Run(ir);
    count += run->NSegments();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b271
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39fe0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b223
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NCameras() const
int GSVScene::
NCameras(void) const
{
  // Return number of cameras in scene
  int count = 0;
  for (int ir = 0; ir < NRuns(); ir++) {
    GSVRun *run = Run(ir);
    count += run->NCameras();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b2f1
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44320
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b2a3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NTapestries() const
int GSVScene::
NTapestries(void) const
{
  // Return number of tapestries in scene
  int count = 0;
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    count += run->NTapestries();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b371
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45430
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b323
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NPanoramas() const
int GSVScene::
NPanoramas(void) const
{
  // Return number of panoramas in scene
  int count = 0;
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    count += run->NPanoramas();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b3f1
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x454b0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b3a3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NImages() const
int GSVScene::
NImages(void) const
{
  // Return number of images in scene
  int count = 0;
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    count += run->NImages();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b471
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45530
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b423
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NLasers() const
int GSVScene::
NLasers(void) const
{
  // Return number of lasers in scene
  int count = 0;
  for (int ir = 0; ir < NRuns(); ir++) {
    GSVRun *run = Run(ir);
    count += run->NLasers();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b4f1
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44340
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b4a3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NSurveys() const
int GSVScene::
NSurveys(void) const
{
  // Return number of surveys in scene
  int count = 0;
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    count += run->NSurveys();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b571
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x455b0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b523
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NScans() const
int GSVScene::
NScans(void) const
{
  // Return number of scans in scene
  int count = 0;
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    count += run->NScans();
  }
  return count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b5f1
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45630
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b5a3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::NPoints() const
int GSVScene::
NPoints(void) const
{
  // Return number of points in all runs
  int npoints = 0;
  for (int i = 0; i < NRuns(); i++) 
    npoints += Run(i)->NPoints();
  return npoints;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b6ea
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x39fb0
movq %rax, %rdi
callq 0x45730
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b6a3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::RemoveRun(gaps::GSVRun*)
void GSVScene::
RemoveRun(GSVRun *run)
{
  // Just checking
  assert(run->scene_index >= 0);
  assert(run->scene_index < runs.NEntries());
  assert(run->scene == this);

  // Remove run
  RNArrayEntry *entry = runs.KthEntry(run->scene_index);
  GSVRun *tail = runs.Tail();
  tail->scene_index = run->scene_index;
  runs.EntryContents(entry) = tail;
  runs.RemoveTail();
  run->scene_index = -1;
  run->scene = NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq 0x28(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x44390
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x443b0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x443c0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq %rcx, (%rax)
addq $0x8, %rdi
callq 0x443d0
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::Draw(gaps::RNFlags) const
void GSVScene::
Draw(RNFlags flags) const
{
  // Draw runs
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    run->Draw(flags);
  }
}

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

  // Print scene header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "%s", "GSVScene");
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

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

   // Print runs
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    run->Print(fp, indented_prefix, suffix);
  }
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movq %rdx, 0x430(%rsp)
movq %rcx, 0x428(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x438(%rsp)
jne 0x3b8d1
movq 0x2b3702(%rip), %rax    # 0x2eefc8
movq (%rax), %rax
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x430(%rsp)
je 0x3b8fa
movq 0x438(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x244934(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x438(%rsp), %rdi
leaq 0x24491e(%rip), %rsi    # 0x280227
leaq 0x22b1dd(%rip), %rdx    # 0x266aed
movb $0x0, %al
callq 0x293c0
cmpq $0x0, 0x428(%rsp)
je 0x3b940
movq 0x438(%rsp), %rdi
movq 0x428(%rsp), %rdx
leaq 0x2448ee(%rip), %rsi    # 0x280227
movb $0x0, %al
callq 0x293c0
movq 0x438(%rsp), %rdi
leaq 0x22b4b7(%rip), %rsi    # 0x266e06
movb $0x0, %al
callq 0x293c0
leaq 0x20(%rsp), %rdi
movq 0x430(%rsp), %rdx
leaq 0x22b18c(%rip), %rsi    # 0x266af6
movb $0x0, %al
callq 0x2a280
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3b9d5
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x438(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x428(%rsp), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3b979
addq $0x448, %rsp            # imm = 0x448
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::SetRawDataDirectoryName(char const*)
void GSVScene::
SetRawDataDirectoryName(const char *directory_name)
{
  // Set name of directory to store rawd data
  if (this->raw_data_directory_name) free(this->raw_data_directory_name);
  if (directory_name) this->raw_data_directory_name = RNStrdup(directory_name);
  else this->raw_data_directory_name = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rax)
je 0x3ba0b
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x29350
cmpq $0x0, 0x8(%rsp)
je 0x3ba2a
movq 0x8(%rsp), %rdi
callq 0x1cbcf0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x3ba36
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::SetCacheDataDirectoryName(char const*)
void GSVScene::
SetCacheDataDirectoryName(const char *directory_name)
{
  // Set name of directory to store cached data
  if (this->cache_data_directory_name) free(this->cache_data_directory_name);
  if (directory_name) this->cache_data_directory_name = RNStrdup(directory_name);
  else this->cache_data_directory_name = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rax)
je 0x3ba6b
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x29350
cmpq $0x0, 0x8(%rsp)
je 0x3ba8a
movq 0x8(%rsp), %rdi
callq 0x1cbcf0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3ba96
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::UpdateBBox()
void GSVScene::
UpdateBBox(void) 
{
  // Update bounding box
  bbox = R3null_box;
  for (int i = 0; i < NRuns(); i++) {
    bbox.Union(Run(i)->BBox());
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x30, %rdi
leaq 0x2c67fa(%rip), %rsi    # 0x3024f8
callq 0x386d0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x3bd61
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %esi
callq 0x39fb0
movq %rax, %rdi
callq 0x44400
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1538e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3bd0b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::UpdateNormals()
void GSVScene::
UpdateNormals(void) 
{
  // Update normals
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    run->UpdateNormals();
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3be81
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45f40
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3be3b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::InvalidateNormals()
void GSVScene::
InvalidateNormals(void) 
{
  // Invalidate normals
  for (int i = 0; i < NRuns(); i++) {
    GSVRun *run = Run(i);
    run->InvalidateNormals();
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x39f90
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3bef1
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x39fb0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45fb0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3beab
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::WriteFile(char const*) const
int GSVScene::
WriteFile(const char *filename) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    RNFail("Filename %s has no extension (e.g., .gsv)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  if (!strncmp(extension, ".gsv", 4)) return WriteGSVFile(filename);

  // Did not recognize extension
  RNFail("Unable to write file %s (unrecognized extension: %s)\n", filename, extension);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x2e, %esi
callq 0x2a110
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x3c43e
movq 0x10(%rsp), %rsi
leaq 0x22a734(%rip), %rdi    # 0x266b61
movb $0x0, %al
callq 0x1cbff0
movl $0x0, 0x24(%rsp)
jmp 0x3c48e
movq 0x8(%rsp), %rdi
leaq 0x22a0f3(%rip), %rsi    # 0x26653d
movl $0x4, %edx
callq 0x29440
cmpl $0x0, %eax
jne 0x3c46e
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, 0x24(%rsp)
jmp 0x3c48e
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x22a751(%rip), %rdi    # 0x266bd0
movb $0x0, %al
callq 0x1cbff0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::ReadGSVFile(char const*, int)
int GSVScene::
ReadGSVFile(const char *filename, RNBoolean read_points)
{
  // Get version
  int major_version = GetGSVMajorVersion(filename);
  
  // Open file
  FILE *fp = fopen(filename, "rb");
  if (!fp) {
    RNFail("Unable to open GSV scene file: %s\n", filename);
    return 0;
  }

  // Read file
  if (major_version < 1) {
    if (!ReadGSVStreamFromOldVersion(fp)) return 0;
  }
  else {
    if (!ReadGSVStream(fp)) return 0;
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x3d1e0
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x229b8b(%rip), %rsi    # 0x266cc1
callq 0x2a520
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3d165
movq 0x20(%rsp), %rsi
leaq 0x229ab2(%rip), %rdi    # 0x266c06
movb $0x0, %al
callq 0x1cbff0
movl $0x0, 0x34(%rsp)
jmp 0x3d1c9
cmpl $0x1, 0x18(%rsp)
jge 0x3d191
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x3d360
cmpl $0x0, %eax
jne 0x3d18f
movl $0x0, 0x34(%rsp)
jmp 0x3d1c9
jmp 0x3d1b7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x58(%rax)
cmpl $0x0, %eax
jne 0x3d1b5
movl $0x0, 0x34(%rsp)
jmp 0x3d1c9
jmp 0x3d1b7
movq 0x10(%rsp), %rdi
callq 0x297e0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::GetGSVMajorVersion(char const*)
int GSVScene::
GetGSVMajorVersion(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "rb");
  if (!fp) {
    RNFail("Unable to open GSV scene file: %s\n", filename);
    return 0;
  }

  // Read magic keyword
  char magic[16] = { '\0' };
  if (fread(magic, sizeof(char), 16, fp) != (unsigned int) 16) {
    RNFail("Unable to read first bytes from GSV scene file\n");
    fclose(fp);
    return 0;
  }

  // Check magic keyword
  if (strcmp(magic, "GSV")) {
    RNFail("Invalid file format for GSV scene file\n");
    fclose(fp);
    return 0;
  }

  // Read header
  int dummy0, major_version;
  unsigned long long dummy1;
  fread(&dummy0, sizeof(int), 1, fp);
  fread(&dummy0, sizeof(int), 1, fp);
  fread(&dummy1, sizeof(unsigned long long), 1, fp);
  fread(&dummy0, sizeof(int), 1, fp);
  fread(&major_version, sizeof(int), 1, fp);

  // Close file
  fclose(fp);

  // Return major version
  return major_version;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x229ac7(%rip), %rsi    # 0x266cc1
callq 0x2a520
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3d22c
movq 0x30(%rsp), %rsi
leaq 0x2299ee(%rip), %rdi    # 0x266c06
movb $0x0, %al
callq 0x1cbff0
movl $0x0, 0x44(%rsp)
jmp 0x3d349
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x295e0
leaq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x299d0
cmpq $0x10, %rax
je 0x3d281
leaq 0x229a64(%rip), %rdi    # 0x266cc7
movb $0x0, %al
callq 0x1cbff0
movq 0x28(%rsp), %rdi
callq 0x297e0
movl $0x0, 0x44(%rsp)
jmp 0x3d349
leaq 0x10(%rsp), %rdi
leaq 0x229a6a(%rip), %rsi    # 0x266cf7
callq 0x29f00
cmpl $0x0, %eax
je 0x3d2bc
leaq 0x229a5d(%rip), %rdi    # 0x266cfb
movb $0x0, %al
callq 0x1cbff0
movq 0x28(%rsp), %rdi
callq 0x297e0
movl $0x0, 0x44(%rsp)
jmp 0x3d349
movq 0x28(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x28(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x28(%rsp), %rcx
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x28(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x28(%rsp), %rdi
callq 0x297e0
movl 0x8(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::WriteGSVFile(char const*) const
int GSVScene::
WriteGSVFile(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "wb");
  if (!fp) {
    RNFail("Unable to open GSV scene file: %s\n", filename);
    return 0;
  }

  // Write file
  if (!WriteGSVStream(fp)) return 0;

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
leaq 0x227ac1(%rip), %rsi    # 0x266cc4
callq 0x2a520
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3f232
movq 0x10(%rsp), %rsi
leaq 0x2279e5(%rip), %rdi    # 0x266c06
movb $0x0, %al
callq 0x1cbff0
movl $0x0, 0x24(%rsp)
jmp 0x3f262
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x0, %eax
jne 0x3f250
movl $0x0, 0x24(%rsp)
jmp 0x3f262
movq 0x8(%rsp), %rdi
callq 0x297e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/GSV/GSVScene.cpp
// Function: gaps::GSVScene::ReadScanlinePointsFromOldVersion(_IO_FILE*, gaps::GSVScanline*)
int GSVScene::
ReadScanlinePointsFromOldVersion(FILE *fp, GSVScanline *scanline)
{
  // Get current file offset
  scanline->file_offset = RNFileTell(fp);

  // Read number of points
  int npoints;
  fread(&npoints, sizeof(int), 1, fp);
  if (npoints == 0) return 1;

  // Allocate points
  GSVPoint *points = new GSVPoint [ npoints ];
  if (!points) return 0;
  
  // Read positions
  for (int i = 0; i < npoints; i++) {
    R3Point position;
    fread(&position, sizeof(R3Point), 1, fp);
    points[i].SetPosition(position);
  }

  // Set points
  scanline->SetPoints(points, npoints);

  // Delete positions
  delete [] points;

  // Return success
  return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1caef0
movq %rax, %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x80(%rsp), %rcx
leaq 0x74(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x299d0
cmpl $0x0, 0x74(%rsp)
jne 0x44158
movl $0x1, 0x94(%rsp)
jmp 0x442be
movslq 0x74(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x50, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, 0x28(%rsp)
callq 0x29820
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rsp)
cmpq $0x0, %rax
je 0x441e2
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq $0x50, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5ee80
jmp 0x441ca
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
addq $0x50, %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x441b9
movq 0x38(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x44226
movl $0x0, 0x94(%rsp)
jmp 0x442be
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x29030
jmp 0x442cd
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x74(%rsp), %eax
jge 0x44286
leaq 0x40(%rsp), %rdi
callq 0x17fd80
movq 0x80(%rsp), %rcx
leaq 0x40(%rsp), %rdi
movl $0x18, %esi
movl $0x1, %edx
callq 0x299d0
movq 0x68(%rsp), %rdi
movslq 0x58(%rsp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x44e10
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x4422e
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x74(%rsp), %edx
callq 0x574f0
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x442b3
movq 0x8(%rsp), %rdi
callq 0x296f0
movl $0x1, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x29c10
nopw (%rax,%rax)