LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::R3Point const*, int, int)
R3Plane::
R3Plane(const R3Point *points, int npoints, RNBoolean polygon_vertices)
{
    // Initialize plane
    v = R3null_vector;
    d = 0;

    // Check number of points
    if (npoints < 3) {
      *this = R3null_plane;
      return;
    }

    // Compute centroid
    R3Point c = R3Centroid(npoints, points);

    // Check if points form (counter-clockwise) boundary of polygon
    if (polygon_vertices) {
        // Compute best normal for counter-clockwise array of points using newell's method 
        const R3Point *p1 = &points[npoints-1];
        for (int i = 0; i < npoints; i++) {
            const R3Point *p2 = &points[i];
            v[0] += (p1->Y() - p2->Y()) * (p1->Z() + p2->Z());
            v[1] += (p1->Z() - p2->Z()) * (p1->X() + p2->X());
            v[2] += (p1->X() - p2->X()) * (p1->Y() + p2->Y());
            p1 = p2;
        }

        // Normalize 
        v.Normalize();
    }
    else {
        // Compute principle axes
        R3Triad triad = R3PrincipleAxes(c, npoints, points);

        // Select direction of least variation
        v = triad[2];
    }

    // Compute d from centroid and normal
    d = -(v[0]*c[0] + v[1]*c[1] + v[2]*c[2]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3d4bc
leaq 0x6cda3(%rip), %rsi     # 0xa86e0
movq %rbx, %rdi
callq 0x3dc6a
movq $0x0, 0x18(%rbx)
cmpl $0x2, %ebp
jg 0x3b973
leaq 0x4aad37(%rip), %rsi    # 0x4e6690
movq %rbx, %rdi
callq 0x3dc6a
movsd 0x4aad3f(%rip), %xmm0   # 0x4e66a8
movsd %xmm0, 0x18(%rbx)
jmp 0x3ba7f
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x4e65d
testl %r15d, %r15d
je 0x3ba23
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movl %ebp, %eax
leaq (%rax,%rax,2), %rcx
leaq (%r14,%rcx,8), %rcx
addq $-0x18, %rcx
movsd 0x10(%rbx), %xmm2
movsd 0x8(%rcx), %xmm3
subsd 0x8(%r14), %xmm3
movsd 0x10(%rcx), %xmm4
addsd 0x10(%r14), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
movsd %xmm0, (%rbx)
movsd (%rcx), %xmm3
movsd 0x10(%rcx), %xmm4
subsd 0x10(%r14), %xmm4
addsd (%r14), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rbx)
movsd (%rcx), %xmm3
movsd 0x8(%rcx), %xmm4
subsd (%r14), %xmm3
addsd 0x8(%r14), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
movsd %xmm2, 0x10(%rbx)
movq %r14, %rcx
addq $0x18, %r14
decq %rax
jne 0x3b9a9
movq %rbx, %rdi
callq 0x3d7e0
jmp 0x3ba4a
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4e6e7
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x3dc6a
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd 0x665a6(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::Mirror(gaps::R3Plane const&)
void R3Plane::
Mirror(const R3Plane& plane)
{
    // Mirror plane ???
    R3Point p = Point();
    p.Mirror(plane);
    v.Mirror(plane);
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x6653b(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3de8e
leaq 0x4aaf64(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x3cd71
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ce3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e03a
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r12), %xmm1
mulsd (%r12), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r12), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x664cc(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::Transform(gaps::R3Transformation const&)
void R3Plane::
Transform (const R3Transformation& transformation)
{
    // Transform plane ???
    R3Point p = Point();
    p.Transform(transformation);
    transformation.ApplyInverseTranspose(v);
    v.Normalize();
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x663d3(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3de8e
leaq 0x4aadfc(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x3cd71
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d342
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x78(%rax)
movq %rbx, %rdi
callq 0x3d7e0
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r14), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x6635e(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::InverseTransform(gaps::R3Transformation const&)
void R3Plane::
InverseTransform (const R3Transformation& transformation)
{
    // Transform plane ???
    R3Point p = Point();
    p.InverseTransform(transformation);
    transformation.ApplyTranspose(v);
    v.Normalize();
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x6632f(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3de8e
leaq 0x4aad58(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x3cd71
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d354
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x80(%rax)
movq %rbx, %rdi
callq 0x3d7e0
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r14), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x662b7(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(gaps::R3Point const&, gaps::R3Vector const&)
R3Span::
R3Span(const R3Point& point, const R3Vector& vector)
    : end(point + vector)
{
    R3Vector v(vector);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c608
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3cd71
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d4ce
movq %r12, %rdi
callq 0x3d5c4
movsd %xmm0, 0x48(%rbx)
leaq 0xa9d34(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3be7c
xorpd 0x661aa(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3be84
movq %rsp, %rdi
callq 0x3e0ec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cd94
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3dc6a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(gaps::R3Point const&, gaps::R3Point const&)
R3Span::
R3Span(const R3Point& point1, const R3Point& point2)
    : end(point2)
{
    R3Vector v(point2 - point1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point1, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c608
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x3ca36
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3cc88
movq %r12, %rdi
callq 0x3d5c4
movsd %xmm0, 0x48(%rbx)
leaq 0xa9ca4(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3bf0c
xorpd 0x6611a(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3bf14
movq %rsp, %rdi
callq 0x3e0ec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cd94
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3dc6a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(double, double, double, double, double, double)
R3Span::
R3Span(RNCoord x1, RNCoord y1, RNCoord z1, RNCoord x2, RNCoord y2, RNCoord z2)
    : end(x2, y2, z2)
{
    R3Point p1(x1, y1, z1);
    R3Point p2(x2, y2, z2);
    R3Vector v(p2 - p1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(p1, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm3, (%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
callq 0x3c608
leaq 0x30(%rbx), %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3ca26
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0x3ca26
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3ca26
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3cc88
movq %r12, %rdi
callq 0x3d5c4
movsd %xmm0, 0x48(%rbx)
leaq 0xa9baa(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3c006
xorpd 0x66020(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3c010
leaq 0x30(%rsp), %rdi
callq 0x3e0ec
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cd94
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x3dc6a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::T(gaps::R3Point const&) const
const RNScalar R3Span::
T(const R3Point& point) const
{
    // Return parametric value of closest point on span
    if (length == 0.0) return 0.0;
    R3Vector topoint = point - Start();
    return Vector().Dot(topoint);
}

// Assembly:
movsd 0x48(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3c162
jp 0x3c162
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3cc88
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d756
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Reposition(int, gaps::R3Point const&)
void R3Span::
Reposition(int k, const R3Point& point)
{
    // Set one endpoint of span
    if (k == 0) ray = R3Ray(point, end);
    else { end = point; ray.Align(end - ray.Start()); }
    length = R3Distance(Start(), End());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
testl %esi, %esi
je 0x3c1f3
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3cd94
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r14, %rdi
movq %r12, %rsi
callq 0x3dc6a
movq %r14, %rdi
callq 0x3d7e0
jmp 0x3c222
leaq 0x30(%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3c61a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cd94
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3dc6a
leaq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0x49efc
movsd %xmm0, 0x48(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Flip()
void R3Span::
Flip(void)
{
    // Flip direction of span
    R3Point swap = Start();
    ray.Reposition(end);
    end = swap;
    ray.Flip();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ca36
leaq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cd94
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cd94
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3d84c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Reset(gaps::R3Point const&, gaps::R3Point const&)
void R3Span::
Reset(const R3Point& point1, const R3Point& point2)
{
    // Reset span
    ray = R3Ray(point1, point2);
    end = point2;
    length = R3Distance(point1, point2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c61a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3cd94
leaq 0x18(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3dc6a
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x3cd94
movq %r15, %rdi
movq %r14, %rsi
callq 0x49efc
movsd %xmm0, 0x48(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ray.cpp
// Function: gaps::R3Ray::T(gaps::R3Point const&) const
const RNScalar R3Ray::
T(const R3Point& point) const
{
    // Return parametric value of closest point on ray
    if (IsZero()) return 0.0;
    RNScalar denom = Vector().Dot(Vector());
    assert(RNIsNotZero(denom));
    R3Vector topoint = point - Start();
    return (Vector().Dot(topoint) / denom);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3c6a2
jp 0x3c6a2
movsd 0x20(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x3c6a2
jp 0x3c6a2
movsd 0x28(%rbx), %xmm2
ucomisd %xmm1, %xmm2
jne 0x3c6a2
jnp 0x3c6db
leaq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x3d756
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d756
divsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Line.cpp
// Function: gaps::R3Line::R3Line(gaps::RNArray<gaps::R3Point*> const&)
R3Line::
R3Line(const RNArray<R3Point *>& points)
    : point(0, 0, 0),
      vector(0, 0, 0)
{
    // Check number of points
    if (points.NEntries() < 2) return;

    // Compute centroid
    point = R3Centroid(points);

    // Compute principle axes
    R3Triad triad = R3PrincipleAxes(point, points);

    // Select direction of most variation
    vector = triad[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3ca26
leaq 0x18(%r14), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3d4be
cmpl $0x2, 0xc(%rbx)
jl 0x3c886
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4ccf0
movq %r14, %rdi
movq %r12, %rsi
callq 0x3cd94
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4cd9c
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc6a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Line.cpp
// Function: gaps::R3Line::R3Line(gaps::R3Point*, int)
R3Line::
R3Line(R3Point *points, int npoints)
    : point(0, 0, 0),
      vector(0, 0, 0)
{
    // Check number of points
    if (npoints < 2) return;

    // Compute centroid
    point = R3Centroid(npoints, points);

    // Compute principle axes
    R3Triad triad = R3PrincipleAxes(point, npoints, points);

    // Select direction of most variation
    vector = triad[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3ca26
leaq 0x18(%r14), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3d4be
cmpl $0x2, %ebp
jl 0x3c913
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x4e65d
movq %r14, %rdi
movq %r12, %rsi
callq 0x3cd94
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4e6e7
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dc6a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Line.cpp
// Function: gaps::R3Line::operator==(gaps::R3Line const&) const
const RNBoolean R3Line::
operator==(const R3Line& line) const
{
    // Check if vectors are equal
    if (vector != line.vector) return FALSE;

    // Return whether point lies on this line
    R3Vector v = vector;
    v.Cross(line.Point() - point);
    return v.IsZero();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
addq $0x18, %rsi
movq %r15, %rdi
callq 0x3d7ac
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x3ca0e
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d4ce
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3cc88
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d86a
movsd 0x8(%r12), %xmm0
xorpd %xmm1, %xmm1
movsd (%r12), %xmm2
cmpeqpd %xmm1, %xmm2
cmpeqpd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
movsd 0x10(%r12), %xmm0
ucomisd %xmm1, %xmm0
setnp %cl
sete %dl
andb %cl, %dl
andb %al, %dl
movzbl %dl, %eax
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/R3Point.cpp
// Function: gaps::R3Point::Collinear(gaps::R3Point const&, gaps::R3Point const&) const
const RNBoolean R3Point::
Collinear(const R3Point& point1, const R3Point& point2) const
{
    // Check if two of points are same
    if ((*this == point1) || (*this == point2) || (point1 == point2)) return TRUE;

    /// Check if three points are collinear
    R3Vector v = point1 - *this;
    v.Cross(point1 - point2);
    if (RNIsZero(v.Length())) return TRUE;
    return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd (%rdi), %xmm1
movsd (%rsi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x3cb91
jp 0x3cb91
movsd 0x8(%rdi), %xmm2
ucomisd 0x8(%r14), %xmm2
jne 0x3cb91
jp 0x3cb91
movsd 0x10(%rdi), %xmm2
ucomisd 0x10(%r14), %xmm2
jne 0x3cb91
jnp 0x3cc79
movsd (%rbx), %xmm2
ucomisd %xmm2, %xmm1
jne 0x3cbbd
jp 0x3cbbd
movsd 0x8(%rdi), %xmm3
ucomisd 0x8(%rbx), %xmm3
jne 0x3cbbd
jp 0x3cbbd
movsd 0x10(%rdi), %xmm3
ucomisd 0x10(%rbx), %xmm3
jne 0x3cbbd
jnp 0x3cc79
ucomisd %xmm2, %xmm0
jne 0x3cbe7
jp 0x3cbe7
movsd 0x8(%r14), %xmm2
ucomisd 0x8(%rbx), %xmm2
jne 0x3cbe7
jp 0x3cbe7
movsd 0x10(%r14), %xmm2
ucomisd 0x10(%rbx), %xmm2
jne 0x3cbe7
jnp 0x3cc79
subsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x10(%r14), %xmm2
subsd 0x8(%rdi), %xmm1
subsd 0x10(%rdi), %xmm2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
subsd (%rbx), %xmm0
subsd 0x8(%rbx), %xmm1
movsd 0x10(%r14), %xmm2
subsd 0x10(%rbx), %xmm2
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3d4be
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d86a
movq %r15, %rdi
callq 0x3d5c4
leaq 0xa8f46(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x653c2(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
jmp 0x3cc7e
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::Project(gaps::R3Line const&)
void R3Point::
Project(const R3Line& line)
{
    // Move point to closest point on line
    const R3Point *p = &(line.Point());
    const R3Vector *v = &(line.Vector());
    RNScalar denom = v->Dot(*v);
    if (RNIsZero(denom)) return;
    RNScalar t = (v->X() * (X() - p->X()) + v->Y() *(Y() - p->Y()) + v->Z() * (Z() - p->Z())) / denom;
    *this = *p + *v * t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x3d756
leaq 0xa8ebf(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x6533b(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x3ccf5
ucomisd %xmm0, %xmm1
jae 0x3cd65
movsd (%rbx), %xmm2
movsd 0x8(%rbx), %xmm1
subsd (%r14), %xmm2
subsd 0x8(%r14), %xmm1
mulsd 0x20(%r14), %xmm1
mulsd 0x18(%r14), %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rbx), %xmm1
subsd 0x10(%r14), %xmm1
mulsd 0x28(%r14), %xmm1
addsd %xmm2, %xmm1
divsd %xmm0, %xmm1
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movapd %xmm1, %xmm0
callq 0x3de8e
movsd 0x10(%r14), %xmm0
addsd 0x10(%r12), %xmm0
movupd (%r14), %xmm1
addpd (%r12), %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::operator=(gaps::R3Point const&)
R3Point& R3Point::
operator=(const R3Point& point)
{
    v[0] = point.v[0];
    v[1] = point.v[1];
    v[2] = point.v[2];
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::operator+=(gaps::R3Vector const&)
R3Point& R3Point::
operator+=(const R3Vector& vector)
{
    v[0] += vector[0];
    v[1] += vector[1];
    v[2] += vector[2];
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::XRotate(double)
void R3Point:: 
XRotate(RNAngle radians)
{
    // rotate matrix around X axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    RNScalar y = v[1];
    RNScalar z = v[2];
    v[1] = c*y - s*z;
    v[2] = s*y + c*z;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd 0x8(%rbx), %xmm1
movapd 0x65158(%rip), %xmm2    # 0xa2020
xorpd %xmm0, %xmm2
movsd 0x10(%rbx), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm3, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::YRotate(double)
void R3Point:: 
YRotate(RNAngle radians)
{
    // rotate matrix around Y axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    RNScalar x = v[0];
    RNScalar z = v[2];
    v[0] =  c*x + s*z;
    v[2] = -s*x + c*z;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe860
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movsd (%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movsd 0x8(%rsp), %xmm5
movapd %xmm5, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rbx)
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::ZRotate(double)
void R3Point:: 
ZRotate(RNAngle radians)
{
    // rotate matrix around Z axis counterclockwise 
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    RNScalar x = v[0];
    RNScalar y = v[1];
    v[0] = c*x - s*y;
    v[1] = s*x + c*y;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd (%rbx), %xmm1
movupd 0x8(%rbx), %xmm2
movapd 0x6508e(%rip), %xmm3    # 0xa2020
xorpd %xmm0, %xmm3
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::Rotate(int, double)
void R3Point:: 
Rotate(RNAxis axis, RNAngle radians)
{
    // rotate point around an axis counterclockwise
    switch (axis) {
    case RN_XAXIS: 
	XRotate(radians); 
	break;

    case RN_YAXIS: 
	YRotate(radians); 
	break;

    case RN_ZAXIS: 
	ZRotate(radians); 
	break;

    default: 
	RNWarning("Matrix rotation around undefined axis");
	break;
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x3d093
cmpl $0x1, %esi
je 0x3d03d
testl %esi, %esi
jne 0x3d0ef
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd 0x8(%rbx), %xmm1
movapd 0x65018(%rip), %xmm2    # 0xa2020
xorpd %xmm0, %xmm2
movsd 0x10(%rbx), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm3, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
jmp 0x3d0e9
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd (%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movsd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rbx)
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rbx)
jmp 0x3d0e9
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd (%rbx), %xmm1
movupd 0x8(%rbx), %xmm2
movapd 0x64f61(%rip), %xmm3    # 0xa2020
xorpd %xmm0, %xmm3
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
leaq 0x65e40(%rip), %rdi     # 0xa2f36
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x72ad9
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::Rotate(gaps::R3Vector const&)
void R3Point:: 
Rotate(const R3Vector& radians)
{
    // Rotate first around X, then around Y, and finally around Z
    ZRotate(radians.Z());
    YRotate(radians.Y());
    XRotate(radians.X());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd (%rbx), %xmm1
movsd 0x8(%rbx), %xmm2
movsd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm4
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm3
subsd %xmm2, %xmm3
movsd %xmm3, (%rbx)
mulsd %xmm1, %xmm0
addsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd (%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movsd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rbx)
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd 0x8(%rbx), %xmm1
movapd 0x64e35(%rip), %xmm2    # 0xa2020
xorpd %xmm0, %xmm2
movsd 0x10(%rbx), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm3, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::Rotate(gaps::R3Vector const&, double)
void R3Point::
Rotate(const R3Vector& axis, RNAngle theta)
{
    // Rotate point counterclockwise around axis through origin by radians ???
    R3Vector v = Vector();
    v.Rotate(axis, theta);
    *this = v.Point();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movq %r15, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3dc8a
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d5fa
movaps (%rbx), %xmm0
movups %xmm0, (%r14)
movsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x10(%r14)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::R3Point::Rotate(gaps::R3Line const&, double)
void R3Point::
Rotate(const R3Line& axis, RNAngle theta)
{
    // Translate axis to origin
    R3Vector v = *this - axis.Point();

    // Rotate point counterclockwise around axis through origin by radians ???
    v.Rotate(axis.Vector(), theta);

    // Translate axis back from origin
    *this = axis.Point() + v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm1
subsd (%rsi), %xmm3
subsd 0x8(%rsi), %xmm1
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rdi), %xmm2
subsd 0x10(%rsi), %xmm2
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movapd %xmm3, %xmm0
callq 0x3d4be
leaq 0x18(%r14), %rsi
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3dc8a
movsd 0x10(%r14), %xmm0
addsd 0x10(%r15), %xmm0
movupd (%r14), %xmm1
addpd (%r15), %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Point.cpp
// Function: gaps::operator/(gaps::R3Point const&, double)
R3Point 
operator/(const R3Point& point, const RNScalar a)
{
    assert(a != 0);
    return R3Point(point.X() / a, 
		   point.Y() / a, 
		   point.Z() / a);
}

// Assembly:
movq %rdi, %rax
movsd 0x10(%rsi), %xmm1
divsd %xmm0, %xmm1
movupd (%rsi), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm2
movupd %xmm2, (%rdi)
movsd %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::R3Vector(double, double)
R3Vector::
R3Vector(RNAngle pitch, RNAngle yaw)
{
    RNScalar cosine_yaw = cos(yaw);
    v[0] = cosine_yaw * cos(pitch);
    v[1] = cosine_yaw * sin(pitch); 
    v[2] = sin(yaw);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movaps %xmm1, %xmm0
callq 0xe860
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0xe860
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm0
callq 0xe0f0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x18(%rsp), %xmm0
callq 0xe0f0
movsd %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Sextant() const
const RNSextant R3Vector::
Sextant(void) const
{
    // Return principal direction of vector
    if (fabs(v[0]) >= fabs(v[1])) {
        if (fabs(v[0]) >= fabs(v[2])) {
            if (v[0] >= 0.0) return RN_PX_SEXTANT;
            else return RN_NX_SEXTANT;
        }
        else {
            if (v[2] >= 0.0) return RN_PZ_SEXTANT;
            else return RN_NZ_SEXTANT;
        }
    }
    else {
        if (fabs(v[1]) >= fabs(v[2])) {
            if (v[1] >= 0.0) return RN_PY_SEXTANT;
            else return RN_NY_SEXTANT;
        }
        else {
            if (v[2] >= 0.0) return RN_PZ_SEXTANT;
            else return RN_NZ_SEXTANT;
        }
    }
}

// Assembly:
movdqu (%rdi), %xmm0
movdqa 0x64bd6(%rip), %xmm2    # 0xa2270
movdqa %xmm0, %xmm3
pand %xmm2, %xmm3
pshufd $0xee, %xmm3, %xmm4     # xmm4 = xmm3[2,3,2,3]
ucomisd %xmm4, %xmm3
movq 0x10(%rdi), %xmm1
pand %xmm1, %xmm2
jae 0x3d6cf
ucomisd %xmm2, %xmm4
jb 0x3d6d5
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
pxor %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0x3, %eax
jmp 0x3d6e2
ucomisd %xmm2, %xmm3
jae 0x3d6e6
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movl $0x5, %eax
sbbl $0x0, %eax
retq
pxor %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Octant() const
const RNOctant R3Vector::
Octant(void) const
{
    // Return octant vector points into
    if (v[0] >= 0.0) {
        if (v[1] >= 0.0) {
	    if (v[2] >= 0.0) return RN_PPP_OCTANT;
            else return RN_PPN_OCTANT;
        }
	else {
	    if (v[2] >= 0.0) return RN_PNP_OCTANT;
            else return RN_PNN_OCTANT;
        }
    }
    else {
        if (v[1] >= 0.0) {
	    if (v[2] >= 0.0) return RN_NPP_OCTANT;
            else return RN_NPN_OCTANT;
        }
	else {
	    if (v[2] >= 0.0) return RN_NNP_OCTANT;
            else return RN_NNN_OCTANT;
        }
    }
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd 0x10(%rdi), %xmm0
jae 0x3d720
ucomisd %xmm2, %xmm1
jae 0x3d735
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
retq
ucomisd %xmm2, %xmm1
jae 0x3d744
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0x5, %eax
jmp 0x3d751
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0x3, %eax
jmp 0x3d751
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0x7, %eax
sbbl $0x0, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Normalize()
void R3Vector::
Normalize(void)
{
    RNLength length = Length();
    if (length == 0.0) return;
    v[0] /= length;
    v[1] /= length;
    v[2] /= length;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3d816
sqrtsd %xmm0, %xmm0
jmp 0x3d81f
callq 0xe340
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3d827
jnp 0x3d849
movupd (%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, (%rbx)
movsd 0x10(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Cross(gaps::R3Vector const&)
void R3Vector::
Cross(const R3Vector& vector)
{
    const RNScalar x = (v[1]*vector.v[2]) - (v[2]*vector.v[1]);
    const RNScalar y = (v[2]*vector.v[0]) - (v[0]*vector.v[2]);
    const RNScalar z = (v[0]*vector.v[1]) - (v[1]*vector.v[0]);
    v[2] = z; v[1] = y; v[0] = x; 
}

// Assembly:
movsd (%rsi), %xmm0
movsd (%rdi), %xmm1
movupd 0x8(%rdi), %xmm2
movupd 0x8(%rsi), %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd %xmm3, %xmm4
mulsd %xmm3, %xmm1
shufpd $0x1, %xmm0, %xmm3      # xmm3 = xmm3[1],xmm0[0]
mulpd %xmm2, %xmm3
subpd %xmm4, %xmm3
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movupd %xmm3, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Rotate(int, double)
void R3Vector:: 
Rotate(RNAxis axis, RNAngle radians)
{
    // rotate vector around an axis counterclockwise
    switch (axis) {
    case RN_XAXIS: 
	XRotate(radians); 
	break;

    case RN_YAXIS: 
	YRotate(radians); 
	break;

    case RN_ZAXIS: 
	ZRotate(radians); 
	break;

    default: 
	RNWarning("Matrix rotation around undefined axis");
	break;
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x3daa7
cmpl $0x1, %esi
je 0x3da51
testl %esi, %esi
jne 0x3db03
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd 0x8(%rbx), %xmm1
movapd 0x64604(%rip), %xmm2    # 0xa2020
xorpd %xmm0, %xmm2
movsd 0x10(%rbx), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0]
mulpd %xmm3, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
jmp 0x3dafd
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd (%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
movsd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rbx)
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rbx)
jmp 0x3dafd
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movupd (%rbx), %xmm1
movupd 0x8(%rbx), %xmm2
movapd 0x6454d(%rip), %xmm3    # 0xa2020
xorpd %xmm0, %xmm3
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
leaq 0x6542c(%rip), %rdi     # 0xa2f36
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x72ad9
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Rotate(gaps::R3Vector const&, double)
void R3Vector::
Rotate(const R3Vector& axis, RNAngle theta)
{
    // Rotate vector counterclockwise around axis (looking at axis end-on) (rz(xaxis) = yaxis)
    // From Goldstein: v' = v cos t + a (v . a) [1 - cos t] - (v x a) sin t
    if (RNIsEqual(fabs(Dot(axis)), 1.0)) return;
    const RNScalar cos_theta = cos(theta);
    const RNScalar dot = this->Dot(axis);
    R3Vector cross = *this % axis;
    *this *= cos_theta;
    *this += axis * dot * (1.0 - cos_theta);
    *this -= cross * sin(theta); 
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
mulsd 0x8(%rsi), %xmm2
mulsd (%rsi), %xmm1
movsd 0x10(%rdi), %xmm3
mulsd 0x10(%rsi), %xmm3
addsd %xmm2, %xmm1
addsd %xmm1, %xmm3
andpd 0x645ad(%rip), %xmm3    # 0xa2270
leaq 0xa7ece(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
addsd 0x64372(%rip), %xmm3    # 0xa2048
movapd 0x64342(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm3
jb 0x3dcf2
ucomisd %xmm3, %xmm1
jae 0x3de0a
movsd %xmm0, 0x8(%rsp)
callq 0xe860
movsd (%rbx), %xmm8
movsd (%r14), %xmm4
movsd 0x64329(%rip), %xmm1    # 0xa2038
subsd %xmm0, %xmm1
movupd (%rbx), %xmm3
movupd 0x8(%rbx), %xmm5
movupd 0x8(%r14), %xmm9
movapd %xmm5, %xmm2
mulsd %xmm9, %xmm2
movapd %xmm8, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movapd %xmm9, %xmm2
movapd %xmm5, %xmm7
shufpd $0x1, %xmm8, %xmm7      # xmm7 = xmm7[1],xmm8[0]
mulpd %xmm9, %xmm7
mulsd %xmm9, %xmm8
shufpd $0x1, %xmm4, %xmm9      # xmm9 = xmm9[1],xmm4[0]
mulpd %xmm5, %xmm9
mulsd %xmm5, %xmm4
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm5, %xmm2
addsd %xmm6, %xmm2
subpd %xmm7, %xmm9
movapd %xmm9, 0x20(%rsp)
subsd %xmm4, %xmm8
movapd %xmm8, 0x10(%rsp)
mulsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rbx)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
movupd %xmm0, (%rbx)
movupd (%r14), %xmm3
movapd %xmm2, %xmm4
unpcklpd %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0]
mulpd %xmm3, %xmm4
mulsd 0x10(%r14), %xmm2
mulsd %xmm1, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rbx)
addsd %xmm5, %xmm2
movsd %xmm2, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movapd 0x10(%rsp), %xmm2
mulsd %xmm0, %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd 0x20(%rsp), %xmm0
movupd (%rbx), %xmm1
subpd %xmm0, %xmm1
movupd %xmm1, (%rbx)
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::operator%(gaps::R3Vector const&, gaps::R3Vector const&)
R3Vector 
operator%(const R3Vector& vector1, const R3Vector& vector2)
{
    // Cross product 
    R3Vector v = vector1;
    v.Cross(vector2);
    return v;
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movupd %xmm0, (%rdi)
movsd 0x10(%rsi), %xmm1
movsd %xmm1, 0x10(%rdi)
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
movsd (%rdx), %xmm3
mulsd %xmm3, %xmm2
movupd 0x8(%rdx), %xmm4
movapd %xmm0, %xmm5
shufpd $0x1, %xmm1, %xmm5      # xmm5 = xmm5[1],xmm1[0]
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm4, %xmm1
mulsd %xmm4, %xmm0
shufpd $0x1, %xmm3, %xmm4      # xmm4 = xmm4[1],xmm3[0]
mulpd %xmm5, %xmm4
subpd %xmm1, %xmm4
subsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rdi)
movupd %xmm4, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::Project(gaps::R3Vector const&)
void R3Vector::
Project(const R3Vector& vector)
{
    // Project onto another vector    
    RNScalar dot = this->Dot(vector);
    RNLength length = vector.Length();
    if ((RNIsPositive(length)) && (length != 1.0)) 
	dot /= (length * length);
    *this = vector * dot;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
movsd 0x8(%rdi), %xmm0
mulsd %xmm2, %xmm0
movsd (%rdi), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0x10(%rsi), %xmm0
movsd 0x10(%rdi), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3df6d
sqrtsd %xmm0, %xmm0
jmp 0x3df7c
movapd %xmm4, (%rsp)
callq 0xe340
movapd (%rsp), %xmm4
leaq 0xa7c15(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm4, %xmm3
divsd %xmm2, %xmm3
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm4, %xmm1
orpd %xmm3, %xmm1
cmpneqsd 0x64087(%rip), %xmm0    # 0xa2038
andpd %xmm0, %xmm1
andnpd %xmm4, %xmm0
orpd %xmm1, %xmm0
movsd 0x10(%r14), %xmm1
mulsd %xmm0, %xmm1
movupd (%r14), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
movupd %xmm0, (%rbx)
movsd %xmm1, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::operator*=(gaps::R3Vector const&)
R3Vector& R3Vector::
operator*=(const R3Vector& vector)
{
    // Entry by entry multiply (not dot or cross product)
    v[0] *= vector.v[0];
    v[1] *= vector.v[1];
    v[2] *= vector.v[2];
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
mulsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
mulsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
mulsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3Vector::operator/=(gaps::R3Vector const&)
R3Vector& R3Vector::
operator/=(const R3Vector& vector)
{
    // Entry by entry divide
    assert(vector.v[0] != 0);
    v[0] /= vector.v[0];
    assert(vector.v[1] != 0);
    v[1] /= vector.v[1];
    assert(vector.v[2] != 0);
    v[2] /= vector.v[2];
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
divsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
divsd 0x8(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x10(%rdi), %xmm0
divsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::operator*(gaps::R3Vector const&, gaps::R3Vector const&)
R3Vector 
operator*(const R3Vector& vector1, const R3Vector& vector2)
{
    // Entry by entry multiply (not dot or cross product)
    return R3Vector(vector1.v[0] * vector2.v[0], 
		    vector1.v[1] * vector2.v[1], 
		    vector1.v[2] * vector2.v[2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x10(%rsi), %xmm0
mulsd 0x10(%rdx), %xmm0
movupd (%rsi), %xmm1
movupd (%rdx), %xmm2
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::operator/(gaps::R3Vector const&, gaps::R3Vector const&)
R3Vector 
operator/(const R3Vector& vector1, const R3Vector& vector2)
{
    assert(vector2.v[0] != 0);
    assert(vector2.v[1] != 0);
    assert(vector2.v[2] != 0);
    return R3Vector(vector1.v[0]/vector2.v[0], 
		    vector1.v[1]/vector2.v[1], 
		    vector1.v[2]/vector2.v[2]);
}

// Assembly:
movq %rdi, %rax
movsd 0x10(%rsi), %xmm0
divsd 0x10(%rdx), %xmm0
movupd (%rsi), %xmm1
movupd (%rdx), %xmm2
divpd %xmm2, %xmm1
movupd %xmm1, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Vector.cpp
// Function: gaps::R3RandomDirection()
R3Vector 
R3RandomDirection(void)
{
  RNScalar phi = RN_TWO_PI * RNRandomScalar();
  RNScalar z = RNRandomScalar();
  RNScalar theta = acos(z);
  RNScalar sin_theta = sin(theta);
  RNScalar x = sin_theta * cos(phi);
  RNScalar y = sin_theta * sin(phi);
  R3Vector vector(x, y, z);
  if (RNRandomScalar() < 0.5) vector.Flip();
  return vector;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x6bd95(%rip), %r14     # 0xa9fc8
callq 0x72630
mulsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x72630
movapd %xmm0, 0x20(%rsp)
callq 0xe3f0
callq 0xe0f0
movapd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movapd %xmm2, 0x10(%rsp)
movupd %xmm2, (%rbx)
movapd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
callq 0x72630
movsd 0x63d7d(%rip), %xmm1    # 0xa2030
ucomisd %xmm0, %xmm1
jbe 0x3e2de
movapd 0x63d5f(%rip), %xmm0    # 0xa2020
movapd 0x10(%rsp), %xmm1
xorpd %xmm0, %xmm1
movupd %xmm1, (%rbx)
movapd 0x20(%rsp), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, 0x10(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)