LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Length() const
const RNLength R3Triangle::
Length (void) const
{
    // Return perimeter of closed triangle
    RNLength length = 0.0;
    length += R3Distance(v[0]->Position(), v[1]->Position());
    length += R3Distance(v[1]->Position(), v[2]->Position());
    length += R3Distance(v[2]->Position(), v[0]->Position());
    return length;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
callq 0x49efc
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x49efc
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x49efc
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Area() const
const RNArea R3Triangle::
Area(void) const
{
    // Compute area using Newell's method
    R3Vector sum = R3null_vector;
    sum += v[0]->Position().Vector() % v[2]->Position().Vector();
    sum += v[1]->Position().Vector() % v[0]->Position().Vector();
    sum += v[2]->Position().Vector() % v[1]->Position().Vector();
    return 0.5 * sum.Length();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x53dd1(%rip), %rsi     # 0xa86e0
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d4ce
movq 0x8(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movq 0x18(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movq %rsp, %r12
movq %r12, %rdi
callq 0x3d4be
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3deb0
movq 0x10(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movq 0x8(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movq %rsp, %r12
movq %r12, %rdi
callq 0x3d4be
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3deb0
movq 0x18(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3d4be
movq 0x10(%r14), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movq %rsp, %r14
movq %r14, %rdi
callq 0x3d4be
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3de12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3deb0
movq %rbx, %rdi
callq 0x3d5c4
mulsd 0x4d5f6(%rip), %xmm0    # 0xa2030
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Centroid() const
const R3Point R3Triangle::
Centroid(void) const
{
    // Return centroid of vertex set
    R3Point centroid = R3zero_point;
    centroid += v[0]->Position();
    centroid += v[1]->Position();
    centroid += v[2]->Position();
    centroid /= 3;
    return centroid;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x492007(%rip), %rsi    # 0x4e6a60
callq 0x3ca36
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3d366
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3d366
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x3d366
movsd 0x4d74e(%rip), %xmm0    # 0xa21d8
movq %rbx, %rdi
callq 0x3d3e4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::RandomPoint() const
const R3Point R3Triangle::
RandomPoint(void) const
{
  // Get vertex positions
  const R3Point& p0 = v[0]->Position();
  const R3Point& p1 = v[1]->Position();
  const R3Point& p2 = v[2]->Position();
  
  // Return random point on triangle
  RNScalar r1 = sqrt(RNRandomScalar());
  RNScalar r2 = RNRandomScalar();
  R3Point p = p0 * (1.0 - r1) + p1 * r1 * (1.0 - r2) + p2 * r1 * r2;
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r14
callq 0x72630
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x54ad2
sqrtsd %xmm0, %xmm0
jmp 0x54ad7
callq 0xe340
movsd %xmm0, (%rsp)
callq 0x72630
movsd %xmm0, 0x8(%rsp)
movsd 0x4d549(%rip), %xmm0    # 0xa2038
subsd (%rsp), %xmm0
leaq 0x70(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3d470
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
callq 0x3d470
movsd 0x4d517(%rip), %xmm0    # 0xa2038
subsd 0x8(%rsp), %xmm0
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d470
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3d42a
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq 0x3d470
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3d470
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3d42a
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::ClosestPoint(gaps::R3Point const&) const
const R3Point R3Triangle::
ClosestPoint(const R3Point& point) const
{
    // Start with projection onto plane
    R3Point closest_point = point;
    closest_point.Project(Plane());

    // Project onto edge plane if point is on other side
    for (int i = 0; i < 3; i++) {
      R3TriangleVertex *v0 = v[i];
      R3TriangleVertex *v1 = v[(i+1)%3];
      R3Point p0 = v0->Position();
      R3Point p1 = v1->Position();
      R3Span span(p0, p1);
      if (RNIsZero(span.Length())) return Centroid();
      R3Vector n = span.Vector() % Normal();
      R3Plane edge_plane(p0, n);
      RNScalar d1 = R3SignedDistance(edge_plane, closest_point);
      if (RNIsPositive(d1)) {
        RNScalar t = span.T(closest_point);
        if (t < 0) t = 0;
        if (t > span.Length()) t = span.Length();
        closest_point = span.Point(t);
      }
    }
   
    // Return closest point;
    return closest_point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3ca36
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %rsi, 0x18(%rsp)
callq 0x3cdb4
movq $-0x3, %r12
leaq 0x50(%rsp), %r15
leaq 0x38(%rsp), %r13
leaq 0x90fac(%rip), %rbp     # 0xe5b98
movq %r14, 0x10(%rsp)
testq %r12, %r12
je 0x54d2d
movq 0x20(%r14,%r12,8), %rsi
leaq 0x4(%r12), %rax
incq %r12
movl $0x0, %ecx
cmoveq %rcx, %rax
movq 0x8(%r14,%rax,8), %rbx
movq %r15, %rdi
callq 0x3ca36
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3ca36
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3beaa
movsd (%rbp), %xmm0
movsd 0xb0(%rsp), %xmm1
movapd %xmm1, %xmm2
cmpnlepd %xmm0, %xmm2
xorpd 0x4d3c9(%rip), %xmm0    # 0xa2020
cmpnlepd %xmm1, %xmm0
orpd %xmm2, %xmm0
movd %xmm0, %ebx
testb $0x1, %bl
je 0x54d14
leaq 0xd0(%rsp), %r13
movq %r13, %rdi
leaq 0x80(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3de12
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3b5a6
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4a10f
ucomisd (%rbp), %xmm0
jbe 0x54cfc
leaq 0x68(%rsp), %r13
movq %r13, %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0x3c150
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd 0xb0(%rsp), %xmm0
minsd %xmm1, %xmm0
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x3c03a
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cd94
leaq 0x50(%rsp), %r15
leaq 0x38(%rsp), %r13
leaq 0x90e8b(%rip), %rbp     # 0xe5b98
movq 0x10(%rsp), %r14
jmp 0x54d22
movq (%r14), %rax
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x68(%rax)
testb $0x1, %bl
jne 0x54bf1
jmp 0x54d3c
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3ca36
movq 0x8(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::FurthestPoint(gaps::R3Point const&) const
const R3Point R3Triangle::
FurthestPoint(const R3Point& point) const
{
    // Find furthest point
    RNLength furthest_dd = 0;
    R3Point furthest_point = R3zero_point;
    for (int i = 0; i < 3; i++) {
      R3TriangleVertex *vertex = v[i];
      R3Point p = vertex->Position();
      RNLength dd = R3SquaredDistance(p, point);
      if (dd > furthest_dd) {
        furthest_dd = dd;
        furthest_point = p;
      }
    }

    // Return furthest point
    return furthest_point;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x491cef(%rip), %rsi    # 0x4e6a60
callq 0x3ca36
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movl $0x1, %r13d
leaq 0x8(%rsp), %r12
movq (%r15,%r13,8), %rsi
movq %r12, %rdi
callq 0x3ca36
movq %r12, %rdi
movq %rbx, %rsi
callq 0x49ed3
ucomisd (%rsp), %xmm0
jbe 0x54db8
movq %r14, %rdi
movq %r12, %rsi
movsd %xmm0, (%rsp)
callq 0x3cd94
incq %r13
cmpq $0x4, %r13
jne 0x54d8a
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::operator=(gaps::R3Triangle const&)
R3Triangle& R3Triangle::
operator=(const R3Triangle& triangle)
{
    // Delete prevous vertices
    if (v[0] && !v[0]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[0];
    if (v[1] && !v[1]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[1];
    if (v[2] && !v[2]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[2];
  
    // Copy properties
    plane = triangle.plane;
    bbox = triangle.bbox;
    flags = triangle.flags;
    mark = 0;

    // Copy vertices 
    if (!triangle.v[0] || triangle.v[0]->Flags()[R3_VERTEX_SHARED_FLAG]) v[0] = triangle.v[0];
    else v[0] = new R3TriangleVertex(*(triangle.v[0]));
    if (!triangle.v[1] || triangle.v[1]->Flags()[R3_VERTEX_SHARED_FLAG]) v[1] = triangle.v[1];
    else v[1] = new R3TriangleVertex(*(triangle.v[1]));
    if (!triangle.v[2] || triangle.v[2]->Flags()[R3_VERTEX_SHARED_FLAG]) v[2] = triangle.v[2];
    else v[2] = new R3TriangleVertex(*(triangle.v[2]));

    // Update the triangle
    Update();

    // Return this
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x54e53
testb $0x1, 0x5a(%rdi)
jne 0x54e53
movl $0x68, %esi
callq 0xe450
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x54e6c
testb $0x1, 0x5a(%rdi)
jne 0x54e6c
movl $0x68, %esi
callq 0xe450
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x54e85
testb $0x1, 0x5a(%rdi)
jne 0x54e85
movl $0x68, %esi
callq 0xe450
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0x3dc6a
movsd 0x38(%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x48(%r14), %rsi
callq 0x3cd94
leaq 0x60(%rbx), %rdi
leaq 0x60(%r14), %rsi
callq 0x3cd94
movq 0x78(%r14), %rax
movq %rax, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x54ef5
testb $0x1, 0x5a(%r12)
jne 0x54ef5
movl $0x68, %edi
callq 0xe440
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x540c2
movq %r15, %r12
movq %r12, 0x8(%rbx)
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x54f25
testb $0x1, 0x5a(%r12)
jne 0x54f25
movl $0x68, %edi
callq 0xe440
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x540c2
movq %r15, %r12
movq %r12, 0x10(%rbx)
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x54f54
testb $0x1, 0x5a(%r14)
jne 0x54f54
movl $0x68, %edi
callq 0xe440
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x540c2
movq %r15, %r14
movq %r14, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x250(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x54f77
jmp 0x54f77
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0xe450
movq %rbx, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Flip()
void R3Triangle::
Flip (void) 
{
    // Flip orientation of plane
    plane.Flip();

    // Reverse order of vertices
    R3TriangleVertex *swap = v[0];
    v[0] = v[2];
    v[2] = swap;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e154
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dc6a
movsd 0x38(%rbx), %xmm0
xorps 0x4d027(%rip), %xmm0    # 0xa2020
movlps %xmm0, 0x38(%rbx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Mirror(gaps::R3Plane const&)
void R3Triangle::
Mirror (const R3Plane& plane)
{
    // Mirror vertices (what if they are shared?)
    v[0]->Mirror(plane);
    v[1]->Mirror(plane);
    v[2]->Mirror(plane);

    // Reverse order of vertices
    R3TriangleVertex *swap = v[0];
    v[0] = v[2];
    v[2] = swap;

    // Update
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x3ce3c
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e03a
movq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ce3c
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e03a
movq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ce3c
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e03a
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x250(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Transform(gaps::R3Transformation const&)
void R3Triangle::
Transform (const R3Transformation& transformation) 
{
    // Transform vertices
    v[0]->Transform(transformation);
    v[1]->Transform(transformation);
    v[2]->Transform(transformation);

    // Check if need to flip orientation
    if (transformation.IsMirrored()) {
      R3TriangleVertex *swap = v[0];
      v[0] = v[2];
      v[2] = swap;
    }

    // Update
    Update();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq (%rsi), %rax
movq %rsi, %rdi
movq %r15, %rsi
callq *0x40(%rax)
addq $0x18, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x78(%rax)
movq 0x10(%rbx), %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x40(%rax)
addq $0x18, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x78(%rax)
movq 0x18(%rbx), %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x40(%rax)
addq $0x18, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x78(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testl %eax, %eax
je 0x55124
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x250(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Update()
void R3Triangle::
Update(void)
{
    // Recompute plane equation
    plane = R3Plane(v[0]->Position(), v[1]->Position(), v[2]->Position()); 

    // Recompute bounding box
    bbox = R3null_box;
    bbox.Union(v[0]->Position());
    bbox.Union(v[1]->Position());
    bbox.Union(v[2]->Position());

    // Recompute flags
    UpdateFlags();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3b712
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x3dc6a
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0x38(%rbx)
leaq 0x40(%rbx), %r14
leaq 0x48(%rbx), %rdi
leaq 0x90cdb(%rip), %r15     # 0xe5e98
leaq 0x8(%r15), %rsi
callq 0x3cd94
leaq 0x60(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x3cd94
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x27f0e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x27f0e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x27f0e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x248(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::UpdateFlags()
void R3Triangle::
UpdateFlags(void)
{
    // Recompute flags
    flags.Add(R3_EVERYTHING_DRAW_FLAGS);
    for (int i = 0; i < 3; i++) {
	RNFlags vertex_flags = v[i]->Flags();
	if (!(vertex_flags[R3_VERTEX_NORMALS_DRAW_FLAG]))
	    flags.Remove(R3_VERTEX_NORMALS_DRAW_FLAG);
	if (!(vertex_flags[R3_VERTEX_COLORS_DRAW_FLAG]))
	    flags.Remove(R3_VERTEX_COLORS_DRAW_FLAG);
	if (!(vertex_flags[R3_VERTEX_TEXTURE_COORDS_DRAW_FLAG]))
	    flags.Remove(R3_VERTEX_TEXTURE_COORDS_DRAW_FLAG);
    }
}

// Assembly:
movl $0x7777, %ecx           # imm = 0x7777
orq 0x78(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movl $0x1, %eax
movq (%rdi,%rax,8), %rdx
movl 0x58(%rdx), %edx
movq %rcx, %rsi
andq $-0x101, %rsi           # imm = 0xFEFF
btl $0x8, %edx
cmovbq %rcx, %rsi
movq %rsi, %r8
andq $-0x401, %r8            # imm = 0xFBFF
btl $0xa, %edx
cmovbq %rsi, %r8
movq %r8, %rcx
andq $-0x201, %rcx           # imm = 0xFDFF
btl $0x9, %edx
cmovbq %r8, %rcx
notl %edx
testl $0x700, %edx            # imm = 0x700
je 0x5526d
movq %rcx, 0x78(%rdi)
incq %rax
cmpq $0x4, %rax
jne 0x55222
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ellipsoid.cpp
// Function: gaps::R3Ellipsoid::IsLinear() const
const RNBoolean R3Ellipsoid::
IsLinear(void) const
{
    // A ellipsoid only lies on a single line if two radii are zero
    int nzeros = 0;
    if (radii.X() == 0.0) nzeros++;
    if (radii.Y() == 0.0) nzeros++;
    if (radii.Z() == 0.0) nzeros++;
    return (nzeros >= 2);
}

// Assembly:
xorpd %xmm0, %xmm0
movsd 0x68(%rdi), %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
movl $0x1, %ecx
subl %eax, %ecx
andl $0x1, %eax
ucomisd 0x70(%rdi), %xmm0
cmovnel %eax, %ecx
cmovpl %eax, %ecx
cmpeqsd 0x78(%rdi), %xmm0
movq %xmm0, %rax
subl %eax, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ellipsoid.cpp
// Function: gaps::R3Ellipsoid::BSphere() const
const R3Sphere R3Ellipsoid::
BSphere(void) const
{
    // Return bounding sphere
    switch(radii.Sextant()) {
    case RN_NX_SEXTANT: return R3Sphere(Center(), radii.X());
    case RN_PX_SEXTANT: return R3Sphere(Center(), radii.X());
    case RN_NY_SEXTANT: return R3Sphere(Center(), radii.Y());
    case RN_PY_SEXTANT: return R3Sphere(Center(), radii.Y());
    case RN_NZ_SEXTANT: return R3Sphere(Center(), radii.Z());
    case RN_PZ_SEXTANT: return R3Sphere(Center(), radii.Z());
    default:
	RNAbort("Illegal sextant found");
	return R3null_sphere;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
callq 0x3d68e
cmpl $0x5, %eax
ja 0x555ee
movl %eax, %eax
leaq 0x53c2b(%rip), %rcx     # 0xa91e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x68(%r14), %xmm0
jmp 0x555d4
movsd 0x78(%r14), %xmm0
jmp 0x555d4
movsd 0x70(%r14), %xmm0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x270d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x53c24(%rip), %rdi     # 0xa9219
xorl %eax, %eax
callq 0x72942
leaq 0x9073d(%rip), %rsi     # 0xe5d40
movq %rbx, %rdi
callq 0x2708a
jmp 0x555e3
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ellipsoid.cpp
// Function: gaps::R3Ellipsoid::Empty()
void R3Ellipsoid::
Empty(void)
{
    // Empty ellipsoid
    cs = R3xyz_coordinate_system;
    radii = R3null_vector;
    bbox = R3null_box;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x90af0(%rip), %r14     # 0xe6110
movq %r14, %rsi
callq 0x3cd94
leaq 0x20(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x3dc6a
leaq 0x38(%rbx), %rdi
leaq 0x30(%r14), %rsi
callq 0x3dc6a
leaq 0x50(%rbx), %rdi
addq $0x48, %r14
movq %r14, %rsi
callq 0x3dc6a
leaq 0x68(%rbx), %rdi
leaq 0x53083(%rip), %rsi     # 0xa86e0
callq 0x3dc6a
leaq 0x88(%rbx), %rdi
leaq 0x90828(%rip), %r14     # 0xe5e98
leaq 0x8(%r14), %rsi
callq 0x3cd94
addq $0xa0, %rbx
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3cd94
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cone.cpp
// Function: gaps::R3Cone::BBox() const
const R3Box R3Cone::
BBox(void) const
{
    // Return bounding box 
    R3Box bbox(Apex(), Apex());
    bbox.Union(base.BBox());
    return bbox;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsi), %rdx
movq %rdx, %rsi
callq 0x27542
addq $0x58, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x522d2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x27fd8
movq %rsp, %rdi
callq 0x28348
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x28348
jmp 0x55ab2
movq %rax, %r14
movq %rbx, %rdi
callq 0x28348
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cone.cpp
// Function: gaps::R3Cone::BSphere() const
const R3Sphere R3Cone::
BSphere(void) const
{
    // Compute distance up axis for sphere center using quadradic formula
    if (RNIsLessOrEqual(Height(), Radius())) return base.BSphere();
    RNScalar d = 1.0 - 4.0 * (Radius() * Radius() - Height());
    if (RNIsNegativeOrZero(d)) return base.BSphere();
    d = sqrt(d);
    if (d <= 1.0) d = 0.5 * (1.0 + d);
    else  d = 0.5 * (1.0 + d);
    R3Point center = base.Center() + d * axis.Vector();
    return R3Sphere(center, Height() - d); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x50(%rsi), %xmm2
movsd 0x78(%rsi), %xmm0
leaq 0x900b2(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
ucomisd %xmm3, %xmm1
jae 0x55b26
mulsd %xmm0, %xmm0
subsd %xmm2, %xmm0
mulsd 0x53448(%rip), %xmm0    # 0xa8f50
addsd 0x4c528(%rip), %xmm0    # 0xa2038
ucomisd %xmm0, %xmm1
jae 0x55b26
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x55b37
sqrtsd %xmm0, %xmm0
jmp 0x55b3c
addq $0x58, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52318
jmp 0x55b91
callq 0xe340
addsd 0x4c4f4(%rip), %xmm0    # 0xa2038
mulsd 0x4c4e4(%rip), %xmm0    # 0xa2030
leaq 0x60(%r14), %r15
leaq 0x20(%r14), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x3de8e
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3cd71
movsd 0x50(%r14), %xmm0
subsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x270d6
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cone.cpp
// Function: gaps::R3Cone::Reposition(gaps::R3Span const&)
void R3Cone::
Reposition(const R3Span& axis)
{
    // Set cone axis
    this->axis = axis;
    base.Reposition(axis.Start());
    base.Align(-axis.Vector());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3cd94
leaq 0x20(%rbx), %rdi
leaq 0x18(%r14), %r15
movq %r15, %rsi
callq 0x3dc6a
leaq 0x38(%rbx), %rdi
leaq 0x30(%r14), %rsi
callq 0x3cd94
movsd 0x48(%r14), %xmm0
movsd %xmm0, 0x50(%rbx)
addq $0x58, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52376
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e154
movq %rbx, %rdi
movq %r14, %rsi
callq 0x523ca
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cylinder.cpp
// Function: gaps::R3Cylinder::operator==(gaps::R3Cylinder const&) const
RNBoolean R3Cylinder::
operator==(const R3Cylinder& cylinder) const
{
    // Return whether cylinder is equal
    return ((axis == cylinder.axis) && 
	    (base == cylinder.base) &&
	    (top == cylinder.top));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x3c5c4
xorl %ebp, %ebp
testl %eax, %eax
je 0x560e9
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0x3caec
testl %eax, %eax
je 0x560e9
movsd 0x78(%r14), %xmm0
ucomisd 0x78(%rbx), %xmm0
jne 0x560e9
jp 0x560e9
movl $0x80, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x3d77c
testl %eax, %eax
je 0x560e9
movsd 0x98(%r14), %xmm0
ucomisd 0x98(%rbx), %xmm0
jne 0x560e9
jp 0x560e9
movl $0xa8, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x3caec
testl %eax, %eax
je 0x560e9
movsd 0xc0(%r14), %xmm0
ucomisd 0xc0(%rbx), %xmm0
jne 0x560e9
jp 0x560e9
movl $0xc8, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x3d77c
testl %eax, %eax
setne %al
movsd 0xe0(%r14), %xmm0
ucomisd 0xe0(%rbx), %xmm0
setnp %cl
sete %dl
andb %cl, %dl
andb %al, %dl
movzbl %dl, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cylinder.cpp
// Function: gaps::R3Cylinder::BBox() const
const R3Box R3Cylinder::
BBox(void) const
{
    // Return bounding box of cylinder ???
    R3Box bbox(R3null_box);
    bbox.Union(base.BBox());
    bbox.Union(top.BBox());
    return bbox;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8fd20(%rip), %rsi     # 0xe5e98
callq 0x274f0
leaq 0x58(%r14), %rsi
movq %rsp, %rdi
callq 0x522d2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x27fd8
movq %rsp, %rdi
callq 0x28348
addq $0xa0, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x522d2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x27fd8
movq %rsp, %rdi
callq 0x28348
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x561d0
jmp 0x561dd
movq %rax, %r14
movq %rsp, %rdi
callq 0x28348
jmp 0x561e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x28348
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cylinder.cpp
// Function: gaps::R3Cylinder::BSphere() const
const R3Sphere R3Cylinder::
BSphere(void) const
{
    // Return BSphere
    RNScalar a = 0.5 * Height();
    RNScalar r = sqrt(a * a + Radius() * Radius());
    return R3Sphere(Centroid(), r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x50(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
mulsd 0x4be1f(%rip), %xmm0    # 0xa2030
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5622d
sqrtsd %xmm0, %xmm0
jmp 0x56232
callq 0xe340
movsd %xmm0, (%rsp)
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
callq 0x270d6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cylinder.cpp
// Function: gaps::R3Cylinder::Reposition(gaps::R3Span const&)
void R3Cylinder::
Reposition(const R3Span& axis)
{
    // Set cylinder axis
    this->axis = axis;
    base.Reposition(axis.Start());
    base.Align(-(axis.Vector()));
    top.Reposition(axis.End());
    top.Align(axis.Vector());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3cd94
leaq 0x20(%rbx), %rdi
leaq 0x18(%r15), %r14
movq %r14, %rsi
callq 0x3dc6a
leaq 0x38(%rbx), %rdi
leaq 0x30(%r15), %r12
movq %r12, %rsi
callq 0x3cd94
movsd 0x48(%r15), %xmm0
movsd %xmm0, 0x50(%rbx)
leaq 0x58(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x52376
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e154
movq %r13, %rdi
movq %r15, %rsi
callq 0x523ca
addq $0xa0, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x52376
movq %rbx, %rdi
movq %r14, %rsi
callq 0x523ca
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::R3OrientedBox(gaps::R3OrientedBox const&)
R3OrientedBox::
R3OrientedBox(const R3OrientedBox& box)
    : cs(box.cs)
{
    // Copy radii from box
    this->radius[0] = box.radius[0];
    this->radius[1] = box.radius[1];
    this->radius[2] = box.radius[2];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2833c
leaq 0x8db10(%rip), %rax     # 0xe4078
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x2a946
movsd 0x68(%r14), %xmm0
movsd %xmm0, 0x68(%rbx)
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%rbx)
movsd 0x78(%r14), %xmm0
movsd %xmm0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x28348
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Plane(int, int) const
const R3Plane R3OrientedBox::
Plane(RNDirection dir, RNDimension dim) const
{
    if (IsEmpty()) return R3null_plane;
    R3Vector normal = (dir == 0) ? Axis(dim) : -1.0 * Axis(dim);
    R3Point point = cs.Origin() + Radius(dim)*normal;
    return R3Plane(point, normal);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x56be9
movq %rsi, %r14
movslq %ecx, %r15
leaq (%r15,%r15,2), %rax
leaq (%rsi,%rax,8), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
testl %edx, %edx
je 0x56bfa
movsd 0x4b466(%rip), %xmm0    # 0xa2048
callq 0x3de8e
jmp 0x56bff
leaq 0x48faa0(%rip), %rsi    # 0x4e6690
movq %rbx, %rdi
callq 0x3b51a
jmp 0x56c40
callq 0x3d4ce
movsd 0x68(%r14,%r15,8), %xmm0
addq $0x8, %r14
leaq 0x20(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3de8e
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3cd71
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3b5a6
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Plane(int) const
const R3Plane R3OrientedBox::
Plane(RNSide side) const
{
    // Return plane for appropriate side
    switch (side) {
    case RN_LX_SIDE: return Plane(RN_LO, RN_X);
    case RN_HX_SIDE: return Plane(RN_HI, RN_X);
    case RN_LY_SIDE: return Plane(RN_LO, RN_Y);
    case RN_HY_SIDE: return Plane(RN_HI, RN_Y);
    case RN_LZ_SIDE: return Plane(RN_LO, RN_Z);
    case RN_HZ_SIDE: return Plane(RN_HI, RN_Z);
    }
    
    // Should never reach here
    return R3null_plane;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x5, %edx
ja 0x56cb4
movl %edx, %eax
leaq 0x5262c(%rip), %rcx     # 0xa9290
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x56c99
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x56ca5
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x56c8a
movq %rbx, %rdi
movl $0x1, %edx
movl $0x1, %ecx
jmp 0x56caa
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
jmp 0x56caa
movq %rbx, %rdi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x56b92
movq %rbx, %rax
popq %rbx
retq
leaq 0x48f9d5(%rip), %rsi    # 0x4e6690
movq %rbx, %rdi
callq 0x3b51a
jmp 0x56caf
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::ClosestPoint(gaps::R3Point const&) const
const R3Point R3OrientedBox::
ClosestPoint(const R3Point& point) const
{
    // Check if box is empty
    if (IsEmpty()) return R3zero_point;

    // Start with original point
    R3Point closest_point = point;

    // Iteratively project onto each plane, if outside
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Plane plane = Plane(dir, dim);
        RNScalar d = R3SignedDistance(plane, closest_point);
        if (d > 0) closest_point -= d * plane.Normal();
      }
    }

    // Return closest point
    return closest_point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x56d60
movq %rsi, %r14
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3ca36
xorl %r12d, %r12d
leaq 0x18(%rsp), %r15
movq %rsp, %r13
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x56b92
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4a10f
ucomisd 0x4b4b6(%rip), %xmm0    # 0xa21e8
jbe 0x56d4a
movq %r13, %rdi
movq %r15, %rsi
callq 0x3de8e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3d394
incl %ebp
cmpl $0x3, %ebp
jne 0x56d0f
leal 0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
je 0x56d0d
jmp 0x56d6f
leaq 0x48fcf9(%rip), %rsi    # 0x4e6a60
movq %rbx, %rdi
callq 0x3ca36
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::operator==(gaps::R3OrientedBox const&) const
RNBoolean R3OrientedBox::
operator==(const R3OrientedBox& box) const
{
    // Return whether box is equal
    return ((Center() == Center()) &&
            (Axis(0) == box.Axis(0)) && 
	    (Axis(1) == box.Axis(1)) && 
	    (Axis(2) == box.Axis(2)) && 
	    (Radius(0) == box.Radius(0)) && 
	    (Radius(1) == box.Radius(1)) && 
	    (Radius(2) == box.Radius(2)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq %rdi, %rsi
callq 0x3caec
xorl %ebx, %ebx
testl %eax, %eax
je 0x5702d
leaq 0x20(%r14), %rdi
leaq 0x20(%r15), %rsi
callq 0x3d77c
testl %eax, %eax
je 0x5702d
leaq 0x38(%r14), %rdi
leaq 0x38(%r15), %rsi
callq 0x3d77c
testl %eax, %eax
je 0x5702d
leaq 0x50(%r14), %rdi
leaq 0x50(%r15), %rsi
callq 0x3d77c
testl %eax, %eax
je 0x5702d
movsd 0x68(%r14), %xmm0
ucomisd 0x68(%r15), %xmm0
jne 0x5702d
jp 0x5702d
movsd 0x70(%r14), %xmm0
ucomisd 0x70(%r15), %xmm0
jne 0x5702d
jp 0x5702d
movsd 0x78(%r15), %xmm0
cmpeqsd 0x78(%r14), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::NFacets() const
const RNInterval R3OrientedBox::
NFacets(void) const
{
    // Check if box is empty
    if (IsEmpty()) return RNInterval(0, 0);

    // Return number of facets (polygons)
    return RNInterval(6, 6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x57068
movsd 0x4bc59(%rip), %xmm0    # 0xa2cb8
movq %rbx, %rdi
movapd %xmm0, %xmm1
jmp 0x5706f
xorpd %xmm1, %xmm1
movq %rbx, %rdi
callq 0x72556
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Centroid() const
const R3Point R3OrientedBox::
Centroid(void) const
{
    // Check if box is empty
    if (IsEmpty()) return R3zero_point;

    // Return centroid of box
    return Center();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5713e
leaq 0x48f924(%rip), %rsi    # 0x4e6a60
jmp 0x57142
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x3ca36
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::BBox() const
const R3Box R3OrientedBox::
BBox(void) const
{
    // Check if box is empty
    if (IsEmpty()) return R3null_box;

    // Return bounding box 
    R3Box bbox = R3null_box;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      bbox.Union(Corner(i));
    return bbox;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x70(%rsi), %xmm0
movsd 0x78(%rsi), %xmm1
minsd 0x68(%rsi), %xmm0
minsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x8ed14(%rip), %rsi     # 0xe5e98
callq 0x274f0
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
ja 0x571bb
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x247ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27f0e
incl %ebp
cmpl $0x8, %ebp
jne 0x5719c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x28348
movq %r14, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::BSphere() const
const R3Sphere R3OrientedBox::
BSphere(void) const
{
    // Check if box is empty
    if (IsEmpty()) return R3null_sphere;

    // Return BSphere
    return R3Sphere(Center(), DiagonalRadius());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm1
movsd 0x70(%rsi), %xmm2
movapd %xmm2, %xmm3
minsd %xmm1, %xmm3
movsd 0x78(%rsi), %xmm0
movapd %xmm0, %xmm4
minsd %xmm3, %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm4, %xmm3
ja 0x57233
movq %rsi, %r14
addq $0x8, %r14
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x57244
sqrtsd %xmm0, %xmm0
jmp 0x57249
leaq 0x8eb06(%rip), %rsi     # 0xe5d40
movq %rbx, %rdi
callq 0x2708a
jmp 0x57254
callq 0xe340
movq %rbx, %rdi
movq %r14, %rsi
callq 0x270d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Point const&, gaps::R2Box const&)
RNBoolean R2Contains(const R2Point& point, const R2Box& box)
{
    // Return whether point contains box
    if (!box.IsPoint()) return FALSE;
    if (!R2Contains(point, box.Min())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x57b0c
movsd (%r14), %xmm2
leaq 0x8e0cd(%rip), %rcx     # 0xe5b98
movsd (%rcx), %xmm0
subsd 0x8(%rbx), %xmm2
movapd 0x4a544(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x57b0c
ucomisd %xmm2, %xmm0
jb 0x57b0c
movsd 0x8(%r14), %xmm2
subsd 0x10(%rbx), %xmm2
cmplepd %xmm2, %xmm1
cmplepd %xmm0, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Point const&, gaps::R2Circle const&)
RNBoolean R2Contains(const R2Point& point, const R2Circle& circle)
{
    // Return whether point contains circle
    if (!circle.IsPoint()) return FALSE;
    if (!R2Contains(point, circle.Center())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x57b7c
movsd (%r14), %xmm2
leaq 0x8e05d(%rip), %rcx     # 0xe5b98
movsd (%rcx), %xmm0
subsd 0x8(%rbx), %xmm2
movapd 0x4a4d4(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x57b7c
ucomisd %xmm2, %xmm0
jb 0x57b7c
movsd 0x8(%r14), %xmm2
subsd 0x10(%rbx), %xmm2
cmplepd %xmm2, %xmm1
cmplepd %xmm0, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Line const&, gaps::R2Box const&)
RNBoolean R2Contains(const R2Line& line, const R2Box& box)
{
    // Return whether line contains box 
    if (!box.IsLinear()) return FALSE;
    if (!R2Contains(line, box.Min())) return FALSE;
    if (!R2Contains(line, box.Max())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
xorl %ebp, %ebp
testl %eax, %eax
je 0x57d81
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6d501
leaq 0x8de69(%rip), %r15     # 0xe5b98
movsd (%r15), %xmm1
movapd 0x4a2e4(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x57d81
ucomisd %xmm0, %xmm1
jb 0x57d81
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d501
movsd (%r15), %xmm1
movapd 0x4a2b8(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %ebp
andl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Line const&, gaps::R2Circle const&)
RNBoolean R2Contains(const R2Line& line, const R2Circle& circle)
{
    // Return whether line contains circle 
    if (!circle.IsPoint()) return FALSE;
    if (!R2Contains(line, circle.Center())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
testl %eax, %eax
je 0x57de2
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d501
leaq 0x8dddd(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
movapd 0x4a259(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
jmp 0x57de4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Span const&, gaps::R2Box const&)
RNBoolean R2Contains(const R2Span& span, const R2Box& box)
{
    // Return whether span contains box
    if (!R2Contains(span.Line(), box)) return FALSE;
    if (!R2Contains(span, box.Min())) return FALSE;
    if (!R2Contains(span, box.Max())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x57d00
xorl %ebp, %ebp
testl %eax, %eax
je 0x580c3
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x57fa0
testl %eax, %eax
je 0x580c3
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x57fa0
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Halfspace const&, gaps::R2Halfspace const&)
RNBoolean R2Contains(const R2Halfspace& halfspace1, const R2Halfspace& halfspace2)
{
    // Return whether halfspace1 contains halfspace2
    RNScalar dot = halfspace1.Normal().Dot(halfspace2.Normal());
    if (RNIsEqual(dot, 1.0)) {
	// Halfspaces are parallel ???
	return RNIsLessOrEqual(halfspace1.Line().C(), halfspace2.Line().C());
    }
    else {
	// Halfspaces are not parallel
	return FALSE;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x692f6
leaq 0x8d904(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
addsd 0x49da8(%rip), %xmm0    # 0xa2048
movapd 0x49d78(%rip), %xmm2    # 0xa2020
xorpd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
jb 0x582ce
ucomisd %xmm0, %xmm1
jb 0x582ce
movsd 0x20(%r14), %xmm0
subsd 0x20(%rbx), %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Box const&, gaps::R2Span const&)
RNBoolean R2Contains(const R2Box& box, const R2Span& span)
{
    // Return whether box contains span
    if (!R2Contains(box, span.Start())) return FALSE;
    if (!R2Contains(box, span.End())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rsi
callq 0x58377
testl %eax, %eax
je 0x58452
addq $0x38, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x58377
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Box const&, gaps::R2Halfspace const&)
RNBoolean R2Contains(const R2Box& box, const R2Halfspace& halfspace)
{
    // Return whether box contains halfspace
    RNQuadrant quadrant = halfspace.Normal().Quadrant();
    R2Point corner = box.Corner(quadrant);
    if (!RNIsFinite(corner.X())) return FALSE;
    if (!RNIsFinite(corner.Y())) return FALSE;
    RNAbort("Not Implemented");
    return FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsi), %rdi
callq 0x692cc
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x662b6
movsd (%r14), %xmm2
leaq 0x8d71b(%rip), %rax     # 0xe5ba8
movsd (%rax), %xmm0
movapd 0x49b87(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x584c9
ucomisd %xmm2, %xmm0
jbe 0x584c9
movsd 0x10(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x584c9
ucomisd %xmm2, %xmm0
jbe 0x584c9
leaq 0x4a863(%rip), %rdi     # 0xa2d25
xorl %eax, %eax
callq 0x72942
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Circle const&, gaps::R2Point const&)
RNBoolean R2Contains(const R2Circle& circle, const R2Point& point)
{
    // Return whether circle contains point
    RNScalar radius_squared = circle.Radius() * circle.Radius();
    R2Vector v = circle.Center() - point;
    RNScalar distance_squared = v.X() * v.X() + v.Y() * v.Y();
    return RNIsLessOrEqual(distance_squared, radius_squared);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rdi), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x6906b
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd 0x8(%rsp), %xmm0
leaq 0x8d51f(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Circle const&, gaps::R2Span const&)
RNBoolean R2Contains(const R2Circle& circle, const R2Span& span)
{
    // Return whether circle contains span
    if (!R2Contains(circle, span.Start())) return FALSE;
    if (!R2Contains(circle, span.End())) return FALSE;
    return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x28(%rsi), %rdx
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rdi), %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6906b
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd (%rsp), %xmm0
leaq 0x8d44c(%rip), %r12     # 0xe5b98
movsd (%r12), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
jb 0x587ab
addq $0x38, %rbx
movsd 0x18(%r15), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6906b
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd (%rsp), %xmm0
movsd (%r12), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq