LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::SetPoints(gaps::GSVPoint const*, int)
void GSVScanline::
SetPoints(const GSVPoint *points, int npoints) 
{
  // Delete previous points
  if (this->points) delete [] this->points;

  // Reset everything
  this->npoints = npoints;
  this->points = NULL;
  this->bbox = R3null_box;

  // Copy points
  if (points && (npoints > 0)) {
    // Allocate points 
    this->points = new GSVPoint [ npoints ];
    if (!this->points) {
      RNAbort("Unable to allocate points for scanline\n");
    }
    
    // Copy points
    for (int i = 0; i < npoints; i++) {
      this->points[i] = points[i];
    }

    // Update bounding box
    for (int i = 0; i < npoints; i++) {
      bbox.Union(this->points[i].Position());
    }
  }

  // Set read count
  read_count = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x41552
callq 0x27cb0
movl %ebp, 0x30(%rbx)
movq $0x0, 0x28(%rbx)
leaq 0x90(%rbx), %rdi
leaq 0x19f43d(%rip), %r15    # 0x1e09a8
leaq 0x8(%r15), %rsi
callq 0xd619c
leaq 0xa8(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0xd619c
testq %r14, %r14
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x4165a
leaq 0x88(%rbx), %r15
movl %ebp, 0xc(%rsp)
movl %ebp, %eax
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
movq %r12, %rdi
callq 0x27040
movq %rax, %r13
xorl %ebp, %ebp
movq %r13, %rdi
addq %rbp, %rdi
callq 0x459f0
addq $0x50, %rbp
cmpq %rbp, %r12
jne 0x415bc
movq %r13, 0x28(%rbx)
xorl %eax, %eax
leaq (%r14,%rax), %rsi
movq 0x28(%rbx), %rcx
leaq (%rcx,%rax), %rdi
movzwl 0x4c(%r14,%rax), %edx
movw %dx, 0x4c(%rcx,%rax)
movl 0x48(%r14,%rax), %edx
movl %edx, 0x48(%rcx,%rax)
movl $0x9, %ecx
rep  movsq (%rsi), %es:(%rdi)
addq $0x50, %rax
cmpq %rax, %r12
jne 0x415d6
movl 0xc(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
movq 0x28(%rbx), %rax
movsd (%rax,%r13), %xmm0
movsd 0x8(%rax,%r13), %xmm1
movsd 0x10(%rax,%r13), %xmm2
movq %r14, %rdi
callq 0xd5e2e
movq %r15, %rdi
movq %r14, %rsi
callq 0xbfa56
addq $0x50, %r13
cmpq %r13, %r12
jne 0x41626
movl $0x1, 0x20(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x28340
movq %rbx, %rdi
callq 0x28160
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::SetPose(gaps::GSVPose const&)
void GSVScanline::
SetPose(const GSVPose& pose)
{
  // Update points
  if ((NPoints() > 0) && (points) && (!(this->pose.Orientation().IsZero()))) {
    // Determine transformation of points
    R4Matrix matrix = R4identity_matrix;
    matrix.Translate(pose.Viewpoint().Vector());
    matrix.Multiply(pose.Orientation().Matrix());
    matrix.Multiply(this->pose.Orientation().Inverse().Matrix());
    matrix.Translate(-this->pose.Viewpoint().Vector());
    R3Affine transformation(matrix, 0);
    
    // Transform points
    for (int i = 0; i < npoints; i++) {
      points[i].Transform(transformation);
    }
  }

  // Set pose
  this->pose = pose;

  // Invalidate bounding box
  InvalidateBBox();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jle 0x41814
cmpq $0x0, 0x28(%rbx)
je 0x41814
movupd 0x58(%rbx), %xmm0
movupd 0x68(%rbx), %xmm1
xorpd %xmm2, %xmm2
cmpneqpd %xmm2, %xmm1
cmpneqpd %xmm2, %xmm0
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movmskps %xmm0, %eax
testl %eax, %eax
je 0x41814
leaq 0x58(%rbx), %r12
leaq 0x111d5c(%rip), %rsi    # 0x153440
leaq 0x1b8(%rsp), %r15
movq %r15, %rdi
callq 0xc4102
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x18(%r14), %xmm2
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xd68c6
movq %r15, %rdi
movq %r13, %rsi
callq 0xc523c
leaq 0x20(%r14), %rsi
leaq 0x138(%rsp), %r13
movq %r13, %rdi
callq 0xc37dc
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc60f3
movq %r15, %rdi
movq %rbp, %rsi
callq 0xc5ce6
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xc395c
leaq 0x138(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xc37dc
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc60f3
movq %r15, %rdi
movq %r13, %rsi
callq 0xc5ce6
movsd 0x40(%rbx), %xmm0
movsd 0x48(%rbx), %xmm1
movsd 0x50(%rbx), %xmm2
leaq 0x138(%rsp), %r12
movq %r12, %rdi
callq 0xd68c6
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xd755c
movq %r15, %rdi
movq %r13, %rsi
callq 0xc523c
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc1d76
cmpl $0x0, 0x30(%rbx)
jle 0x4180a
xorl %r12d, %r12d
leaq 0x28(%rsp), %r15
xorl %r13d, %r13d
movq 0x28(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x42fa8
incq %r13
movslq 0x30(%rbx), %rax
addq $0x50, %r12
cmpq %rax, %r13
jl 0x417eb
leaq 0x28(%rsp), %rdi
callq 0xc1dc4
leaq 0x40(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0xd619c
leaq 0x58(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0xc3158
movq %rbx, %rdi
callq 0x41860
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xc1dc4
movq %rbx, %rdi
callq 0x28160
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::Draw(gaps::RNFlags) const
void GSVScanline::
Draw(RNFlags flags) const
{
  // Just checking
  if (NPoints() == 0) return;
  assert(points);

  // Draw scanline
  if (flags & GSV_DRAW_SCANLINES_WITH_POINT_INDEX_COLOR) {
    const int ncolors = 3;
    GLfloat color[3][3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
    RNLength max_edge_length_squared = 1;
    RNGrfxBegin(RN_GRFX_LINES);
    R3Point prev_point = PointPosition(0);
    for (int ik = 1; ik < NPoints(); ik++) {
      const R3Point& current_point = PointPosition(ik);
      RNScalar dx = prev_point[0] - current_point[0];
      RNScalar dy = prev_point[1] - current_point[1];
      RNScalar dd = dx*dx + dy*dy;
      if (dd < max_edge_length_squared) {
        RNLoadRgb(color[(int) (0.1 * (NPoints()-ik)) % ncolors]);
        R3LoadPoint(prev_point);
        R3LoadPoint(current_point);
      }
      prev_point = current_point;
    }
    RNGrfxEnd();
  }
  else {
    // Draw points
    RNGrfxBegin(RN_GRFX_POINTS);
    LoadPoints(flags);
    RNGrfxEnd();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x0, 0x30(%rdi)
je 0x41a75
movq %rsi, %r14
movq %rdi, %rbx
btl $0xc, %r14d
jb 0x41944
xorl %edi, %edi
callq 0x271a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41a84
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27ce0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rsp)
movl %eax, 0x10(%rsp)
movl %eax, 0x20(%rsp)
movl $0x1, %edi
callq 0x271a0
movq 0x28(%rbx), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0x28(%rsp), %rdi
callq 0xd5e2e
cmpl $0x2, 0x30(%rbx)
jl 0x41a70
movl $0x1, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x60, %r13d
leaq 0x40(%rsp), %r14
leaq 0x28(%rsp), %r15
movq 0x28(%rbx), %rax
movsd -0x10(%rax,%r13), %xmm0
movsd -0x8(%rax,%r13), %xmm1
movsd (%rax,%r13), %xmm2
movq %r14, %rdi
callq 0xd5e2e
movsd 0x28(%rsp), %xmm0
subsd 0x40(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
subsd 0x48(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10c691(%rip), %xmm1   # 0x14e088
ucomisd %xmm0, %xmm1
jbe 0x41a4f
movl 0x30(%rbx), %eax
addl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x10c6a7(%rip), %xmm0   # 0x14e0b8
cvttsd2si %xmm0, %eax
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%rsp,%rax,4), %rdi
callq 0x27380
movq %r15, %rdi
callq 0x271c0
movq %r14, %rdi
callq 0x271c0
movq %r15, %rdi
movq %r14, %rsi
callq 0xd619c
incq %r12
movslq 0x30(%rbx), %rax
decl %ebp
addq $0x50, %r13
cmpq %rax, %r12
jl 0x419ab
callq 0x27ce0
addq $0x58, %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/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::Print(_IO_FILE*, char const*, char const*) const
void GSVScanline::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print scanline header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Scanline %d:", scan_index);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");

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

  // Print points
  // ???
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
testq %rsi, %rsi
jne 0x42b7d
movq 0x194396(%rip), %rax    # 0x1d6f10
movq (%rax), %r14
testq %rbx, %rbx
je 0x42b8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27aa0
movl 0x10(%r12), %edx
leaq 0x10c707(%rip), %rsi    # 0x14f2a0
movq %r14, %rdi
xorl %eax, %eax
callq 0x27e10
testq %r15, %r15
je 0x42bb3
movq %r15, %rdi
movq %r14, %rsi
callq 0x27aa0
movl $0xa, %edi
movq %r14, %rsi
callq 0x27c40
leaq 0x10be1d(%rip), %rsi    # 0x14e9e4
movq %rsp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x27140
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::FindPointIndexWithClosestBeamIndex(int) const
int GSVScanline::
FindPointIndexWithClosestBeamIndex(int query_beam_index) const
{
  // Initialize result
  int closest_delta = INT_MAX;
  int closest_point_index = -1;

  // Search for closest point (by beam index)
  for (int i = 0; i < npoints; i++) {
    const GSVPoint *point = &points[i];
    int delta = abs(point->BeamIndex() - query_beam_index);
    if (delta < closest_delta) {
      closest_delta = delta;
      closest_point_index = i;
      if (closest_delta == 0) break;
    }
  }

  // Return closest point index
  return closest_point_index;
}

// Assembly:
movslq 0x30(%rdi), %rcx
testq %rcx, %rcx
jle 0x42c40
pushq %rbx
movq 0x28(%rdi), %rdx
addq $0x46, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movl %eax, %r10d
movzbl (%rdx), %eax
subl %esi, %eax
setne %r11b
movl %eax, %r9d
negl %r9d
cmovsl %eax, %r9d
cmpl %edi, %r9d
setge %bl
movl %r8d, %eax
cmovgel %r10d, %eax
orb %r11b, %bl
je 0x42c3e
cmpl %edi, %r9d
cmovll %r9d, %edi
incq %r8
addq $0x50, %rdx
cmpq %r8, %rcx
jne 0x42c03
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::UpdateBBox()
void GSVScanline::
UpdateBBox(void) 
{
  // Just checking
  assert(read_count > 0);
  assert(points);

  // Update bounding box
  bbox = R3null_box;
  for (int i = 0; i < NPoints(); i++) {
    bbox.Union(PointPosition(i));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x90, %rdi
leaq 0x19dd2a(%rip), %r14    # 0x1e09a8
leaq 0x8(%r14), %rsi
callq 0xd619c
leaq 0xa8(%rbx), %rdi
addq $0x20, %r14
movq %r14, %rsi
callq 0xd619c
cmpl $0x0, 0x30(%rbx)
jle 0x42cf0
leaq 0x88(%rbx), %r14
movl $0x10, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq 0x28(%rbx), %rax
movsd -0x10(%rax,%r12), %xmm0
movsd -0x8(%rax,%r12), %xmm1
movsd (%rax,%r12), %xmm2
movq %r15, %rdi
callq 0xd5e2e
movq %r14, %rdi
movq %r15, %rsi
callq 0xbfa56
incq %r13
movslq 0x30(%rbx), %rax
addq $0x50, %r12
cmpq %rax, %r13
jl 0x42cb5
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVScanline.cpp
// Function: gaps::GSVScanline::WritePoints(_IO_FILE*, int)
int GSVScanline::
WritePoints(FILE *fp, RNBoolean seek) 
{
  // Seek within file
  if (seek && (file_offset > 0)) {
    // Seek to file offset
    if (!RNFileSeek(fp, file_offset, RN_FILE_SEEK_SET)) {
      RNFail("Unable to seek to scanline points\n");
      return 0;
    }
  }
  else {
    // Update file offset
    file_offset = RNFileTell(fp);
  }

  // Write number of points 
  if (fwrite(&npoints, sizeof(int), 1, fp) != (unsigned int) 1) {
    RNFail("Unable to write number of scanline points\n");
    return 0;
  }

  // Write points
  if (npoints > 0) {
    if (fwrite(points, sizeof(GSVPoint), npoints, fp) != (unsigned int) npoints) {
      RNFail("Unable to write scanline points\n");
      return 0;
    }
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x42f0b
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x42f0b
movq %r14, %rdi
xorl %edx, %edx
callq 0xfc9e6
testl %eax, %eax
jne 0x42f17
leaq 0x10c3a4(%rip), %rdi    # 0x14f2ad
jmp 0x42f6c
movq %r14, %rdi
callq 0xfc9f7
movq %rax, 0x18(%rbx)
leaq 0x30(%rbx), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x28330
cmpq $0x1, %rax
jne 0x42f65
movslq (%r15), %rdx
movl $0x1, %ebp
testq %rdx, %rdx
jle 0x42f75
movq 0x28(%rbx), %rdi
movl $0x50, %esi
movq %r14, %rcx
callq 0x28330
movl 0x30(%rbx), %ecx
cmpq %rcx, %rax
je 0x42f75
leaq 0x10c3e2(%rip), %rdi    # 0x14f345
jmp 0x42f6c
leaq 0x10c3ae(%rip), %rdi    # 0x14f31a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xfd64a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/./GSVPoint.h
// Function: gaps::GSVPoint::Transform(gaps::R3Transformation const&)
inline void GSVPoint::
Transform(const R3Transformation& transformation)
{
  // Transform position and normal
  R3Point position = Position();
  R3Vector normal = Normal();
  R3Vector tangent = Tangent();
  position.Transform(transformation);
  normal.Transform(transformation);
  tangent.Transform(transformation);
  SetPosition(position);
  SetNormal(normal);
  SetTangent(tangent);

  // Transform radii
  double scale = transformation.ScaleFactor();
  if (RNIsNotEqual(scale, 1.0)) {
    for (int i = 0; i < 2; i++) {
      double r = this->radius[i];
      r *= fabs(scale);
      if (r > 64000) r = 64000;
      this->radius[i] = r;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xd5e2e
xorps %xmm0, %xmm0
cvtss2sd 0x20(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x24(%rbx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x28(%rbx), %xmm2
movq %rsp, %r12
movq %r12, %rdi
callq 0xd68c6
xorps %xmm0, %xmm0
cvtss2sd 0x2c(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x30(%rbx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x34(%rbx), %xmm2
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0xd68c6
movq %r15, %rdi
movq %r14, %rsi
callq 0xd674a
movq %r12, %rdi
movq %r14, %rsi
callq 0xd74a2
movq %r13, %rdi
movq %r14, %rsi
callq 0xd74a2
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x10(%r12), %xmm0
movhpd (%r13), %xmm0           # xmm0 = xmm0[0],mem[0]
cvtpd2ps %xmm0, %xmm0
cvtpd2ps (%r12), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd %xmm1, 0x20(%rbx)
movupd 0x8(%r13), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x30(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
leaq 0x1953d5(%rip), %rax    # 0x1d8468
movsd (%rax), %xmm1
movsd 0x10afd1(%rip), %xmm2   # 0x14e070
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
ja 0x430b7
xorpd 0x10bbff(%rip), %xmm1   # 0x14ecb0
ucomisd %xmm2, %xmm1
jbe 0x430f2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
andpd 0x10bdfd(%rip), %xmm0   # 0x14eec0
movq 0x40(%rbx), %xmm1
xorpd %xmm2, %xmm2
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
cvtdq2pd %xmm1, %xmm1
mulpd %xmm0, %xmm1
movapd 0x10c1b0(%rip), %xmm0   # 0x14f290
minpd %xmm1, %xmm0
cvttpd2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movd %xmm0, 0x40(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::~GSVMesh()
GSVMesh::
~GSVMesh(void)
{
  // Delete everything
  Empty();

  // Delete search tree
  if (search_tree) delete search_tree;

  // Delete vertices
  if (gsv_vertex_block) delete [] gsv_vertex_block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18b9fd(%rip), %rax    # 0x1ceb30
movq %rax, (%rdi)
callq 0xa4a9c
movq 0x140(%rbx), %r14
testq %r14, %r14
je 0x4315c
movq %r14, %rdi
callq 0x9277a
movl $0x18, %esi
movq %r14, %rdi
callq 0x27950
movq 0x138(%rbx), %r15
testq %r15, %r15
je 0x431a8
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x43195
addq $-0xa8, %r15
imulq $0xa8, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0xb491c
addq $-0xa8, %r13
jne 0x43183
imulq $0xa8, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x28340
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa26ea
movq %rax, %rdi
callq 0x39936
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::VertexHeight(gaps::R3MeshVertex*) const
RNScalar GSVMesh::
VertexHeight(R3MeshVertex *v) const
{
  // Return vertex height
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  GSVScanline *scanline = vertex->scanline;
  if (!scanline) return RN_UNKNOWN;
  RNCoord groundZ = scanline->EstimatedGroundZ();
  const R3Point& position = VertexPosition(vertex);
  return position.Z() - groundZ;
}

// Assembly:
movq 0x98(%rsi), %rdi
testq %rdi, %rdi
je 0x4321a
pushq %rbx
movq %rsi, %rbx
callq 0x412bc
movapd %xmm0, %xmm1
movsd 0x28(%rbx), %xmm0
subsd %xmm1, %xmm0
popq %rbx
retq
movsd 0x10ae4e(%rip), %xmm0   # 0x14e070
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::VertexLaserAngle(gaps::R3MeshVertex*) const
RNScalar GSVMesh::
VertexLaserAngle(R3MeshVertex *v) const
{
  // Return vertex angle
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  GSVScanline *scanline = vertex->scanline;
  if (!scanline) return RN_UNKNOWN;
  const GSVPose& pose = scanline->Pose();
  const R3Point& viewpoint = pose.Viewpoint();
  const R3Vector& towards = pose.Towards();
  R3Vector up = pose.Up();
  const R3Point& position = VertexPosition(vertex);
  R3Vector vec = position - viewpoint;
  RNLength distance = vec.Length();
  if (RNIsZero(distance)) return RN_UNKNOWN;
  vec /= distance;
  RNScalar dot = vec.Dot(towards);
  RNAngle angle = acos(dot);
  if (vec.Dot(up) > 0) angle = RN_PI_OVER_TWO + angle;
  else angle = RN_PI_OVER_TWO - angle;
  return angle;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq 0x98(%rsi), %rbx
testq %rbx, %rbx
je 0x432a0
movq %rsi, %r14
leaq 0x38(%rbx), %r15
addq $0x40, %rbx
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x455c6
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x4560c
addq $0x18, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd6090
movq %r15, %rdi
callq 0xd69cc
leaq 0x1951e4(%rip), %rax    # 0x1d8468
movsd (%rax), %xmm1
movapd 0x10ba20(%rip), %xmm2   # 0x14ecb0
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x432aa
ucomisd %xmm0, %xmm1
jb 0x432aa
movsd 0x10adc8(%rip), %xmm0   # 0x14e070
jmp 0x43310
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xd74f4
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xd6b5e
callq 0x278b0
movapd %xmm0, (%rsp)
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xd6b5e
movapd %xmm0, %xmm1
leaq 0x116fe2(%rip), %rax    # 0x15a2c8
movapd 0x10b9c2(%rip), %xmm2   # 0x14ecb0
movapd (%rsp), %xmm3
xorpd %xmm3, %xmm2
xorpd %xmm0, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
addsd (%rax), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::VertexLaserDepth(gaps::R3MeshVertex*) const
RNScalar GSVMesh::
VertexLaserDepth(R3MeshVertex *v) const
{
  // Return vertex depth
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  GSVScanline *scanline = vertex->scanline;
  if (!scanline) return RN_UNKNOWN;
  const GSVPose& pose = scanline->Pose();
  R3Vector towards = pose.Towards();
  const R3Point& viewpoint = pose.Viewpoint();
  const R3Point& position = VertexPosition(vertex);
  R3Vector vec = position - viewpoint;
  RNScalar depth = vec.Dot(towards);
  return depth;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x98(%rsi), %rbx
testq %rbx, %rbx
je 0x4336d
movq %rsi, %r14
leaq 0x38(%rbx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x455c6
addq $0x40, %rbx
addq $0x18, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd6090
movq %r12, %rdi
movq %r15, %rsi
callq 0xd6b5e
jmp 0x43375
movsd 0x10acfb(%rip), %xmm0   # 0x14e070
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::VertexLaserTowards(gaps::R3MeshVertex*) const
R3Vector GSVMesh::
VertexLaserTowards(R3MeshVertex *v) const
{
  // Return vertex viewpoint
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  GSVScanline *scanline = vertex->scanline;
  if (!scanline) return R3zero_vector;
  const GSVPose& pose = scanline->Pose();
  return pose.Towards();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdx), %rsi
testq %rsi, %rsi
je 0x433f0
addq $0x38, %rsi
movq %rbx, %rdi
callq 0x455c6
jmp 0x433ff
leaq 0x115949(%rip), %rsi    # 0x158d40
movq %rbx, %rdi
callq 0xd68d6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::VertexLaserUp(gaps::R3MeshVertex*) const
R3Vector GSVMesh::
VertexLaserUp(R3MeshVertex *v) const
{
  // Return vertex viewpoint
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  GSVScanline *scanline = vertex->scanline;
  if (!scanline) return R3zero_vector;
  const GSVPose& pose = scanline->Pose();
  return pose.Up();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdx), %rsi
testq %rsi, %rsi
je 0x43422
addq $0x38, %rsi
movq %rbx, %rdi
callq 0x4560c
jmp 0x43431
leaq 0x115917(%rip), %rsi    # 0x158d40
movq %rbx, %rdi
callq 0xd68d6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::CreateVertex(gaps::R3Point const&, gaps::R3MeshVertex*)
R3MeshVertex *GSVMesh::
CreateVertex(const R3Point& position, R3MeshVertex *v)
{
  // Create GSV vertex
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  if (!v) {
    vertex = new GSVMeshVertex();
    vertex->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Fill in GSV stuff
  vertex->scanline = NULL;
  vertex->point_index = -1;
  vertex->boundary_type = GSV_MESH_NO_BOUNDARY;

  // Fill in R3Mesh stuff 
  return R3Mesh::CreateVertex(position, vertex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
jne 0x4405d
movl $0xa8, %edi
callq 0x27930
movq %rax, %rbx
movq %rax, %rdi
callq 0xb487c
leaq 0x18ae31(%rip), %rax    # 0x1cee70
movq %rax, (%rbx)
movq $0x0, 0x98(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%rbx)
orb $0x1, 0x78(%rbx)
movq $0x0, 0x98(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xa5596
movq %rax, %r14
movl $0xa8, %esi
movq %rbx, %rdi
callq 0x27950
movq %r14, %rdi
callq 0x28160
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::CreateVertex(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3MeshVertex*)
R3MeshVertex *GSVMesh::
CreateVertex(const R3Point& position, const R3Vector& normal, R3MeshVertex *v)
{
  // Create GSV vertex
  GSVMeshVertex *vertex = (GSVMeshVertex *) v;
  if (!vertex) {
    vertex = new GSVMeshVertex();
    vertex->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Fill in GSV stuff
  vertex->scanline = NULL;
  vertex->point_index = -1;
  vertex->boundary_type = GSV_MESH_NO_BOUNDARY;

  // Fill in R3Mesh stuff 
  return R3Mesh::CreateVertex(position, normal, vertex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
jne 0x440f3
movl $0xa8, %edi
callq 0x27930
movq %rax, %rbx
movq %rax, %rdi
callq 0xb487c
leaq 0x18ad9b(%rip), %rax    # 0x1cee70
movq %rax, (%rbx)
movq $0x0, 0x98(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%rbx)
orb $0x1, 0x78(%rbx)
movq $0x0, 0x98(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xa0(%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa5610
movq %rax, %r14
movl $0xa8, %esi
movq %rbx, %rdi
callq 0x27950
movq %r14, %rdi
callq 0x28160
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::Draw(int) const
void GSVMesh::
Draw(RNBoolean texture_coordinates) const
{
  if (texture_coordinates) {
    RNGrfxBegin(RN_GRFX_TRIANGLES);
    for (int i = 0; i < NFaces(); i++) {
      GSVMeshFace *face = Face(i);
      R3LoadNormal(FaceNormal(face));
      GSVMeshVertex *v0 = VertexOnFace(face, 0);
      int s0 = VertexScanlineIndex(v0);
      int t0 = (int) (180.0 * VertexLaserAngle(v0) / RN_PI + 0.5);
      R3LoadTextureCoords(s0, t0);
      R3LoadPoint(VertexPosition(v0));
      GSVMeshVertex *v1 = VertexOnFace(face, 1);
      int s1 = VertexScanlineIndex(v1);
      int t1 = (int) (180.0 * VertexLaserAngle(v1) / RN_PI + 0.5);
      R3LoadTextureCoords(s1, t1);
      R3LoadPoint(VertexPosition(v1));
      GSVMeshVertex *v2 = VertexOnFace(face, 2);
      int s2 = VertexScanlineIndex(v2);
      int t2 = (int) (180.0 * VertexLaserAngle(v2) / RN_PI + 0.5);
      R3LoadTextureCoords(s2, t2);
      R3LoadPoint(VertexPosition(v2));
    }
    RNGrfxEnd();
  }
  else {
    DrawFaces();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x442dd
movl $0x4, %edi
callq 0x271a0
cmpl $0x0, 0x34(%rbx)
jle 0x442ca
leaq 0x11611d(%rip), %rax    # 0x15a2b8
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %r14
testb $0x4, 0xa8(%r14)
jne 0x441c8
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x2c8(%rax)
leaq 0x38(%r14), %rdi
callq 0x27e90
movq 0x8(%r14), %r15
movq 0x98(%r15), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x441f0
movl 0x10(%rax), %r12d
movq %r15, %rsi
callq 0x43224
mulsd 0x10aaa0(%rip), %xmm0   # 0x14eca0
divsd (%rsp), %xmm0
addsd 0x109e03(%rip), %xmm0   # 0x14e010
cvttsd2si %xmm0, %esi
movl %r12d, %edi
callq 0x276d0
addq $0x18, %r15
movq %r15, %rdi
callq 0x271c0
movq 0x10(%r14), %r15
movq 0x98(%r15), %rax
testq %rax, %rax
je 0x44238
movl 0x10(%rax), %ebp
movq %r15, %rsi
callq 0x43224
mulsd 0x10aa58(%rip), %xmm0   # 0x14eca0
divsd (%rsp), %xmm0
addsd 0x109dbb(%rip), %xmm0   # 0x14e010
cvttsd2si %xmm0, %esi
movl %ebp, %edi
callq 0x276d0
addq $0x18, %r15
movq %r15, %rdi
callq 0x271c0
movq 0x18(%r14), %r14
movq 0x98(%r14), %rax
testq %rax, %rax
je 0x44281
movl 0x10(%rax), %ebp
jmp 0x44286
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x43224
mulsd 0x10aa0a(%rip), %xmm0   # 0x14eca0
divsd (%rsp), %xmm0
addsd 0x109d6d(%rip), %xmm0   # 0x14e010
cvttsd2si %xmm0, %esi
movl %ebp, %edi
callq 0x276d0
addq $0x18, %r14
movq %r14, %rdi
callq 0x271c0
incq %r13
movslq 0x34(%rbx), %rax
cmpq %rax, %r13
jl 0x441a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27ce0
movq (%rbx), %rax
movq 0x138(%rax), %rax
movl $0x772, %esi            # imm = 0x772
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVMesh.cpp
// Function: gaps::GSVMesh::Intersection(gaps::R3Ray const&, gaps::R3MeshIntersection*, double, double, int (*)(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Mesh*, gaps::R3MeshFace*, void*), void*) const
R3MeshType GSVMesh::
Intersection(const R3Ray& ray, R3MeshIntersection *intersection, 
  RNScalar min_t, RNScalar max_t,
  int (*IsCompatible)(const R3Point&, const R3Vector&, R3Mesh *, R3MeshFace *, void *), 
  void *compatible_data) const
{
  // Create search tree
  if (!search_tree) {
    GSVMesh *mesh = (GSVMesh *) this;
    mesh->search_tree = new R3MeshSearchTree((R3Mesh *) this);
    if (!search_tree) {
      RNFail("Unable to build mesh search tree\n");
      return R3_MESH_NULL_TYPE;
    }
  }

  // Use search tree to find intersection
  R3MeshIntersection closest;
  search_tree->FindIntersection(ray, closest, min_t, max_t, IsCompatible, compatible_data);
  if (intersection) *intersection = closest;
  return closest.type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
cmpq $0x0, 0x140(%rdi)
jne 0x44372
movl $0x18, %edi
callq 0x27930
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
callq 0x92664
movq %r13, 0x140(%rbp)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0xd5e2c
movq 0x140(%rbp), %rdi
leaq 0x18(%rsp), %rdx
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r15, %rcx
movq %r14, %r8
callq 0x95996
testq %rbx, %rbx
je 0x443d2
movups 0x18(%rsp), %xmm0
movups 0x28(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x20(%rbx), %rdi
movq %r13, %rsi
callq 0xd619c
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movl 0x18(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r13, %rdi
callq 0x27950
movq %rbx, %rdi
callq 0x28160
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Towards() const
const R3Vector GSVPose::
Towards(void) const
{
  // Return vector along view direction
  R4Matrix rotation = orientation.Matrix();
  R3Vector towards = rotation * R3negz_vector;
  towards.Normalize();
  return towards;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x20, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc37dc
leaq 0x1137fd(%rip), %rdx    # 0x158de8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc6186
movq %rbx, %rdi
callq 0xd6be8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Up() const
const R3Vector GSVPose::
Up(void) const
{
  // Return up vector
  R4Matrix rotation = orientation.Matrix();
  R3Vector up = rotation * R3posy_vector;
  up.Normalize();
  return up;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x20, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc37dc
leaq 0x113757(%rip), %rdx    # 0x158d88
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc6186
movq %rbx, %rdi
callq 0xd6be8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Right() const
const R3Vector GSVPose::
Right(void) const
{
  // Return up vector
  R4Matrix rotation = orientation.Matrix();
  R3Vector right = rotation * R3posx_vector;
  right.Normalize();
  return right;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x20, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc37dc
leaq 0x1136f9(%rip), %rdx    # 0x158d70
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc6186
movq %rbx, %rdi
callq 0xd6be8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Matrix() const
const R4Matrix GSVPose::
Matrix(void) const
{
  // Return matrix (std -> pose)
  R4Matrix matrix = R4identity_matrix;
  matrix.Translate(viewpoint.Vector());
  matrix.Multiply(orientation.Matrix());
  return matrix;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10dd8f(%rip), %rsi    # 0x153440
callq 0xc4102
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x18(%r14), %xmm2
movq %rsp, %r15
movq %r15, %rdi
callq 0xd68c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc523c
addq $0x20, %r14
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc37dc
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xc60f3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc5ce6
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Draw(gaps::RNFlags) const
void GSVPose::
Draw(RNFlags flags) const
{
  // Draw viewpoint
  R3Sphere(viewpoint, 0.1).Draw();

  // Draw towards vector
  R3Span(viewpoint, viewpoint + Towards()).Draw();

  // Draw up vector
  R3Span(viewpoint, viewpoint + 0.5 * Up()).Draw();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x30(%rsp), %r15
movsd 0x1088ea(%rip), %xmm0   # 0x14e0b8
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbca82
movl $0x772, %esi            # imm = 0x772
movq %r15, %rdi
callq 0x92364
leaq 0x30(%rsp), %rdi
callq 0xbfe90
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x455c6
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xd6179
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xd52b2
movq %r15, %rdi
callq 0x90c2a
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4560c
movq %rsp, %r14
movsd 0x1087c6(%rip), %xmm0   # 0x14e010
movq %r14, %rdi
movq %r15, %rsi
callq 0xd7296
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd6179
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xd52b2
movq %r14, %rdi
callq 0x90c2a
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbfe90
movq %rbx, %rdi
callq 0x28160
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVPose::Print(_IO_FILE*, char const*, char const*) const
void GSVPose::
Print(FILE *fp, const char *prefix, const char *suffix) const
{
  // Check fp
  if (!fp) fp = stdout;

  // Print pose header
  if (prefix) fprintf(fp, "%s", prefix);
  fprintf(fp, "Pose:   %g %g %g   %g %g %g %g", 
    viewpoint[0], viewpoint[1], viewpoint[2], 
    orientation[0], orientation[1], orientation[2], orientation[3]);
  if (suffix) fprintf(fp, "%s", suffix);
  fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
jne 0x458c5
movq 0x19164e(%rip), %rax    # 0x1d6f10
movq (%rax), %rbx
testq %rdx, %rdx
je 0x458d5
movq %rdx, %rdi
movq %rbx, %rsi
callq 0x27aa0
movsd 0x8(%r15), %xmm0
movsd 0x10(%r15), %xmm1
movsd 0x18(%r15), %xmm2
movsd 0x20(%r15), %xmm3
movsd 0x28(%r15), %xmm4
movsd 0x30(%r15), %xmm5
movsd 0x38(%r15), %xmm6
leaq 0x109e3b(%rip), %rsi    # 0x14f741
movq %rbx, %rdi
movb $0x7, %al
callq 0x27e10
testq %r14, %r14
je 0x45920
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27aa0
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x27c40
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/GSV/GSVPose.cpp
// Function: gaps::GSVInterpolatedPose(gaps::GSVPose const&, gaps::GSVPose const&, double)
GSVPose 
GSVInterpolatedPose(const GSVPose& pose0, const GSVPose& pose1, RNScalar t)
{
  // Return interpolated pose (with spherical interpolation of orientation)
  R3Point viewpoint = (1-t)*pose0.Viewpoint() + t*pose1.Viewpoint();
  R3Quaternion orientation = R3QuaternionSlerp(pose0.Orientation(), pose1.Orientation(), t);
  return GSVPose(viewpoint, orientation);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x10872e(%rip), %xmm0   # 0x14e088
subsd %xmm1, %xmm0
addq $0x8, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xd6878
leaq 0x8(%r14), %rsi
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movsd (%rsp), %xmm0
callq 0xd6878
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd6832
addq $0x20, %r15
addq $0x20, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movsd (%rsp), %xmm0
callq 0xc2fbb
leaq 0x189501(%rip), %rax    # 0x1ceec0
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbp, %rsi
callq 0xd5e3e
movq %rbx, %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0xc2f66
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/flowers.cpp
// Function: getMinimumPrice(std::vector<int, std::allocator<int>>, int)
int getMinimumPrice(vector<int> flowers, int K) {
    int p = 0;
    int N = flowers.size();
    int x = 0;
    int c = 0;
    vector<int> m = vector<int>(N, 0);

    sort(flowers.begin(), flowers.end());
    for (int i = N - 1; i >= 0; i--) {
        m[i] = x;
        c++;
        if (c >= K) {
            x++;
            c = 0;
        }
    }

    for (int i = 0; i < N; i++)
        p += (m[i] + 1) * flowers[i];

    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
movslq %r12d, %rsi
leaq 0x2c(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x14ce
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x12be
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x16dd
movq %r14, %rdi
movq %r15, %rsi
callq 0x17c0
testl %r12d, %r12d
jle 0x12f8
movq 0x10(%rsp), %rax
movl %r12d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
incq %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
movl %esi, -0x8(%rax,%rcx,4)
incl %edi
xorl %r8d, %r8d
cmpl %ebp, %edi
cmovgel %edx, %edi
setge %r8b
addl %r8d, %esi
decq %rcx
cmpq $0x1, %rcx
jg 0x12da
testl %r12d, %r12d
jle 0x1325
movq 0x10(%rsp), %rax
movq (%rbx), %rcx
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ebx, %ebx
movl (%rax,%rdx,4), %esi
incl %esi
imull (%rcx,%rdx,4), %esi
addl %esi, %ebx
incq %rdx
cmpq %rdx, %r12
jne 0x1310
jmp 0x1327
xorl %ebx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x133e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1367
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/flowers.cpp
// Function: main
int main() {
    int N, K, f;
    cin >> N >> K;

    vector<int> flowers;
    for (int i = 0; i < N; i++) {
        cin >> f;
        flowers.push_back(f);
    }

    cout << getMinimumPrice(flowers, K) << endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2c60(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x13fe
xorl %ebp, %ebp
movq 0x2c27(%rip), %rbx      # 0x3fe0
leaq 0x4(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x13eb
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x13f6
movq %r15, %rdi
movq %r14, %rdx
callq 0x1a30
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x13c3
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1642
movl 0x8(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x124c
movq 0x2bae(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x146a
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1481
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14ac
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14af
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x14af
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14c6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Tokens.cxx
// Function: Tokens::open(char const*)
int Tokens::open(const char *filename)
{
  in = fopen(filename, "rb");

  if (in == NULL)
  {
    return -1;
  }

  this->filename = filename;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x499a(%rip), %rsi      # 0x71b7
movq %rbx, %rdi
callq 0x2200
movq %rax, (%r14)
testq %rax, %rax
je 0x2855
movq 0x10(%r14), %r12
addq $0x8, %r14
movq %rbx, %rdi
callq 0x20e0
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x22b0
jmp 0x285b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/MidiFile.cxx
// Function: MidiFile::write_int32(int)
int MidiFile::write_int32(int n)
{
  putc(((n >> 24) & 0xff), out);
  putc(((n >> 16) & 0xff), out);
  putc(((n >> 8) & 0xff), out);
  putc((n & 0xff), out);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
shrl $0x18, %edi
movq (%r14), %rsi
callq 0x2330
movl %ebx, %edi
shrl $0x10, %edi
movl $0xff, %ebp
andl %ebp, %edi
movq (%r14), %rsi
callq 0x2330
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
movq (%r14), %rsi
callq 0x2330
andl %ebp, %ebx
movq (%r14), %rsi
movl %ebx, %edi
callq 0x2330
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Pattern.cxx
// Function: Pattern::add(unsigned char, unsigned char, unsigned char, unsigned int)
void Pattern::add(
  uint8_t value,
  uint8_t volume,
  uint8_t channel,
  uint32_t duration)
{
  Data current;

  current.value = value;
  current.volume = volume;
  current.channel = channel;
  current.duration = duration;

  data.push_back(current);
}

// Assembly:
pushq %rax
movb %sil, (%rsp)
movb %dl, 0x1(%rsp)
movb %cl, 0x2(%rsp)
movl %r8d, 0x4(%rsp)
movq 0x28(%rdi), %rsi
cmpq 0x30(%rdi), %rsi
je 0x3148
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rdi)
jmp 0x3154
addq $0x20, %rdi
movq %rsp, %rdx
callq 0x31ac
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Pattern.cxx
// Function: Pattern::print()
void Pattern::print()
{
  printf("  -- Pattern %s -- \n", name.c_str());

  for (auto it = data.begin(); it != data.end(); it++)
  {
    printf("   value: %d, volume: %d, channel: %d, duration: %d\n",
      it->value,
      it->volume,
      it->channel,
      it->duration);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x412f(%rip), %rdi      # 0x7297
xorl %eax, %eax
callq 0x2050
movq 0x20(%rbx), %r15
cmpq 0x28(%rbx), %r15
je 0x31a6
leaq 0x412c(%rip), %r14      # 0x72ac
movzbl (%r15), %esi
movzbl 0x1(%r15), %edx
movzbl 0x2(%r15), %ecx
movl 0x4(%r15), %r8d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
addq $0x8, %r15
cmpq 0x28(%rbx), %r15
jne 0x3180
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Section.cxx
// Function: Section::print()
void Section::print()
{
  printf("  -- Section -- \n");

  for (auto it = patterns.begin(); it != patterns.end(); it++)
  {
    printf(" %d", *it);
  }

  printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3f86(%rip), %rdi      # 0x72ff
callq 0x22a0
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x33a5
leaq 0x3f6d(%rip), %r14      # 0x72fb
movl (%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
addq $0x4, %r15
cmpq 0x8(%rbx), %r15
jne 0x338e
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/mikeakohn[P]drumsplusplus/build/../src/Song.cxx
// Function: Song::parse(Tokens*)
int Song::parse(Tokens *tokens)
{
  int token_type;
  char token[1024];

#ifndef WINDOWS
  signal_catch(0);
  play_timer.it_value.tv_sec = 0;
  play_timer.it_value.tv_usec = 0;
#endif

  while(1)
  {
    token_type = tokens->get(token);

    if (token_type == -1) { break; }

    if (strcmp(token, "set") == 0)
    {
      if (parse_set(tokens) == -1) { return -1; }
    }
      else
    if (strcmp(token, "define") == 0)
    {
      if (parse_define(tokens) == -1) { return -1; }
    }
      else
    if (strcmp(token, "include") == 0)
    {
      if (parse_include(tokens) == -1) { return -1; }
    }
      else
    if (strcmp(token, "pattern") == 0)
    {
      if (parse_pattern(tokens) == -1) { return -1; }
    }
      else
    if (strcmp(token, "section") == 0)
    {
      if (parse_section(tokens) == -1) { return -1; }
    }
      else
    if (strcmp(token, "song") == 0)
    {
      if (parse_song(tokens) == -1) { return -1; }
    }
      else
    {
      printf("Error: Unknown token '%s' at %s:%d.\n",
        token, tokens->get_filename(), tokens->get_line());
      return -1;
    }
  }

#ifdef WINDOWS
  Sleep(1000);
#endif

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %r15
leaq 0x132(%rip), %rsi       # 0x3728
movl $0x1b, %edi
callq 0x2210
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2880
xorl %ebx, %ebx
cmpl $-0x1, %eax
je 0x3714
movq %rsp, %r12
movl $0x69666564, %ebp       # imm = 0x69666564
movl $0x656e69, %r13d        # imm = 0x656E69
cmpl $0x746573, (%rsp)       # imm = 0x746573
jne 0x3648
movq %r15, %rdi
movq %r14, %rsi
callq 0x373a
jmp 0x36db
movl (%rsp), %eax
xorl %ebp, %eax
movl 0x3(%rsp), %ecx
xorl %r13d, %ecx
orl %eax, %ecx
je 0x3696
movq (%rsp), %rax
movabsq $0x6e726574746170, %rcx # imm = 0x6E726574746170
cmpq %rcx, %rax
je 0x36b0
movabsq $0x6e6f6974636573, %rcx # imm = 0x6E6F6974636573
cmpq %rcx, %rax
je 0x36a3
movabsq $0x6564756c636e69, %rcx # imm = 0x6564756C636E69
cmpq %rcx, %rax
jne 0x36bd
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c38
jmp 0x36db
movq %r15, %rdi
movq %r14, %rsi
callq 0x3aa2
jmp 0x36db
movq %r15, %rdi
movq %r14, %rsi
callq 0x4648
jmp 0x36db
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d9e
jmp 0x36db
movl (%rsp), %eax
movl $0x676e6f73, %ecx       # imm = 0x676E6F73
xorl %ecx, %eax
movzbl 0x4(%rsp), %ecx
orl %eax, %ecx
jne 0x36f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x4988
cmpl $-0x1, %eax
je 0x370f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2880
cmpl $-0x1, %eax
jne 0x362f
jmp 0x3714
movq 0x8(%r14), %rdx
movl 0x2c(%r14), %ecx
leaq 0x3c23(%rip), %rdi      # 0x7328
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq