LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::ShortestAxis() const
const RNAxis R3Box::
ShortestAxis (void) const
{
    // Compute length of each axis
    RNLength dx = this->XLength();
    RNLength dy = this->YLength();
    RNLength dz = this->ZLength();

    // Return shortest axis
    if (dx < dy) {
	if (dx < dz) return RN_XAXIS;
	else return RN_ZAXIS;
    }
    else {
	if (dy < dz) return RN_YAXIS;
	else return RN_ZAXIS;
    }    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37850
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x378a0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x378f0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43b16
movsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43b0c
movl $0x0, 0x34(%rsp)
jmp 0x43b3a
movl $0x2, 0x34(%rsp)
jmp 0x43b3a
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43b32
movl $0x1, 0x34(%rsp)
jmp 0x43b3a
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::LongestAxis() const
const RNAxis R3Box::
LongestAxis (void) const
{
    // Compute length of each axis
    RNLength dx = this->XLength();
    RNLength dy = this->YLength();
    RNLength dz = this->ZLength();

    // Return longest axis
    if (dx > dy) {
	if (dx > dz) return RN_XAXIS;
	else return RN_ZAXIS;
    }
    else {
	if (dy > dz) return RN_YAXIS;
	else return RN_ZAXIS;
    }    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37850
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x378a0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x378f0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x43bbe
movsd 0x20(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x43bb4
movl $0x0, 0x34(%rsp)
jmp 0x43bde
movl $0x2, 0x34(%rsp)
jmp 0x43bde
movsd 0x18(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x43bd6
movl $0x1, 0x34(%rsp)
jmp 0x43bde
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::ShortestAxisLength() const
const RNLength R3Box::
ShortestAxisLength (void) const
{
    // Compute length of each axis
    RNLength dx = this->XLength();
    RNLength dy = this->YLength();
    RNLength dz = this->ZLength();

    // Return length of shortest axis
    if (dx < dy) {
	if (dx < dz) return dx;
	else return dz;
    }
    else {
	if (dy < dz) return dy;
	else return dz;
    }    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37850
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x378a0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x378f0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43c6e
movsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43c60
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43c9a
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43c9a
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43c8e
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43c9a
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::LongestAxisLength() const
const RNLength R3Box::
LongestAxisLength (void) const
{
    // Compute length of each axis
    RNLength dx = this->XLength();
    RNLength dy = this->YLength();
    RNLength dz = this->ZLength();

    // Return longest axis
    if (dx > dy) {
	if (dx > dz) return dx;
	else return dz;
    }
    else {
	if (dy > dz) return dy;
	else return dz;
    }    
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x37850
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x378a0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x378f0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x43d26
movsd 0x20(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x43d18
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43d4e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43d4e
movsd 0x18(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x43d42
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x43d4e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::ClosestPoint(gaps::R3Point const&) const
const R3Point R3Box::
ClosestPoint(const R3Point& point) const
{
    // Return closest point in box
    R3Point closest(point);
    if (closest.X() < XMin()) closest[RN_X] = XMin();
    else if (closest.X() > XMax()) closest[RN_X] = XMax();
    if (closest.Y() < YMin()) closest[RN_Y] = YMin();
    else if (closest.Y() > YMax()) closest[RN_Y] = YMax();
    if (closest.Z() < ZMin()) closest[RN_Z] = ZMin();
    else if (closest.Z() > ZMax()) closest[RN_Z] = ZMax();
    return closest;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x68(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rsi
callq 0x6eb90
movq 0x68(%rsp), %rdi
callq 0x37820
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x78(%rsp)
callq 0x37830
movsd 0x78(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43e14
movq 0x70(%rsp), %rdi
callq 0x37830
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x58(%rsp)
xorl %esi, %esi
callq 0x36be0
movsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43e65
movq 0x68(%rsp), %rdi
callq 0x37820
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
callq 0x44f80
movaps %xmm0, %xmm1
movsd 0x50(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43e63
movq 0x70(%rsp), %rdi
callq 0x44f80
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x48(%rsp)
xorl %esi, %esi
callq 0x36be0
movsd 0x48(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43e65
movq 0x68(%rsp), %rdi
callq 0x37870
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
callq 0x37880
movsd 0x40(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43eb6
movq 0x70(%rsp), %rdi
callq 0x37880
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x38(%rsp)
movl $0x1, %esi
callq 0x36be0
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43f0a
movq 0x68(%rsp), %rdi
callq 0x37870
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
callq 0x44fa0
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43f08
movq 0x70(%rsp), %rdi
callq 0x44fa0
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x28(%rsp)
movl $0x1, %esi
callq 0x36be0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43f0a
movq 0x68(%rsp), %rdi
callq 0x378c0
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x378d0
movsd 0x20(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43f5b
movq 0x70(%rsp), %rdi
callq 0x378d0
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
movl $0x2, %esi
callq 0x36be0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43faf
movq 0x68(%rsp), %rdi
callq 0x378c0
movq 0x70(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x44fc0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43fad
movq 0x70(%rsp), %rdi
callq 0x44fc0
movq 0x68(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl $0x2, %esi
callq 0x36be0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x43faf
movq 0x60(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::FurthestPoint(gaps::R3Point const&) const
const R3Point R3Box::
FurthestPoint(const R3Point& point) const
{
    // Return furthest point in box
    R3Point furthest(point);
    RNScalar x = (point.X() < XCenter()) ? XMax() : XMin();
    RNScalar y = (point.Y() < YCenter()) ? YMax() : YMin();
    RNScalar z = (point.Z() < ZCenter()) ? ZMax() : ZMin();
    return R3Point(x, y, z);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x6eb90
movq 0x80(%rsp), %rdi
callq 0x37820
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x48(%rsp)
callq 0x44fe0
movsd 0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44046
movq 0x40(%rsp), %rdi
callq 0x44f80
movsd %xmm0, 0x28(%rsp)
jmp 0x44056
movq 0x40(%rsp), %rdi
callq 0x37830
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movq 0x80(%rsp), %rdi
callq 0x37870
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x45000
movsd 0x20(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4409d
movq 0x40(%rsp), %rdi
callq 0x44fa0
movsd %xmm0, 0x18(%rsp)
jmp 0x440ad
movq 0x40(%rsp), %rdi
callq 0x37880
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x80(%rsp), %rdi
callq 0x378c0
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x45020
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x440f4
movq 0x40(%rsp), %rdi
callq 0x44fc0
movsd %xmm0, 0x8(%rsp)
jmp 0x44104
movq 0x40(%rsp), %rdi
callq 0x378d0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
callq 0x6eb50
movq 0x38(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Area() const
const RNArea R3Box::
Area (void) const
{
    // Return surface area of bounding box
    RNLength dx = XLength();
    RNLength dy = YLength();
    RNLength dz = ZLength();
    return (2.0*dx*dy + 2.0*dx*dz + 2.0*dy*dz);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x37850
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
callq 0x378a0
movq (%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x378f0
movsd %xmm0, 0x8(%rsp)
movsd 0xef04d(%rip), %xmm1    # 0x133200
mulsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0xef039(%rip), %xmm0    # 0x133200
mulsd 0x18(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xef01d(%rip), %xmm0    # 0x133200
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Inflate(double)
void R3Box::
Inflate (RNScalar fraction) 
{
  // Scale box around centroid by fraction
  if (IsEmpty()) return;
  R3Point centroid = Centroid();
  R3Vector diagonal = Max() - centroid;
  Reset(centroid - fraction * diagonal, centroid + fraction * diagonal);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movsd %xmm0, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x44d80
cmpl $0x0, %eax
je 0x443c3
jmp 0x44468
movq (%rsp), %rsi
movq (%rsi), %rax
leaq 0x80(%rsp), %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
callq 0x45060
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x6eeb0
movsd 0x98(%rsp), %xmm0
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x13800
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x6fab0
movsd 0x98(%rsp), %xmm0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x13800
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6f110
movq (%rsp), %rdi
movq (%rdi), %rax
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq *0x250(%rax)
addq $0xa8, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Union(gaps::R3Point const&)
void R3Box::
Union (const R3Point& point) 
{
    // Expand this to include point
    if (IsEmpty()) {
        minpt = point;
        maxpt = point;
    }
    else {
        if (minpt.X() > point.X()) minpt[0] = point.X();
        if (minpt.Y() > point.Y()) minpt[1] = point.Y();
        if (minpt.Z() > point.Z()) minpt[2] = point.Z();
        if (maxpt.X() < point.X()) maxpt[0] = point.X();
        if (maxpt.Y() < point.Y()) maxpt[1] = point.Y();
        if (maxpt.Z() < point.Z()) maxpt[2] = point.Z();
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x44d80
cmpl $0x0, %eax
je 0x444fd
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x8, %rdi
callq 0x6f1e0
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x20, %rdi
callq 0x6f1e0
jmp 0x4470a
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37820
movsd %xmm0, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37820
movaps %xmm0, %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44554
movq 0x68(%rsp), %rdi
callq 0x37820
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37870
movsd %xmm0, 0x48(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37870
movaps %xmm0, %xmm1
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x445ae
movq 0x68(%rsp), %rdi
callq 0x37870
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x378c0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x378c0
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44608
movq 0x68(%rsp), %rdi
callq 0x378c0
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
addq $0x8, %rdi
movl $0x2, %esi
callq 0x36be0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37820
movsd %xmm0, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37820
movsd 0x28(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4465c
movq 0x68(%rsp), %rdi
callq 0x37820
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37870
movsd %xmm0, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37870
movsd 0x18(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x446b3
movq 0x68(%rsp), %rdi
callq 0x37870
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x378c0
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x378c0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44708
movq 0x68(%rsp), %rdi
callq 0x378c0
movq 0x60(%rsp), %rdi
movsd %xmm0, (%rsp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x36be0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x4470a
addq $0x78, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Union(gaps::R3Box const&)
void R3Box::
Union (const R3Box& box) 
{
    // Expand this to include box
    if (IsEmpty()) {
        *this = box;
    }
    else if (!box.IsEmpty()) {
        if (minpt.X() > box.XMin()) minpt[0] = box.XMin();
        if (minpt.Y() > box.YMin()) minpt[1] = box.YMin();
        if (minpt.Z() > box.ZMin()) minpt[2] = box.ZMin();
        if (maxpt.X() < box.XMax()) maxpt[0] = box.XMax();
        if (maxpt.Y() < box.YMax()) maxpt[1] = box.YMax();
        if (maxpt.Z() < box.ZMax()) maxpt[2] = box.ZMax();
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x44d80
cmpl $0x0, %eax
je 0x44746
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x37500
jmp 0x44968
movq 0x68(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
jne 0x44966
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37820
movsd %xmm0, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37830
movaps %xmm0, %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x447b0
movq 0x68(%rsp), %rdi
callq 0x37830
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37870
movsd %xmm0, 0x48(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37880
movaps %xmm0, %xmm1
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4480a
movq 0x68(%rsp), %rdi
callq 0x37880
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x378c0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x378d0
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44864
movq 0x68(%rsp), %rdi
callq 0x378d0
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
addq $0x8, %rdi
movl $0x2, %esi
callq 0x36be0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37820
movsd %xmm0, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44f80
movsd 0x28(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x448b8
movq 0x68(%rsp), %rdi
callq 0x44f80
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37870
movsd %xmm0, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44fa0
movsd 0x18(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4490f
movq 0x68(%rsp), %rdi
callq 0x44fa0
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x378c0
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44fc0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44964
movq 0x68(%rsp), %rdi
callq 0x44fc0
movq 0x60(%rsp), %rdi
movsd %xmm0, (%rsp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x36be0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x44966
jmp 0x44968
addq $0x78, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Intersect(gaps::R3Box const&)
void R3Box::
Intersect (const R3Box& box) 
{
    // Intersect with box
    if (!IsEmpty()) {
        if (box.IsEmpty()) {
            *this = box;
        }
        else {
            if (minpt.X() < box.XMin()) minpt[0] = box.XMin();
            if (minpt.Y() < box.YMin()) minpt[1] = box.YMin();
            if (minpt.Z() < box.ZMin()) minpt[2] = box.ZMin();
            if (maxpt.X() > box.XMax()) maxpt[0] = box.XMax();
            if (maxpt.Y() > box.YMax()) maxpt[1] = box.YMax();
            if (maxpt.Z() > box.ZMax()) maxpt[2] = box.ZMax();
        }
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x44d80
cmpl $0x0, %eax
jne 0x44c48
movq 0x68(%rsp), %rdi
callq 0x44d80
cmpl $0x0, %eax
je 0x44a39
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x37500
jmp 0x44c46
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37820
movsd %xmm0, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37830
movsd 0x58(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44a8d
movq 0x68(%rsp), %rdi
callq 0x37830
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x37870
movsd %xmm0, 0x48(%rsp)
movq 0x68(%rsp), %rdi
callq 0x37880
movsd 0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44ae4
movq 0x68(%rsp), %rdi
callq 0x37880
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x40(%rsp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x378c0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0x378d0
movsd 0x38(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44b3b
movq 0x68(%rsp), %rdi
callq 0x378d0
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
addq $0x8, %rdi
movl $0x2, %esi
callq 0x36be0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37820
movsd %xmm0, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44f80
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44b92
movq 0x68(%rsp), %rdi
callq 0x44f80
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x36be0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x37870
movsd %xmm0, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44fa0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44bec
movq 0x68(%rsp), %rdi
callq 0x44fa0
movq 0x60(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x36be0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x378c0
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x44fc0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44c44
movq 0x68(%rsp), %rdi
callq 0x44fc0
movq 0x60(%rsp), %rdi
movsd %xmm0, (%rsp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x36be0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x44c46
jmp 0x44c48
addq $0x78, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Box.cpp
// Function: gaps::R3Box::Transform(gaps::R3Transformation const&)
void R3Box::
Transform (const R3Transformation& transformation)
{
    // Do not transform empty box
    if (IsEmpty()) return;

    // Transform box ???
    R3Box tmp = R3null_box;
    for (RNOctant octant = 0; octant < RN_NUM_OCTANTS; octant++) {
	R3Point corner(Corner(octant));
	corner.Transform(transformation);
	tmp.Union(corner);
    }
    *this = tmp;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x44d80
cmpl $0x0, %eax
je 0x44c80
jmp 0x44d1b
leaq 0x40(%rsp), %rdi
leaq 0x133b5c(%rip), %rsi    # 0x1787e8
callq 0x428c0
movl $0x0, 0x3c(%rsp)
cmpl $0x8, 0x3c(%rsp)
jge 0x44d00
movq 0x8(%rsp), %rsi
movl 0x3c(%rsp), %edx
leaq 0x20(%rsp), %rdi
callq 0x42e40
jmp 0x44cb5
movq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6f7c0
jmp 0x44cc6
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x444b0
jmp 0x44cd7
jmp 0x44cd9
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x44c99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x36a80
jmp 0x44d23
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x37500
jmp 0x44d11
leaq 0x40(%rsp), %rdi
callq 0x36a80
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Affine.cpp
// Function: gaps::R3Affine::InverseMatrix() const
const R4Matrix& R3Affine::
InverseMatrix(void) const
{
    // Update inverse matrix 
    if (!flags[R3_AFFINE_INVERSE_UPTODATE_FLAG]) {
        // Update inverse matrix
        R3Affine *affine = (R3Affine *) this;
	affine->inverse = matrix.Inverse();
	affine->flags.Add(R3_AFFINE_INVERSE_UPTODATE_FLAG);
    }

    // Return inverse matrix
    return inverse;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x108, %rax            # imm = 0x108
movq %rax, 0x10(%rsp)
leaq 0xa8(%rsp), %rdi
movl $0x2, %esi
callq 0x13d80
movq 0x10(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x13d50
cmpl $0x0, %eax
jne 0x4d523
movq 0x8(%rsp), %rsi
movq %rsi, 0xa0(%rsp)
addq $0x8, %rsi
leaq 0x20(%rsp), %rdi
callq 0x527e0
movq 0xa0(%rsp), %rdi
addq $0x88, %rdi
leaq 0x20(%rsp), %rsi
callq 0x54260
movq 0xa0(%rsp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x13d80
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x37560
movq 0x8(%rsp), %rax
addq $0x88, %rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Affine.cpp
// Function: gaps::R3Affine::Transform(gaps::R3Affine const&)
void R3Affine::
Transform(const R3Affine& affine) 
{
    // Transform affine transformation
    matrix = matrix * affine.matrix;
    if (affine.HasMirror()) Mirror();
    InvalidateInverse();
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x8, %rsi
movq 0x88(%rsp), %rdx
addq $0x8, %rdx
leaq 0x8(%rsp), %rdi
callq 0x54ea0
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x54260
movq 0x88(%rsp), %rdi
callq 0x4e240
cmpl $0x0, %eax
je 0x4d76a
movq (%rsp), %rdi
callq 0x4e2b0
movq (%rsp), %rdi
callq 0x3a630
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Affine.cpp
// Function: gaps::R3Affine::InverseTransform(gaps::R3Affine const&)
void R3Affine::
InverseTransform(const R3Affine& affine) 
{
    // Transform affine transformation
    matrix = matrix * affine.InverseMatrix();
    if (affine.HasMirror()) Mirror();
    InvalidateInverse();
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rdi
callq 0x4d470
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x54ea0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
leaq 0x18(%rsp), %rsi
callq 0x54260
movq 0x98(%rsp), %rdi
callq 0x4e240
cmpl $0x0, %eax
je 0x4d8db
movq 0x10(%rsp), %rdi
callq 0x4e2b0
movq 0x10(%rsp), %rdi
callq 0x3a630
addq $0xa8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Affine.cpp
// Function: gaps::R3Affine::ApplyInverseTranspose(gaps::R3Vector&) const
void R3Affine::
ApplyInverseTranspose (R3Vector& vector) const
{
    // Transform (normal) vector by inverse transpose
    const R4Matrix& m = InverseMatrix();
    RNCoord x = m[0][0] * vector.X() + m[1][0] * vector.Y() + m[2][0] * vector.Z();
    RNCoord y = m[0][1] * vector.X() + m[1][1] * vector.Y() + m[2][1] * vector.Z();
    RNCoord z = m[0][2] * vector.X() + m[1][2] * vector.Y() + m[2][2] * vector.Z();
    vector = R3Vector(x, y, z);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x4d470
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x4e280
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c20
movsd %xmm0, 0x10(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x4e280
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xb8(%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)
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x4e280
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c40
movsd 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x4e280
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c20
movsd %xmm0, 0x38(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x4e280
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c30
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x40(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x4e280
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c40
movsd 0x48(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x50(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x4e280
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c20
movsd %xmm0, 0x60(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x4e280
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c30
movsd 0x58(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x68(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x4e280
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x78(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x38c40
movsd 0x70(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x78(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0xa8(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
movsd 0x98(%rsp), %xmm2
leaq 0x80(%rsp), %rdi
callq 0x6fcb0
movq 0xb8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x70970
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Affine.cpp
// Function: gaps::R3Affine::Mirror(gaps::R3Plane const&)
void R3Affine::
Mirror(const R3Plane& plane)
{
  // Compute translation
  R3Vector translation = plane.D() * plane.Normal();

  // Compute dimension to rotate to and reflect across
  RNDimension dim = plane.Normal().MinDimension();
  R3Vector target_vector = R3xyz_triad[dim];

  // Compute rotation axis
  R3Vector rotation_axis = plane.Normal() % target_vector;
  RNLength rotation_axis_length = rotation_axis.Length();
  if (RNIsZero(rotation_axis_length)) return;
  rotation_axis /= rotation_axis_length;

  // Compute rotation angle
  RNAngle rotation_angle = R3InteriorAngle(plane.Normal(), target_vector);
  
  // Transform
  Translate(-translation);
  Rotate(rotation_axis, -rotation_angle);
  Mirror(dim);
  Rotate(rotation_axis, rotation_angle);
  Translate(translation);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rdi
callq 0x4e330
movsd %xmm0, 0x8(%rsp)
movq 0x88(%rsp), %rdi
callq 0x13e60
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x13800
movq 0x88(%rsp), %rdi
callq 0x13e60
movq %rax, %rdi
callq 0x6ff10
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %esi
leaq 0x12aafe(%rip), %rdi    # 0x178b08
callq 0x39fb0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x6fcf0
movq 0x88(%rsp), %rdi
callq 0x13e60
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x70af0
leaq 0x38(%rsp), %rdi
callq 0x6fe90
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
leaq 0x12a488(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x4e06b
jmp 0x4e112
movsd 0x30(%rsp), %xmm0
leaq 0x38(%rsp), %rdi
callq 0x70ec0
movq 0x88(%rsp), %rdi
callq 0x13e60
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x8c230
movsd %xmm0, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x70fa0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x36cd0
movq (%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
leaq 0x38(%rsp), %rsi
callq 0x4e340
movq (%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x4df50
movq (%rsp), %rdi
movsd 0x28(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
callq 0x4e340
movq (%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x36cd0
addq $0x98, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Crdsys.cpp
// Function: gaps::R3CoordSystem::Matrix() const
const R4Matrix R3CoordSystem::
Matrix(void) const
{
    // Return matrix (std -> cs)
    R4Matrix m(R4identity_matrix);
    m.Translate(origin.Vector());
    m.Transform(axes.Matrix());
    return m;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x12a6f8(%rip), %rsi    # 0x178c30
callq 0x51b60
movq 0x8(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x36d10
movq 0x10(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x534b0
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x20(%rsp), %rdi
callq 0x4ee60
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4eac0
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Crdsys.cpp
// Function: gaps::R3CoordSystemSlerp(gaps::R3CoordSystem const&, gaps::R3CoordSystem const&, double)
R3CoordSystem
R3CoordSystemSlerp(const R3CoordSystem& cs0, const R3CoordSystem& cs1, RNScalar t)
{                            
  // Compute interpolated origin
  const R3Point& origin0 = cs0.Origin();
  const R3Point& origin1 = cs1.Origin();
  R3Point origin = (1-t)*origin0 + t*origin1;

  // Slerp orientation
  R3Quaternion q0(cs0.Matrix(), 0);
  R3Quaternion q1(cs1.Matrix(), 0);
  R3Quaternion q = R3QuaternionSlerp(q0, q1, t);

  // Compute interpolated axes
  R3Vector ax = q * R3posx_vector;
  R3Vector ay = q * R3posy_vector;
  ay.Normalize();
  R3Vector az = ax % ay;
  az.Normalize();
  ax = ay % az;
  ax.Normalize();
  R3Triad triad(ax, ay, az);

  // Return interpolated coordinate system
  return R3CoordSystem(origin, triad);
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movsd %xmm0, 0x278(%rsp)
movq 0x288(%rsp), %rdi
callq 0x3c2b0
movq %rax, 0x270(%rsp)
movq 0x280(%rsp), %rdi
callq 0x3c2b0
movq %rax, 0x268(%rsp)
movsd 0xe4701(%rip), %xmm0    # 0x133008
subsd 0x278(%rsp), %xmm0
movq 0x270(%rsp), %rsi
leaq 0x238(%rsp), %rdi
callq 0x36b10
movsd 0x278(%rsp), %xmm0
movq 0x268(%rsp), %rsi
leaq 0x220(%rsp), %rdi
callq 0x36b10
leaq 0x250(%rsp), %rdi
leaq 0x238(%rsp), %rsi
leaq 0x220(%rsp), %rdx
callq 0x6fa40
movq 0x288(%rsp), %rsi
leaq 0x180(%rsp), %rdi
callq 0x4e500
leaq 0x200(%rsp), %rdi
leaq 0x180(%rsp), %rsi
xorl %edx, %edx
callq 0x4ffb0
movq 0x280(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x4e500
leaq 0x160(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
xorl %edx, %edx
callq 0x4ffb0
movsd 0x278(%rsp), %xmm0
leaq 0xc0(%rsp), %rdi
leaq 0x200(%rsp), %rsi
leaq 0x160(%rsp), %rdx
callq 0x4f8a0
leaq 0xa8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x52abdb(%rip), %rdx    # 0x5795d0
callq 0x51780
leaq 0x90(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x52abd7(%rip), %rdx    # 0x5795e8
callq 0x51780
leaq 0x90(%rsp), %rdi
callq 0x70410
leaq 0x78(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x70af0
leaq 0x78(%rsp), %rdi
callq 0x70410
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x70af0
leaq 0xa8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x70970
leaq 0xa8(%rsp), %rdi
callq 0x70410
leaq 0x18(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x78(%rsp), %rcx
callq 0x4ec80
movq 0x8(%rsp), %rdi
leaq 0x250(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x4e4c0
movq 0x10(%rsp), %rax
addq $0x298, %rsp            # imm = 0x298
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Triad.h
// Function: gaps::R3Triad::operator=(gaps::R3Triad const&)
inline R3Triad& R3Triad::
operator=(const R3Triad& triad)
{
    axis[0] = triad.axis[0];
    axis[1] = triad.axis[1];
    axis[2] = triad.axis[2];
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x70970
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x70970
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x70970
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::R3Triad(gaps::R3Vector const&, gaps::R3Vector const&)
R3Triad::
R3Triad(const R3Vector& towards, const R3Vector& up)
{
    axis[2] = -towards;
    axis[2].Normalize();
    axis[0] = up % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, %rcx
addq $0x48, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6fca0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x4ed97
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x70fa0
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
leaq 0x58(%rsp), %rsi
callq 0x70970
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x70410
movq 0x10(%rsp), %rdx
movq 0x70(%rsp), %rsi
addq $0x30, %rdx
leaq 0x40(%rsp), %rdi
callq 0x70af0
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x70970
movq 0x10(%rsp), %rdi
callq 0x70410
movq 0x10(%rsp), %rdx
movq %rdx, %rsi
addq $0x30, %rsi
leaq 0x28(%rsp), %rdi
callq 0x70af0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
leaq 0x28(%rsp), %rsi
callq 0x70970
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x70410
addq $0x88, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Matrix() const
const R4Matrix R3Triad::
Matrix(void) const
{
    // Return change of basis matrix (std -> triad)
    return R4Matrix(axis[0].X(), axis[1].X(), axis[2].X(), 0.0,
		    axis[0].Y(), axis[1].Y(), axis[2].Y(), 0.0,
		    axis[0].Z(), axis[1].Z(), axis[2].Z(), 0.0,
		    0.0,         0.0,         0.0,         1.0);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x38c20
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x88(%rsp)
addq $0x18, %rdi
callq 0x38c20
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x50(%rsp)
addq $0x30, %rdi
callq 0x38c20
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x58(%rsp)
callq 0x38c30
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x60(%rsp)
addq $0x18, %rdi
callq 0x38c30
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x68(%rsp)
addq $0x30, %rdi
callq 0x38c30
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x70(%rsp)
callq 0x38c40
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x78(%rsp)
addq $0x18, %rdi
callq 0x38c40
movq 0x40(%rsp), %rdi
movsd %xmm0, 0x80(%rsp)
addq $0x30, %rdi
callq 0x38c40
movq 0x48(%rsp), %rdi
movsd 0x50(%rsp), %xmm1
movsd 0x58(%rsp), %xmm2
movsd 0x60(%rsp), %xmm4
movsd 0x68(%rsp), %xmm5
movsd 0x70(%rsp), %xmm6
movsd 0x78(%rsp), %xmm12
movsd 0x80(%rsp), %xmm11
movaps %xmm0, %xmm10
movsd 0x88(%rsp), %xmm0
xorps %xmm9, %xmm9
movsd 0xe4083(%rip), %xmm8    # 0x133008
movaps %xmm9, %xmm3
movaps %xmm9, %xmm7
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm9, 0x20(%rsp)
movsd %xmm9, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x90(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Rotate(int, double)
void R3Triad:: 
Rotate(RNAxis axis, RNAngle radians)
{
    // Rotate triad around an axis counterclockwise
    switch (axis) {
    case RN_XAXIS: 
	Rotate(R3posx_vector, radians); 
	break;

    case RN_YAXIS: 
	Rotate(R3posy_vector, radians); 
	break;

    case RN_ZAXIS: 
	Rotate(R3posz_vector, radians); 
	break;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x4f1e0
jmp 0x4f1ca
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x4f1f8
jmp 0x4f1d5
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x4f210
jmp 0x4f228
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x52a3df(%rip), %rsi    # 0x5795d0
callq 0x4f240
jmp 0x4f236
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x52a3df(%rip), %rsi    # 0x5795e8
callq 0x4f240
jmp 0x4f236
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
leaq 0x52a3df(%rip), %rsi    # 0x579600
callq 0x4f240
jmp 0x4f236
leaq 0xe4b84(%rip), %rdi     # 0x133db3
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Rotate(gaps::R3Vector const&, double)
void R3Triad::
Rotate(const R3Vector& rotaxis, RNAngle radians)
{
    // Rotate each axis
    axis[0].Rotate(rotaxis, radians);
    axis[1].Rotate(rotaxis, radians);
    axis[2].Rotate(rotaxis, radians);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
callq 0x709b0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
callq 0x709b0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x48(%rsp), %rsi
movsd 0x40(%rsp), %xmm0
callq 0x709b0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x70410
movq 0x8(%rsp), %rdx
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x30, %rdx
leaq 0x28(%rsp), %rdi
callq 0x70af0
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x70970
movq 0x8(%rsp), %rdi
callq 0x70410
movq 0x8(%rsp), %rdx
movq %rdx, %rsi
addq $0x30, %rsi
leaq 0x10(%rsp), %rdi
callq 0x70af0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x10(%rsp), %rsi
callq 0x70970
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x70410
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Rotate(gaps::R3Vector const&, gaps::R3Vector const&)
void R3Triad::
Rotate(const R3Vector& from, const R3Vector& to)
{
    // Rotate each axis
    RNAngle angle = R3InteriorAngle(from, to);
    R3Vector rotaxis = from % to;
    rotaxis.Normalize();
    Rotate(rotaxis, angle);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x8c230
movsd %xmm0, 0x58(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x70af0
leaq 0x40(%rsp), %rdi
callq 0x70410
movq 0x8(%rsp), %rdi
movsd 0x58(%rsp), %xmm0
leaq 0x40(%rsp), %rsi
callq 0x4f240
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x70410
movq 0x8(%rsp), %rdx
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x30, %rdx
leaq 0x28(%rsp), %rdi
callq 0x70af0
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x70970
movq 0x8(%rsp), %rdi
callq 0x70410
movq 0x8(%rsp), %rdx
movq %rdx, %rsi
addq $0x30, %rsi
leaq 0x10(%rsp), %rdi
callq 0x70af0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x10(%rsp), %rsi
callq 0x70970
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x70410
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triad.cpp
// Function: gaps::R3Triad::Mirror(gaps::R3Plane const&)
void R3Triad::
Mirror(const R3Plane& plane)
{
    // Mirror each axis 
    axis[0].Mirror(plane);
    axis[1].Mirror(plane);
    axis[2].Mirror(plane);
    axis[2].Normalize();
    axis[0] = axis[1] % axis[2];
    axis[0].Normalize();
    axis[1] = axis[2] % axis[0];
    axis[1].Normalize();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rsi
callq 0x70da0
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x38(%rsp), %rsi
callq 0x70da0
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x38(%rsp), %rsi
callq 0x70da0
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x70410
movq (%rsp), %rdx
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x30, %rdx
leaq 0x20(%rsp), %rdi
callq 0x70af0
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x70970
movq (%rsp), %rdi
callq 0x70410
movq (%rsp), %rdx
movq %rdx, %rsi
addq $0x30, %rsi
leaq 0x8(%rsp), %rdi
callq 0x70af0
movq (%rsp), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x70970
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x70410
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(double, double, double, double)
R3Quaternion::
R3Quaternion(RNScalar a, RNScalar b, RNScalar c, RNScalar d)
{
    v[0] = a; 
    v[1] = b; 
    v[2] = c;
    v[3] = d;
    Normalize();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, (%rsp)
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
callq 0x4f6e0
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Normalize()
void R3Quaternion::
Normalize(void)
{
  // Normalize -- internal function because all R3Quaternions are normalized
  RNScalar sum = 0;
  sum += v[0]*v[0];
  sum += v[1]*v[1];
  sum += v[2]*v[2];
  sum += v[3]*v[3];
  RNScalar length = sqrt(sum);
  if (RNIsZero(length)) return;
  v[0] /= length;
  v[1] /= length;
  v[2] /= length;
  v[3] /= length;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%rax), %xmm0
movsd (%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rax), %xmm0
movsd 0x8(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rax), %xmm0
movsd 0x10(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rax), %xmm0
movsd 0x18(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0xf390
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
leaq 0x128d50(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x4f7a0
jmp 0x4f7f3
movq 0x8(%rsp), %rax
movsd 0x10(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm1
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(gaps::R3Quaternion const&)
R3Quaternion::
R3Quaternion(const R3Quaternion& quaternion)
{
    v[0] = quaternion.v[0]; 
    v[1] = quaternion.v[1]; 
    v[2] = quaternion.v[2]; 
    v[3] = quaternion.v[3]; 
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(gaps::R3Vector const&, double)
R3Quaternion::
R3Quaternion(const R3Vector& axis, RNAngle theta)
{
    RNAngle half_theta = 0.5 * theta;
    RNScalar sine_half_theta = sin(half_theta);
    R3Vector normalized_axis = axis;
    normalized_axis.Normalize();
    v[0] = cos(half_theta);
    v[1] = normalized_axis[0] * sine_half_theta; 
    v[2] = normalized_axis[1] * sine_half_theta; 
    v[3] = normalized_axis[2] * sine_half_theta; 
    Normalize();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movsd 0xe321b(%rip), %xmm0    # 0x133010
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6fcf0
leaq 0x8(%rsp), %rdi
callq 0x70410
movsd 0x28(%rsp), %xmm0
callq 0xf930
movq (%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x36c00
movq %rax, %rcx
movq (%rsp), %rax
movsd (%rcx), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x36c00
movq %rax, %rcx
movq (%rsp), %rax
movsd (%rcx), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x36c00
movq (%rsp), %rdi
movsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
callq 0x4f6e0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)