LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Crdsys.cpp
// Function: gaps::R3CoordSystem::Matrix() const
const R4Matrix R3CoordSystem::
Matrix(void) const
{
    // Return matrix (std -> cs)
    R4Matrix m(R4identity_matrix);
    m.Translate(origin.Vector());
    m.Transform(axes.Matrix());
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78491(%rip), %rsi     # 0xa2e40
callq 0x2c5ba
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x10(%r14), %xmm2
movq %rsp, %r15
movq %r15, %rdi
callq 0x3d4be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d6f4
addq $0x18, %r14
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2af16
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2e5ab
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e19e
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Crdsys.cpp
// Function: gaps::R3CoordSystem::InverseMatrix() const
const R4Matrix R3CoordSystem::
InverseMatrix(void) const
{
    // Return matrix (cs -> std)
    R4Matrix m(axes.InverseMatrix());
    m.Translate(-origin.Vector());
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rsi
callq 0x2af90
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3d4be
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e154
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d6f4
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Crdsys.cpp
// Function: gaps::R3CoordSystemSlerp(gaps::R3CoordSystem const&, gaps::R3CoordSystem const&, double)
R3CoordSystem
R3CoordSystemSlerp(const R3CoordSystem& cs0, const R3CoordSystem& cs1, RNScalar t)
{                            
  // Compute interpolated origin
  const R3Point& origin0 = cs0.Origin();
  const R3Point& origin1 = cs1.Origin();
  R3Point origin = (1-t)*origin0 + t*origin1;

  // Slerp orientation
  R3Quaternion q0(cs0.Matrix(), 0);
  R3Quaternion q1(cs1.Matrix(), 0);
  R3Quaternion q = R3QuaternionSlerp(q0, q1, t);

  // Compute interpolated axes
  R3Vector ax = q * R3posx_vector;
  R3Vector ay = q * R3posy_vector;
  ay.Normalize();
  R3Vector az = ax % ay;
  az.Normalize();
  ax = ay % az;
  ax.Normalize();
  R3Triad triad(ax, ay, az);

  // Return interpolated coordinate system
  return R3CoordSystem(origin, triad);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movapd %xmm0, %xmm1
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movsd 0x7743e(%rip), %xmm0    # 0xa2038
subsd %xmm1, %xmm0
leaq 0x88(%rsp), %r13
movq %r13, %rdi
callq 0x3d470
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
callq 0x3d470
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3d42a
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2a996
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2b746
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2a996
leaq 0x128(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2b746
leaq 0x108(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd (%rsp), %xmm0
callq 0x2b473
leaq 0x7da6b(%rip), %rdx     # 0xa8710
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2c1ea
leaq 0x7da6c(%rip), %rdx     # 0xa8728
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2c1ea
movq %r12, %rdi
callq 0x3d7e0
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3de12
movq %r13, %rdi
callq 0x3d7e0
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3de12
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3dc6a
movq %r15, %rdi
callq 0x3d7e0
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x2ade0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ca36
movq %rbx, %rdi
addq $0x18, %rdi
movq %rbp, %rsi
callq 0x2ad8e
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::R3Triad(gaps::R3Vector const&, gaps::R3Vector const&)
R3Triad::
R3Triad(const R3Vector& towards, const R3Vector& up)
{
    axis[2] = -towards;
    axis[2].Normalize();
    axis[0] = up % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
leaq (%rbx,%r12), %rdi
callq 0x3d4bc
addq $0x18, %r12
cmpq $0x48, %r12
jne 0x2ae85
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e154
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc6a
movq %r15, %rdi
callq 0x3d7e0
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3de12
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Matrix() const
const R4Matrix R3Triad::
Matrix(void) const
{
    // Return change of basis matrix (std -> triad)
    return R4Matrix(axis[0].X(), axis[1].X(), axis[2].X(), 0.0,
		    axis[0].Y(), axis[1].Y(), axis[2].Y(), 0.0,
		    axis[0].Z(), axis[1].Z(), axis[2].Z(), 0.0,
		    0.0,         0.0,         0.0,         1.0);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movsd 0x18(%rsi), %xmm1
movsd 0x30(%rsi), %xmm2
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm4
movsd 0x20(%rsi), %xmm5
movsd 0x38(%rsi), %xmm6
movsd 0x10(%rsi), %xmm3
movsd 0x28(%rsi), %xmm7
movsd 0x40(%rsi), %xmm8
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rsp)
xorps %xmm9, %xmm9
movups %xmm9, 0x28(%rsp)
movups %xmm9, 0x18(%rsp)
movsd %xmm8, 0x10(%rsp)
movsd %xmm7, 0x8(%rsp)
movsd %xmm3, (%rsp)
xorps %xmm3, %xmm3
xorps %xmm7, %xmm7
callq 0x2c65a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::InverseMatrix() const
const R4Matrix R3Triad::
InverseMatrix(void) const
{
    // Return change of basis matrix (triad -> std)
    return R4Matrix(axis[0].X(), axis[0].Y(), axis[0].Z(), 0.0,
		    axis[1].X(), axis[1].Y(), axis[1].Z(), 0.0,
		    axis[2].X(), axis[2].Y(), axis[2].Z(), 0.0,
		    0.0,         0.0,         0.0,         1.0);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
movsd 0x18(%rsi), %xmm4
movsd 0x20(%rsi), %xmm5
movsd 0x28(%rsi), %xmm6
movups 0x30(%rsi), %xmm3
movsd 0x40(%rsi), %xmm7
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rsp)
xorps %xmm8, %xmm8
movups %xmm8, 0x28(%rsp)
movups %xmm8, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movups %xmm3, (%rsp)
xorps %xmm3, %xmm3
xorps %xmm7, %xmm7
callq 0x2c65a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Rotate(gaps::R3Vector const&, double)
void R3Triad::
Rotate(const R3Vector& rotaxis, RNAngle radians)
{
    // Rotate each axis
    axis[0].Rotate(rotaxis, radians);
    axis[1].Rotate(rotaxis, radians);
    axis[2].Rotate(rotaxis, radians);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r14
callq 0x3dc8a
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3dc8a
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3dc8a
movq %r12, %rdi
callq 0x3d7e0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3de12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %r14, %rdi
callq 0x3d7e0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Rotate(gaps::R3Vector const&, gaps::R3Vector const&)
void R3Triad::
Rotate(const R3Vector& from, const R3Vector& to)
{
    // Rotate each axis
    RNAngle angle = R3InteriorAngle(from, to);
    R3Vector rotaxis = from % to;
    rotaxis.Normalize();
    Rotate(rotaxis, angle);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4c77b
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3de12
movq %r12, %rdi
callq 0x3d7e0
movq %rbx, %rdi
movq %r12, %rsi
movsd (%rsp), %xmm0
callq 0x2b05c
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x3d7e0
leaq 0x18(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3de12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc6a
movq %r15, %rdi
callq 0x3d7e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Mirror(gaps::R3Plane const&)
void R3Triad::
Mirror(const R3Plane& plane)
{
    // Mirror each axis 
    axis[0].Mirror(plane);
    axis[1].Mirror(plane);
    axis[2].Mirror(plane);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x3e03a
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e03a
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e03a
movq %r12, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3de12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %r14, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Transform(gaps::R3Transformation const&)
void R3Triad::
Transform(const R3Transformation& transformation)
{
    // Transform each axis 
    axis[0].Transform(transformation);
    axis[1].Transform(transformation);
    axis[2].Transform(transformation);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x3e09a
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e09a
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e09a
movq %r12, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3de12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %r14, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::InverseTransform(gaps::R3Transformation const&)
void R3Triad::
InverseTransform(const R3Transformation& transformation)
{
    // Transform each axis 
    axis[0].InverseTransform(transformation);
    axis[1].InverseTransform(transformation);
    axis[2].InverseTransform(transformation);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x3e0ac
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e0ac
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e0ac
movq %r12, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3de12
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %r14, %rdi
callq 0x3d7e0
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dc6a
movq %rbx, %rdi
callq 0x3d7e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Normalize()
void R3Quaternion::
Normalize(void)
{
  // Normalize -- internal function because all R3Quaternions are normalized
  RNScalar sum = 0;
  sum += v[0]*v[0];
  sum += v[1]*v[1];
  sum += v[2]*v[2];
  sum += v[3]*v[3];
  RNScalar length = sqrt(sum);
  if (RNIsZero(length)) return;
  v[0] /= length;
  v[1] /= length;
  v[2] /= length;
  v[3] /= length;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm0
xorpd %xmm2, %xmm2
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jb 0x2b3d5
sqrtsd %xmm0, %xmm0
jmp 0x2b3da
callq 0xe340
leaq 0xba7b7(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x76c33(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x2b3fd
ucomisd %xmm0, %xmm1
jae 0x2b41b
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rbx), %xmm1
movupd 0x10(%rbx), %xmm2
divpd %xmm0, %xmm1
movupd %xmm1, (%rbx)
divpd %xmm0, %xmm2
movupd %xmm2, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(gaps::R3Quaternion const&)
R3Quaternion::
R3Quaternion(const R3Quaternion& quaternion)
{
    v[0] = quaternion.v[0]; 
    v[1] = quaternion.v[1]; 
    v[2] = quaternion.v[2]; 
    v[3] = quaternion.v[3]; 
}

// Assembly:
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)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::operator=(gaps::R3Quaternion const&)
R3Quaternion& R3Quaternion::
operator=(const R3Quaternion& quaternion)
{
    // Assign quaternion
    v[0] = quaternion.v[0];
    v[1] = quaternion.v[1];
    v[2] = quaternion.v[2];
    v[3] = quaternion.v[3];
    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)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(gaps::R3Vector const&, double)
R3Quaternion::
R3Quaternion(const R3Vector& axis, RNAngle theta)
{
    RNAngle half_theta = 0.5 * theta;
    RNScalar sine_half_theta = sin(half_theta);
    R3Vector normalized_axis = axis;
    normalized_axis.Normalize();
    v[0] = cos(half_theta);
    v[1] = normalized_axis[0] * sine_half_theta; 
    v[2] = normalized_axis[1] * sine_half_theta; 
    v[3] = normalized_axis[2] * sine_half_theta; 
    Normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
mulsd 0x769df(%rip), %xmm0    # 0xa2030
movsd %xmm0, 0x8(%rsp)
callq 0xe0f0
movapd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d4ce
movq %r15, %rdi
callq 0x3d7e0
movsd 0x8(%rsp), %xmm0
callq 0xe860
movsd %xmm0, (%rbx)
movapd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
mulpd (%r15), %xmm0
movupd %xmm0, 0x8(%rbx)
mulsd 0x10(%r15), %xmm1
movsd %xmm1, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2b38e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(int, double)
R3Quaternion::
R3Quaternion(int dimension, RNAngle theta)
{
    RNAngle half_theta = 0.5 * theta;
    RNScalar sine_half_theta = sin(half_theta);
    R3Vector axis = R3xyz_triad[dimension];
    v[0] = cos(half_theta);
    v[1] = axis[0] * sine_half_theta; 
    v[2] = axis[1] * sine_half_theta; 
    v[3] = axis[2] * sine_half_theta; 
    Normalize();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
mulsd 0x7695d(%rip), %xmm0    # 0xa2030
movsd %xmm0, 0x8(%rsp)
callq 0xe0f0
movapd %xmm0, 0x10(%rsp)
movslq %ebp, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0xb98ba(%rip), %rsi     # 0xe4fb0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3d4ce
movsd 0x8(%rsp), %xmm0
callq 0xe860
movsd %xmm0, (%rbx)
movapd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
mulpd (%r14), %xmm0
movupd %xmm0, 0x8(%rbx)
mulsd 0x10(%r14), %xmm1
movsd %xmm1, 0x18(%rbx)
movq %rbx, %rdi
callq 0x2b38e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Matrix() const
const R4Matrix R3Quaternion::
Matrix(void) const
{
    // Return rotation matrix
    RNScalar a = v[0];
    RNScalar b = v[1];
    RNScalar c = v[2];
    RNScalar d = v[3];
    R4Matrix m = R4identity_matrix;
    m[0][0] = a*a + b*b - c*c - d*d;
    m[0][1] = 2*b*c - 2*a*d;
    m[0][2] = 2*b*d + 2*a*c;
    m[1][0] = 2*b*c + 2*a*d;
    m[1][1] = a*a - b*b + c*c - d*d;
    m[1][2] = 2*c*d - 2*a*b;
    m[2][0] = 2*b*d - 2*a*c;
    m[2][1] = 2*c*d + 2*a*b;
    m[2][2] = a*a - b*b - c*c + d*d;
    return m;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
addsd %xmm1, %xmm0
movapd %xmm0, 0x30(%rsp)
addsd %xmm2, %xmm2
movapd %xmm2, 0x40(%rsp)
movups 0x10(%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x8(%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x7714c(%rip), %rsi     # 0xa2e40
callq 0x2c5ba
movapd 0x7631f(%rip), %xmm2    # 0xa2020
movapd 0x20(%rsp), %xmm9
movapd %xmm9, %xmm3
xorpd %xmm2, %xmm3
movapd %xmm3, %xmm1
mulsd %xmm9, %xmm1
movapd 0x30(%rsp), %xmm7
addsd %xmm1, %xmm7
movapd %xmm9, %xmm0
unpckhpd %xmm9, %xmm0            # xmm0 = xmm0[1],xmm9[1]
movapd 0x40(%rsp), %xmm6
movapd %xmm6, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm4, %xmm5
xorpd %xmm2, %xmm5
unpcklpd %xmm5, %xmm7            # xmm7 = xmm7[0],xmm5[0]
movapd %xmm7, %xmm10
movapd %xmm6, %xmm5
movapd %xmm6, %xmm8
mulsd %xmm9, %xmm5
movsd 0x10(%rsp), %xmm7
subsd 0x8(%rsp), %xmm7
movapd %xmm9, %xmm6
movapd %xmm9, %xmm11
mulsd %xmm9, %xmm6
addsd %xmm7, %xmm6
unpcklpd %xmm6, %xmm4            # xmm4 = xmm4[0],xmm6[0]
mulsd 0x18(%rsp), %xmm8
xorpd %xmm5, %xmm2
movapd 0x50(%rsp), %xmm9
addpd %xmm9, %xmm9
movsd %xmm9, %xmm3            # xmm3 = xmm9[0],xmm3[1]
mulpd %xmm11, %xmm3
movapd %xmm3, %xmm6
shufpd $0x1, %xmm3, %xmm6      # xmm6 = xmm6[1],xmm3[0]
addpd %xmm10, %xmm6
movupd %xmm6, (%rbx)
movapd %xmm9, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, 0x10(%rbx)
addpd %xmm4, %xmm3
movupd %xmm3, 0x20(%rbx)
movapd %xmm9, %xmm3
unpckhpd %xmm9, %xmm3            # xmm3 = xmm3[1],xmm9[1]
mulsd %xmm0, %xmm3
subsd %xmm8, %xmm3
movsd %xmm3, 0x30(%rbx)
unpcklpd %xmm8, %xmm2            # xmm2 = xmm2[0],xmm8[0]
mulpd %xmm0, %xmm9
addpd %xmm2, %xmm9
movupd %xmm9, 0x40(%rbx)
addsd %xmm1, %xmm7
mulsd %xmm0, %xmm0
addsd %xmm7, %xmm0
movsd %xmm0, 0x50(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::operator==(gaps::R3Quaternion const&) const
const RNBoolean R3Quaternion::
operator==(const R3Quaternion& quaternion) const
{
    // Return whether quaternion is equal
    return ((v[0] == quaternion.v[0]) && 
            (v[1] == quaternion.v[1]) && 
            (v[2] == quaternion.v[2]) && 
            (v[3] == quaternion.v[3]));
}

// Assembly:
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd (%rsi), %xmm0
jne 0x2be85
jp 0x2be85
movsd 0x8(%rdi), %xmm0
ucomisd 0x8(%rsi), %xmm0
jne 0x2be85
jp 0x2be85
movsd 0x10(%rdi), %xmm0
ucomisd 0x10(%rsi), %xmm0
jne 0x2be85
jp 0x2be85
movsd 0x18(%rsi), %xmm0
cmpeqsd 0x18(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::operator!=(gaps::R3Quaternion const&) const
const RNBoolean R3Quaternion::
operator!=(const R3Quaternion& quaternion) const
{
    // Return whether quaternion is not equal
    return ((v[0] != quaternion.v[0]) || 
            (v[1] != quaternion.v[1]) || 
            (v[2] != quaternion.v[2]) || 
            (v[3] != quaternion.v[3]));
}

// Assembly:
movsd (%rdi), %xmm0
movl $0x1, %eax
ucomisd (%rsi), %xmm0
jne 0x2be97
jnp 0x2be98
retq
movsd 0x8(%rdi), %xmm0
ucomisd 0x8(%rsi), %xmm0
jne 0x2be97
jp 0x2be97
movsd 0x10(%rdi), %xmm0
ucomisd 0x10(%rsi), %xmm0
jne 0x2be97
jp 0x2be97
movsd 0x18(%rsi), %xmm0
cmpneqsd 0x18(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Flip()
void R3Quaternion::
Flip(void)
{
    // Negate all numbers (does not change rotation)
    v[0] = -v[0];
    v[1] = -v[1];
    v[2] = -v[2];
    v[3] = -v[3];
}

// Assembly:
movaps 0x76151(%rip), %xmm0    # 0xa2020
movups (%rdi), %xmm1
movups 0x10(%rdi), %xmm2
xorps %xmm0, %xmm1
movups %xmm1, (%rdi)
xorps %xmm0, %xmm2
movups %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Multiply(gaps::R3Quaternion const&)
void R3Quaternion::
Multiply(const R3Quaternion& q2)
{
    // Multiply quaternion (equivalent to concatenating rotations)
    RNScalar q1[4]; q1[0] = v[0]; q1[1] = v[1]; q1[2] = v[2]; q1[3] = v[3];
    v[0] = q1[0]*q2[0] - q1[1]*q2[1] - q1[2]*q2[2] - q1[3]*q2[3];
    v[1] = q1[0]*q2[1] + q1[1]*q2[0] + q1[2]*q2[3] - q1[3]*q2[2];
    v[2] = q1[0]*q2[2] - q1[1]*q2[3] + q1[2]*q2[0] + q1[3]*q2[1];
    v[3] = q1[0]*q2[3] + q1[1]*q2[2] - q1[2]*q2[1] + q1[3]*q2[0];
    // Normalize();
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm3
movsd 0x10(%rdi), %xmm2
movsd 0x18(%rdi), %xmm1
movsd 0x8(%rsi), %xmm4
mulsd %xmm3, %xmm4
movsd (%rsi), %xmm5
mulsd %xmm0, %xmm5
subsd %xmm4, %xmm5
movsd 0x10(%rsi), %xmm4
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm5
movsd 0x18(%rsi), %xmm4
mulsd %xmm1, %xmm4
subsd %xmm4, %xmm5
movsd %xmm5, (%rdi)
movsd (%rsi), %xmm4
mulsd %xmm3, %xmm4
movsd 0x8(%rsi), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x18(%rsi), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
movsd 0x10(%rsi), %xmm5
mulsd %xmm1, %xmm5
subsd %xmm5, %xmm4
movsd %xmm4, 0x8(%rdi)
movsd 0x18(%rsi), %xmm4
mulsd %xmm3, %xmm4
movsd 0x10(%rsi), %xmm5
mulsd %xmm0, %xmm5
subsd %xmm4, %xmm5
movsd (%rsi), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
movsd 0x8(%rsi), %xmm5
mulsd %xmm1, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, 0x10(%rdi)
mulsd 0x10(%rsi), %xmm3
mulsd 0x18(%rsi), %xmm0
addsd %xmm3, %xmm0
mulsd 0x8(%rsi), %xmm2
subsd %xmm2, %xmm0
mulsd (%rsi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Rotate(gaps::R3Vector const&)
void R3Quaternion:: 
Rotate(const R3Vector& xyz_radians)
{
    // Rotate first around X, then around Y, and finally around Z
    ZRotate(xyz_radians.Z());
    YRotate(xyz_radians.Y());
    XRotate(xyz_radians.X());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
leaq 0x7c671(%rip), %rsi     # 0xa8740
movq %rsp, %r15
movq %r15, %rdi
callq 0x2b63a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bee4
movsd 0x8(%r14), %xmm0
leaq 0x7c636(%rip), %rsi     # 0xa8728
movq %rsp, %r15
movq %r15, %rdi
callq 0x2b63a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bee4
movsd (%r14), %xmm0
leaq 0x7c5fc(%rip), %rsi     # 0xa8710
movq %rsp, %r14
movq %r14, %rdi
callq 0x2b63a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bee4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::R4Matrix(gaps::R4Matrix const&)
R4Matrix::
R4Matrix(const R4Matrix& matrix)
{
    // Assign matrix entries
    m[0][0] = matrix.m[0][0]; m[0][1] = matrix.m[0][1]; m[0][2] = matrix.m[0][2]; m[0][3] = matrix.m[0][3];
    m[1][0] = matrix.m[1][0]; m[1][1] = matrix.m[1][1]; m[1][2] = matrix.m[1][2]; m[1][3] = matrix.m[1][3];
    m[2][0] = matrix.m[2][0]; m[2][1] = matrix.m[2][1]; m[2][2] = matrix.m[2][2]; m[2][3] = matrix.m[2][3];
    m[3][0] = matrix.m[3][0]; m[3][1] = matrix.m[3][1]; m[3][2] = matrix.m[3][2]; m[3][3] = matrix.m[3][3];
}

// Assembly:
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)
movsd 0x48(%rsi), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rsi), %xmm0
movsd %xmm0, 0x60(%rdi)
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x70(%rdi)
movsd 0x78(%rsi), %xmm0
movsd %xmm0, 0x78(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::R4Matrix(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
R4Matrix::
R4Matrix(RNScalar a00, RNScalar a01, RNScalar a02, RNScalar a03,
         RNScalar a10, RNScalar a11, RNScalar a12, RNScalar a13,
	 RNScalar a20, RNScalar a21, RNScalar a22, RNScalar a23,
	 RNScalar a30, RNScalar a31, RNScalar a32, RNScalar a33)
{
    // Assign matrix entries
    m[0][0] = a00; m[0][1] = a01; m[0][2] = a02; m[0][3] = a03;
    m[1][0] = a10; m[1][1] = a11; m[1][2] = a12; m[1][3] = a13;
    m[2][0] = a20; m[2][1] = a21; m[2][2] = a22; m[2][3] = a23;
    m[3][0] = a30; m[3][1] = a31; m[3][2] = a32; m[3][3] = a33;
}

// Assembly:
movaps 0x38(%rsp), %xmm8
movaps 0x28(%rsp), %xmm9
movaps 0x18(%rsp), %xmm10
movaps 0x8(%rsp), %xmm11
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
movsd %xmm4, 0x20(%rdi)
movsd %xmm5, 0x28(%rdi)
movsd %xmm6, 0x30(%rdi)
movsd %xmm7, 0x38(%rdi)
movups %xmm11, 0x40(%rdi)
movups %xmm10, 0x50(%rdi)
movups %xmm9, 0x60(%rdi)
movups %xmm8, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::IsIsotropic() const
const RNBoolean R4Matrix::
IsIsotropic(void) const
{
    // Return whether matrix transformation is isotropic
    RNScalar d0 = m[0][0]*m[0][0] + m[1][0]*m[1][0] + m[2][0]*m[2][0];
    RNScalar d1 = m[0][1]*m[0][1] + m[1][1]*m[1][1] + m[2][1]*m[2][1];
    if (RNIsNotEqual(d0, d1)) return FALSE;
    RNScalar d2 = m[0][2]*m[0][2] + m[1][2]*m[1][2] + m[2][2]*m[2][2];
    if (RNIsNotEqual(d0, d2)) return FALSE;
    return TRUE;
}

// Assembly:
movupd (%rdi), %xmm1
movupd 0x20(%rdi), %xmm2
movupd 0x40(%rdi), %xmm0
mulpd %xmm2, %xmm2
mulpd %xmm1, %xmm1
addpd %xmm2, %xmm1
mulpd %xmm0, %xmm0
addpd %xmm1, %xmm0
leaq 0xb93e5(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
xorl %eax, %eax
ucomisd %xmm1, %xmm3
ja 0x2c81d
movapd 0x75849(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm3, %xmm2
ja 0x2c81d
movsd 0x10(%rdi), %xmm3
movsd 0x30(%rdi), %xmm4
mulsd %xmm4, %xmm4
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
movsd 0x50(%rdi), %xmm4
mulsd %xmm4, %xmm4
addsd %xmm3, %xmm4
subsd %xmm4, %xmm0
cmpnltpd %xmm0, %xmm1
cmpnltpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasTranslation() const
const RNBoolean R4Matrix::
HasTranslation(void) const
{
    // Return whether matrix transformation has translation
    if (RNIsNotZero(m[0][3])) return TRUE;
    if (RNIsNotZero(m[1][3])) return TRUE;
    if (RNIsNotZero(m[2][3])) return TRUE;
    return FALSE;
}

// Assembly:
movsd 0x18(%rdi), %xmm2
leaq 0xb936e(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x2c876
movapd 0x757df(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x2c876
movsd 0x38(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2c876
ucomisd %xmm2, %xmm1
ja 0x2c876
movsd 0x58(%rdi), %xmm2
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/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasScale() const
const RNBoolean R4Matrix::
HasScale(void) const
{
    // Return whether matrix transformation has scale
    RNScalar d0 = m[0][0]*m[0][0] + m[1][0]*m[1][0] + m[2][0]*m[2][0];
    if (RNIsNotEqual(d0, 1.0)) return TRUE;
    RNScalar d1 = m[0][1]*m[0][1] + m[1][1]*m[1][1] + m[2][1]*m[2][1];
    if (RNIsNotEqual(d1, 1.0)) return TRUE;
    RNScalar d2 = m[0][2]*m[0][2] + m[1][2]*m[1][2] + m[2][2]*m[2][2];
    if (RNIsNotEqual(d2, 1.0)) return TRUE;
    return FALSE;
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x20(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x40(%rdi), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
leaq 0xb92f7(%rip), %rax     # 0xe5b98
addsd 0x7579f(%rip), %xmm2    # 0xa2048
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x2c945
movapd 0x7575c(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x2c945
movsd 0x8(%rdi), %xmm3
movsd 0x28(%rdi), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
movsd 0x48(%rdi), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
addsd 0x7574f(%rip), %xmm2    # 0xa2048
ucomisd %xmm0, %xmm2
ja 0x2c945
ucomisd %xmm2, %xmm1
ja 0x2c945
movsd 0x10(%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
movsd 0x50(%rdi), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
addsd 0x75718(%rip), %xmm3    # 0xa2048
cmpltpd %xmm3, %xmm0
cmpltpd %xmm1, %xmm3
orpd %xmm0, %xmm3
movd %xmm3, %eax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasRotation() const
const RNBoolean R4Matrix::
HasRotation(void) const
{
    // Return whether matrix transformation has rotation
    if (RNIsNotZero(m[0][1])) return TRUE;
    if (RNIsNotZero(m[0][2])) return TRUE;
    if (RNIsNotZero(m[1][0])) return TRUE;
    if (RNIsNotZero(m[1][2])) return TRUE;
    if (RNIsNotZero(m[2][0])) return TRUE;
    if (RNIsNotZero(m[2][1])) return TRUE;
    return FALSE;
}

// Assembly:
movsd 0x8(%rdi), %xmm2
leaq 0xb9246(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
movl $0x1, %eax
ja 0x2c9d1
movapd 0x756b7(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x2c9d1
movsd 0x10(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2c9d1
ucomisd %xmm2, %xmm1
ja 0x2c9d1
movsd 0x20(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2c9d1
ucomisd %xmm2, %xmm1
ja 0x2c9d1
movsd 0x30(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2c9d1
ucomisd %xmm2, %xmm1
ja 0x2c9d1
movsd 0x40(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x2c9d1
ucomisd %xmm2, %xmm1
ja 0x2c9d1
movsd 0x48(%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/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasMirror() const
const RNBoolean R4Matrix::
HasMirror(void) const
{
    // Return whether matrix transformation has mirror operator
    R3Vector vx(m[0][0], m[1][0], m[2][0]);
    R3Vector vy(m[0][1], m[1][1], m[2][1]);
    R3Vector vz(m[0][2], m[1][2], m[2][2]);
    return RNIsNegative(vz.Dot(vx % vy));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movsd (%rdi), %xmm0
movsd 0x20(%rdi), %xmm1
movsd 0x40(%rdi), %xmm2
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d4be
movsd 0x8(%r14), %xmm0
movsd 0x28(%r14), %xmm1
movsd 0x48(%r14), %xmm2
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movsd 0x10(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movsd 0x50(%r14), %xmm2
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3d4be
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3de12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d756
leaq 0xb913a(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
xorpd 0x755b6(%rip), %xmm1    # 0xa2020
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Determinant() const
const RNScalar R4Matrix::
Determinant(void) const
{
    // Return matrix determinant
    return R4MatrixDet4(
        m[0][0], m[0][1], m[0][2], m[0][3],
        m[1][0], m[1][1], m[1][2], m[1][3],
        m[2][0], m[2][1], m[2][2], m[2][3],
        m[3][0], m[3][1], m[3][2], m[3][3]);
}

// Assembly:
movsd 0x28(%rdi), %xmm4
movsd 0x30(%rdi), %xmm8
movsd 0x38(%rdi), %xmm0
movsd 0x40(%rdi), %xmm1
movsd 0x48(%rdi), %xmm11
movsd 0x50(%rdi), %xmm13
movsd 0x58(%rdi), %xmm10
movsd 0x60(%rdi), %xmm12
movsd 0x68(%rdi), %xmm7
movsd 0x70(%rdi), %xmm2
movsd 0x78(%rdi), %xmm3
movapd %xmm10, %xmm6
mulsd %xmm2, %xmm6
movapd %xmm13, %xmm5
mulsd %xmm3, %xmm5
subsd %xmm6, %xmm5
movapd %xmm10, %xmm9
mulsd %xmm7, %xmm9
movapd %xmm11, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm9, %xmm6
movapd %xmm13, %xmm9
mulsd %xmm12, %xmm10
mulsd %xmm1, %xmm3
subsd %xmm10, %xmm3
movapd %xmm11, %xmm10
mulsd %xmm2, %xmm10
mulsd %xmm12, %xmm13
mulsd %xmm1, %xmm2
subsd %xmm13, %xmm2
movapd %xmm0, %xmm13
mulsd %xmm12, %xmm11
movapd %xmm8, %xmm12
mulsd %xmm7, %xmm1
subsd %xmm11, %xmm1
movapd %xmm0, %xmm11
mulsd %xmm1, %xmm0
mulsd %xmm8, %xmm1
mulsd %xmm6, %xmm8
mulsd %xmm3, %xmm12
mulsd %xmm2, %xmm11
mulsd %xmm4, %xmm3
mulsd %xmm4, %xmm2
mulsd %xmm5, %xmm4
subsd %xmm8, %xmm4
mulsd %xmm7, %xmm9
subsd %xmm9, %xmm10
mulsd %xmm10, %xmm13
addsd %xmm4, %xmm13
mulsd (%rdi), %xmm13
xorpd %xmm4, %xmm4
addsd %xmm13, %xmm4
movsd 0x20(%rdi), %xmm7
mulsd %xmm7, %xmm5
subsd %xmm12, %xmm5
addsd %xmm5, %xmm11
mulsd 0x8(%rdi), %xmm11
subsd %xmm11, %xmm4
mulsd %xmm7, %xmm6
subsd %xmm3, %xmm6
addsd %xmm6, %xmm0
mulsd 0x10(%rdi), %xmm0
addsd %xmm4, %xmm0
mulsd %xmm7, %xmm10
subsd %xmm2, %xmm10
addsd %xmm10, %xmm1
mulsd 0x18(%rdi), %xmm1
subsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4MatrixDet4(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
RNScalar R4MatrixDet4 (
    RNScalar a, RNScalar b, RNScalar c, RNScalar d, 
    RNScalar e, RNScalar f, RNScalar g, RNScalar h, 
    RNScalar i, RNScalar j, RNScalar k, RNScalar l, 
    RNScalar m, RNScalar n, RNScalar o, RNScalar p)
{
    /* Return determinant of 4x4 matrix */
    RNScalar det = 0.0;
    det += a * R4MatrixDet3(f,g,h,j,k,l,n,o,p);
    det -= b * R4MatrixDet3(e,g,h,i,k,l,m,o,p);
    det += c * R4MatrixDet3(e,f,h,i,j,l,m,n,p);
    det -= d * R4MatrixDet3(e,f,g,i,j,k,m,n,o);
    return (det);
}

// Assembly:
movapd %xmm7, %xmm9
movsd %xmm3, -0x8(%rsp)
movsd %xmm2, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm7
movsd 0x30(%rsp), %xmm2
movsd 0x40(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm15
movsd 0x38(%rsp), %xmm8
movapd %xmm8, %xmm11
mulsd %xmm15, %xmm11
movapd %xmm1, %xmm12
mulsd %xmm0, %xmm12
subsd %xmm11, %xmm12
movapd %xmm2, %xmm13
mulsd %xmm15, %xmm13
movapd %xmm7, %xmm11
mulsd %xmm0, %xmm11
subsd %xmm13, %xmm11
movsd 0x28(%rsp), %xmm13
mulsd %xmm13, %xmm15
movsd 0x8(%rsp), %xmm14
mulsd %xmm14, %xmm0
subsd %xmm15, %xmm0
movapd %xmm7, %xmm15
mulsd %xmm8, %xmm15
mulsd %xmm14, %xmm8
mulsd %xmm2, %xmm14
mulsd %xmm1, %xmm2
mulsd %xmm13, %xmm1
subsd %xmm1, %xmm8
movapd %xmm11, %xmm1
mulsd %xmm6, %xmm1
movapd %xmm9, %xmm7
mulsd %xmm8, %xmm7
movapd %xmm0, %xmm10
mulsd %xmm5, %xmm0
mulsd %xmm5, %xmm8
mulsd %xmm12, %xmm5
subsd %xmm1, %xmm5
subsd %xmm2, %xmm15
movapd %xmm9, %xmm1
mulsd %xmm15, %xmm1
addsd %xmm5, %xmm1
mulsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm3
mulsd %xmm6, %xmm10
mulsd %xmm4, %xmm12
subsd %xmm10, %xmm12
addsd %xmm12, %xmm7
mulsd -0x18(%rsp), %xmm7
subsd %xmm7, %xmm3
mulsd %xmm4, %xmm11
subsd %xmm0, %xmm11
mulsd 0x10(%rsp), %xmm13
subsd %xmm13, %xmm14
mulsd %xmm14, %xmm9
addsd %xmm9, %xmm11
mulsd -0x10(%rsp), %xmm11
addsd %xmm11, %xmm3
mulsd %xmm4, %xmm15
subsd %xmm8, %xmm15
mulsd %xmm6, %xmm14
addsd %xmm15, %xmm14
mulsd -0x8(%rsp), %xmm14
subsd %xmm14, %xmm3
movapd %xmm3, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Transpose() const
const R4Matrix R4Matrix::
Transpose(void) const
{
    // Return transpose of matrix
    return R4Matrix(
        m[0][0], m[1][0], m[2][0], m[3][0],
        m[0][1], m[1][1], m[2][1], m[3][1],
        m[0][2], m[1][2], m[2][2], m[3][2],
        m[0][3], m[1][3], m[2][3], m[3][3]);
}

// Assembly:
movq %rdi, %rax
movsd 0x20(%rsi), %xmm0
movsd 0x40(%rsi), %xmm1
movsd 0x60(%rsi), %xmm2
movsd (%rsi), %xmm3
movsd 0x8(%rsi), %xmm4
movsd 0x28(%rsi), %xmm5
movsd 0x48(%rsi), %xmm6
movsd 0x68(%rsi), %xmm7
movsd 0x10(%rsi), %xmm8
movsd 0x30(%rsi), %xmm9
movsd 0x50(%rsi), %xmm10
movsd 0x70(%rsi), %xmm11
movsd 0x18(%rsi), %xmm12
movsd 0x38(%rsi), %xmm13
movsd 0x58(%rsi), %xmm14
movsd 0x78(%rsi), %xmm15
movsd %xmm3, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm4, 0x20(%rdi)
movsd %xmm5, 0x28(%rdi)
movsd %xmm6, 0x30(%rdi)
movsd %xmm7, 0x38(%rdi)
movsd %xmm8, 0x40(%rdi)
movsd %xmm9, 0x48(%rdi)
movsd %xmm10, 0x50(%rdi)
movsd %xmm11, 0x58(%rdi)
movsd %xmm12, 0x60(%rdi)
movsd %xmm13, 0x68(%rdi)
movsd %xmm14, 0x70(%rdi)
movsd %xmm15, 0x78(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Flip()
void R4Matrix::
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[3][0]; m[3][0] = m[0][3]; m[0][3] = tmp;
    tmp = m[1][2]; m[1][2] = m[2][1]; m[2][1] = tmp;
    tmp = m[1][3]; m[1][3] = m[3][1]; m[3][1] = tmp;
    tmp = m[2][3]; m[2][3] = m[3][2]; m[3][2] = tmp;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
movsd %xmm1, 0x20(%rdi)
movsd %xmm0, 0x8(%rdi)
movsd 0x40(%rdi), %xmm0
movsd %xmm2, 0x40(%rdi)
movsd %xmm0, 0x10(%rdi)
movsd 0x60(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
movsd %xmm1, 0x60(%rdi)
movsd %xmm0, 0x18(%rdi)
movsd 0x30(%rdi), %xmm0
movsd 0x48(%rdi), %xmm1
movsd %xmm1, 0x30(%rdi)
movsd %xmm0, 0x48(%rdi)
movsd 0x38(%rdi), %xmm0
movsd 0x68(%rdi), %xmm1
movsd %xmm1, 0x38(%rdi)
movsd %xmm0, 0x68(%rdi)
movsd 0x58(%rdi), %xmm0
movsd 0x70(%rdi), %xmm1
movsd %xmm1, 0x58(%rdi)
movsd %xmm0, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Translate(int, double)
void R4Matrix:: 
Translate(RNAxis axis, RNScalar offset)
{
    // Translate matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XTranslate(offset); 
	break;

    case RN_YAXIS: 
	YTranslate(offset); 
	break;

    case RN_ZAXIS: 
	ZTranslate(offset); 
	break;

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

// Assembly:
cmpl $0x2, %esi
je 0x2d62b
cmpl $0x1, %esi
je 0x2d5fe
testl %esi, %esi
jne 0x2d661
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%rdi), %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x20(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x38(%rdi), %xmm1
movsd %xmm1, 0x38(%rdi)
mulsd 0x40(%rdi), %xmm0
jmp 0x2d656
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%rdi), %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x28(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x38(%rdi), %xmm1
movsd %xmm1, 0x38(%rdi)
mulsd 0x48(%rdi), %xmm0
jmp 0x2d656
movsd 0x10(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%rdi), %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x30(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x38(%rdi), %xmm1
movsd %xmm1, 0x38(%rdi)
mulsd 0x50(%rdi), %xmm0
addsd 0x58(%rdi), %xmm0
movsd %xmm0, 0x58(%rdi)
retq
leaq 0x75886(%rip), %rdi     # 0xa2eee
xorl %eax, %eax
jmp 0x72ad9
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Translate(double)
void R4Matrix::
Translate(RNScalar offset)
{
    // Translate matrix
    XTranslate(offset);
    YTranslate(offset);
    ZTranslate(offset);
}

// Assembly:
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%rdi), %xmm1
movsd 0x20(%rdi), %xmm2
mulsd %xmm0, %xmm2
addsd 0x38(%rdi), %xmm2
movsd 0x40(%rdi), %xmm3
mulsd %xmm0, %xmm3
addsd 0x58(%rdi), %xmm3
movsd 0x8(%rdi), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm1, %xmm4
movsd 0x28(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd 0x48(%rdi), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd 0x10(%rdi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, 0x18(%rdi)
movsd 0x30(%rdi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x38(%rdi)
mulsd 0x50(%rdi), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Scale(int, double)
void R4Matrix:: 
Scale(RNAxis axis, RNScalar scale)
{
    // Scale matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XScale(scale); 
	break;

    case RN_YAXIS: 
	YScale(scale); 
	break;

    case RN_ZAXIS: 
	ZScale(scale); 
	break;

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

// Assembly:
cmpl $0x2, %esi
je 0x2d86c
cmpl $0x1, %esi
je 0x2d845
testl %esi, %esi
jne 0x2d893
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x20(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rdi)
mulsd 0x40(%rdi), %xmm0
movsd %xmm0, 0x40(%rdi)
retq
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x28(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rdi)
mulsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x48(%rdi)
retq
movsd 0x10(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movsd 0x30(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rdi)
mulsd 0x50(%rdi), %xmm0
movsd %xmm0, 0x50(%rdi)
retq
leaq 0x7567a(%rip), %rdi     # 0xa2f14
xorl %eax, %eax
jmp 0x72ad9
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Scale(double)
void R4Matrix:: 
XScale(RNScalar scale)
{
    // Scale matrix -- post-multiply by: 
    //   [ sx 0 0 0 ]
    //   [ 0  1 0 0 ]
    //   [ 0  0 1 0 ]
    //   [ 0  0 0 1 ]
    m[0][0] *= scale;
    m[1][0] *= scale;
    m[2][0] *= scale;
}

// Assembly:
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd (%rdi), %xmm2
movupd 0x20(%rdi), %xmm3
movupd 0x40(%rdi), %xmm4
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulpd %xmm1, %xmm3
movupd %xmm3, 0x20(%rdi)
mulpd %xmm1, %xmm4
movupd %xmm4, 0x40(%rdi)
movsd 0x10(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movsd 0x30(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rdi)
mulsd 0x50(%rdi), %xmm0
movsd %xmm0, 0x50(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::XRotate(double)
void R4Matrix:: 
XRotate(RNAngle radians)
{
    // rotate matrix around X axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        1.0, 0.0, 0.0, 0.0,
        0.0, c,   -s,  0.0,
        0.0, s,   c,   0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe860
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movaps 0x74678(%rip), %xmm1    # 0xa2020
xorps %xmm0, %xmm1
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x98(%rsp), %rdx
movq %rax, (%rdx)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%rdx)
movups %xmm2, 0x18(%rdx)
movsd 0x8(%rsp), %xmm3
movsd %xmm3, 0x28(%rdx)
movlps %xmm1, 0x30(%rdx)
movups %xmm2, 0x38(%rdx)
movsd %xmm0, 0x48(%rdx)
movsd %xmm3, 0x50(%rdx)
movups %xmm2, 0x58(%rdx)
movups %xmm2, 0x68(%rdx)
movq %rax, 0x78(%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e5ab
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movaps 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movaps 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movaps 0x60(%r14), %xmm0
movups %xmm0, 0x60(%rbx)
movaps 0x70(%r14), %xmm0
movups %xmm0, 0x70(%rbx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
nop