LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65cfe
movl $0x10, %esi
callq 0xe450
movq $0x0, 0x8(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x20(%r14), %rsi
callq 0x68f66
leaq 0x30(%rbx), %rdi
leaq 0x30(%r14), %rsi
callq 0x68f66
movslq 0x10(%r14), %r15
movl %r15d, 0x10(%rbx)
testq %r15, %r15
jle 0x65d83
shlq $0x4, %r15
movq %r15, %rdi
callq 0xe030
movq %rax, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
callq 0x68e2c
addq $0x10, %r13
cmpq %r13, %r15
jne 0x65d3e
movq %r12, 0x8(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0x65d83
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rbx), %rdi
addq %r15, %rdi
callq 0x68f66
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x65d60
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe8c0
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3cf62(%rip), %rsi     # 0xa2d21
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe670
cmpl $0x0, 0x10(%r14)
jle 0x65e0e
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x43a60(%rip), %r15     # 0xa9840
movq 0x8(%r14), %rax
movsd -0x8(%rax,%r12), %xmm0
movsd (%rax,%r12), %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movb $0x2, %al
callq 0xe670
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x65de0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f60(%rip), %rsi     # 0xabd93
movq %rbx, %rdi
callq 0xe530
testq %rax, %rax
je 0x65f63
movq %rax, %r15
leaq 0x10(%r14), %r12
leaq 0x43a1e(%rip), %rsi     # 0xa9870
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 0xe840
cmpl $0x4, %eax
jne 0x65f6e
movq %rbx, 0x8(%rsp)
movslq (%r12), %r13
movq %r13, %rbx
shlq $0x4, %rbx
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rbx, %rdi
movq %rdi, (%rsp)
callq 0xe030
movq %rax, %rbp
testq %r13, %r13
je 0x65ebf
xorl %r13d, %r13d
movq %rbp, %rdi
addq %r13, %rdi
callq 0x68e2c
addq $0x10, %r13
cmpq %r13, %rbx
jne 0x65eab
movq %rbp, 0x8(%r14)
cmpl $0x0, 0x10(%r14)
jle 0x65f55
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %ebx, %ebx
movq %r15, %rdi
leaq 0x43991(%rip), %rsi     # 0xa9876
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0xe840
movl %eax, %ebp
cmpl $0x2, %eax
jne 0x65f29
movq 0x8(%r14), %rax
leaq (%rax,%r13), %rsi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm0, (%rax,%r13)
movsd %xmm1, 0x8(%rax,%r13)
movq (%rsp), %rdi
callq 0x66714
jmp 0x65f40
movl (%r12), %esi
leaq 0x43972(%rip), %rdi     # 0xa98a6
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x72a1e
cmpl $0x2, %ebp
jne 0x65f90
incq %rbx
movslq (%r12), %rax
addq $0x10, %r13
cmpq %rax, %rbx
jl 0x65edb
movq %r15, %rdi
callq 0xe430
movl (%r12), %ebp
jmp 0x65f7f
leaq 0x438e5(%rip), %rdi     # 0xa984f
xorl %ebp, %ebp
jmp 0x65f75
leaq 0x43909(%rip), %rdi     # 0xa987e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x72a1e
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x65f7f
movq %rax, %rbx
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0xe8c0
movq %rbx, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x662fd
movl %edx, %eax
leaq 0x43620(%rip), %rcx     # 0xa98e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsi
jmp 0x66312
movsd 0x10(%rsi), %xmm1
movsd 0x18(%rsi), %xmm0
jmp 0x662f3
addq $0x18, %rsi
jmp 0x66312
movsd 0x8(%rsi), %xmm0
movsd 0x20(%rsi), %xmm1
movq %rbx, %rdi
callq 0x68e2e
jmp 0x6631a
leaq 0x43602(%rip), %rdi     # 0xa9906
xorl %eax, %eax
callq 0x72942
leaq 0x481f6e(%rip), %rsi    # 0x4e8280
movq %rbx, %rdi
callq 0x68e38
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Box.cpp
// Function: gaps::R2Box::Quadrant(int, int) const
const R2Box R2Box::
Quadrant (RNDirection xdir, RNDirection ydir) const
{
    // Return box in quadrant (xdir, ydir)
    R2Box result;
    R2Point centroid = Centroid();
    if (xdir == RN_HI) { result[RN_LO][RN_X] = centroid[RN_X]; result[RN_HI][RN_X] = maxpt[RN_X]; }
    else { result[RN_LO][RN_X] = minpt[RN_X]; result[RN_HI][RN_X] = centroid[RN_X]; }
    if (ydir == RN_HI) { result[RN_LO][RN_Y] = centroid[RN_Y]; result[RN_HI][RN_Y] = maxpt[RN_Y]; }
    else { result[RN_LO][RN_Y] = minpt[RN_Y]; result[RN_HI][RN_Y] = centroid[RN_Y]; }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x65fb4
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
addsd 0x8(%r14), %xmm0
movsd 0x3bcac(%rip), %xmm2    # 0xa2030
mulsd %xmm2, %xmm0
addsd 0x10(%r14), %xmm1
mulsd %xmm2, %xmm1
movq %rsp, %r12
movq %r12, %rdi
callq 0x68e2e
leaq 0x8(%r14), %rax
cmpl $0x1, %r15d
cmoveq %r12, %rax
leaq 0x18(%r14), %rcx
cmovneq %r12, %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rbx)
cmpl $0x1, %ebp
jne 0x663d9
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x20, %r14
jmp 0x663e9
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
leaq 0x8(%rsp), %r14
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6699c
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68e38
movsd (%rbx), %xmm1
movsd 0x8(%r14), %xmm0
ucomisd %xmm1, %xmm0
ja 0x664fe
movsd 0x18(%r14), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x66502
movsd %xmm0, (%rbx)
movsd 0x8(%rbx), %xmm1
movsd 0x10(%r14), %xmm0
ucomisd %xmm1, %xmm0
ja 0x6651f
movsd 0x20(%r14), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x66524
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movaps %xmm0, %xmm4
movsd 0x8(%rdi), %xmm0
movsd 0x18(%rdi), %xmm2
ucomisd %xmm2, %xmm0
ja 0x666e8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
movsd 0x20(%rdi), %xmm3
ucomisd %xmm3, %xmm1
ja 0x666db
leaq 0x18(%rbx), %r15
addsd %xmm2, %xmm0
movsd 0x3b9eb(%rip), %xmm2    # 0xa2030
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movsd %xmm4, 0x8(%rsp)
callq 0x68e2e
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6906b
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x694f6
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6908b
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x694f6
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x69057
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %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_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Diad.cpp
// Function: gaps::R2Diad::InverseMatrix() const
const R3Matrix R2Diad::
InverseMatrix(void) const
{
    // Return change of basis matrix (diad -> std)
    return R3Matrix(axis[0].X(), axis[0].Y(), 0.0,
		    axis[1].X(), axis[1].Y(), 0.0,
		    0.0,         0.0,         1.0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm3
movsd 0x18(%rsi), %xmm4
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rsp)
xorps %xmm2, %xmm2
xorps %xmm5, %xmm5
xorps %xmm6, %xmm6
xorps %xmm7, %xmm7
callq 0x66f54
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7eb34(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x6709f
movapd 0x3afa5(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x6709f
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_O1/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 0x7eadc(%rip), %rax     # 0xe5b98
addsd 0x3af84(%rip), %xmm2    # 0xa2048
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x67118
movapd 0x3af45(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x67118
movsd 0x8(%rdi), %xmm2
movsd 0x20(%rdi), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
addsd 0x3af45(%rip), %xmm2    # 0xa2048
cmpltpd %xmm2, %xmm0
cmpltpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ea72(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x67161
movapd 0x3aee3(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x67161
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_O1/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 0x6915a
movsd 0x8(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6915a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6970b
leaq 0x7e9ed(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
xorpd 0x3ae69(%rip), %xmm1    # 0xa2020
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Invert()
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 (%rdi), %xmm0
movsd 0x8(%rdi), %xmm5
movsd 0x20(%rdi), %xmm1
movupd 0x10(%rdi), %xmm2
movupd 0x28(%rdi), %xmm3
movupd 0x38(%rdi), %xmm6
movapd %xmm3, %xmm4
mulsd %xmm6, %xmm4
movapd %xmm6, %xmm7
unpckhpd %xmm6, %xmm7            # xmm7 = xmm7[1],xmm6[1]
movapd %xmm1, %xmm8
mulsd %xmm7, %xmm8
subsd %xmm4, %xmm8
movapd %xmm3, %xmm9
unpckhpd %xmm3, %xmm9            # xmm9 = xmm9[1],xmm3[1]
movapd %xmm3, %xmm10
mulsd %xmm9, %xmm10
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4            # xmm4 = xmm4[1],xmm2[1]
mulsd %xmm4, %xmm7
subsd %xmm10, %xmm7
mulsd %xmm5, %xmm7
mulsd %xmm0, %xmm8
subsd %xmm7, %xmm8
mulsd %xmm1, %xmm9
mulsd %xmm6, %xmm4
subsd %xmm9, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm8, %xmm4
movapd 0x3aed8(%rip), %xmm7    # 0xa2270
andpd %xmm4, %xmm7
movsd 0x3ba13(%rip), %xmm8    # 0xa2db8
ucomisd %xmm7, %xmm8
jae 0x674d8
movapd %xmm6, %xmm8
shufpd $0x1, %xmm6, %xmm8      # xmm8 = xmm8[1],xmm6[0]
movapd %xmm3, %xmm7
unpcklpd %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0]
movapd 0x3ac54(%rip), %xmm9    # 0xa2020
movapd %xmm6, %xmm10
mulpd %xmm7, %xmm10
xorpd %xmm9, %xmm7
movapd %xmm1, %xmm11
unpcklpd %xmm2, %xmm11           # xmm11 = xmm11[0],xmm2[0]
mulpd %xmm8, %xmm11
subpd %xmm10, %xmm11
movapd %xmm4, %xmm8
unpcklpd %xmm4, %xmm8            # xmm8 = xmm8[0],xmm4[0]
divpd %xmm8, %xmm11
movupd %xmm11, (%rdi)
movapd %xmm6, %xmm10
movsd %xmm1, %xmm10           # xmm10 = xmm1[0],xmm10[1]
mulpd %xmm2, %xmm10
movapd %xmm5, %xmm11
unpcklpd %xmm3, %xmm11           # xmm11 = xmm11[0],xmm3[0]
mulpd %xmm3, %xmm11
subpd %xmm10, %xmm11
divpd %xmm8, %xmm11
movupd %xmm11, 0x10(%rdi)
movapd %xmm1, %xmm10
unpcklpd %xmm0, %xmm10           # xmm10 = xmm10[0],xmm0[0]
movapd %xmm2, %xmm11
unpcklpd %xmm2, %xmm11           # xmm11 = xmm11[0],xmm2[0]
xorpd 0x3abd2(%rip), %xmm11   # 0xa2020
xorpd %xmm10, %xmm9
movhlps %xmm9, %xmm11           # xmm11 = xmm9[1],xmm11[1]
mulpd %xmm3, %xmm11
movapd %xmm2, %xmm9
unpcklpd %xmm0, %xmm9            # xmm9 = xmm9[0],xmm0[0]
movapd %xmm2, %xmm12
unpckhpd %xmm6, %xmm12           # xmm12 = xmm12[1],xmm6[1]
mulpd %xmm9, %xmm12
addpd %xmm11, %xmm12
divpd %xmm8, %xmm12
shufpd $0x1, %xmm12, %xmm12    # xmm12 = xmm12[1,0]
movupd %xmm12, 0x20(%rdi)
movapd %xmm3, %xmm9
shufpd $0x1, %xmm6, %xmm9      # xmm9 = xmm9[1],xmm6[0]
mulpd %xmm10, %xmm9
movapd %xmm2, %xmm10
shufpd $0x1, %xmm5, %xmm10     # xmm10 = xmm10[1],xmm5[0]
movsd %xmm6, %xmm3            # xmm3 = xmm6[0],xmm3[1]
mulpd %xmm10, %xmm3
subpd %xmm9, %xmm3
divpd %xmm8, %xmm3
movupd %xmm3, 0x30(%rdi)
mulpd %xmm2, %xmm7
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
mulsd %xmm1, %xmm0
addsd %xmm7, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, 0x40(%rdi)
retq
leaq 0x3b9e1(%rip), %rdi     # 0xa2ec0
xorl %eax, %eax
jmp 0x72ad9
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Transpose() const
const R3Matrix R3Matrix::
Transpose(void) const
{
    // Return transpose of matrix
    return R3Matrix(
        m[0][0], m[1][0], m[2][0], 
        m[0][1], m[1][1], m[2][1], 
        m[0][2], m[1][2], m[2][2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x18(%rsi), %xmm0
movsd 0x30(%rsi), %xmm1
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm3
movsd 0x20(%rsi), %xmm4
movsd 0x38(%rsi), %xmm5
movsd 0x10(%rsi), %xmm6
movsd 0x28(%rsi), %xmm7
movsd 0x40(%rsi), %xmm8
movsd %xmm2, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
movsd %xmm4, 0x20(%rdi)
movsd %xmm5, 0x28(%rdi)
movsd %xmm6, 0x30(%rdi)
movsd %xmm7, 0x38(%rdi)
movsd %xmm8, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Inverse() const
const R3Matrix R3Matrix::
Inverse(void) const
{
    // Return inverse of matrix
    R3Matrix inverse(*this);
    inverse.Invert();
    return inverse;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x30(%rsi), %xmm0
movups %xmm0, 0x30(%rdi)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%rdi)
callq 0x6730a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Flip()
void R3Matrix::
Flip(void)
{
    // Transpose matrix
    RNScalar tmp;
    tmp = m[1][0]; m[1][0] = m[0][1]; m[0][1] = tmp;
    tmp = m[2][0]; m[2][0] = m[0][2]; m[0][2] = tmp;
    tmp = m[1][2]; m[1][2] = m[2][1]; m[2][1] = tmp;
}

// Assembly:
movsd 0x18(%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
movsd %xmm1, 0x18(%rdi)
movsd %xmm0, 0x8(%rdi)
movsd 0x30(%rdi), %xmm0
movsd %xmm2, 0x30(%rdi)
movsd %xmm0, 0x10(%rdi)
movsd 0x28(%rdi), %xmm0
movsd 0x38(%rdi), %xmm1
movsd %xmm1, 0x28(%rdi)
movsd %xmm0, 0x38(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67598
testl %esi, %esi
jne 0x675bb
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x10(%rdi)
mulsd 0x18(%rdi), %xmm0
jmp 0x675b0
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 0x3b92c(%rip), %rdi     # 0xa2eee
xorl %eax, %eax
jmp 0x72ad9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x676a4
testl %esi, %esi
jne 0x676bd
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 0x3b850(%rip), %rdi     # 0xa2f14
xorl %eax, %eax
jmp 0x72ad9
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::Scale(double)
void R3Matrix:: 
XScale(RNScalar scale)
{
    // Scale matrix -- post-multiply by: 
    //   [ sx 0 0 ]
    //   [ 0  1 0 ]
    //   [ 0  0 1 ]
    m[0][0] *= scale;
    m[1][0] *= scale;
}

// Assembly:
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rdi), %xmm1
movupd 0x18(%rdi), %xmm2
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
mulpd %xmm0, %xmm2
movupd %xmm2, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xb0, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movapd 0x3a8cd(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm2
movsd %xmm2, 0x18(%rsp)
movlpd %xmm1, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm2, 0x38(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x40(%rsp)
movq %rax, 0x50(%rsp)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x58(%rsp)
leaq 0x60(%rsp), %rcx
leaq (%rax,%rax,2), %rdx
movsd (%rbx,%rdx,8), %xmm0
movsd 0x8(%rbx,%rdx,8), %xmm1
movsd 0x10(%rbx,%rdx,8), %xmm2
xorl %edx, %edx
movsd 0x30(%rsp,%rdx,8), %xmm3
mulsd %xmm1, %xmm3
movsd 0x18(%rsp,%rdx,8), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x48(%rsp,%rdx,8), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, (%rcx,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x677b6
incq %rax
addq $0x18, %rcx
cmpq $0x3, %rax
jne 0x6779f
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rbx)
movaps 0x70(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x80(%rsp), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x90(%rsp), %xmm0
movups %xmm0, 0x30(%rbx)
movsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0xb0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::operator=(gaps::R3Matrix const&)
R3Matrix& R3Matrix::
operator=(const R3Matrix& a)
{
    // Assign matrix entry-by-entry
    m[0][0] = a.m[0][0]; m[0][1] = a.m[0][1]; m[0][2] = a.m[0][2]; 
    m[1][0] = a.m[1][0]; m[1][1] = a.m[1][1]; m[1][2] = a.m[1][2]; 
    m[2][0] = a.m[2][0]; m[2][1] = a.m[2][1]; m[2][2] = a.m[2][2]; 
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::R3Matrix::operator*=(double)
R3Matrix& R3Matrix::
operator*=(RNScalar a)
{
    // Scale matrix entry-by-entry
    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] *= a; 
    return *this;
}

// Assembly:
movq %rdi, %rax
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd (%rdi), %xmm2
movupd 0x10(%rdi), %xmm3
movupd 0x20(%rdi), %xmm4
movupd 0x30(%rdi), %xmm5
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulpd %xmm1, %xmm3
movupd %xmm3, 0x10(%rdi)
mulpd %xmm1, %xmm4
movupd %xmm4, 0x20(%rdi)
mulpd %xmm1, %xmm5
movupd %xmm5, 0x30(%rdi)
mulsd 0x40(%rdi), %xmm0
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a5d5(%rip), %xmm1    # 0xa2020
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_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator+(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator+(const R3Matrix& a, const R3Matrix& b) 
{
    // Sum matrix
    return R3Matrix(
  	a.m[0][0]+b.m[0][0], a.m[0][1]+b.m[0][1], a.m[0][2]+b.m[0][2], 
  	a.m[1][0]+b.m[1][0], a.m[1][1]+b.m[1][1], a.m[1][2]+b.m[1][2], 
  	a.m[2][0]+b.m[2][0], a.m[2][1]+b.m[2][1], a.m[2][2]+b.m[2][2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x40(%rsi), %xmm0
addsd 0x40(%rdx), %xmm0
movupd (%rsi), %xmm1
movupd (%rdx), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movupd 0x10(%rsi), %xmm1
movupd 0x10(%rdx), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, 0x10(%rdi)
movupd 0x20(%rsi), %xmm1
movupd 0x20(%rdx), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, 0x20(%rdi)
movupd 0x30(%rsi), %xmm1
movupd 0x30(%rdx), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, 0x30(%rdi)
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator-(gaps::R3Matrix const&, gaps::R3Matrix const&)
R3Matrix 
operator-(const R3Matrix& a, const R3Matrix& b) 
{
    // Subtract matrix
    return R3Matrix(
  	a.m[0][0]-b.m[0][0], a.m[0][1]-b.m[0][1], a.m[0][2]-b.m[0][2], 
  	a.m[1][0]-b.m[1][0], a.m[1][1]-b.m[1][1], a.m[1][2]-b.m[1][2], 
  	a.m[2][0]-b.m[2][0], a.m[2][1]-b.m[2][1], a.m[2][2]-b.m[2][2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x40(%rsi), %xmm0
subsd 0x40(%rdx), %xmm0
movupd (%rsi), %xmm1
movupd (%rdx), %xmm2
subpd %xmm2, %xmm1
movupd %xmm1, (%rdi)
movupd 0x10(%rsi), %xmm1
movupd 0x10(%rdx), %xmm2
subpd %xmm2, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd 0x20(%rsi), %xmm1
movupd 0x20(%rdx), %xmm2
subpd %xmm2, %xmm1
movupd %xmm1, 0x20(%rdi)
movupd 0x30(%rsi), %xmm1
movupd 0x30(%rdx), %xmm2
subpd %xmm2, %xmm1
movupd %xmm1, 0x30(%rdi)
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R3Matrix.cpp
// Function: gaps::operator*(gaps::R3Matrix const&, double)
R3Matrix 
operator*(const R3Matrix& a, RNScalar b)
{
    // Scale matrix
    return R3Matrix(
  	a.m[0][0]*b, a.m[0][1]*b, a.m[0][2]*b, 
  	a.m[1][0]*b, a.m[1][1]*b, a.m[1][2]*b, 
  	a.m[2][0]*b, a.m[2][1]*b, a.m[2][2]*b);
}

// Assembly:
movq %rdi, %rax
movsd 0x40(%rsi), %xmm1
mulsd %xmm0, %xmm1
movupd (%rsi), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm0, %xmm2
movupd %xmm2, (%rdi)
movupd 0x10(%rsi), %xmm2
mulpd %xmm0, %xmm2
movupd %xmm2, 0x10(%rdi)
movupd 0x20(%rsi), %xmm2
mulpd %xmm0, %xmm2
movupd %xmm2, 0x20(%rdi)
movupd 0x30(%rsi), %xmm2
mulpd %xmm0, %xmm2
movupd %xmm2, 0x30(%rdi)
movsd %xmm1, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq (%rcx,%rcx,2), %r8
movsd (%rsi,%r8,8), %xmm0
movsd 0x8(%rsi,%r8,8), %xmm1
movsd 0x10(%rsi,%r8,8), %xmm2
xorl %r8d, %r8d
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
cmpq $0x3, %r8
jne 0x67ba1
incq %rcx
addq $0x18, %rdi
cmpq $0x3, %rcx
jne 0x67b86
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6915a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68640
leaq 0x38(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x69057
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x69164
movq %r12, %rdi
callq 0x691fe
movsd %xmm0, 0x48(%r14)
leaq 0x7de15(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x67d9b
xorpd 0x3a28b(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x67da5
leaq 0x8(%rsp), %rdi
callq 0x6962c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x68c1e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68bf8
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68f66
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68640
leaq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x68e38
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6906b
movq %r12, %rdi
callq 0x691fe
movsd %xmm0, 0x48(%r14)
leaq 0x7dd6d(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x67e43
xorpd 0x3a1e3(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x67e4d
leaq 0x8(%rsp), %rdi
callq 0x6962c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x68c1e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68bf8
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68f66
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68640
leaq 0x38(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x68e2e
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x68e2e
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x68e2e
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6906b
movq %r12, %rdi
callq 0x691fe
movsd %xmm0, 0x48(%rbx)
leaq 0x7dc79(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x67f37
xorpd 0x3a0ef(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x67f41
leaq 0x28(%rsp), %rdi
callq 0x6962c
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x68e2e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x68c1e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68bf8
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f66
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6604a
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66714
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6699c
movq %r14, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68108
leaq 0x38(%rbx), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x68f66
leaq 0x28(%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6906b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x68c1e
jmp 0x68154
leaq 0x38(%rbx), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x686a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6950a
leaq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x6950a
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x68f66
leaq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rsi
callq 0x6d2e7
movsd %xmm0, 0x48(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x692f6
mulsd 0x48(%r14), %xmm0
movapd 0x39e93(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, 0x48(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x687d4
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68eb8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68f42
movq %r14, %rdi
movq %rbx, %rsi
callq 0x687fa
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x6d2e7
movsd %xmm0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68f54
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68820
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x6d2e7
movsd %xmm0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x68e38
leaq 0x38(%rbx), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x68bf8
movq %r14, %rdi
movq %r12, %rsi
callq 0x68f66
movq %r12, %rdi
movq %r15, %rsi
callq 0x68f66
movq %rbx, %rdi
callq 0x693c2
leaq 0x10(%rbx), %rdi
callq 0x693c2
movsd 0x20(%rbx), %xmm0
xorps 0x39d0a(%rip), %xmm0    # 0xa2020
movlps %xmm0, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Span.cpp
// Function: gaps::R2Span::Reset(gaps::R2Point const&, gaps::R2Point const&)
void R2Span::
Reset(const R2Point& point1, const R2Point& point2)
{
    // Reset span
    ray = R2Ray(point1, point2);
    end = point2;
    length = R2Distance(point1, point2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x686a6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6950a
leaq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x6950a
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x68f66
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x68f66
movq %r15, %rdi
movq %r14, %rsi
callq 0x6d2e7
movsd %xmm0, 0x48(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69126
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x6862d
addq $0x38, %r14
addq $0x38, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x69126
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x692f6
movapd %xmm0, %xmm2
leaq 0x7d440(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x398bc(%rip), %xmm0    # 0xa2020
xorpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jb 0x68778
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
jae 0x687a3
leaq 0x28(%rbx), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x6906b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x692f6
divsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3951f(%rip), %xmm0    # 0xa2020
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x694f6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x69298
movq %r15, %rdi
movq %r12, %rsi
callq 0x68ec6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x69520
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x394db(%rip), %xmm1    # 0xa2020
movq %rsp, %r12
movq %r12, %rdi
callq 0x6915a
movq %r14, %rdi
movq %r12, %rsi
callq 0x6950a
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r15), %xmm1
mulsd (%r15), %xmm0
addsd %xmm1, %xmm0
xorpd 0x394a4(%rip), %xmm0    # 0xa2020
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_O1/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 0x6950a
testl %ebp, %ebp
jne 0x68c3c
movq %rbx, %rdi
callq 0x69376
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x393d4(%rip), %xmm1    # 0xa2020
movq %rsp, %r14
movq %r14, %rdi
callq 0x6915a
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6950a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6957a
movq %rbx, %rdi
callq 0x69376
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x39382(%rip), %xmm1    # 0xa2020
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6915a
leaq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6950a
movsd 0x20(%rbx), %xmm0
xorps 0x3935a(%rip), %xmm0    # 0xa2020
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x694f6
leaq 0x47f5a3(%rip), %rsi    # 0x4e8280
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x69057
movq %r12, %rdi
movq %r14, %rsi
callq 0x68f42
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r12), %xmm1
mulsd (%r12), %xmm0
addsd %xmm1, %xmm0
xorpd 0x39305(%rip), %xmm0    # 0xa2020
movlpd %xmm0, 0x20(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6958c
movq %rbx, %rdi
callq 0x69376
movsd 0x8(%rbx), %xmm0
movsd (%rbx), %xmm1
xorps 0x392c6(%rip), %xmm1    # 0xa2020
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6915a
leaq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6950a
movsd 0x20(%rbx), %xmm0
xorps 0x3929e(%rip), %xmm0    # 0xa2020
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x694f6
leaq 0x47f4e7(%rip), %rsi    # 0x4e8280
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x69057
movq %r12, %rdi
movq %r14, %rsi
callq 0x68f54
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd 0x8(%r12), %xmm1
mulsd (%r12), %xmm0
addsd %xmm1, %xmm0
xorpd 0x39249(%rip), %xmm0    # 0xa2020
movlpd %xmm0, 0x20(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Point.cpp
// Function: gaps::R2Point::operator*=(gaps::R3Matrix const&)
R2Point& R2Point::
operator*=(const R3Matrix& m)
{
    // Multiply point by matrix 
    RNCoord x = v[0], y = v[1];
    v[0] = x*m[0][0] + y*m[1][0] + m[2][0];
    v[1] = x*m[0][1] + y*m[1][1] + m[2][1];
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x18(%rsi), %xmm2
mulsd %xmm1, %xmm2
movsd (%rsi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0x30(%rsi), %xmm3
movsd %xmm3, (%rdi)
mulsd 0x20(%rsi), %xmm1
mulsd 0x8(%rsi), %xmm0
addsd %xmm1, %xmm0
addsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Vector.cpp
// Function: gaps::R2Vector::Angle() const
const RNAngle R2Vector::
Angle(void) const
{
    // Return angle to positive x axis
    RNLength length = Length();
    if (length == 0) return 0;
    RNCoord x = v[0] / length;
    if (x == 0) return RN_PI_OVER_TWO;
    RNCoord y = v[1] / length;
    return atan2(y, x);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6924f
sqrtsd %xmm0, %xmm0
jmp 0x69258
callq 0xe340
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x69260
jnp 0x6927f
movsd (%rbx), %xmm1
divsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x69285
jp 0x69285
leaq 0x40d3d(%rip), %rax     # 0xa9fb8
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
popq %rbx
retq
movsd 0x8(%rbx), %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
popq %rbx
jmp 0xe0a0