LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b064(%rip), %xmm0    # 0x93008
subsd %xmm1, %xmm0
leaq 0x88(%rsp), %r13
movq %r13, %rdi
callq 0x382c0
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
callq 0x382c0
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3827a
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x27dbc
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x28b5e
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x27dbc
leaq 0x128(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x28b5e
leaq 0x108(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd (%rsp), %xmm0
callq 0x28859
leaq 0x71671(%rip), %rdx     # 0x996c0
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x294f5
leaq 0x71672(%rip), %rdx     # 0x996d8
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x294f5
movq %r12, %rdi
callq 0x3860e
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x389be
movq %r13, %rdi
callq 0x3860e
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x389be
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3887c
movq %r15, %rdi
callq 0x3860e
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x281ea
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x27d96
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_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Triad.h
// Function: gaps::R3Triad::operator=(gaps::R3Triad const&)
inline R3Triad& R3Triad::
operator=(const R3Triad& triad)
{
    axis[0] = triad.axis[0];
    axis[1] = triad.axis[1];
    axis[2] = triad.axis[2];
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3887c
leaq 0x18(%rbx), %rsi
leaq 0x18(%r14), %rdi
callq 0x3887c
addq $0x30, %rbx
leaq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x3887c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3830a
addq $0x18, %r12
cmpq $0x48, %r12
jne 0x2827b
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x38c72
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3887c
movq %r15, %rdi
callq 0x3860e
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x389be
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3889c
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3889c
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3889c
movq %r12, %rdi
callq 0x3860e
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x389be
movq %r14, %rdi
movq %r15, %rsi
callq 0x3887c
movq %r14, %rdi
callq 0x3860e
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4555f
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x389be
movq %r12, %rdi
callq 0x3860e
movq %rbx, %rdi
movq %r12, %rsi
movsd (%rsp), %xmm0
callq 0x28452
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x3860e
leaq 0x18(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x389be
movq %r15, %rdi
movq %r12, %rsi
callq 0x3887c
movq %r15, %rdi
callq 0x3860e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38b6c
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38b6c
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x38b6c
movq %r12, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x389be
movq %r14, %rdi
movq %r15, %rsi
callq 0x3887c
movq %r14, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38bb8
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38bb8
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x38bb8
movq %r12, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x389be
movq %r14, %rdi
movq %r15, %rsi
callq 0x3887c
movq %r14, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38bca
leaq 0x18(%r14), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38bca
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x38bca
movq %r12, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x389be
movq %r14, %rdi
movq %r15, %rsi
callq 0x3887c
movq %r14, %rdi
callq 0x3860e
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x389be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3887c
movq %rbx, %rdi
callq 0x3860e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movupd (%rdi), %xmm1
movupd 0x10(%rdi), %xmm0
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm3, %xmm3
addsd %xmm2, %xmm3
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
sqrtsd %xmm2, %xmm2
leaq 0xb23d8(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm3
movapd 0x6a854(%rip), %xmm4    # 0x93030
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
jb 0x287ed
ucomisd %xmm2, %xmm3
jb 0x287ed
retq
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movupd %xmm1, (%rdi)
divpd %xmm2, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a5a3(%rip), %xmm0    # 0x93010
movsd %xmm0, 0x8(%rsp)
callq 0xe0f0
movapd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3831c
movq %r15, %rdi
callq 0x3860e
movsd 0x8(%rsp), %xmm0
callq 0xe890
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 0x28780
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a521(%rip), %xmm0    # 0x93010
movsd %xmm0, 0x8(%rsp)
callq 0xe0f0
movapd %xmm0, 0x10(%rsp)
movslq %ebp, %rax
imulq $0x18, %rax, %rsi
addq 0xb14aa(%rip), %rsi     # 0xd9fb8
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3831c
movsd 0x8(%rsp), %xmm0
callq 0xe890
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 0x28780
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29283
jp 0x29283
movsd 0x8(%rdi), %xmm0
ucomisd 0x8(%rsi), %xmm0
jne 0x29283
jp 0x29283
movsd 0x10(%rdi), %xmm0
ucomisd 0x10(%rsi), %xmm0
jne 0x29283
jp 0x29283
movsd 0x18(%rsi), %xmm0
cmpeqsd 0x18(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rax
ucomisd (%rsi), %xmm0
jne 0x29293
jnp 0x29294
retq
movsd 0x8(%rdi), %xmm0
ucomisd 0x8(%rsi), %xmm0
jne 0x29293
jp 0x29293
movsd 0x10(%rdi), %xmm0
ucomisd 0x10(%rsi), %xmm0
jne 0x29293
jp 0x29293
movsd 0x18(%rsi), %xmm0
cmpneqsd 0x18(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x69d65(%rip), %xmm0    # 0x93030
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x10(%rsi), %xmm0
callq 0x293f6
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x293ea
movsd (%rbx), %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x293b4
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::operator*(gaps::R3Quaternion const&, gaps::R3Vector const&)
R3Vector
operator*(const R3Quaternion& q, const R3Vector& v)
{
    // Compute quaternion representation of vector
    RNLength length = v.Length();
    if (RNIsZero(length)) return v;
    R3Quaternion vector(0, v[0] / length, v[1] / length, v[2] / length);

    // Compute quaternion representation of rotated vector
    R3Quaternion conjugate(q[0], -q[1], -q[2], -q[3]);
    R3Quaternion result = q;
    result.Multiply(vector);
    result.Multiply(conjugate);
    assert(RNIsZero(result[0]));

    // Return rotated vector
    return R3Vector(length * result[1], length * result[2], length * result[3]); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x38412
leaq 0xb168d(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm2
movapd 0x69b09(%rip), %xmm1    # 0x93030
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x29547
ucomisd %xmm0, %xmm2
jb 0x29547
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3831c
jmp 0x29641
movsd 0x10(%r12), %xmm3
leaq 0x88(%rsp), %r15
andq $0x0, (%r15)
divsd %xmm0, %xmm3
movupd (%r12), %xmm1
movapd %xmm0, %xmm2
movapd %xmm0, 0x30(%rsp)
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x8(%r15)
movsd %xmm3, 0x18(%r15)
movq %r15, %rdi
callq 0x28780
movsd (%r14), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x18(%r14), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps 0x69a89(%rip), %xmm0    # 0x93030
xorps %xmm0, %xmm1
leaq 0x68(%rsp), %r12
movsd %xmm2, (%r12)
movups 0x8(%r14), %xmm2
movaps %xmm2, 0x10(%rsp)
xorps %xmm2, %xmm0
movups %xmm0, 0x8(%r12)
movlps %xmm1, 0x18(%r12)
movq %r12, %rdi
callq 0x28780
leaq 0x48(%rsp), %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x8(%r14)
movaps 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x292e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x292e0
movsd 0x8(%r14), %xmm0
movapd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x10(%r14), %xmm1
mulsd %xmm2, %xmm1
movapd %xmm2, %xmm3
movsd 0x18(%r14), %xmm2
mulsd %xmm3, %xmm2
movq %rbx, %rdi
callq 0x3830c
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb1357(%rip), %rax     # 0xdaba8
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 0x298bb
movapd 0x697bb(%rip), %xmm2    # 0x93030
xorpd %xmm1, %xmm2
ucomisd %xmm3, %xmm2
ja 0x298bb
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_O2/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 0xb12e0(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x29912
movapd 0x69753(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x29912
movsd 0x38(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x29912
ucomisd %xmm2, %xmm1
ja 0x29912
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_O2/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 0xb126b(%rip), %rax     # 0xdaba8
addsd 0x696db(%rip), %xmm2    # 0x93020
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x299df
movapd 0x696d2(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x299df
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 0x6968d(%rip), %xmm2    # 0x93020
ucomisd %xmm0, %xmm2
ja 0x299df
ucomisd %xmm2, %xmm1
ja 0x299df
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 0x69656(%rip), %xmm3    # 0x93020
cmpltpd %xmm3, %xmm0
cmpltpd %xmm1, %xmm3
orpd %xmm0, %xmm3
movd %xmm3, %eax
andl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb11bc(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm2
pushq $0x1
popq %rax
ja 0x29a69
movapd 0x6962f(%rip), %xmm1    # 0x93030
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
ja 0x29a69
movsd 0x10(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x29a69
ucomisd %xmm2, %xmm1
ja 0x29a69
movsd 0x20(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x29a69
ucomisd %xmm2, %xmm1
ja 0x29a69
movsd 0x30(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x29a69
ucomisd %xmm2, %xmm1
ja 0x29a69
movsd 0x40(%rdi), %xmm2
ucomisd %xmm0, %xmm2
ja 0x29a69
ucomisd %xmm2, %xmm1
ja 0x29a69
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_O2/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 0x3830c
movsd 0x8(%r14), %xmm0
movsd 0x28(%r14), %xmm1
movsd 0x48(%r14), %xmm2
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x3830c
movsd 0x10(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movsd 0x50(%r14), %xmm2
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3830c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x389be
movq %r14, %rdi
movq %r12, %rsi
callq 0x38586
leaq 0xb10b2(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
xorpd 0x6952e(%rip), %xmm1    # 0x93030
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_O2/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:
subq $0x48, %rsp
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
movsd 0x18(%rdi), %xmm3
movsd 0x20(%rdi), %xmm4
movsd 0x28(%rdi), %xmm5
movsd 0x30(%rdi), %xmm6
movsd 0x38(%rdi), %xmm7
movups 0x40(%rdi), %xmm8
movups 0x50(%rdi), %xmm9
movups 0x60(%rdi), %xmm10
movups 0x70(%rdi), %xmm11
movups %xmm11, 0x30(%rsp)
movups %xmm10, 0x20(%rsp)
movups %xmm9, 0x10(%rsp)
movups %xmm8, (%rsp)
callq 0x29b78
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Translate(gaps::R3Vector const&)
void R4Matrix:: 
Translate(const R3Vector& offset)
{
    // Translate matrix
    XTranslate(offset.X());
    YTranslate(offset.Y());
    ZTranslate(offset.Z());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
callq 0x2a4cc
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x2a502
movsd 0x10(%rbx), %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a538
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Scale(gaps::R3Vector const&)
void R4Matrix:: 
Scale(const R3Vector& scale)
{
    // Scale matrix
    XScale(scale.X());
    YScale(scale.Y());
    ZScale(scale.Z());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
callq 0x2a600
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x2a626
movsd 0x10(%rbx), %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a64e
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x90, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe890
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movaps 0x688fc(%rip), %xmm1    # 0x93030
xorps %xmm0, %xmm1
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%rsi)
movups %xmm2, 0x18(%rsi)
movsd 0x8(%rsp), %xmm3
movsd %xmm3, 0x28(%rsi)
movlps %xmm1, 0x30(%rsi)
movups %xmm2, 0x38(%rsi)
movsd %xmm0, 0x48(%rsi)
movsd %xmm3, 0x50(%rsi)
movups %xmm2, 0x58(%rsi)
movups %xmm2, 0x68(%rsi)
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2b2b6
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::YRotate(double)
void R4Matrix:: 
YRotate(RNAngle radians)
{
    // rotate matrix around Y axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        c,   0.0, s,   0.0,
        0.0, 1.0, 0.0, 0.0,
        -s,  0.0, c,   0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe890
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
leaq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rsi)
andq $0x0, 0x8(%rsi)
movaps 0x68862(%rip), %xmm1    # 0x93030
xorps %xmm0, %xmm1
movsd %xmm0, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rsi)
movups %xmm0, 0x30(%rsi)
movlps %xmm1, 0x40(%rsi)
andq $0x0, 0x48(%rsi)
movsd %xmm2, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2b2b6
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::ZRotate(double)
void R4Matrix:: 
ZRotate(RNAngle radians)
{
    // rotate matrix around Z axis counterclockwise 
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        c,   -s,  0.0, 0.0,
        s,   c,   0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe890
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movaps 0x687ea(%rip), %xmm1    # 0x93030
xorps %xmm0, %xmm1
leaq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rsi)
movlps %xmm1, 0x8(%rsi)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rsi)
movsd %xmm0, 0x20(%rsi)
movsd %xmm2, 0x28(%rsi)
movups %xmm1, 0x30(%rsi)
movups %xmm1, 0x40(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x50(%rsi)
movups %xmm1, 0x58(%rsi)
movups %xmm1, 0x68(%rsi)
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2b2b6
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&)
void R4Matrix:: 
Rotate(const R3Vector& radians)
{
#if 1
    // Rotate first around X, then around Y, and finally around Z
    R4Matrix rotation = R4identity_matrix;
    rotation.ZRotate(radians.Z());
    rotation.YRotate(radians.Y());
    rotation.XRotate(radians.X());
    *this *= rotation;
#else
    // This is faster way to do same thing (not tested)
    // Note: this matrix is for pre-multiplication -- need one for postmultiplication
    R4Matrix rotation(
      cos(radians.Y())*cos(radians.Z()),  
      sin(radians.X())*sin(radians.Y())*cos(radians.Z()) - cos(radians.X())*sin(radians.Z()), 
      cos(radians.X())*sin(radians.Y())*cos(radians.Z()) + sin(radians.X())*sin(radians.Z()), 0,
      cos(radians.Y())*sin(radians.Z()),
      sin(radians.X())*sin(radians.Y())*sin(radians.Z()) + cos(radians.X())*cos(radians.Z()),
      cos(radians.X())*sin(radians.Y())*sin(radians.Z()) - sin(radians.X())*cos(radians.Z()), 0,
      -sin(radians.Y()), 
      sin(radians.X())*cos(radians.Y()),
      cos(radians.X())*cos(radians.Y()), 0,
      0, 0, 0, 1);
    *this *= rotation;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6950d(%rip), %rsi     # 0x93df0
movq %rsp, %r15
movq %r15, %rdi
callq 0x2967c
movsd 0x10(%rbx), %xmm0
movq %r15, %rdi
callq 0x2a81a
movsd 0x8(%rbx), %xmm0
movq %r15, %rdi
callq 0x2a78e
movsd (%rbx), %xmm0
movq %r15, %rdi
callq 0x2a708
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b2b6
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&, double)
void R4Matrix:: 
Rotate(const R3Vector& axis, RNAngle radians)
{
    // rotate matrix for arbitrary axis counterclockwise
    // From Graphics Gems I, p. 466
    RNCoord x = axis.X();
    RNCoord y = axis.Y();
    RNCoord z = axis.Z();
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    RNScalar t = 1.0 - c;
    R4Matrix rotation(
        t*x*x + c, t*x*y - s*z, t*x*z + s*y, 0.0,
        t*x*y + s*z, t*y*y + c, t*y*z - s*x, 0.0,
        t*x*z - s*y, t*y*z + s*x, t*z*z + c, 0.0,
        0.0, 0.0, 0.0, 1.0);
    *this *= rotation;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movaps %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, %xmm0
callq 0xe890
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd 0x68696(%rip), %xmm5    # 0x93008
movapd 0x10(%rsp), %xmm4
subsd %xmm4, %xmm5
movapd 0x20(%rsp), %xmm8
movapd %xmm8, %xmm2
mulsd %xmm0, %xmm2
movapd 0x6869c(%rip), %xmm1    # 0x93030
movapd %xmm2, %xmm3
xorpd %xmm1, %xmm3
movapd %xmm4, %xmm6
movapd %xmm4, %xmm11
unpcklpd %xmm3, %xmm6            # xmm6 = xmm6[0],xmm3[0]
movapd 0x30(%rsp), %xmm4
movapd %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
movapd %xmm3, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm4, %xmm0
movapd %xmm4, %xmm12
movapd %xmm8, %xmm4
mulsd %xmm5, %xmm4
mulsd %xmm8, %xmm4
movapd %xmm8, %xmm10
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm12, %xmm5
movapd %xmm5, %xmm8
mulsd %xmm10, %xmm8
mulpd %xmm5, %xmm3
movapd %xmm5, %xmm9
unpckhpd %xmm5, %xmm9            # xmm9 = xmm9[1],xmm5[1]
mulsd %xmm10, %xmm9
unpcklpd %xmm10, %xmm10          # xmm10 = xmm10[0,0]
mulpd %xmm5, %xmm10
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm12, %xmm5
xorpd %xmm7, %xmm1
addsd %xmm11, %xmm4
leaq 0x40(%rsp), %rsi
andq $0x0, 0x18(%rsi)
addpd %xmm6, %xmm5
addsd %xmm7, %xmm8
unpcklpd %xmm11, %xmm2           # xmm2 = xmm2[0],xmm11[0]
addpd %xmm2, %xmm3
subsd %xmm0, %xmm9
movapd %xmm5, (%rsi)
movsd %xmm8, 0x10(%rsi)
movapd %xmm3, 0x20(%rsi)
movsd %xmm9, 0x30(%rsi)
andq $0x0, 0x38(%rsi)
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd %xmm1, %xmm10
movapd %xmm10, 0x40(%rsi)
movsd %xmm4, 0x50(%rsi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x58(%rsi)
movupd %xmm0, 0x68(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2b2b6
addq $0xc0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&, gaps::R3Vector const&)
void R4Matrix:: 
Rotate(const R3Vector& from, const R3Vector& to)
{
    // rotate matrix that takes direction of vector "from" -> "to"
    // This is a quickie hack -- there's got to be a better way
    RNAngle radians = R3InteriorAngle(from, to);
    R3Vector axis = from % to;
    axis.Normalize();
    Rotate(axis, radians);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4555f
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x389be
movq %r12, %rdi
callq 0x3860e
movq %r15, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x2a92c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator-(gaps::R4Matrix const&)
R4Matrix 
operator-(const R4Matrix& a)
{
    // Negate matrix
    return R4Matrix(
   	-a.m[0][0], -a.m[0][1], -a.m[0][2], -a.m[0][3], 
	-a.m[1][0], -a.m[1][1], -a.m[1][2], -a.m[1][3], 
        -a.m[2][0], -a.m[2][1], -a.m[2][2], -a.m[2][3], 
        -a.m[3][0], -a.m[3][1], -a.m[3][2], -a.m[3][3]);
}

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

    // Multiply matrix
    for (r=0; r<4; r++)
	for (c=0; c<4; 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] + a.m[r][3] * b.m[3][c];

    // Return result
    return result;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2b192
movq %rcx, %r8
shlq $0x5, %r8
movsd (%rsi,%r8), %xmm0
movsd 0x8(%rsi,%r8), %xmm1
movsd 0x10(%rsi,%r8), %xmm2
movsd 0x18(%rsi,%r8), %xmm3
xorl %r8d, %r8d
cmpq $0x4, %r8
je 0x2b189
movsd 0x20(%rdx,%r8,8), %xmm4
mulsd %xmm1, %xmm4
movsd (%rdx,%r8,8), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x40(%rdx,%r8,8), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
movsd 0x60(%rdx,%r8,8), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, (%rdi,%r8,8)
incq %r8
jmp 0x2b141
incq %rcx
addq $0x20, %rdi
jmp 0x2b116
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::R3Grid(int, int, int)
R3Grid::
R3Grid(int xresolution, int yresolution, int zresolution)
{
  // Set grid resolution
  grid_resolution[0] = xresolution;
  grid_resolution[1] = yresolution;
  grid_resolution[2] = zresolution;
  grid_row_size = xresolution;
  grid_sheet_size = grid_row_size * yresolution;
  grid_size = grid_sheet_size * zresolution;

  // Allocate grid values
  if (grid_size == 0) grid_values = NULL;
  else grid_values = new RNScalar [ grid_size ];
  assert(!grid_size || grid_values);

  // Set all values to zero
  for (int i = 0; i < grid_size; i++) grid_values[i] = 0;

  // Set transformations
  grid_to_world_transform = R3identity_affine;
  world_to_grid_transform = R3identity_affine;
  world_to_grid_scale_factor = 1.0;
  grid_to_world_scale_factor = 1.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0x27652
leaq 0x110(%rbx), %r14
movq %r14, %rdi
callq 0x27652
movl %r12d, 0x238(%rbx)
movl %r15d, 0x23c(%rbx)
movl %ebp, 0x240(%rbx)
movl %r12d, 0x244(%rbx)
imull %r12d, %r15d
movl %r15d, 0x248(%rbx)
imull %ebp, %r15d
movl %r15d, 0x24c(%rbx)
xorl %r12d, %r12d
testl %r15d, %r15d
je 0x2b364
movl %r15d, %eax
shlq $0x3, %rax
testl %r15d, %r15d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0xe030
jmp 0x2b366
xorl %eax, %eax
movq %rax, 0x230(%rbx)
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x2b383
andq $0x0, (%rax,%r12,8)
incq %r12
jmp 0x2b374
leaq 0xafc86(%rip), %rsi     # 0xdb010
movq %rbx, %rdi
callq 0x21db8
leaq 0xafc77(%rip), %rsi     # 0xdb010
movq %r14, %rdi
callq 0x21db8
movaps 0x68b68(%rip), %xmm0    # 0x93f10
movups %xmm0, 0x220(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x2b3c8
movq %rax, %r15
movq %r14, %rdi
callq 0x276ee
movq %rbx, %rdi
callq 0x276ee
movq %r15, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::R3Grid(int, int, int, gaps::R3Box const&)
R3Grid::
R3Grid(int xresolution, int yresolution, int zresolution, const R3Box& bbox)
{
  // Set grid resolution
  grid_resolution[0] = xresolution;
  grid_resolution[1] = yresolution;
  grid_resolution[2] = zresolution;
  grid_row_size = xresolution;
  grid_sheet_size = grid_row_size * yresolution;
  grid_size = grid_sheet_size * zresolution;

  // Allocate grid values
  if (grid_size == 0) grid_values = NULL;
  else grid_values = new RNScalar [ grid_size ];
  assert(!grid_size || grid_values);

  // Set all values to zero
  for (int i = 0; i < grid_size; i++) grid_values[i] = 0;

  // Set transformations
  SetWorldToGridTransformation(bbox);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
callq 0x27652
leaq 0x110(%rbx), %r14
movq %r14, %rdi
callq 0x27652
movl %r13d, 0x238(%rbx)
movl %r12d, 0x23c(%rbx)
movl %ebp, 0x240(%rbx)
movl %r13d, 0x244(%rbx)
imull %r13d, %r12d
movl %r12d, 0x248(%rbx)
imull %ebp, %r12d
movl %r12d, 0x24c(%rbx)
xorl %r13d, %r13d
testl %r12d, %r12d
je 0x2b456
movl %r12d, %eax
shlq $0x3, %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0xe030
jmp 0x2b458
xorl %eax, %eax
movq %rax, 0x230(%rbx)
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x2b475
andq $0x0, (%rax,%r13,8)
incq %r13
jmp 0x2b466
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b4b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x2b49f
movq %rax, %r15
movq %r14, %rdi
callq 0x276ee
movq %rbx, %rdi
callq 0x276ee
movq %r15, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::operator=(gaps::R3Grid const&)
R3Grid& R3Grid::
operator=(const R3Grid& grid) 
{
  // Delete old grid values
  if (grid_values) {
    if (grid_size != grid.grid_size) {
      delete [] grid_values;
      grid_values = NULL;
    }
  }

  // Allocate new grid values
  if (!grid_values && (grid.grid_size > 0)) {
    grid_values = new RNScalar [ grid.grid_size ];
    assert(grid_values);
  }

  // Copy grid resolution
  grid_resolution[0] = grid.grid_resolution[0];
  grid_resolution[1] = grid.grid_resolution[1];
  grid_resolution[2] = grid.grid_resolution[2];
  grid_row_size = grid.grid_row_size;
  grid_sheet_size = grid.grid_sheet_size;
  grid_size = grid.grid_size;

  // Copy grid values
  for (int i = 0; i < grid_size; i++) {
    grid_values[i] = grid.grid_values[i];
  }

  // Copy transforms
  grid_to_world_transform = grid.grid_to_world_transform;
  world_to_grid_transform = grid.world_to_grid_transform;
  world_to_grid_scale_factor = grid.world_to_grid_scale_factor;
  grid_to_world_scale_factor = grid.grid_to_world_scale_factor;

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x230(%rdi), %rax
testq %rax, %rax
je 0x2baef
movl 0x24c(%rbx), %ecx
cmpl 0x24c(%r14), %ecx
je 0x2bb0f
movq %rax, %rdi
callq 0xe5d0
andq $0x0, 0x230(%rbx)
movslq 0x24c(%r14), %rdi
testq %rdi, %rdi
jle 0x2bb0d
shlq $0x3, %rdi
callq 0xe030
movq %rax, 0x230(%rbx)
jmp 0x2bb0f
xorl %eax, %eax
movl 0x238(%r14), %ecx
movl %ecx, 0x238(%rbx)
movl 0x23c(%r14), %ecx
movl %ecx, 0x23c(%rbx)
movl 0x240(%r14), %ecx
movl %ecx, 0x240(%rbx)
movq 0x244(%r14), %rcx
movq %rcx, 0x244(%rbx)
movl 0x24c(%r14), %ecx
movl %ecx, 0x24c(%rbx)
movq 0x230(%r14), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x2bb73
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0x2bb5f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21db8
movl $0x110, %edi            # imm = 0x110
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x21db8
movups 0x220(%r14), %xmm0
movups %xmm0, 0x220(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Variance() const
RNScalar R3Grid::
Variance(void) const
{
  // Return the variance of the values in the grid
  RNScalar sum = 0;
  RNScalar mean = Mean();
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar delta = (*(grid_valuep++) - mean);
    sum += delta * delta;
  }
  return sum / grid_size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x365b4
movq 0x230(%rbx), %rcx
movl 0x24c(%rbx), %eax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
xorpd %xmm1, %xmm1
cmpl %edx, %esi
je 0x2bc6c
movsd (%rcx,%rdx,8), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
incq %rdx
jmp 0x2bc52
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Percentile(double) const
RNScalar R3Grid::
Percentile(RNScalar percentile) const
{
  // Return value at given percentile 
  if (grid_size == 0) return 0.0;
  RNScalar *tmp_values = new RNScalar [ grid_size ];
  for (int i = 0; i < grid_size; i++) tmp_values[i] = grid_values[i];
  qsort(tmp_values, grid_size, sizeof(RNScalar), RNCompareScalars);
  int percentile_index = percentile * grid_size;
  RNScalar value = tmp_values[percentile_index];
  delete [] tmp_values;
  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq 0x24c(%rdi), %r14
testq %r14, %r14
je 0x2bd29
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
leaq (,%r14,8), %rax
xorl %r12d, %r12d
testl %r14d, %r14d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movl $0x0, %r13d
cmovgl %r14d, %r13d
callq 0xe030
movq %rax, %r15
movq 0x230(%rbx), %rax
cmpq %r12, %r13
je 0x2bce4
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%r15,%r12,8)
incq %r12
jmp 0x2bcce
leaq 0x3c14a(%rip), %rcx     # 0x67e35
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xe8b0
cvtsi2sdl 0x24c(%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
cltq
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xe5d0
movsd 0x8(%rsp), %xmm0
jmp 0x2bd2c
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Range() const
RNInterval R3Grid::
Range(void) const
{
  // Find smallest and largest values
  RNScalar minimum = FLT_MAX;
  RNScalar maximum = -FLT_MAX;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (*grid_valuep < minimum) minimum = *grid_valuep;
    if (*grid_valuep > maximum) maximum = *grid_valuep;
    grid_valuep++;
  }
  return RNInterval(minimum, maximum);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x230(%rsi), %rax
movl 0x24c(%rsi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movsd 0x67f0e(%rip), %xmm1    # 0x93c68
movsd 0x672b6(%rip), %xmm0    # 0x93018
cmpl %edx, %ecx
je 0x2bd84
movsd (%rax,%rdx,8), %xmm2
movapd %xmm2, %xmm3
minsd %xmm0, %xmm3
maxsd %xmm1, %xmm2
incq %rdx
movapd %xmm3, %xmm0
movapd %xmm2, %xmm1
jmp 0x2bd62
movq %rbx, %rdi
callq 0x67d3c
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L1Norm() const
RNScalar R3Grid::
L1Norm(void) const
{
  // Return L1 norm of grid
  RNScalar sum = 0.0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    sum += *(grid_valuep++);
  return sum;
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorpd %xmm0, %xmm0
cmpl %edx, %ecx
je 0x2bdb8
addsd (%rax,%rdx,8), %xmm0
incq %rdx
jmp 0x2bdaa
retq
nop