LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::InsertPoint(int, gaps::R2Point const&)
void R2Polygon::
InsertPoint(int k, const R2Point& position)
{
    // Add point in position k, moving others starting at k+1 up to make room
    R2Point *p = new R2Point [npoints+1];
    for (int i = 0; i < k; i++) p[i] = points[i];
    p[k] = position;
    for (int i = k; i < npoints; i++) p[i+1] = points[i];
    if (points) delete [] points;
    points = p;
    npoints++;
    
    // Update bounding box
    bbox.Union(position);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %r14
movl 0x10(%rdi), %ebx
leal 0x1(%rbx), %eax
movslq %eax, %r13
shlq $0x4, %r13
cmpl $-0x1, %ebx
pushq $-0x1
popq %r12
cmovgeq %r13, %r12
movq %r12, %rdi
callq 0xe030
movq %rax, %r15
incl %ebx
je 0x5c107
xorl %ebx, %ebx
leaq (%r15,%rbx), %rdi
callq 0x5f58a
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0x5c0f5
xorl %r12d, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
shlq $0x4, %r13
movq (%rsp), %rbx
cmpq %r12, %r13
je 0x5c139
movq 0x8(%r14), %rsi
addq %r12, %rsi
leaq (%r15,%r12), %rdi
callq 0x5f6c4
addq $0x10, %r12
jmp 0x5c11e
movslq %ebp, %r12
movq %r12, %r13
shlq $0x4, %r13
movq %rbx, %rsi
leaq (%r15,%r13), %rdi
callq 0x5f6c4
movslq 0x10(%r14), %rax
movq 0x8(%r14), %rsi
cmpq %rax, %r12
jge 0x5c168
incq %r12
addq %r13, %rsi
addq $0x10, %r13
jmp 0x5c146
testq %rsi, %rsi
je 0x5c179
movq %rsi, %rdi
callq 0xe5d0
movl 0x10(%r14), %eax
movq %r15, 0x8(%r14)
incl %eax
movl %eax, 0x10(%r14)
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5d088
movq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0xe8f0
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::SetPoint(int, gaps::R2Point const&)
void R2Polygon::
SetPoint(int k, const R2Point& position)
{
    // Set point
    points[k] = position;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rdi
shlq $0x4, %rdi
addq 0x8(%rbx), %rdi
movq %rdx, %rsi
callq 0x5f6c4
leaq 0x18(%rbx), %r14
leaq 0x480d09(%rip), %rsi    # 0x4dcee8
movq %r14, %rdi
callq 0x51550
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x5c20e
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x5d088
incq %r12
addq $0x10, %r15
jmp 0x5c1ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::Clip(gaps::R2Box const&)
void R2Polygon::
Clip(const R2Box& box) 
{
  // Clip to each side of box
  if (npoints == 0) return;
  Clip(R2Line(1, 0, -(box.XMin())));
  if (npoints == 0) return;
  Clip(R2Line(-1, 0, box.XMax()));
  if (npoints == 0) return;
  Clip(R2Line(0, 1, -(box.YMin())));
  if (npoints == 0) return;
  Clip(R2Line(0, -1, box.YMax()));
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
je 0x5c6ad
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x8(%rsi), %xmm2
xorps 0x36a4b(%rip), %xmm2    # 0x93030
leaq 0x8(%rsp), %r15
movsd 0x36a16(%rip), %xmm0    # 0x93008
xorps %xmm1, %xmm1
movq %r15, %rdi
callq 0x5f080
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x78(%rax)
cmpl $0x0, 0x10(%rbx)
je 0x5c6a4
movsd 0x18(%r14), %xmm2
leaq 0x8(%rsp), %r15
movsd 0x369fa(%rip), %xmm0    # 0x93020
xorps %xmm1, %xmm1
movq %r15, %rdi
callq 0x5f080
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x78(%rax)
cmpl $0x0, 0x10(%rbx)
je 0x5c6a4
movsd 0x10(%r14), %xmm2
xorps 0x369e0(%rip), %xmm2    # 0x93030
leaq 0x8(%rsp), %r15
movsd 0x369ab(%rip), %xmm1    # 0x93008
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x5f080
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x78(%rax)
cmpl $0x0, 0x10(%rbx)
je 0x5c6a4
movsd 0x20(%r14), %xmm2
leaq 0x8(%rsp), %r14
movsd 0x36993(%rip), %xmm1    # 0x93020
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x5f080
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x78(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::Transform(gaps::R2Transformation const&)
void R2Polygon::
Transform(const R2Transformation& transformation) 
{
  // Transform points
  bbox = R2null_box;
  for (int i = 0; i < npoints; i++) {
    points[i].Transform(transformation);
    bbox.Union(points[i]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
leaq 0x480820(%rip), %rsi    # 0x4dcee8
movq %r15, %rdi
callq 0x51550
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jge 0x5c706
movq 0x8(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x5f6a0
movq 0x8(%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x5d088
incq %r13
addq $0x10, %r12
jmp 0x5c6d6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::operator=(gaps::R2Polygon const&)
R2Polygon& R2Polygon::
operator=(const R2Polygon& polygon) 
{
  // Delete previous points
  if (points) {
    delete points;
    points = NULL;
  }
  
  // Copy properties
  clockwise = polygon.clockwise;
  bbox = polygon.bbox;

  // Copy points
  npoints = polygon.npoints;
  if (npoints > 0) {
    points = new R2Point [ npoints ];
    for (int i = 0; i < npoints; i++) {
      points[i] = polygon.points[i];
    }
  }

  // Return this
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5c735
pushq $0x10
popq %rsi
callq 0xe460
andq $0x0, 0x8(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x51550
movslq 0x10(%r14), %r15
movl %r15d, 0x10(%rbx)
testq %r15, %r15
jle 0x5c7a9
shlq $0x4, %r15
movq %r15, %rdi
callq 0xe030
movq %rax, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
callq 0x5f58a
addq $0x10, %r13
cmpq %r13, %r15
jne 0x5c768
movq %r12, 0x8(%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x5c7a9
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x5f6c4
incq %r12
addq $0x10, %r15
jmp 0x5c784
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe8f0
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::Print(_IO_FILE*) const
void R2Polygon::
Print(FILE *fp) const
{
  // Print points
  fprintf(fp, "%d\n", npoints);
  for (int i = 0; i < npoints; i++) {
    fprintf(fp, "%12.6f %12.6f\n", points[i].X(), points[i].Y());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %edx
leaq 0x374e4(%rip), %rsi     # 0x93cc9
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe6a0
pushq $0x8
popq %r13
leaq 0x3dfd3(%rip), %r15     # 0x9a7d0
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0x5c82d
movq 0x8(%r14), %rax
movsd -0x8(%rax,%r13), %xmm0
movsd (%rax,%r13), %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movb $0x2, %al
callq 0xe6a0
incq %r12
addq $0x10, %r13
jmp 0x5c7fd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Polygon.cpp
// Function: gaps::R2Polygon::ReadTheraFile(char const*)
int R2Polygon::
ReadTheraFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open polygon file: %s\n", filename);
    return 0;
  }

  // Read header line
  int ndimensions;
  double polygon_depth, sample_spacing;
  if (fscanf(fp, "%d %d %lf %lf", &ndimensions, &npoints, &polygon_depth, &sample_spacing) != 4) {
    RNFail("Unable to read polygon file header: %s\n", filename);
    return 0;
  }

  // Allocate points
  points = new R2Point [ npoints ];
  if (!points) {
    RNFail("Unable to allocate points for polygon: %s\n", filename);
    return 0;
  }

  // Read points
  for (int i = 0; i < npoints; i++) {
    double x, y;
    if (fscanf(fp, "%lf %lf", &x, &y) != 2) {
      RNFail("Unable to read point %d from polygon file %s\n", npoints, filename);
      return 0;
    }

    // Add point
    points[i].Reset(x,y);
    bbox.Union(points[i]);
  }

  // Close file
  fclose(fp);

  // Return success
  return npoints;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x402a0(%rip), %rsi     # 0x9caf3
movq %rbx, %rdi
callq 0xe550
testq %rax, %rax
je 0x5c93d
movq %rax, %r15
leaq 0x10(%r14), %r12
leaq 0x3df8e(%rip), %rsi     # 0x9a800
xorl %ebp, %ebp
leaq 0x24(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %rax, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0xe870
cmpl $0x4, %eax
jne 0x5c948
movq %rbx, 0x8(%rsp)
movslq (%r12), %rbx
movq %rbx, %rbp
shlq $0x4, %rbp
testq %rbx, %rbx
pushq $-0x1
popq %rdi
cmovnsq %rbp, %rdi
movq %rdi, (%rsp)
callq 0xe030
movq %rax, %r13
testq %rbx, %rbx
je 0x5c8d8
xorl %ebx, %ebx
leaq (%rbx,%r13), %rdi
callq 0x5f58a
addq $0x10, %rbx
cmpq %rbx, %rbp
jne 0x5c8c6
movq %r13, 0x8(%r14)
leaq 0x18(%r14), %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
movslq (%r12), %rax
cmpq %rax, %rbp
jge 0x5c96a
movq %r15, %rdi
leaq 0x3df0f(%rip), %rsi     # 0x9a806
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0xe870
cmpl $0x2, %eax
jne 0x5c978
movq 0x8(%r14), %rax
leaq (%rax,%rbx), %rsi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm0, (%rax,%rbx)
movsd %xmm1, 0x8(%rax,%rbx)
movq %r13, %rdi
callq 0x5d088
incq %rbp
addq $0x10, %rbx
jmp 0x5c8e4
leaq 0x3de9b(%rip), %rdi     # 0x9a7df
xorl %ebp, %ebp
jmp 0x5c94f
leaq 0x3debf(%rip), %rdi     # 0x9a80e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x681ca
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0xe440
movl (%r12), %ebp
jmp 0x5c959
movl (%r12), %esi
leaq 0x3deb3(%rip), %rdi     # 0x9a836
xorl %ebp, %ebp
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x681ca
jmp 0x5c959
movq %rax, %r14
movq %r13, %rdi
movq (%rsp), %rsi
callq 0xe8f0
movq %r14, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::IsFinite() const
const RNBoolean R2Box::
IsFinite (void) const
{
    // Return whether bounding box contains a finite amount of space
    if (IsEmpty()) return TRUE;
    if (!RNIsFinite(minpt.X())) return FALSE;
    if (!RNIsFinite(minpt.Y())) return FALSE;
    if (!RNIsFinite(maxpt.X())) return FALSE;
    if (!RNIsFinite(maxpt.Y())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x50606
testl %eax, %eax
je 0x5cc7a
pushq $0x1
popq %rax
popq %rbx
retq
movsd 0x8(%rbx), %xmm2
leaq 0x7df32(%rip), %rax     # 0xdabb8
movsd (%rax), %xmm1
movapd 0x3639e(%rip), %xmm0    # 0x93030
xorpd %xmm1, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm2
jbe 0x5cc78
ucomisd %xmm2, %xmm1
jbe 0x5cc78
movsd 0x10(%rbx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5cc78
ucomisd %xmm2, %xmm1
jbe 0x5cc78
movsd 0x18(%rbx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x5cc78
ucomisd %xmm2, %xmm1
jbe 0x5cc78
movsd 0x20(%rbx), %xmm2
cmpltpd %xmm2, %xmm0
cmpltpd %xmm1, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
jmp 0x5cc78
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::Corner(int) const
const R2Point R2Box::
Corner (RNQuadrant quadrant) const
{
    // Return corner point 
    switch (quadrant) {
    case RN_NN_QUADRANT: return minpt;
    case RN_NP_QUADRANT: return R2Point(minpt.X(), maxpt.Y());
    case RN_PN_QUADRANT: return R2Point(maxpt.X(), minpt.Y());
    case RN_PP_QUADRANT: return maxpt;
    default: RNAbort("Invalid quadrant for box corner"); return R2null_point;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x3, %edx
ja 0x5cd29
movl %edx, %eax
leaq 0x3db9c(%rip), %rcx     # 0x9a890
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsi
jmp 0x5cd3e
movsd 0x10(%rsi), %xmm1
movsd 0x18(%rsi), %xmm0
jmp 0x5cd1f
addq $0x18, %rsi
jmp 0x5cd3e
movsd 0x8(%rsi), %xmm0
movsd 0x20(%rsi), %xmm1
movq %rbx, %rdi
callq 0x5f58c
jmp 0x5cd46
leaq 0x3db7e(%rip), %rdi     # 0x9a8ae
xorl %eax, %eax
callq 0x680f0
leaq 0x480552(%rip), %rsi    # 0x4dd290
movq %rbx, %rdi
callq 0x5f596
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::ClosestPoint(gaps::R2Point const&) const
const R2Point R2Box::
ClosestPoint(const R2Point& point) const
{
    // Return closest point in box
    R2Point closest(point);
    if (closest.X() < XMin()) closest[RN_X] = XMin();
    else if (closest.X() > XMax()) closest[RN_X] = XMax();
    if (closest.Y() < YMin()) closest[RN_Y] = YMin();
    else if (closest.Y() > YMax()) closest[RN_Y] = YMax();
    return closest;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x5f596
movsd (%rbx), %xmm1
movsd 0x8(%r14), %xmm0
ucomisd %xmm1, %xmm0
ja 0x5cefe
movsd 0x18(%r14), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x5cf02
movsd %xmm0, (%rbx)
movsd 0x8(%rbx), %xmm1
movsd 0x10(%r14), %xmm0
ucomisd %xmm1, %xmm0
ja 0x5cf1f
movsd 0x20(%r14), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x5cf24
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::Inflate(double)
void R2Box::
Inflate (RNScalar fraction) 
{
  // Scale box around centroid by fraction
  if (IsEmpty()) return;
  R2Point centroid = Centroid();
  R2Vector diagonal = Max() - centroid;
  Reset(centroid - fraction * diagonal, centroid + fraction * diagonal);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x50606
testl %eax, %eax
jne 0x5d04f
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ce16
leaq 0x18(%rbx), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5f7c9
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x5fbe5
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5f7e9
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x5fbe5
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5f7b5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq *0x90(%rax)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::Transform(gaps::R2Transformation const&)
void R2Box::
Transform (const R2Transformation& transformation)
{
    // Do not transform empty box
    if (IsEmpty()) return;

    // Transform box ???
    R2Box tmp = R2null_box;
    for (RNQuadrant quadrant = 0; quadrant < RN_NUM_QUADRANTS; quadrant++) {
	R2Point corner(Corner(quadrant));
	corner.Transform(transformation);
	tmp.Union(corner);
    }
    *this = tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x50606
testl %eax, %eax
jne 0x5d269
leaq 0x47fd0e(%rip), %rsi    # 0x4dcee8
movq %rsp, %rdi
callq 0x5ca56
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
cmpl $0x4, %ebp
je 0x5d256
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5cce2
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f6a0
movsd 0x8(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x5d21e
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
ucomisd %xmm1, %xmm2
jbe 0x5d236
movsd %xmm1, 0x10(%rsp)
ucomisd 0x18(%rsp), %xmm0
jbe 0x5d244
movsd %xmm0, 0x18(%rsp)
ucomisd 0x20(%rsp), %xmm1
jbe 0x5d252
movsd %xmm1, 0x20(%rsp)
incl %ebp
jmp 0x5d1e9
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x51550
movq %rsp, %rdi
callq 0x5d2ee
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d276
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5d2ee
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::HasTranslation() const
const RNBoolean R3Matrix::
HasTranslation(void) const
{
    // Return whether matrix transformation has translation
    if (RNIsNotZero(m[0][2])) return TRUE;
    if (RNIsNotZero(m[1][2])) return TRUE;
    return FALSE;
}

// Assembly:
movsd 0x10(%rdi), %xmm2
leaq 0x7d22e(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x5d9b3
movapd 0x356a1(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x5d9b3
movsd 0x28(%rdi), %xmm2
cmpltpd %xmm2, %xmm0
cmpltpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::HasScale() const
const RNBoolean R3Matrix::
HasScale(void) const
{
    // Return whether matrix transformation has scale
    RNScalar d0 = m[0][0]*m[0][0] + m[1][0]*m[1][0];
    if (RNIsNotEqual(d0, 1.0)) return TRUE;
    RNScalar d1 = m[0][1]*m[0][1] + m[1][1]*m[1][1];
    if (RNIsNotEqual(d1, 1.0)) return TRUE;
    return FALSE;
}

// Assembly:
movsd (%rdi), %xmm2
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
leaq 0x7d1d8(%rip), %rax     # 0xdaba8
addsd 0x35648(%rip), %xmm2    # 0x93020
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x5da2a
movapd 0x35643(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x5da2a
movsd 0x8(%rdi), %xmm2
movsd 0x20(%rdi), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
addsd 0x3560b(%rip), %xmm2    # 0x93020
cmpltpd %xmm2, %xmm0
cmpltpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::HasRotation() const
const RNBoolean R3Matrix::
HasRotation(void) const
{
    // Return whether matrix transformation has rotation
    if (RNIsNotZero(m[0][1])) return TRUE;
    if (RNIsNotZero(m[1][0])) return TRUE;
    return FALSE;
}

// Assembly:
movsd 0x8(%rdi), %xmm2
leaq 0x7d170(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x5da71
movapd 0x355e3(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x5da71
movsd 0x18(%rdi), %xmm2
cmpltpd %xmm2, %xmm0
cmpltpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::HasMirror() const
const RNBoolean R3Matrix::
HasMirror(void) const
{
    // Return whether matrix transformation has mirror operator
    R2Vector vx(m[0][0], m[1][0]);
    R2Vector vy(m[0][1], m[1][1]);
    return RNIsNegative(vx % vy);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x5f8b4
movsd 0x8(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5f8b4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5fdfb
leaq 0x7d0ed(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
xorpd 0x35569(%rip), %xmm1    # 0x93030
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Determinant() const
const RNScalar R3Matrix::
Determinant(void) const
{
    // Return matrix determinant
    return R3MatrixDet3(
        m[0][0], m[0][1], m[0][2], 
        m[1][0], m[1][1], m[1][2], 
        m[2][0], m[2][1], m[2][2]);
}

// Assembly:
movsd 0x18(%rdi), %xmm0
movsd 0x20(%rdi), %xmm1
movsd 0x28(%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
movsd 0x38(%rdi), %xmm4
movsd 0x40(%rdi), %xmm5
movapd %xmm2, %xmm6
mulsd %xmm4, %xmm6
movapd %xmm1, %xmm7
mulsd %xmm5, %xmm7
subsd %xmm6, %xmm7
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm5
subsd %xmm2, %xmm5
mulsd 0x8(%rdi), %xmm5
mulsd (%rdi), %xmm7
subsd %xmm5, %xmm7
mulsd %xmm3, %xmm1
mulsd %xmm4, %xmm0
subsd %xmm1, %xmm0
mulsd 0x10(%rdi), %xmm0
addsd %xmm7, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Translate(int, double)
void R3Matrix:: 
Translate(RNAxis axis, RNScalar offset)
{
    // Translate matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XTranslate(offset); 
	break;

    case RN_YAXIS: 
	YTranslate(offset); 
	break;

    default: 
	RNWarning("Matrix translate along undefined axis");
	break;
    }
}

// Assembly:
cmpl $0x1, %esi
je 0x5de0c
testl %esi, %esi
jne 0x5de2f
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x10(%rdi)
mulsd 0x18(%rdi), %xmm0
jmp 0x5de24
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x10(%rdi)
mulsd 0x20(%rdi), %xmm0
addsd 0x28(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
retq
leaq 0x36068(%rip), %rdi     # 0x93e9e
xorl %eax, %eax
jmp 0x68283
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Scale(int, double)
void R3Matrix:: 
Scale(RNAxis axis, RNScalar scale)
{
    // Scale matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XScale(scale); 
	break;

    case RN_YAXIS: 
	YScale(scale); 
	break;

    default: 
	RNWarning("Matrix scale along undefined axis");
	break;
    }
}

// Assembly:
cmpl $0x1, %esi
je 0x5df18
testl %esi, %esi
jne 0x5df31
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
mulsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
retq
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
mulsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
retq
leaq 0x35f8c(%rip), %rdi     # 0x93ec4
xorl %eax, %eax
jmp 0x68283
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Rotate(double)
void R3Matrix:: 
Rotate(RNAngle radians)
{
    // rotate matrix counterclockwise 
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R3Matrix rotation(
        c,   -s,  0.0, 
        s,   c,   0.0, 
        0.0, 0.0, 1.0);
    *this *= rotation;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe890
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movaps 0x3506d(%rip), %xmm1    # 0x93030
xorps %xmm0, %xmm1
leaq 0x18(%rsp), %rsi
movsd 0x10(%rsp), %xmm2
movsd %xmm2, (%rsi)
movlps %xmm1, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
movsd %xmm0, 0x18(%rsi)
movsd %xmm2, 0x20(%rsi)
andq $0x0, 0x38(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rsi)
movq %rbx, %rdi
callq 0x5e454
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator-(gaps::R3Matrix const&)
R3Matrix 
operator-(const R3Matrix& a)
{
    // Negate matrix
    return R3Matrix(
   	-a.m[0][0], -a.m[0][1], -a.m[0][2], 
	-a.m[1][0], -a.m[1][1], -a.m[1][2], 
        -a.m[2][0], -a.m[2][1], -a.m[2][2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x40(%rsi), %xmm0
movaps 0x34e0d(%rip), %xmm1    # 0x93030
xorps %xmm1, %xmm0
movups (%rsi), %xmm2
xorps %xmm1, %xmm2
movups %xmm2, (%rdi)
movups 0x10(%rsi), %xmm2
xorps %xmm1, %xmm2
movups %xmm2, 0x10(%rdi)
movups 0x20(%rsi), %xmm2
xorps %xmm1, %xmm2
movups %xmm2, 0x20(%rdi)
movups 0x30(%rsi), %xmm2
xorps %xmm1, %xmm2
movups %xmm2, 0x30(%rdi)
movlps %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator*(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator*(const R3Matrix& a, const R3Matrix& b) 
{
    R3Matrix result;
    int r, c;

    // Multiply matrix
    for (r=0; r<3; r++)
	for (c=0; c<3; c++)
	    result.m[r][c] = a.m[r][0] * b.m[0][c] + 
		             a.m[r][1] * b.m[1][c] +
		             a.m[r][2] * b.m[2][c];

    // Return result
    return result;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x5e3c1
imulq $0x18, %rcx, %r8
movsd (%rsi,%r8), %xmm0
movsd 0x8(%rsi,%r8), %xmm1
movsd 0x10(%rsi,%r8), %xmm2
xorl %r8d, %r8d
cmpq $0x3, %r8
je 0x5e3b8
movsd 0x18(%rdx,%r8,8), %xmm3
mulsd %xmm1, %xmm3
movsd (%rdx,%r8,8), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x30(%rdx,%r8,8), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, (%rdi,%r8,8)
incq %r8
jmp 0x5e37f
incq %rcx
addq $0x18, %rdi
jmp 0x5e35e
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator*(gaps::R3Matrix const&, gaps::R2Vector const&)
R2Vector
operator*(const R3Matrix& a, const R2Vector& v)
{
    // Multiply matrix by vector
    RNCoord x = a.m[0][0] * v.X() + a.m[0][1] * v.Y();
    RNCoord y = a.m[1][0] * v.X() + a.m[1][1] * v.Y();
    return R2Vector(x, y);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdx), %xmm1
movsd 0x8(%rdx), %xmm2
movsd 0x8(%rsi), %xmm3
mulsd %xmm2, %xmm3
movsd (%rsi), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x20(%rsi), %xmm2
addsd %xmm3, %xmm0
mulsd 0x18(%rsi), %xmm1
addsd %xmm2, %xmm1
callq 0x5f8b4
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(gaps::R2Point const&, gaps::R2Vector const&)
R2Span::
R2Span(const R2Point& point, const R2Vector& vector)
    : end(point + vector)
{
    R2Vector v(vector);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5ee2e
leaq 0x38(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5f7b5
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5f8be
movq %r12, %rdi
callq 0x5f958
movsd %xmm0, 0x48(%r14)
leaq 0x7c60b(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x5e5b5
xorpd 0x34a81(%rip), %xmm1    # 0x93030
ucomisd %xmm0, %xmm1
jbe 0x5e5bf
leaq 0x8(%rsp), %rdi
callq 0x5fd1c
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ecee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(gaps::R2Point const&, gaps::R2Point const&)
R2Span::
R2Span(const R2Point& point1, const R2Point& point2)
    : end(point2)
{
    R2Vector v(point2 - point1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point1, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5ee2e
leaq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x5f596
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5f7c9
movq %r12, %rdi
callq 0x5f958
movsd %xmm0, 0x48(%r14)
leaq 0x7c57d(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x5e643
xorpd 0x349f3(%rip), %xmm1    # 0x93030
ucomisd %xmm0, %xmm1
jbe 0x5e64d
leaq 0x8(%rsp), %rdi
callq 0x5fd1c
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ecee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::R2Span(double, double, double, double)
R2Span::
R2Span(RNCoord x1, RNCoord y1, RNCoord x2, RNCoord y2)
    : end(x2, y2)
{
    R2Point p1(x1, y1);
    R2Point p2(x2, y2);
    R2Vector v(p2 - p1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(R2Point(x1, y1), v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm3, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
callq 0x5ee2e
leaq 0x38(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5f58c
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x5f58c
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x5f58c
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5f7c9
movq %r12, %rdi
callq 0x5f958
movsd %xmm0, 0x48(%rbx)
leaq 0x7c4a3(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x5e71d
xorpd 0x34919(%rip), %xmm1    # 0x93030
ucomisd %xmm0, %xmm1
jbe 0x5e727
leaq 0x28(%rsp), %rdi
callq 0x5fd1c
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x5f58c
leaq 0x28(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ecee
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::BBox() const
const R2Box R2Span::
BBox(void) const
{
    // Return bounding box 
    R2Box bbox(Start(), Start());
    bbox.Union(End());
    return bbox;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rdx
movq %rdx, %rsi
callq 0x5caa8
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5d088
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d2ee
movq %r14, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Reposition(int, gaps::R2Point const&)
void R2Span::
Reposition(int k, const R2Point& point)
{
    // Set one endpoint of span
    if (k == 0) ray = R2Ray(point, end);
    else { end = point; ray.Align(end - ray.Start()); }
    length = R2Distance(Start(), End());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x5e8ae
leaq 0x38(%rbx), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x5f6c4
leaq 0x28(%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f7c9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ed3e
jmp 0x5e8d0
leaq 0x38(%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5ee94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ed14
leaq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rsi
callq 0x63469
movsd %xmm0, 0x48(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Project(gaps::R2Line const&)
void R2Span::
Project(const R2Line& line)
{
    // Project span onto line
    length *= Vector().Dot(line.Vector());
    if (length < 0.0) length = -length;
    ray.Project(line);
    end.Project(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5fa20
mulsd 0x48(%r14), %xmm0
movapd 0x34727(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x48(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5efc2
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5f616
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Transform(gaps::R2Transformation const&)
void R2Span::
Transform (const R2Transformation& transformation)
{
    // Transform span
    end.Transform(transformation);
    ray.Transform(transformation);
    length = R2Distance(Start(), End());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x5f6a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5efe8
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x63469
movsd %xmm0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::InverseTransform(gaps::R2Transformation const&)
void R2Span::
InverseTransform (const R2Transformation& transformation)
{
    // Transform span
    end.InverseTransform(transformation);
    ray.InverseTransform(transformation);
    length = R2Distance(Start(), End());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x5f6b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f00e
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x63469
movsd %xmm0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Flip()
void R2Span::
Flip(void)
{
    // Flip direction of span
    R2Point swap = Start();
    ray.Reposition(end);
    end = swap;
    ray.Flip();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x5f596
leaq 0x38(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ed46
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f6c4
movq %rbx, %rdi
callq 0x5edb8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::operator==(gaps::R2Span const&) const
const RNBoolean R2Span::
operator==(const R2Span& span) const
{
    // Return whether span is equal
    if (Start() != span.Start()) return FALSE;
    if (End() != span.End()) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
addq $0x28, %rsi
callq 0x5f884
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x5ece5
addq $0x38, %r14
addq $0x38, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f884
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Ray.cpp
// Function: gaps::R2Ray::T(gaps::R2Point const&) const
const RNScalar R2Ray::
T(const R2Point& point) const
{
    // Return parametric value of closest point on ray
    RNScalar denom = Vector().Dot(Vector());
    if (RNIsZero(denom)) return 0.0;
    R2Vector topoint = point - Start();
    return (Vector().Dot(topoint) / denom);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %rsi
callq 0x5fa20
movapd %xmm0, %xmm2
leaq 0x7bc62(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
movapd 0x340de(%rip), %xmm0    # 0x93030
xorpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jb 0x5ef66
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
jae 0x5ef91
leaq 0x28(%rbx), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x5f7c9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fa20
divsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Mirror(gaps::R2Line const&)
void R2Line::
Mirror(const R2Line& line)
{
    // Mirror line over another line
    R2Point p = (normal * -c).Point();
    p.Mirror(line);
    vector.Mirror(line);
    normal = R2Vector(vector.Y(), -(vector.X()));
    c = -(normal.X()*p.X() + normal.Y()*p.Y());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movsd 0x20(%rdi), %xmm0
xorps 0x33d45(%rip), %xmm0    # 0x93030
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x5fbe5
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x5f9c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x5f624
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5fc10
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x33d01(%rip), %xmm1    # 0x93030
movq %rsp, %r12
movq %r12, %rdi
callq 0x5f8b4
movq %r14, %rdi
movq %r12, %rsi
callq 0x5fbfa
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r15), %xmm1
mulsd (%r15), %xmm0
addsd %xmm1, %xmm0
xorpd 0x33cca(%rip), %xmm0    # 0x93030
movlpd %xmm0, 0x20(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Align(gaps::R2Vector const&, int)
void R2Line::
Align(const R2Vector& vector, RNBoolean normalized)
{
    // Set vector of line
    this->vector = vector;
    if (!normalized) this->vector.Normalize();
    this->normal = R2Vector(this->vector.Y(), -this->vector.X());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0x5fbfa
testl %ebp, %ebp
jne 0x5f3fa
movq %rbx, %rdi
callq 0x5faa0
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x33c26(%rip), %xmm1    # 0x93030
movq %rsp, %r14
movq %r14, %rdi
callq 0x5f8b4
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fbfa
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::Transform(gaps::R2Transformation const&)
void R2Line::
Transform (const R2Transformation& transformation)
{
    // Transform line
    vector.Transform(transformation);
    vector.Normalize();
    normal = R2Vector(vector.Y(), -vector.X());
    R2Point p(Point());
    p.Transform(transformation);
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5fc6a
movq %rbx, %rdi
callq 0x5faa0
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x33bd6(%rip), %xmm1    # 0x93030
movq %rsp, %r15
movq %r15, %rdi
callq 0x5f8b4
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x5fbfa
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x505c2
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f6a0
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r15), %xmm1
mulsd (%r15), %xmm0
addsd %xmm1, %xmm0
xorpd 0x33b85(%rip), %xmm0    # 0x93030
movlpd %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Line.cpp
// Function: gaps::R2Line::InverseTransform(gaps::R2Transformation const&)
void R2Line::
InverseTransform (const R2Transformation& transformation)
{
    // Inverse Transform line
    vector.InverseTransform(transformation);
    vector.Normalize();
    normal = R2Vector(vector.Y(), -vector.X());
    R2Point p(Point());
    p.InverseTransform(transformation);
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5fc7c
movq %rbx, %rdi
callq 0x5faa0
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x33b4a(%rip), %xmm1    # 0x93030
movq %rsp, %r15
movq %r15, %rdi
callq 0x5f8b4
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x5fbfa
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x505c2
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f6b2
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r15), %xmm1
mulsd (%r15), %xmm0
addsd %xmm1, %xmm0
xorpd 0x33af9(%rip), %xmm0    # 0x93030
movlpd %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Rotate(double)
void R2Vector::
Rotate(RNAngle theta)
{
    // Rotate vector counterclockwise 
    RNScalar c = cos(theta);
    RNScalar s = sin(theta);
    RNCoord x = v[0], y = v[1];
    v[0] = c*x - s*y;
    v[1] = s*x + c*y;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe890
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd (%rbx), %xmm1
movapd 0x33507(%rip), %xmm2    # 0x93030
xorpd %xmm0, %xmm2
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm3, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Project(gaps::R2Vector const&)
void R2Vector::
Project(const R2Vector& vector)
{
    // Project onto another vector    
    RNScalar dot = this->Dot(vector);
    RNLength length = vector.Length();
    if ((RNIsPositive(length)) && (length != 1.0)) 
	dot /= (length * length);
    *this = vector * dot;
}

// Assembly:
leaq 0x7b043(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm0
movupd (%rsi), %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
movsd 0x8(%rdi), %xmm3
mulsd %xmm2, %xmm3
movsd (%rdi), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
sqrtsd %xmm3, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm4, %xmm5
divsd %xmm3, %xmm5
cmpltsd %xmm2, %xmm0
cmpneqsd 0x3344c(%rip), %xmm2    # 0x93008
movapd %xmm2, %xmm3
andnpd %xmm4, %xmm3
andpd %xmm5, %xmm2
orpd %xmm3, %xmm2
andpd %xmm0, %xmm2
andnpd %xmm4, %xmm0
orpd %xmm2, %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(int, int, int)
R2Image::
R2Image(int width, int height, int ncomponents)
  : width(width), 
    height(height),
    ncomponents(ncomponents),
    rowsize(0),
    pixels(NULL)
{
  // Initialize pixels
  rowsize = ncomponents * width;
  if ((rowsize % 4) != 0) rowsize = (rowsize / 4 + 1) * 4;
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    while (--nbytes) *(p++) = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
imull %esi, %ecx
testb $0x3, %cl
je 0x6014b
pushq $0x4
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
leal 0x4(,%rax,4), %ecx
movl %ecx, 0xc(%r14)
imull %ecx, %ebx
testl %ebx, %ebx
jle 0x60172
movl %ebx, %edi
callq 0xe030
movq %rax, 0x10(%r14)
decl %ebx
xorl %ecx, %ecx
cmpl %ecx, %ebx
je 0x60172
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x60165
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(int, int, int, unsigned char*)
R2Image::
R2Image(int width, int height, int ncomponents, unsigned char *data)
  : width(width), 
    height(height),
    ncomponents(ncomponents),
    rowsize(0),
    pixels(NULL)
{
  // Copy pixels (first pixel is lower-left)
  rowsize = ncomponents * width;
  if ((rowsize % 4) != 0) rowsize = (rowsize / 4 + 1) * 4;
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    while (--nbytes) *(p++) = *(data++);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r15
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %r8, %r14
imull %esi, %ecx
testb $0x3, %cl
je 0x601ab
pushq $0x4
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
leal 0x4(,%rax,4), %ecx
movl %ecx, 0xc(%r15)
imull %ecx, %ebx
testl %ebx, %ebx
jle 0x601d5
movl %ebx, %edi
callq 0xe030
movq %rax, 0x10(%r15)
decl %ebx
xorl %ecx, %ecx
cmpl %ecx, %ebx
je 0x601d5
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x601c5
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(gaps::R2Grid const&, gaps::R2Grid const&, gaps::R2Grid const&)
R2Image::
R2Image(const R2Grid& red, const R2Grid& green, const R2Grid& blue)
  : width(red.XResolution()), 
    height(red.YResolution()),
    ncomponents(3),
    rowsize(0),
    pixels(NULL)
{
  // Just checking
  assert(red.XResolution() == green.XResolution());
  assert(red.YResolution() == green.YResolution());
  assert(red.XResolution() == blue.XResolution());
  assert(red.YResolution() == blue.YResolution());

  // Copy pixels (first pixel is lower-left)
  rowsize = ncomponents * width;
  if ((rowsize % 4) != 0) rowsize = (rowsize / 4 + 1) * 4;
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    for (int i = 0; i < width*height; i++) {
      int r = 255.0 * red.GridValue(i);
      int g = 255.0 * green.GridValue(i);
      int b = 255.0 * blue.GridValue(i);
      r = (r < 0) ? 0 : ((r > 255) ? 255 : r);
      g = (g < 0) ? 0 : ((g > 255) ? 255 : g);
      b = (b < 0) ? 0 : ((b > 255) ? 255 : b);
      pixels[i*3+0] = r;
      pixels[i*3+1] = g;
      pixels[i*3+2] = b;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc0(%rsi), %r13d
movl %r13d, (%rdi)
movl 0xc4(%rsi), %ebp
movl %ebp, 0x4(%rdi)
movl $0x3, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rcx, %r15
movq %rdx, %r12
leal (%r13,%r13,2), %eax
testb $0x3, %al
je 0x60228
pushq $0x4
popq %rcx
cltd
idivl %ecx
leal 0x4(,%rax,4), %eax
movl %eax, 0xc(%r14)
imull %ebp, %eax
testl %eax, %eax
jle 0x602ff
movl %eax, %edi
callq 0xe030
movq %rax, 0x10(%r14)
xorl %eax, %eax
movsd 0x32fcc(%rip), %xmm0    # 0x93218
xorl %ecx, %ecx
imull %r13d, %ebp
movslq %ebp, %rdx
cmpq %rdx, %rcx
jge 0x602ff
movq 0xb8(%rbx), %rdx
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movl $0xff, %esi
cmpl %esi, %edx
jl 0x60280
movl $0xff, %edx
testl %edx, %edx
jg 0x60286
xorl %edx, %edx
movq 0xb8(%r12), %rdi
movsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edi
cmpl %esi, %edi
jl 0x602a4
movl $0xff, %edi
testl %edi, %edi
jg 0x602aa
xorl %edi, %edi
movq 0xb8(%r15), %r8
movsd (%r8,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %r8d
cmpl %esi, %r8d
jl 0x602cb
movl $0xff, %r8d
testl %r8d, %r8d
jg 0x602d3
xorl %r8d, %r8d
movq 0x10(%r14), %rsi
movb %dl, (%rsi,%rax)
movq 0x10(%r14), %rdx
movb %dil, 0x1(%rdx,%rax)
movq 0x10(%r14), %rdx
movb %r8b, 0x2(%rdx,%rax)
incq %rcx
movl (%r14), %r13d
movl 0x4(%r14), %ebp
addq $0x3, %rax
jmp 0x6024e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Image.cpp
// Function: gaps::R2Image::R2Image(gaps::R2Image const&)
R2Image::
R2Image(const R2Image& image)
  : width(image.width), 
    height(image.height),
    ncomponents(image.ncomponents),
    rowsize(image.rowsize),
    pixels(NULL)
{
  // Copy pixels
  int nbytes = rowsize * height;
  if (nbytes > 0) {
    pixels = new unsigned char [nbytes];
    assert(pixels);
    unsigned char *p = pixels;
    unsigned char *data = image.pixels;
    while (--nbytes) *(p++) = *(data++);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movups (%rsi), %xmm0
movl 0xc(%rsi), %r15d
imull 0x4(%rsi), %r15d
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
testl %r15d, %r15d
jle 0x60359
movq %rsi, %rbx
movq %rdi, %r14
movl %r15d, %edi
callq 0xe030
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rcx
decl %r15d
xorl %edx, %edx
cmpl %edx, %r15d
je 0x60359
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x60347
popq %rbx
popq %r14
popq %r15
retq
nop