LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x78, %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x7777, %esi           # imm = 0x7777
callq 0x13d80
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x37560
movl $0x0, 0x64(%rsp)
cmpl $0x3, 0x64(%rsp)
jge 0x9cba3
movq 0x18(%rsp), %rax
movslq 0x64(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x9a5a0
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x13d80
movq 0x50(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
jne 0x9caf5
movq 0x18(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x13d80
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x372b0
leaq 0x40(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x13d80
movq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
jne 0x9cb44
movq 0x18(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x13d80
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x372b0
leaq 0x30(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x13d80
movq 0x30(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
jne 0x9cb91
movq 0x18(%rsp), %rax
addq $0x78, %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x13d80
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x372b0
jmp 0x9cb93
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x9ca82
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x0, 0xc(%rsp)
addq $0x68, %rdi
callq 0x38c20
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9d019
jp 0x9d019
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0x38c30
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9d03c
jp 0x9d03c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0x38c40
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9d05f
jp 0x9d05f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
setge %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x48(%rsp)
addq $0x68, %rdi
callq 0x70090
movl %eax, %ecx
movq %rcx, 0x50(%rsp)
subl $0x5, %eax
ja 0x9d370
movq 0x50(%rsp), %rax
leaq 0x98906(%rip), %rcx     # 0x135b50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x68, %rdi
callq 0x38c20
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x68, %rdi
callq 0x38c20
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x68, %rdi
callq 0x38c30
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x68, %rdi
callq 0x38c30
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x68, %rdi
callq 0x38c40
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
movq 0x48(%rsp), %rdi
callq 0x39f90
movq 0x48(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x68, %rdi
callq 0x38c40
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x42070
jmp 0x9d38f
leaq 0x98812(%rip), %rdi     # 0x135b89
movb $0x0, %al
callq 0xd4e20
movq 0x38(%rsp), %rdi
leaq 0xdb306(%rip), %rsi     # 0x178690
callq 0x41ff0
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x82030
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x82030
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x42940
movq 0x20(%rsp), %rsi
addq $0x58, %rsi
leaq 0x38(%rsp), %rdi
callq 0x961a0
jmp 0x9dc0b
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x44710
jmp 0x9dc1c
leaq 0x38(%rsp), %rdi
callq 0x36a80
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x9dc68
jmp 0x9dc5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x9dc75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x36a80
jmp 0x9dc75
movq 0x10(%rsp), %rdi
callq 0x36a80
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x36a80
movq 0x30(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x78cf0
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x38(%rsp)
callq 0x78cd0
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
leaq 0xda800(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b50
cmpl $0x0, %eax
je 0x9dd06
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x58, %rsi
callq 0x96290
jmp 0x9de83
movq 0x30(%rsp), %rdi
callq 0x78cd0
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x78cd0
movq 0x30(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x78cf0
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x97bf2(%rip), %xmm1    # 0x135958
mulsd %xmm1, %xmm0
movsd 0x95296(%rip), %xmm1    # 0x133008
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
leaq 0xda757(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x382c0
cmpl $0x0, %eax
je 0x9ddaf
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x58, %rsi
callq 0x96290
jmp 0x9de83
movsd 0x70(%rsp), %xmm0
callq 0xf390
movsd %xmm0, 0x70(%rsp)
movsd 0x95240(%rip), %xmm0    # 0x133008
ucomisd 0x70(%rsp), %xmm0
jb 0x9ddf2
movsd 0x95230(%rip), %xmm1    # 0x133008
addsd 0x70(%rsp), %xmm1
movsd 0x9522a(%rip), %xmm0    # 0x133010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x9de12
movsd 0x9520e(%rip), %xmm1    # 0x133008
addsd 0x70(%rsp), %xmm1
movsd 0x95208(%rip), %xmm0    # 0x133010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x30(%rsp), %rdi
addq $0x58, %rdi
callq 0x81cb0
movq 0x30(%rsp), %rdi
movq %rax, 0x8(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, (%rsp)
addq $0x8, %rdi
callq 0x392b0
movsd (%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x13800
movq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x6f110
movq 0x30(%rsp), %rdi
callq 0x78cf0
movq 0x20(%rsp), %rdi
subsd 0x70(%rsp), %xmm0
leaq 0x58(%rsp), %rsi
callq 0x42070
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x6e110
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
je 0x9e762
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movq 0x18(%rsp), %rsi
addq $0x58, %rsi
callq 0x9ed50
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
je 0x9e762
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x18(%rsp), %rsi
addq $0xa0, %rsi
callq 0x9ed50
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0xa7(%rsp)
leaq 0xd9eb8(%rip), %rsi     # 0x1787e8
callq 0x428c0
movq 0x18(%rsp), %rsi
addq $0x58, %rsi
leaq 0x68(%rsp), %rdi
callq 0x961a0
jmp 0x9e94a
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x44710
jmp 0x9e95b
leaq 0x68(%rsp), %rdi
callq 0x36a80
movq 0x18(%rsp), %rsi
addq $0xa0, %rsi
leaq 0x20(%rsp), %rdi
callq 0x961a0
jmp 0x9e97d
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x44710
jmp 0x9e98e
leaq 0x20(%rsp), %rdi
callq 0x36a80
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x9e9fa
jmp 0x9e9f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x9ea07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x36a80
jmp 0x9ea07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x36a80
jmp 0x9ea07
movq 0x8(%rsp), %rdi
callq 0x36a80
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x36a80
movq 0x60(%rsp), %rdi
callq 0xf890
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rsi
addq $0x8, %rdi
callq 0x39330
movq 0x20(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39250
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x962f0
movq 0x20(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x392b0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x70fa0
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x96370
movq 0x20(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39260
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x962f0
movq 0x20(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x392b0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x96370
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Circle.h
// Function: gaps::R3Circle::operator==(gaps::R3Circle const&) const
inline RNBoolean R3Circle::
operator==(const R3Circle& circle) const
{
    // Return whether circle is equal
    return ((center == circle.center) && 
	    (radius == circle.radius) && 
	    (plane == circle.plane));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x6ece0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
je 0x9edc6
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x18(%rsp), %rcx
xorl %eax, %eax
ucomisd 0x20(%rcx), %xmm0
movb %al, 0x17(%rsp)
jne 0x9edc6
jp 0x9edc6
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsi
callq 0x90680
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x45120
movq (%rsp), %rdi
leaq 0xcf0c1(%rip), %rax     # 0x16e088
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x4e480
jmp 0x9efde
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movsd 0x68(%rcx), %xmm0
movsd %xmm0, 0x68(%rax)
movq 0x18(%rsp), %rcx
movsd 0x70(%rcx), %xmm0
movsd %xmm0, 0x70(%rax)
movq 0x18(%rsp), %rcx
movsd 0x78(%rcx), %xmm0
movsd %xmm0, 0x78(%rax)
addq $0x28, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x45150
movq 0x10(%rsp), %rdi
callq 0xf890
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movl %ecx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0x9f9c3
movq 0x10(%rsp), %rdi
leaq 0x4d9727(%rip), %rsi    # 0x5790e0
callq 0x6c140
jmp 0x9fa62
cmpl $0x0, 0x74(%rsp)
jne 0x9f9e7
movq 0x20(%rsp), %rdi
movl 0x70(%rsp), %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x6fcf0
jmp 0x9fa0a
movq 0x20(%rsp), %rdi
movl 0x70(%rsp), %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
movsd 0x93613(%rip), %xmm0    # 0x133018
callq 0x13800
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x3c2b0
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x70(%rsp), %esi
callq 0x3c1d0
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x13800
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x6f110
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x6c260
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
subq $0x5, %rax
ja 0x9fb4d
movq 0x18(%rsp), %rax
leaq 0x96149(%rip), %rcx     # 0x135c00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x9f970
jmp 0x9fb5d
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9f970
jmp 0x9fb5d
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x9f970
jmp 0x9fb5d
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x9f970
jmp 0x9fb5d
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x9f970
jmp 0x9fb5d
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x9f970
jmp 0x9fb5d
movq (%rsp), %rdi
leaq 0x4d9588(%rip), %rsi    # 0x5790e0
callq 0x6c140
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0x9fbc0
movq 0x10(%rsp), %rdi
leaq 0x4d98fa(%rip), %rsi    # 0x5794b0
callq 0x6eb90
jmp 0x9fc8e
movq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x6eb90
movl $0x0, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jge 0x9fc8c
movl $0x0, 0x68(%rsp)
cmpl $0x3, 0x68(%rsp)
jge 0x9fc7a
movq 0x20(%rsp), %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
leaq 0x48(%rsp), %rdi
callq 0x9f970
movq 0x10(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x86f90
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9fc68
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x13e60
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x13800
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6f890
jmp 0x9fc6a
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x9fbea
jmp 0x9fc7c
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x9fbd7
jmp 0x9fc8e
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::IsLinear() const
const RNBoolean R3OrientedBox::
IsLinear(void) const
{
    // Check if box is empty
    if (IsEmpty()) return FALSE;

    // A box lies on a line if its second highest radius is zero
    if (Radius(0) > Radius(1)) {
        if (Radius(1) > Radius(2)) return RNIsZero(Radius(1));
        else return RNIsZero(Radius(2));
    }
    else {
        if (Radius(0) > Radius(2)) return RNIsZero(Radius(0));
        else return RNIsZero(Radius(2));
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0x9fe1a
movl $0x0, 0x34(%rsp)
jmp 0x9ff43
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
movl $0x1, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9fece
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl $0x2, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9fea9
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
leaq 0xd8649(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
movl %eax, 0x34(%rsp)
jmp 0x9ff43
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
leaq 0xd8621(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
movl %eax, 0x34(%rsp)
jmp 0x9ff43
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9ff20
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
leaq 0xd85cf(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
movl %eax, 0x34(%rsp)
jmp 0x9ff43
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
leaq 0xd85aa(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3c1b0
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x3c1b0
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x6ece0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x47(%rsp)
je 0xa0162
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1f0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1f0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x70310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x47(%rsp)
je 0xa0162
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1f0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1f0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x70310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x47(%rsp)
je 0xa0162
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1f0
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x70310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x47(%rsp)
je 0xa0162
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, 0x47(%rsp)
jne 0xa0162
jp 0xa0162
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, 0x47(%rsp)
jne 0xa0162
jp 0xa0162
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x58, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Area() const
const RNArea R3OrientedBox::
Area(void) const
{
    // Check if box is empty
    if (IsEmpty()) return 0.0;

    // Return surface area of box
    RNScalar area = 0;
    area += 2*4*Radius(0)*Radius(1);
    area += 2*4*Radius(1)*Radius(2);
    area += 2*4*Radius(2)*Radius(0);
    return area;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa01fb
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xa02f8
movq 0x18(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x3c1d0
movq 0x18(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x92fd8(%rip), %xmm0    # 0x1331f8
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movl $0x1, %esi
callq 0x3c1d0
movq 0x18(%rsp), %rdi
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x1, %esi
callq 0x3c1d0
movq 0x18(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x92f8a(%rip), %xmm0    # 0x1331f8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
callq 0x3c1d0
movq 0x18(%rsp), %rdi
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x2, %esi
callq 0x3c1d0
movq 0x18(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x92f3a(%rip), %xmm0    # 0x1331f8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %esi, %esi
callq 0x3c1d0
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa0463
movq (%rsp), %rdi
leaq 0xd838f(%rip), %rsi     # 0x1787e8
callq 0x428c0
jmp 0xa04eb
movq (%rsp), %rdi
movb $0x0, 0x47(%rsp)
leaq 0xd8375(%rip), %rsi     # 0x1787e8
callq 0x428c0
movl $0x0, 0x40(%rsp)
cmpl $0x8, 0x40(%rsp)
jge 0xa04d4
movq 0x10(%rsp), %rsi
movl 0x40(%rsp), %edx
leaq 0x28(%rsp), %rdi
callq 0x39cf0
jmp 0xa049c
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x444b0
jmp 0xa04ac
jmp 0xa04ae
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xa0480
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x36a80
jmp 0xa04f5
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xa04e9
movq (%rsp), %rdi
callq 0x36a80
jmp 0xa04eb
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf890
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Resize(double, double, double)
void R3OrientedBox::
Resize(RNLength radius0, RNLength radius1, RNLength radius2) 
{
    // Check if box is empty
    if (IsEmpty()) return;

    // Set box radius
    this->radius[0] = radius0;
    this->radius[1] = radius1;
    this->radius[2] = radius2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa0660
jmp 0xa0685
movq (%rsp), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x70(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x78(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Rotate(int, double)
void R3OrientedBox::
Rotate(RNAxis rotation_axis, RNAngle theta) 
{
    // Check if box is empty
    if (IsEmpty()) return;

    // Rotate axes
    R3Vector axis0 = Axis(0);
    R3Vector axis1 = Axis(1);
    axis0.Rotate(rotation_axis, theta);
    axis1.Rotate(rotation_axis, theta);

    // Reorient with rotated axes
    Reorient(axis0, axis1);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa0729
jmp 0xa079e
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6fcf0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x6fcf0
movl 0x4c(%rsp), %esi
movsd 0x40(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x70840
movl 0x4c(%rsp), %esi
movsd 0x40(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
callq 0x70840
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq *0x250(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Rotate(gaps::R3Vector const&, double)
void R3OrientedBox::
Rotate(const R3Vector& rotation_axis, RNAngle theta) 
{
    // Check if box is empty
    if (IsEmpty()) return;

    // Rotate axes
    R3Vector axis0 = Axis(0);
    R3Vector axis1 = Axis(1);
    axis0.Rotate(rotation_axis, theta);
    axis1.Rotate(rotation_axis, theta);

    // Reorient with rotated axes
    Reorient(axis0, axis1);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa07da
jmp 0xa0851
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6fcf0
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1f0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x6fcf0
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x709b0
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
callq 0x709b0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq *0x250(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3OrientedBox.cpp
// Function: gaps::R3OrientedBox::Transform(gaps::R3Transformation const&)
void R3OrientedBox::
Transform (const R3Transformation& transformation)
{
    // Check if box is empty
    if (IsEmpty()) return;

    // Transform 
    cs.Transform(transformation);
    radius[0] *= transformation.ScaleFactor();
    radius[1] *= transformation.ScaleFactor();
    radius[2] *= transformation.ScaleFactor();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa08f3
jmp 0xa0959
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
callq 0x4e800
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq (%rsp), %rax
mulsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq (%rsp), %rax
mulsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq (%rsp), %rax
mulsd 0x78(%rax), %xmm0
movsd %xmm0, 0x78(%rax)
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3OrientedBox.h
// Function: gaps::R3OrientedBox::MaxRadius() const
inline const RNLength R3OrientedBox::
MaxRadius(void) const
{
    // Check if box is empty
    if (IsEmpty()) return -1.0;

    // Return smallest radius
    RNLength result = Radius(0);
    if (Radius(1) > result) result = Radius(1);
    if (Radius(2) > result) result = Radius(2);
    return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3c180
cmpl $0x0, %eax
je 0xa11dd
movsd 0x91e43(%rip), %xmm0    # 0x133018
movsd %xmm0, 0x20(%rsp)
jmp 0xa1253
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3c1d0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl $0x1, %esi
callq 0x3c1d0
ucomisd 0x10(%rsp), %xmm0
jbe 0xa121b
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x3c1d0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
ucomisd 0x10(%rsp), %xmm0
jbe 0xa1247
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x3c1d0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, %eax
jne 0xa1c08
movl $0x0, 0x24(%rsp)
jmp 0xa1c6e
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3520
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa1a10
cmpl $0x0, %eax
jne 0xa1c38
movl $0x0, 0x24(%rsp)
jmp 0xa1c6e
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3570
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xa1a10
cmpl $0x0, %eax
jne 0xa1c66
movl $0x0, 0x24(%rsp)
jmp 0xa1c6e
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Ray const&, gaps::R2Box const&)
RNBoolean R2Contains(const R2Ray& ray, const R2Box& box)
{
    // Return whether ray contains box
    if (!R2Contains(ray.Line(), box)) return FALSE;
    RNQuadrant quadrant = ray.Vector().Quadrant();
    if (!R2Contains(ray, box.Corner(~quadrant & 0x3))) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa35d0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0xa1be0
cmpl $0x0, %eax
jne 0xa1ed4
movl $0x0, 0x34(%rsp)
jmp 0xa1f3a
movq 0x28(%rsp), %rdi
callq 0xa35c0
movq %rax, %rdi
callq 0xc3ed0
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
xorl $-0x1, %edx
andl $0x3, %edx
leaq 0x8(%rsp), %rdi
callq 0xbd950
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa1d20
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa1f28
jmp 0xa1f32
movl $0x0, 0x34(%rsp)
jmp 0xa1f3a
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa3610
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xa1be0
cmpl $0x0, %eax
jne 0xa2144
movl $0x0, 0x24(%rsp)
jmp 0xa21aa
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3520
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa1ff0
cmpl $0x0, %eax
jne 0xa2174
movl $0x0, 0x24(%rsp)
jmp 0xa21aa
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3570
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xa1ff0
cmpl $0x0, %eax
jne 0xa21a2
movl $0x0, 0x24(%rsp)
jmp 0xa21aa
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa36a0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa36a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc3f40
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0xd6059(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
movsd 0x90b75(%rip), %xmm1    # 0x133008
callq 0x37170
cmpl $0x0, %eax
je 0xa24e6
movq 0x28(%rsp), %rdi
callq 0xa3620
movq %rax, %rdi
callq 0xa3550
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa3620
movq %rax, %rdi
callq 0xa3550
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xd6009(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b50
movl %eax, 0x34(%rsp)
jmp 0xa24ee
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Box const&, gaps::R2Point const&)
RNBoolean R2Contains(const R2Box& box, const R2Point& 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 (RNIsGreater(point.X(), box.XMax())) return FALSE;
    if (RNIsGreater(point.Y(), box.YMax())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa36c0
cmpl $0x0, %eax
je 0xa262a
movl $0x0, 0x34(%rsp)
jmp 0xa273e
movq 0x20(%rsp), %rdi
callq 0x38c50
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3750
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xd5e8c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa266f
movl $0x0, 0x34(%rsp)
jmp 0xa273e
movq 0x20(%rsp), %rdi
callq 0x38c60
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3770
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0xd5e47(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa26b4
movl $0x0, 0x34(%rsp)
jmp 0xa273e
movq 0x20(%rsp), %rdi
callq 0x38c50
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3790
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xd5e02(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa26f6
movl $0x0, 0x34(%rsp)
jmp 0xa273e
movq 0x20(%rsp), %rdi
callq 0x38c60
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xa37b0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xd5dc2(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa2736
movl $0x0, 0x34(%rsp)
jmp 0xa273e
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa36a0
movq %rax, %rdi
callq 0xc3ed0
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rsi
movl 0x1c(%rsp), %edx
leaq 0x8(%rsp), %rdi
callq 0xbd950
leaq 0x8(%rsp), %rdi
callq 0x38c50
callq 0x44e40
cmpl $0x0, %eax
jne 0xa28c5
movl $0x0, 0x34(%rsp)
jmp 0xa28f9
leaq 0x8(%rsp), %rdi
callq 0x38c60
callq 0x44e40
cmpl $0x0, %eax
jne 0xa28e3
movl $0x0, 0x34(%rsp)
jmp 0xa28f9
leaq 0x91471(%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/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Box const&, gaps::R2Box const&)
RNBoolean R2Contains(const R2Box& box1, const R2Box& box2) 
{
    // Return whether box1 contains box2
    if (box1.IsEmpty()) return FALSE;
    if (box2.IsEmpty()) return TRUE;
    if (RNIsLess(box2.XMin(), box1.XMin())) return FALSE;
    if (RNIsLess(box2.YMin(), box1.YMin())) return FALSE;
    if (RNIsGreater(box2.XMax(), box1.XMax())) return FALSE;
    if (RNIsGreater(box2.YMax(), box1.YMax())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa36c0
cmpl $0x0, %eax
je 0xa293a
movl $0x0, 0x34(%rsp)
jmp 0xa2a6a
movq 0x20(%rsp), %rdi
callq 0xa36c0
cmpl $0x0, %eax
je 0xa2956
movl $0x1, 0x34(%rsp)
jmp 0xa2a6a
movq 0x20(%rsp), %rdi
callq 0xa3750
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3750
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xd5b60(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa299b
movl $0x0, 0x34(%rsp)
jmp 0xa2a6a
movq 0x20(%rsp), %rdi
callq 0xa3770
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3770
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0xd5b1b(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa29e0
movl $0x0, 0x34(%rsp)
jmp 0xa2a6a
movq 0x20(%rsp), %rdi
callq 0xa3790
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa3790
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xd5ad6(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa2a22
movl $0x0, 0x34(%rsp)
jmp 0xa2a6a
movq 0x20(%rsp), %rdi
callq 0xa37b0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xa37b0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xd5a96(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa2a62
movl $0x0, 0x34(%rsp)
jmp 0xa2a6a
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Cont.cpp
// Function: gaps::R2Contains(gaps::R2Box const&, gaps::R2Circle const&)
RNBoolean R2Contains(const R2Box& box, const R2Circle& circle)
{
    // Return whether box contains circle 
    if (box.IsEmpty()) return FALSE;
    if (circle.IsEmpty()) return TRUE;
    if (RNIsLess(circle.Center().X() - circle.Radius(), box.XMin())) return FALSE;
    if (RNIsLess(circle.Center().Y() - circle.Radius(), box.YMin())) return FALSE;
    if (RNIsGreater(circle.Center().X() + circle.Radius(), box.XMax())) return FALSE;
    if (RNIsGreater(circle.Center().Y() + circle.Radius(), box.YMax())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa36c0
cmpl $0x0, %eax
je 0xa2aaa
movl $0x0, 0x54(%rsp)
jmp 0xa2c6e
movq 0x40(%rsp), %rdi
callq 0xa37d0
cmpl $0x0, %eax
je 0xa2ac6
movl $0x1, 0x54(%rsp)
jmp 0xa2c6e
movq 0x40(%rsp), %rdi
callq 0xa3530
movq %rax, %rdi
callq 0x38c50
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa36b0
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa3750
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
leaq 0xd59cb(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa2b30
movl $0x0, 0x54(%rsp)
jmp 0xa2c6e
movq 0x40(%rsp), %rdi
callq 0xa3530
movq %rax, %rdi
callq 0x38c60
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa36b0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa3770
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0xd5961(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x39630
cmpl $0x0, %eax
je 0xa2b9a
movl $0x0, 0x54(%rsp)
jmp 0xa2c6e
movq 0x40(%rsp), %rdi
callq 0xa3530
movq %rax, %rdi
callq 0x38c50
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa36b0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa3790
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0xd58f7(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa2c01
movl $0x0, 0x54(%rsp)
jmp 0xa2c6e
movq 0x40(%rsp), %rdi
callq 0xa3530
movq %rax, %rdi
callq 0x38c60
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
callq 0xa36b0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa37b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0xd5892(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0xa2c66
movl $0x0, 0x54(%rsp)
jmp 0xa2c6e
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xa36b0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xa36b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xa3530
movq %rax, %rsi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0xc3830
leaq 0x30(%rsp), %rdi
callq 0x78aa0
movsd %xmm0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x78aa0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x78ab0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x78ab0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x20(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
leaq 0xd5765(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x81b50
addq $0x58, %rsp
retq
nopl (%rax)