LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Span const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Span& span, const R3Box& box)
{
    // Return whether span contains box
    if (!R3Contains(span.Line(), box)) return FALSE;
    if (!R3Contains(span, box.Min())) return FALSE;
    if (!R3Contains(span, box.Max())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x81e20
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x82940
cmpl $0x0, %eax
jne 0x83064
movl $0x0, 0x24(%rsp)
jmp 0x830ca
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x81b40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x82f00
cmpl $0x0, %eax
jne 0x83094
movl $0x0, 0x24(%rsp)
jmp 0x830ca
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x45060
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x82f00
cmpl $0x0, %eax
jne 0x830c2
movl $0x0, 0x24(%rsp)
jmp 0x830ca
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Span const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Span& span, const R3OrientedBox& box)
{
    // Return whether span contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsLinear()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(span, box.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x8310a
movl $0x0, 0x44(%rsp)
jmp 0x8318e
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, %eax
jne 0x83124
movl $0x0, 0x44(%rsp)
jmp 0x8318e
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x83186
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x82f00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8316d
jmp 0x83177
movl $0x0, 0x44(%rsp)
jmp 0x8318e
jmp 0x83179
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x8312c
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Plane const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Plane& plane, const R3Box& box)
{
    // Return whether plane contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsPlanar()) return FALSE;
    if (!R3Contains(plane, box.Min())) return FALSE;
    if (!R3Contains(plane, box.Max())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x834ea
movl $0x0, 0x24(%rsp)
jmp 0x8356a
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x83504
movl $0x0, 0x24(%rsp)
jmp 0x8356a
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x81b40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x83240
cmpl $0x0, %eax
jne 0x83534
movl $0x0, 0x24(%rsp)
jmp 0x8356a
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x45060
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x83240
cmpl $0x0, %eax
jne 0x83562
movl $0x0, 0x24(%rsp)
jmp 0x8356a
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Plane const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Plane& plane, const R3OrientedBox& box)
{
    // Return whether plane contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsPlanar()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(plane, box.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x835aa
movl $0x0, 0x44(%rsp)
jmp 0x8362e
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x835c4
movl $0x0, 0x44(%rsp)
jmp 0x8362e
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x83626
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x83240
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8360d
jmp 0x83617
movl $0x0, 0x44(%rsp)
jmp 0x8362e
jmp 0x83619
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x835cc
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Box& box, const R3Point& point)
{
    // Return whether box contains point
    if (box.IsEmpty()) return FALSE;
    if (RNIsLess(point.X(), box.XMin())) return FALSE;
    if (RNIsLess(point.Y(), box.YMin())) return FALSE;
    if (RNIsLess(point.Z(), box.ZMin())) return FALSE;
    if (RNIsGreater(point.X(), box.XMax())) return FALSE;
    if (RNIsGreater(point.Y(), box.YMax())) return FALSE;
    if (RNIsGreater(point.Z(), box.ZMax())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x83a4a
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x37820
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x37830
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0xf4a6c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x83a8f
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x37870
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x37880
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
leaq 0xf4a27(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x83ad4
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x378c0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x378d0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xf49e2(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x83b19
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x37820
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44f80
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0xf499d(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x83b5e
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x37870
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44fa0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xf4958(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x83ba0
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movq 0x30(%rsp), %rdi
callq 0x378c0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x44fc0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xf4918(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x83be0
movl $0x0, 0x44(%rsp)
jmp 0x83be8
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Triangle const&, gaps::R3Triangle const&)
RNBoolean R3Contains(const R3Triangle& triangle1, const R3Triangle& triangle2)
{
    // Check whether planes are the same
    if (!R3Contains(triangle1.Plane(), triangle2.Plane())) return FALSE;

    // Check whether triangle1's bounding box contains triangle2
    if (!R3Contains(triangle1.BBox(), triangle2)) return FALSE;

    // Check whether points of triangle2 are inside triangle1
    for (int i = 0; i < 3; i++) {
	if (!R3Contains(triangle1, triangle2.Vertex(i)->Position())) 
            return FALSE;
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x81b30
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
callq 0x81b30
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x83420
cmpl $0x0, %eax
jne 0x83cfc
movl $0x0, 0x84(%rsp)
jmp 0x83de0
movq 0x78(%rsp), %rsi
movq (%rsi), %rax
movq 0x88(%rax), %rax
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x83e00
movl %eax, 0x1c(%rsp)
jmp 0x83d2c
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x36a80
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x83d50
jmp 0x83d7a
movl $0x0, 0x84(%rsp)
jmp 0x83de0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x36a80
jmp 0x83def
movl $0x0, 0x28(%rsp)
cmpl $0x3, 0x28(%rsp)
jge 0x83dd5
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x81eb0
movq %rax, %rdi
callq 0x78950
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x836e0
cmpl $0x0, %eax
jne 0x83dc6
movl $0x0, 0x84(%rsp)
jmp 0x83de0
jmp 0x83dc8
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x83d82
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Triangle const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Triangle& triangle, const R3Box& box)
{
    // Return whether triangle contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsPlanar()) return FALSE;
    if (!R3Contains(triangle, box.Min())) return FALSE;
    if (!R3Contains(triangle, box.Max())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x83e6a
movl $0x0, 0x24(%rsp)
jmp 0x83eea
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x83e84
movl $0x0, 0x24(%rsp)
jmp 0x83eea
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x81b40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x836e0
cmpl $0x0, %eax
jne 0x83eb4
movl $0x0, 0x24(%rsp)
jmp 0x83eea
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x45060
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x836e0
cmpl $0x0, %eax
jne 0x83ee2
movl $0x0, 0x24(%rsp)
jmp 0x83eea
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Triangle const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Triangle& triangle, const R3OrientedBox& box)
{
    // Return whether triangle contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsPlanar()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(triangle, box.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x83f2a
movl $0x0, 0x44(%rsp)
jmp 0x83fae
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x83f44
movl $0x0, 0x44(%rsp)
jmp 0x83fae
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x83fa6
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x836e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x83f8d
jmp 0x83f97
movl $0x0, 0x44(%rsp)
jmp 0x83fae
jmp 0x83f99
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x83f4c
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Circle const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Circle& circle, const R3Point& point)
{
    // Check whether ellipse is empty
    if (circle.IsEmpty()) return FALSE;

    // Check whether circle plane contains point
    if (!R3Contains(circle.Plane(), point)) return FALSE;

    // Check whether point is within radius of center
    RNScalar dd = R3SquaredDistance(circle.Center(), point);
    if (dd > circle.Radius() * circle.Radius()) return FALSE;

    // Circle contains point
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x81c80
cmpl $0x0, %eax
je 0x8408a
movl $0x0, 0x34(%rsp)
jmp 0x8411e
movq 0x28(%rsp), %rdi
callq 0x81ca0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x83240
cmpl $0x0, %eax
jne 0x840b0
movl $0x0, 0x34(%rsp)
jmp 0x8411e
movq 0x28(%rsp), %rdi
callq 0x81cb0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x86c10
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3c2e0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3c2e0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x84116
movl $0x0, 0x34(%rsp)
jmp 0x8411e
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Ellipse const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Ellipse& ellipse, const R3Point& point)
{
    // Check whether ellipse is empty
    if (ellipse.IsEmpty()) return FALSE;
    if (!RNIsPositive(ellipse.Radius(0))) return FALSE;
    if (!RNIsPositive(ellipse.Radius(1))) return FALSE;

    // Check whether ellipse plane contains point
    if (!R3Contains(ellipse.Plane(), point)) return FALSE;

    // Check whether point is within radius of center
    R3Vector v = point - ellipse.Center();
    RNScalar d0 = v.Dot(ellipse.Axis(0)) / ellipse.Radius(0);
    RNScalar d1 = v.Dot(ellipse.Axis(1)) / ellipse.Radius(1);
    RNScalar dd = d0*d0 + d1*d1;
    if (dd > 1.0) return FALSE;

    // Ellipse contains point
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x81cc0
cmpl $0x0, %eax
je 0x84160
movl $0x0, 0x84(%rsp)
jmp 0x842fb
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0x86a30
leaq 0xf436d(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
jne 0x84191
movl $0x0, 0x84(%rsp)
jmp 0x842fb
movq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x86a30
leaq 0xf4339(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
jne 0x841c5
movl $0x0, 0x84(%rsp)
jmp 0x842fb
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x81d20
movq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x83240
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x841f1
jmp 0x84201
movl $0x0, 0x84(%rsp)
jmp 0x842fb
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdi
callq 0x82080
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x38(%rsp), %rdi
callq 0x6eeb0
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0x86b60
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x702c0
movsd %xmm0, 0x10(%rsp)
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0x86a30
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x86b60
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x702c0
movsd %xmm0, 0x18(%rsp)
movq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x86a30
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0xaed2b(%rip), %xmm1    # 0x133008
ucomisd %xmm1, %xmm0
jbe 0x842f0
movl $0x0, 0x84(%rsp)
jmp 0x842fb
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Rectangle const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Rectangle& rectangle, const R3Point& point)
{
    // Check whether rectangle is empty
    if (rectangle.IsEmpty()) return FALSE;
    if (!RNIsPositive(rectangle.Radius(0))) return FALSE;
    if (!RNIsPositive(rectangle.Radius(1))) return FALSE;

    // Check whether rectangle plane contains point
    if (!R3Contains(rectangle.Plane(), point)) return FALSE;

    // Check whether point is within radius of center
    R3Vector v = point - rectangle.Center();
    RNScalar d0 = fabs(v.Dot(rectangle.Axis(0)));
    if (d0 > rectangle.Radius(0)) return FALSE;
    RNScalar d1 = fabs(v.Dot(rectangle.Axis(1)));
    if (d1 > rectangle.Radius(1)) return FALSE;

    // Rectangle contains point
    return TRUE;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x78ac0
cmpl $0x0, %eax
je 0x8433a
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
leaq 0xf4193(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
jne 0x84368
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
leaq 0xf4162(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
jne 0x84399
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x81db0
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x83240
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x843c5
jmp 0x843d2
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x78df0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x28(%rsp), %rdi
callq 0x6eeb0
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x78e10
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x702c0
movaps 0xaee58(%rip), %xmm1    # 0x133270
pand %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x84453
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x78e10
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x702c0
movaps 0xaedfa(%rip), %xmm1    # 0x133270
pand %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x844b2
movl $0x0, 0x74(%rsp)
jmp 0x844ba
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3Triangle const&)
RNBoolean R3Contains(const R3Halfspace& halfspace, const R3Triangle& triangle)
{
    // Check whether halfspace contains triangle bounding shape
    if (R3Contains(halfspace, triangle.Box())) return TRUE;

    // Check whether halfspace contains all vertices of triangle
    if (!R3Contains(halfspace, triangle.Vertex(0)->Position())) return FALSE;
    if (!R3Contains(halfspace, triangle.Vertex(1)->Position())) return FALSE;
    if (!R3Contains(halfspace, triangle.Vertex(2)->Position())) return FALSE;

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x86b50
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x84830
cmpl $0x0, %eax
je 0x84761
movl $0x1, 0x34(%rsp)
jmp 0x8481e
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x81eb0
movq %rax, %rdi
callq 0x78950
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x844d0
cmpl $0x0, %eax
jne 0x8479e
movl $0x0, 0x34(%rsp)
jmp 0x8481e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x81eb0
movq %rax, %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x844d0
cmpl $0x0, %eax
jne 0x847db
movl $0x0, 0x34(%rsp)
jmp 0x8481e
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x81eb0
movq %rax, %rdi
callq 0x78950
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x844d0
cmpl $0x0, %eax
jne 0x84816
movl $0x0, 0x34(%rsp)
jmp 0x8481e
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3Circle const&)
RNBoolean R3Contains(const R3Halfspace& halfspace, const R3Circle& circle)
{
    // Return whether halfspace contains circle
    RNScalar d = R3SignedDistance(halfspace.Plane(), circle.Center());
    if (RNIsNegative(d)) return FALSE;
    else if (RNIsGreater(d, circle.Radius())) return TRUE;
    else {
        RNScalar cos_theta = halfspace.Plane().Normal().Dot(circle.Normal());
	if (cos_theta < 0.0) cos_theta = halfspace.Plane().Normal().Dot(-circle.Normal());
	return (RNIsGreaterOrEqual(d, cos_theta * circle.Radius()));
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x78920
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x81cb0
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x86f90
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
leaq 0xf3be9(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
cmpl $0x0, %eax
je 0x84912
movl $0x0, 0x74(%rsp)
jmp 0x84a1e
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x60(%rsp), %rdi
callq 0x3c2e0
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0xf3ba8(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x84953
movl $0x1, 0x74(%rsp)
jmp 0x84a1e
movq 0x68(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x13e60
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
callq 0x78a80
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0x50(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x50(%rsp), %xmm0
jbe 0x849d5
movq 0x68(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x13e60
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x78a80
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x70fa0
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x702c0
movsd %xmm0, 0x50(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x3c2e0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm1
leaq 0xf3acf(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b80
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3Halfspace const&)
RNBoolean R3Contains(const R3Halfspace& halfspace1, const R3Halfspace& halfspace2)
{
    // Return whether halfspace1 contains halfspace2
    RNScalar dot = halfspace1.Plane().Normal().Dot(halfspace2.Plane().Normal());
    if (RNIsEqual(dot, 1.0)) {
	// Halfspace and plane are parallel ???
	return RNIsLessOrEqual(halfspace1.Plane().D(), halfspace2.Plane().D());
    }
    else {
	// Halfspace and plane are not parallel
	return FALSE;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x13e60
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x13e60
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0xf3a59(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
movsd 0xae575(%rip), %xmm1    # 0x133008
callq 0x37170
cmpl $0x0, %eax
je 0x84ae6
movq 0x28(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x4e330
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x4e330
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xf3a09(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b50
movl %eax, 0x34(%rsp)
jmp 0x84aee
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Halfspace const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Halfspace& halfspace, const R3OrientedBox& box)
{
    // Return whether halfspace contains box
    if (box.IsEmpty()) return FALSE;
    if (!box.IsPlanar()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(halfspace, box.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x84b2a
movl $0x0, 0x44(%rsp)
jmp 0x84bae
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x84b44
movl $0x0, 0x44(%rsp)
jmp 0x84bae
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x84ba6
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x844d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x84b8d
jmp 0x84b97
movl $0x0, 0x44(%rsp)
jmp 0x84bae
jmp 0x84b99
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x84b4c
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Line const&)
RNBoolean R3Contains(const R3Box& box, const R3Line& line)
{
    // Return whether box contains line
    if (box.IsEmpty()) return FALSE;
    if (RNIsFinite(box.XLength())) return FALSE;
    if (RNIsFinite(box.YLength())) return FALSE;
    if (RNIsFinite(box.ZLength())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x84d86
movl $0x0, 0x14(%rsp)
jmp 0x84de8
movq 0x8(%rsp), %rdi
callq 0x37850
callq 0x44e40
cmpl $0x0, %eax
je 0x84da4
movl $0x0, 0x14(%rsp)
jmp 0x84de8
movq 0x8(%rsp), %rdi
callq 0x378a0
callq 0x44e40
cmpl $0x0, %eax
je 0x84dc2
movl $0x0, 0x14(%rsp)
jmp 0x84de8
movq 0x8(%rsp), %rdi
callq 0x378f0
callq 0x44e40
cmpl $0x0, %eax
je 0x84de0
movl $0x0, 0x14(%rsp)
jmp 0x84de8
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Ray const&)
RNBoolean R3Contains(const R3Box& box, const R3Ray& ray)
{
    // Return whether box contains ray
    if (box.IsEmpty()) return FALSE;
    if (RNIsFinite(box.XLength())) return FALSE;
    if (RNIsFinite(box.YLength())) return FALSE;
    if (RNIsFinite(box.ZLength())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x84e26
movl $0x0, 0x14(%rsp)
jmp 0x84e88
movq 0x8(%rsp), %rdi
callq 0x37850
callq 0x44e40
cmpl $0x0, %eax
je 0x84e44
movl $0x0, 0x14(%rsp)
jmp 0x84e88
movq 0x8(%rsp), %rdi
callq 0x378a0
callq 0x44e40
cmpl $0x0, %eax
je 0x84e62
movl $0x0, 0x14(%rsp)
jmp 0x84e88
movq 0x8(%rsp), %rdi
callq 0x378f0
callq 0x44e40
cmpl $0x0, %eax
je 0x84e80
movl $0x0, 0x14(%rsp)
jmp 0x84e88
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Plane const&)
RNBoolean R3Contains(const R3Box& box, const R3Plane& plane)
{
    // Return whether box contains plane
    if (box.IsEmpty()) return FALSE;
    if (RNIsFinite(box.XLength())) return FALSE;
    if (RNIsFinite(box.YLength())) return FALSE;
    if (RNIsFinite(box.ZLength())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x84f46
movl $0x0, 0x14(%rsp)
jmp 0x84fa8
movq 0x8(%rsp), %rdi
callq 0x37850
callq 0x44e40
cmpl $0x0, %eax
je 0x84f64
movl $0x0, 0x14(%rsp)
jmp 0x84fa8
movq 0x8(%rsp), %rdi
callq 0x378a0
callq 0x44e40
cmpl $0x0, %eax
je 0x84f82
movl $0x0, 0x14(%rsp)
jmp 0x84fa8
movq 0x8(%rsp), %rdi
callq 0x378f0
callq 0x44e40
cmpl $0x0, %eax
je 0x84fa0
movl $0x0, 0x14(%rsp)
jmp 0x84fa8
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Halfspace const&)
RNBoolean R3Contains(const R3Box& box, const R3Halfspace& halfspace)
{
    // Return whether box contains halfspace
    if (box.IsEmpty()) return FALSE;
    RNOctant octant = halfspace.Normal().Octant();
    R3Point corner = box.Corner(octant);
    if (!RNIsFinite(corner.X())) return FALSE;
    if (!RNIsFinite(corner.Y())) return FALSE;
    if (!RNIsFinite(corner.Z())) return FALSE;
    RNAbort("Not Implemented");
    return FALSE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x84fea
movl $0x0, 0x34(%rsp)
jmp 0x8507b
movq 0x20(%rsp), %rdi
callq 0x81c10
movq %rax, %rdi
callq 0x701d0
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq %rsp, %rdi
callq 0x42e40
movq %rsp, %rdi
callq 0x37820
callq 0x44e40
cmpl $0x0, %eax
jne 0x8502d
movl $0x0, 0x34(%rsp)
jmp 0x8507b
movq %rsp, %rdi
callq 0x37870
callq 0x44e40
cmpl $0x0, %eax
jne 0x85049
movl $0x0, 0x34(%rsp)
jmp 0x8507b
movq %rsp, %rdi
callq 0x378c0
callq 0x44e40
cmpl $0x0, %eax
jne 0x85065
movl $0x0, 0x34(%rsp)
jmp 0x8507b
leaq 0xaecef(%rip), %rdi     # 0x133d5b
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Box& box1, const R3Box& box2) 
{
    // Return whether box1 contains box2
    if (box1.IsEmpty()) return FALSE;
    if (box2.IsEmpty()) return FALSE;
    if (RNIsLess(box2.XMin(), box1.XMin())) return FALSE;
    if (RNIsLess(box2.YMin(), box1.YMin())) return FALSE;
    if (RNIsLess(box2.ZMin(), box1.ZMin())) return FALSE;
    if (RNIsGreater(box2.XMax(), box1.XMax())) return FALSE;
    if (RNIsGreater(box2.YMax(), box1.YMax())) return FALSE;
    if (RNIsGreater(box2.ZMax(), box1.ZMax())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x850ba
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x850d6
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x37830
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x37830
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0xf33e0(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x8511b
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x37880
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x37880
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
leaq 0xf339b(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x85160
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x378d0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x378d0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xf3356(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0x851a5
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x44f80
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44f80
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0xf3311(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x851ea
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x44fa0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44fa0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xf32cc(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x8522c
movl $0x0, 0x44(%rsp)
jmp 0x85274
movq 0x30(%rsp), %rdi
callq 0x44fc0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x44fc0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xf328c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x8526c
movl $0x0, 0x44(%rsp)
jmp 0x85274
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Box const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Box& box1, const R3OrientedBox& box2)
{
    // Return whether halfspace contains box
    if (box1.IsEmpty()) return FALSE;
    if (box2.IsEmpty()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(box1, box2.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x852aa
movl $0x0, 0x44(%rsp)
jmp 0x8532d
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x852c3
movl $0x0, 0x44(%rsp)
jmp 0x8532d
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x85325
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x83a20
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8530c
jmp 0x85316
movl $0x0, 0x44(%rsp)
jmp 0x8532d
jmp 0x85318
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x852cb
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Point& point)
{
    // Check if box is empty
    if (box.IsEmpty()) return FALSE;

    // Return whether each halfspace contains point
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, point)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x85640
movl $0x0, 0x84(%rsp)
jmp 0x856e6
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x856db
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x856c9
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x9f970
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38f60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xa1630
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x844d0
cmpl $0x0, %eax
jne 0x856ba
movl $0x0, 0x84(%rsp)
jmp 0x856e6
jmp 0x856bc
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x8565b
jmp 0x856cb
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x85648
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Line const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Line& line)
{
    // Return whether box contains line
    if (RNIsFinite(box.Radius(RN_X))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Y))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Z))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x8572d
movl $0x0, 0x14(%rsp)
jmp 0x8577b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x85750
movl $0x0, 0x14(%rsp)
jmp 0x8577b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x85773
movl $0x0, 0x14(%rsp)
jmp 0x8577b
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Ray const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Ray& ray)
{
    // Return whether box contains ray
    if (RNIsFinite(box.Radius(RN_X))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Y))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Z))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x857bd
movl $0x0, 0x14(%rsp)
jmp 0x8580b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x857e0
movl $0x0, 0x14(%rsp)
jmp 0x8580b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x85803
movl $0x0, 0x14(%rsp)
jmp 0x8580b
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Plane const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Plane& plane)
{
    // Return whether box contains plane
    if (RNIsFinite(box.Radius(RN_X))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Y))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Z))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x858cd
movl $0x0, 0x14(%rsp)
jmp 0x8591b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x858f0
movl $0x0, 0x14(%rsp)
jmp 0x8591b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x85913
movl $0x0, 0x14(%rsp)
jmp 0x8591b
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Halfspace const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Halfspace& halfspace)
{
    // Return whether box contains halfspace
    if (RNIsFinite(box.Radius(RN_X))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Y))) return FALSE;
    if (RNIsFinite(box.Radius(RN_Z))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x8595d
movl $0x0, 0x14(%rsp)
jmp 0x859ab
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x85980
movl $0x0, 0x14(%rsp)
jmp 0x859ab
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
callq 0x44e40
cmpl $0x0, %eax
je 0x859a3
movl $0x0, 0x14(%rsp)
jmp 0x859ab
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3OrientedBox& box1, const R3Box& box2)
{
    // Check if box is empty
    if (box1.IsEmpty()) return FALSE;
    if (box2.IsEmpty()) return FALSE;

    // Return whether each halfspace contains box
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box1.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, box2)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x859f0
movl $0x0, 0x84(%rsp)
jmp 0x85ab5
movq 0x70(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x85a0f
movl $0x0, 0x84(%rsp)
jmp 0x85ab5
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x85aaa
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x85a98
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x9f970
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38f60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xa1630
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x84830
cmpl $0x0, %eax
jne 0x85a89
movl $0x0, 0x84(%rsp)
jmp 0x85ab5
jmp 0x85a8b
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x85a2a
jmp 0x85a9a
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x85a17
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3OrientedBox& box1, const R3OrientedBox& box2) 
{
    // Check if box is empty
    if (box1.IsEmpty()) return FALSE;
    if (box2.IsEmpty()) return FALSE;

    // Return whether each halfspace contains box
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box1.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, box2)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x85b00
movl $0x0, 0x84(%rsp)
jmp 0x85bc5
movq 0x70(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x85b1f
movl $0x0, 0x84(%rsp)
jmp 0x85bc5
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x85bba
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x85ba8
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x9f970
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38f60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xa1630
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x84b00
cmpl $0x0, %eax
jne 0x85b99
movl $0x0, 0x84(%rsp)
jmp 0x85bc5
jmp 0x85b9b
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x85b3a
jmp 0x85baa
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x85b27
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Sphere const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Sphere& sphere)
{
    // Check if box is empty
    if (box.IsEmpty()) return FALSE;

    // Return whether each halfspace contains sphere
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, sphere)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x85c10
movl $0x0, 0x84(%rsp)
jmp 0x85cb6
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x85cab
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x85c99
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x9f970
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38f60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xa1630
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x84bc0
cmpl $0x0, %eax
jne 0x85c8a
movl $0x0, 0x84(%rsp)
jmp 0x85cb6
jmp 0x85c8c
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x85c2b
jmp 0x85c9b
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x85c18
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3OrientedBox const&, gaps::R3Shape const&)
RNBoolean R3Contains(const R3OrientedBox& box, const R3Shape& shape)
{
    // Check if box is empty
    if (box.IsEmpty()) return FALSE;

    // Return whether each halfspace contains shape
    for (int dir = 0; dir < 2; dir++) {
      for (int dim = 0; dim < 3; dim++) {
        R3Halfspace halfspace(-box.Plane(dir, dim), 0);
        if (!R3Contains(halfspace, shape)) {
          return FALSE;
        }
      }
    }

    // Passed all tests
    return TRUE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x85d00
movl $0x0, 0x84(%rsp)
jmp 0x85da6
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x85d9b
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x85d89
movq 0x78(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x8(%rsp), %rdi
callq 0x9f970
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38f60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0xa1630
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x84d30
cmpl $0x0, %eax
jne 0x85d7a
movl $0x0, 0x84(%rsp)
jmp 0x85da6
jmp 0x85d7c
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x85d1b
jmp 0x85d8b
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x85d08
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Sphere const&, gaps::R3Point const&)
RNBoolean R3Contains(const R3Sphere& sphere, const R3Point& point)
{
    // Return whether sphere contains point
    RNScalar radius_squared = sphere.Radius() * sphere.Radius();
    R3Vector v = sphere.Center() - point;
    RNScalar distance_squared = v.X() * v.X() + v.Y() * v.Y() + v.Z() * v.Z();
    return RNIsLessOrEqual(distance_squared, radius_squared);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x39f50
movsd %xmm0, (%rsp)
movq 0x60(%rsp), %rdi
callq 0x39f50
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rdi
callq 0x42710
movq %rax, %rsi
movq 0x58(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x6eeb0
leaq 0x38(%rsp), %rdi
callq 0x38c20
movsd %xmm0, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x38c20
movsd %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x38c30
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x38c30
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x38c40
movsd %xmm0, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x38c40
movsd 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
leaq 0xf2620(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b50
addq $0x68, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Sphere const&, gaps::R3Box const&)
RNBoolean R3Contains(const R3Sphere& sphere, const R3Box& box)
{
    // Return whether sphere contains box 
    if (box.IsEmpty()) return FALSE;
    R3Vector v = box.Centroid() - sphere.Center();
    R3Point corner = box.Corner(v.Octant());
    return R3Contains(sphere, corner);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x86077
movl $0x0, 0x64(%rsp)
jmp 0x860d9
movq 0x50(%rsp), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x68(%rax)
movq 0x58(%rsp), %rdi
callq 0x42710
movq %rax, %rdx
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6eeb0
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x701d0
movq (%rsp), %rsi
movl %eax, %edx
leaq 0x8(%rsp), %rdi
callq 0x42e40
movq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x85dc0
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Cont.cpp
// Function: gaps::R3Contains(gaps::R3Sphere const&, gaps::R3OrientedBox const&)
RNBoolean R3Contains(const R3Sphere& sphere, const R3OrientedBox& box)
{
    // Return whether sphere contains box 
    if (box.IsEmpty()) return FALSE;
    for (int i = 0; i < RN_NUM_OCTANTS; i++) 
      if (!R3Contains(sphere, box.Corner(i))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c180
cmpl $0x0, %eax
je 0x86117
movl $0x0, 0x44(%rsp)
jmp 0x86181
movl $0x0, 0x2c(%rsp)
cmpl $0x8, 0x2c(%rsp)
jge 0x86179
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x39cf0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x85dc0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x86160
jmp 0x8616a
movl $0x0, 0x44(%rsp)
jmp 0x86181
jmp 0x8616c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x8611f
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)