LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::FurthestPoint(gaps::R3Point const&) const
const R3Point R3Rectangle::
FurthestPoint(const R3Point& point) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3zero_point;

    // Start with original point
    R3Point closest_point = point;

    // Project onto plane
    closest_point.Project(Plane());

    // Iteratively project onto each edge, if inside
    for (int sign = -1; sign <= 1; sign += 2) {
      for (int dim = 0; dim <= 1; dim++) {
        R3Plane plane(Center() + sign * Radius(dim) * Axis(dim), sign * Axis(dim));
        RNScalar d = R3SignedDistance(plane, closest_point);
        if (d < 0) closest_point -= d * plane.Normal();
      }
    }

    // Return closest point
    return closest_point;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x78ac0
cmpl $0x0, %eax
je 0x945c9
movq 0x28(%rsp), %rdi
leaq 0x4e4ef1(%rip), %rsi    # 0x5794b0
callq 0x6eb90
jmp 0x94789
movq 0x28(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0x6eb90
movq 0x38(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x81db0
movq 0x28(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x6f220
movl $0xffffffff, 0xcc(%rsp) # imm = 0xFFFFFFFF
cmpl $0x1, 0xcc(%rsp)
jg 0x94787
movl $0x0, 0xc8(%rsp)
cmpl $0x1, 0xc8(%rsp)
jg 0x9476f
movq 0x38(%rsp), %rdi
callq 0x78df0
movq 0x38(%rsp), %rdi
movq %rax, 0x18(%rsp)
cvtsi2sdl 0xcc(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0xc8(%rsp), %esi
callq 0x78dd0
movq 0x38(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc8(%rsp), %esi
callq 0x78e10
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x13800
movq 0x18(%rsp), %rsi
leaq 0x90(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x6f110
movq 0x38(%rsp), %rdi
cvtsi2sdl 0xcc(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0xc8(%rsp), %esi
callq 0x78e10
movsd 0x20(%rsp), %xmm0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x13800
leaq 0xa8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x6c260
movq 0x28(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x86f90
movsd %xmm0, 0x58(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x58(%rsp), %xmm0
jbe 0x94757
movsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x13e60
movsd (%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x13800
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6f890
jmp 0x94759
movl 0xc8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc8(%rsp)
jmp 0x94623
jmp 0x94771
movl 0xcc(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xcc(%rsp)
jmp 0x9460a
jmp 0x94789
movq 0x30(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::operator==(gaps::R3Rectangle const&) const
RNBoolean R3Rectangle::
operator==(const R3Rectangle& rectangle) const
{
    // Return whether rectangle is equal
    return ((Center() == Center()) &&
            (Axis(0) == rectangle.Axis(0)) && 
	    (Axis(1) == rectangle.Axis(1)) && 
	    (Radius(0) == rectangle.Radius(0)) && 
	    (Radius(1) == rectangle.Radius(1)));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x78df0
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x78df0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x6ece0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x37(%rsp)
je 0x949c2
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x78e10
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x78e10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x70310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x37(%rsp)
je 0x949c2
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x78e10
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x78e10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x70310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x37(%rsp)
je 0x949c2
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, 0x37(%rsp)
jne 0x949c2
jp 0x949c2
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x48, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::BBox() const
const R3Box R3Rectangle::
BBox(void) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3null_box;

    // Return bounding box 
    R3Box bbox = R3null_box;
    for (int i = 0; i < RN_NUM_QUADRANTS; 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 0x78ac0
cmpl $0x0, %eax
je 0x94b63
movq (%rsp), %rdi
leaq 0xe3c8f(%rip), %rsi     # 0x1787e8
callq 0x428c0
jmp 0x94beb
movq (%rsp), %rdi
movb $0x0, 0x47(%rsp)
leaq 0xe3c75(%rip), %rsi     # 0x1787e8
callq 0x428c0
movl $0x0, 0x40(%rsp)
cmpl $0x4, 0x40(%rsp)
jge 0x94bd4
movq 0x10(%rsp), %rsi
movl 0x40(%rsp), %edx
leaq 0x28(%rsp), %rdi
callq 0x78af0
jmp 0x94b9c
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x444b0
jmp 0x94bac
jmp 0x94bae
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x94b80
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x36a80
jmp 0x94bf5
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x94be9
movq (%rsp), %rdi
callq 0x36a80
jmp 0x94beb
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf890
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Rectangle.cpp
// Function: gaps::R3Rectangle::Transform(gaps::R3Transformation const&)
void R3Rectangle::
Transform (const R3Transformation& transformation)
{
    // Check if rectangle is empty
    if (IsEmpty()) return;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x78ac0
cmpl $0x0, %eax
je 0x94de3
jmp 0x94e2d
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)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Rectangle.h
// Function: gaps::R3Rectangle::MaxRadius() const
inline const RNLength R3Rectangle::
MaxRadius(void) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return -1.0;

    // Return smallest radius
    return (Radius(0) > Radius(1)) ? Radius(0) : Radius(1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x78ac0
cmpl $0x0, %eax
je 0x951ad
movsd 0x9de73(%rip), %xmm0    # 0x133018
movsd %xmm0, 0x20(%rsp)
jmp 0x9520f
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movl $0x1, %esi
callq 0x78dd0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x951f0
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movsd %xmm0, (%rsp)
jmp 0x95204
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ellipse.cpp
// Function: gaps::R3Ellipse::IsLinear() const
const RNBoolean R3Ellipse::
IsLinear(void) const
{
    // A ellipse 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++;
    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 0x78aa0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x95779
jp 0x95779
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0x78ab0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9579c
jp 0x9579c
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
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Circle.cpp
// Function: gaps::R3InitCircle()
int 
R3InitCircle()
{
    // Initialize circle angles and points 
    for (int i = 0; i < R3circle_npoints; i++) {
        R3circle_angles[i] = ((RNScalar) i * RN_TWO_PI) / (RNScalar) R3circle_npoints;
        R3circle_points[i] = R3Point(cos(R3circle_angles[i]), sin(R3circle_angles[i]), 0.0);
        R3circle_texcoords[i] = R2Point(0.5 * (R3circle_points[i].X() + 1.0), 0.5 * (R3circle_points[i].Y() + 1.0));
    }

    /* Return success */
    return TRUE;
}

// Assembly:
subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
cmpl $0x20, 0x44(%rsp)
jge 0x95e13
cvtsi2sdl 0x44(%rsp), %xmm0
leaq 0xa0c14(%rip), %rax     # 0x1368f8
mulsd (%rax), %xmm0
movsd 0x9d528(%rip), %xmm1    # 0x133218
divsd %xmm1, %xmm0
movslq 0x44(%rsp), %rcx
leaq 0x4e3d80(%rip), %rax    # 0x579a80
movsd %xmm0, (%rax,%rcx,8)
movslq 0x44(%rsp), %rcx
leaq 0x4e3d6f(%rip), %rax    # 0x579a80
movsd (%rax,%rcx,8), %xmm0
callq 0xf930
movsd %xmm0, 0x8(%rsp)
movslq 0x44(%rsp), %rcx
leaq 0x4e3d53(%rip), %rax    # 0x579a80
movsd (%rax,%rcx,8), %xmm0
callq 0xf100
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
xorps %xmm2, %xmm2
callq 0x6eb50
movslq 0x44(%rsp), %rax
leaq 0x4e3e27(%rip), %rdi    # 0x579b80
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x6f1e0
movslq 0x44(%rsp), %rax
leaq 0x4e3e0a(%rip), %rdi    # 0x579b80
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x37820
movaps %xmm0, %xmm1
movsd 0x9d27b(%rip), %xmm0    # 0x133008
addsd %xmm0, %xmm1
movsd 0x9d277(%rip), %xmm0    # 0x133010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x44(%rsp), %rax
leaq 0x4e3dd1(%rip), %rdi    # 0x579b80
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x37870
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x9d23c(%rip), %xmm1    # 0x133008
addsd %xmm1, %xmm2
movsd 0x9d238(%rip), %xmm1    # 0x133010
mulsd %xmm2, %xmm1
leaq 0x18(%rsp), %rdi
callq 0xc3140
movslq 0x44(%rsp), %rax
leaq 0x4e408e(%rip), %rdi    # 0x579e80
shlq $0x4, %rax
addq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0xc33e0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x95ccc
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Circle.cpp
// Function: gaps::R3Circle::Transform(gaps::R3Transformation const&)
void R3Circle::
Transform (const R3Transformation& transformation)
{
    // Transform circle ???
    center.Transform(transformation);
    plane.Transform(transformation);
    if (!transformation.IsIsotropic()) RNWarning("Circle transformed by anisotropic transformation");
    radius *= transformation.ScaleFactor();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
callq 0x6f7c0
movq (%rsp), %rdi
addq $0x28, %rdi
movq 0x8(%rsp), %rsi
callq 0x6d210
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $0x0, %eax
jne 0x96415
leaq 0x9f698(%rip), %rdi     # 0x135aa6
movb $0x0, %al
callq 0xd5010
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq (%rsp), %rax
mulsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::~R3TriangleArray()
R3TriangleArray::
~R3TriangleArray(void)
{
    // Delete triangles and vertices
    for (int i = 0; i < triangles.NEntries(); i++) delete triangles[i];
    for (int i = 0; i < vertices.NEntries(); i++) delete vertices[i];

    // Delete vbo
    if (vbo_id > 0) glDeleteBuffers(1, &vbo_id);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xd659e(%rip), %rcx     # 0x16d208
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x3c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x28(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, 0x2c(%rsp)
jmp 0x96c95
movl 0x28(%rsp), %eax
movl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x96ce7
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movl 0x3c(%rsp), %esi
callq 0x9a3d0
movq %rax, 0x20(%rsp)
jmp 0x96cba
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x96cd8
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x96cda
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x96c79
movl $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %eax
movl %eax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, 0x14(%rsp)
jmp 0x96d0b
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x96d5f
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movl 0x38(%rsp), %esi
callq 0x9a3f0
movq %rax, 0x8(%rsp)
jmp 0x96d30
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x96d50
movq (%rsp), %rdi
movl $0x68, %esi
callq 0xf4d0
jmp 0x96d52
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x96cef
movq 0x30(%rsp), %rax
cmpl $0x0, 0x68(%rax)
jbe 0x96d88
movq 0x30(%rsp), %rsi
movq 0xd8262(%rip), %rax     # 0x16efd8
movq (%rax), %rax
addq $0x68, %rsi
movl $0x1, %edi
callq *%rax
jmp 0x96d86
jmp 0x96d88
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x36a80
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x9a240
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x9a250
movq 0x30(%rsp), %rdi
callq 0x9cc00
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x36a90
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::IsPoint() const
const RNBoolean R3TriangleArray::
IsPoint (void) const
{
  // Check if all vertices are at same position
  if (vertices.NEntries() > 1) {
    const R3Point& p0 = vertices[0]->Position();
    for (int i = 1; i < vertices.NEntries(); i++) 
      if (!R3Contains(p0, vertices[i]->Position())) return FALSE;
  }
  return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x13600
cmpl $0x1, %eax
jle 0x96eb9
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x9a410
movq %rax, %rdi
callq 0x78950
movq %rax, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x96eb7
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movl 0x1c(%rsp), %esi
callq 0x9a410
movq %rax, %rdi
callq 0x78950
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x82180
cmpl $0x0, %eax
jne 0x96ea8
movl $0x0, 0x34(%rsp)
jmp 0x96ec1
jmp 0x96eaa
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x96e4a
jmp 0x96eb9
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::IsPlanar() const
const RNBoolean R3TriangleArray::
IsPlanar(void) const
{
  // Check if all triangles are on same plane
  if (triangles.NEntries() > 1) {
    const R3Plane& p0 = triangles[0]->Plane();
    for (int i = 1; i < triangles.NEntries(); i++) 
      if (!R3Contains(p0, triangles[i]->Plane())) return FALSE;
  }
  return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0x13600
cmpl $0x1, %eax
jle 0x96f99
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
callq 0x82060
movq %rax, %rdi
callq 0x81b30
movq %rax, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x96f97
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movl 0x1c(%rsp), %esi
callq 0x82060
movq %rax, %rdi
callq 0x81b30
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x83420
cmpl $0x0, %eax
jne 0x96f88
movl $0x0, 0x34(%rsp)
jmp 0x96fa1
jmp 0x96f8a
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x96f2a
jmp 0x96f99
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Length() const
const RNLength R3TriangleArray::
Length (void) const
{
    // Return cumulative perimeter of triangles
    RNLength length = 0.0;
    for (int i = 0; i < triangles.NEntries(); i++)
      length += triangles[i]->Length();
    return length;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x970b8
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x82060
movq %rax, %rdi
movq (%rdi), %rax
callq *0x50(%rax)
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x97064
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Area() const
const RNArea R3TriangleArray::
Area(void) const
{
    // Return cumulative area of triangles
    RNArea area = 0.0;
    for (int i = 0; i < triangles.NEntries(); i++)
      area += triangles[i]->Area();
    return area;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x97148
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x82060
movq %rax, %rdi
movq (%rdi), %rax
callq *0x58(%rax)
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x970f4
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Centroid() const
const R3Point R3TriangleArray::
Centroid(void) const
{
    // Return centroid of vertices
    R3Point centroid = R3zero_point;
    for (int i = 0; i < vertices.NEntries(); i++) 
      centroid += vertices[i]->Position();
    centroid /= (RNScalar) vertices.NEntries();
    return centroid;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x4e2324(%rip), %rsi    # 0x5794b0
callq 0x6eb90
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x971ed
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movl 0x24(%rsp), %esi
callq 0x9a410
movq %rax, %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6f820
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x97199
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x13600
movq 0x8(%rsp), %rdi
cvtsi2sd %eax, %xmm0
callq 0x6f960
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::ClosestPoint(gaps::R3Point const&) const
const R3Point R3TriangleArray::
ClosestPoint(const R3Point& point) const
{
    // Find closest point
    R3Point closest_point = R3zero_point;
    RNLength closest_dd = RN_INFINITY * RN_INFINITY;
    for (int i = 0; i < triangles.NEntries(); i++) {
      R3Triangle *triangle = triangles.Kth(i);
      R3Point p = triangle->ClosestPoint(point);
      RNLength dd = R3SquaredDistance(p, point);
      if (dd < closest_dd) {
        closest_point = p;
        closest_dd = dd;
      }
    }
        
    // Return closest point
    return closest_point;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4e225f(%rip), %rsi    # 0x5794b0
callq 0x6eb90
leaq 0xe1293(%rip), %rax     # 0x1784f0
movsd (%rax), %xmm0
leaq 0xe1288(%rip), %rax     # 0x1784f0
mulsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x9731e
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x54(%rsp), %esi
callq 0x9a310
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rsi), %rax
leaq 0x30(%rsp), %rdi
callq *0x70(%rax)
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x86c10
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9730c
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6f1e0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
jmp 0x9730e
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x9727a
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::FurthestPoint(gaps::R3Point const&) const
const R3Point R3TriangleArray::
FurthestPoint(const R3Point& point) const
{
    // Find furthest point
    R3Point furthest_point = R3zero_point;
    RNLength furthest_dd = 0;
    for (int i = 0; i < vertices.NEntries(); i++) {
      R3TriangleVertex *vertex = vertices.Kth(i);
      R3Point p = vertex->Position();
      RNLength dd = R3SquaredDistance(p, point);
      if (dd > furthest_dd) {
        furthest_point = p;
        furthest_dd = dd;
      }
    }

    // Return furthest point
    return furthest_point;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4e214f(%rip), %rsi    # 0x5794b0
callq 0x6eb90
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x97415
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movl 0x54(%rsp), %esi
callq 0x9a260
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x6eb90
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x86c10
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
ucomisd 0x58(%rsp), %xmm0
jbe 0x97403
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6f1e0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
jmp 0x97405
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x97377
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Flip()
void R3TriangleArray::
Flip (void)
{
    // Flip the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Flip();

    // Update
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x97896
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %esi
callq 0x9a3d0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x220(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9784b
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x248(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Mirror(gaps::R3Plane const&)
void R3TriangleArray::
Mirror (const R3Plane& plane)
{
    // Mirror vertices
    for (int i = 0; i < vertices.NEntries(); i++) 
      vertices[i]->Mirror(plane);

    // Update the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Update();

    // Update the bounding box
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x9791c
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x14(%rsp), %esi
callq 0x9a3f0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ade0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x978d0
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x9796d
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x10(%rsp), %esi
callq 0x9a3d0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x97924
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x248(%rax)
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Transform(gaps::R3Transformation const&)
void R3TriangleArray::
Transform (const R3Transformation& transformation) 
{
    // Transform vertices
    for (int i = 0; i < vertices.NEntries(); i++) 
      vertices[i]->Transform(transformation);

    // Update the triangles
    for (int i = 0; i < triangles.NEntries(); i++)
      triangles[i]->Update();

    // Check if need to flip triangles
    if (transformation.IsMirrored()) Flip();

    // Update the bounding box
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
callq 0x13600
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x979ec
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x14(%rsp), %esi
callq 0x9a3f0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ae20
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x979a0
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x97a3d
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl 0x10(%rsp), %esi
callq 0x9a3d0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x979f4
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x97a5b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x218(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x248(%rax)
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::MoveVertex(gaps::R3TriangleVertex*, gaps::R3Point const&)
void R3TriangleArray::
MoveVertex(R3TriangleVertex *vertex, const R3Point& position)
{
    // Move vertex
    vertex->SetPosition(position);

    // Update triangles
    for (int i = 0; i < triangles.NEntries(); i++) {
      R3Triangle *triangle = triangles.Kth(i);
      for (int j = 0; j < 3; j++) {
        if (triangle->Vertex(i) == vertex) {
          triangle->Update();
          break;
        }
      }
    }

    // Update
    Update();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9a510
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x13600
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x98f10
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x2c(%rsp), %esi
callq 0x9a310
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x3, 0x1c(%rsp)
jge 0x98efe
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x81eb0
cmpq 0x38(%rsp), %rax
jne 0x98eef
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
jmp 0x98efe
jmp 0x98ef1
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x98ec3
jmp 0x98f00
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x98e84
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x248(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3TriangleArray.cpp
// Function: gaps::R3TriangleArray::Draw(gaps::RNFlags) const
void R3TriangleArray::
Draw(const R3DrawFlags draw_flags) const
{
#if (RN_3D_GRFX == RN_OPENGL)
  // Draw surfaces
  if (draw_flags[R3_SURFACES_DRAW_FLAG]) {
    DrawVBO(draw_flags);
  }

  // Draw edges
  if (draw_flags[R3_EDGES_DRAW_FLAG]) {
#if 1
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    DrawVBO(draw_flags);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
#else
    RNGrfxBegin(RN_GRFX_LINES);
    for (int i = 0; i < NTriangles(); i++) {
      R3Triangle *triangle = Triangle(i);
      for (int j = 0; j < 3; j++) {
        R3TriangleVertex *v0 = triangle->Vertex(j);
        R3TriangleVertex *v1 = triangle->Vertex((j+1)%3);
        R3LoadPoint(v0->Position());
        R3LoadPoint(v1->Position());
      }
    }
    RNGrfxEnd();
#endif
  }
#else
    // Draw all triangles
    for (int i = 0; i < triangles.NEntries(); i++)
        triangles.Kth(i)->Draw(draw_flags);
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x13d80
movq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
je 0x998d6
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x260(%rax)
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x13d80
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
je 0x99933
movl $0x408, %edi            # imm = 0x408
movl $0x1b01, %esi           # imm = 0x1B01
callq 0xf3c0
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x260(%rax)
movl $0x408, %edi            # imm = 0x408
movl $0x1b02, %esi           # imm = 0x1B02
callq 0xf3c0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::~R3Triangle()
R3Triangle::
~R3Triangle(void)
{
  // Delete vertices
  if (v[0] && !v[0]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[0];
  if (v[1] && !v[1]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[1];
  if (v[2] && !v[2]->Flags()[R3_VERTEX_SHARED_FLAG]) delete v[2];
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rcx
movq %rcx, 0x60(%rsp)
leaq 0xd1f85(%rip), %rax     # 0x16d498
addq $0x10, %rax
movq %rax, (%rcx)
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, 0x6f(%rsp)
je 0x9b588
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x9a5a0
movq %rax, 0x58(%rsp)
jmp 0x9b53c
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x90(%rsp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x13d80
jmp 0x9b55d
movq 0x90(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x13d50
movl %eax, 0x54(%rsp)
jmp 0x9b578
movl 0x54(%rsp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0x6f(%rsp)
movb 0x6f(%rsp), %al
testb $0x1, %al
jne 0x9b592
jmp 0x9b5b7
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0x9b5b5
movq 0x48(%rsp), %rdi
movl $0x68, %esi
callq 0xf4d0
jmp 0x9b5b7
movq 0x60(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, 0x47(%rsp)
je 0x9b62a
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x9a5a0
movq %rax, 0x38(%rsp)
jmp 0x9b5de
movq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x80(%rsp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x13d80
jmp 0x9b5ff
movq 0x80(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x13d50
movl %eax, 0x34(%rsp)
jmp 0x9b61a
movl 0x34(%rsp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x9b634
jmp 0x9b659
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x9b657
movq 0x28(%rsp), %rdi
movl $0x68, %esi
callq 0xf4d0
jmp 0x9b659
movq 0x60(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, 0x27(%rsp)
je 0x9b6c0
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9a5a0
movq %rax, 0x18(%rsp)
jmp 0x9b680
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x13d80
jmp 0x9b69b
movq 0x70(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x13d50
movl %eax, 0x14(%rsp)
jmp 0x9b6b0
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x9b6ca
jmp 0x9b6ef
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9b6ed
movq 0x8(%rsp), %rdi
movl $0x68, %esi
callq 0xf4d0
jmp 0x9b6ef
movq 0x60(%rsp), %rdi
addq $0x40, %rdi
callq 0x36a80
movq 0x60(%rsp), %rdi
callq 0x9cc00
addq $0xa8, %rsp
retq
movq %rax, %rdi
callq 0x36a90
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::IsFinite() const
const RNBoolean R3Triangle::
IsFinite (void) const
{
    // Check each point
    if (!(v[0]->Position().IsFinite())) return FALSE;
    if (!(v[1]->Position().IsFinite())) return FALSE;
    if (!(v[2]->Position().IsFinite())) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rdi
callq 0x6ec10
cmpl $0x0, %eax
jne 0x9b8c2
movl $0x0, 0x14(%rsp)
jmp 0x9b912
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rdi
callq 0x6ec10
cmpl $0x0, %eax
jne 0x9b8e6
movl $0x0, 0x14(%rsp)
jmp 0x9b912
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x78950
movq %rax, %rdi
callq 0x6ec10
cmpl $0x0, %eax
jne 0x9b90a
movl $0x0, 0x14(%rsp)
jmp 0x9b912
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Length() const
const RNLength R3Triangle::
Length (void) const
{
    // Return perimeter of closed triangle
    RNLength length = 0.0;
    length += R3Distance(v[0]->Position(), v[1]->Position());
    length += R3Distance(v[1]->Position(), v[2]->Position());
    length += R3Distance(v[2]->Position(), v[0]->Position());
    return length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x86c40
movq 0x18(%rsp), %rax
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rdi
callq 0x78950
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x86c40
movq 0x18(%rsp), %rax
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x18(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x86c40
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Area() const
const RNArea R3Triangle::
Area(void) const
{
    // Compute area using Newell's method
    R3Vector sum = R3null_vector;
    sum += v[0]->Position().Vector() % v[2]->Position().Vector();
    sum += v[1]->Position().Vector() % v[0]->Position().Vector();
    sum += v[2]->Position().Vector() % v[1]->Position().Vector();
    return 0.5 * sum.Length();
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0x4ddb45(%rip), %rsi    # 0x5795a0
callq 0x6fcf0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0xb8(%rsp), %rdi
callq 0x36d10
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x36d10
leaq 0xd0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x70af0
leaq 0xe8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x70be0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x36d10
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x36d10
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x70af0
leaq 0xe8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x70be0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x36d10
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x36d10
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x70af0
leaq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x70be0
leaq 0xe8(%rsp), %rdi
callq 0x6fe90
movaps %xmm0, %xmm1
movsd 0x9746c(%rip), %xmm0    # 0x133010
mulsd %xmm1, %xmm0
addq $0x108, %rsp            # imm = 0x108
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Centroid() const
const R3Point R3Triangle::
Centroid(void) const
{
    // Return centroid of vertex set
    R3Point centroid = R3zero_point;
    centroid += v[0]->Position();
    centroid += v[1]->Position();
    centroid += v[2]->Position();
    centroid /= 3;
    return centroid;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x4dd8d5(%rip), %rsi    # 0x5794b0
callq 0x6eb90
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6f820
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6f820
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x78950
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6f820
movq 0x8(%rsp), %rdi
movsd 0x975a5(%rip), %xmm0    # 0x1331e0
callq 0x6f960
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::RandomPoint() const
const R3Point R3Triangle::
RandomPoint(void) const
{
  // Get vertex positions
  const R3Point& p0 = v[0]->Position();
  const R3Point& p1 = v[1]->Position();
  const R3Point& p2 = v[2]->Position();
  
  // Return random point on triangle
  RNScalar r1 = sqrt(RNRandomScalar());
  RNScalar r2 = RNRandomScalar();
  R3Point p = p0 * (1.0 - r1) + p1 * r1 * (1.0 - r2) + p2 * r1 * r2;
  return p;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xd0(%rsp)
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xc8(%rsp)
movq 0x18(%rax), %rdi
callq 0x78950
movq %rax, 0xc0(%rsp)
callq 0xd4710
callq 0xf390
movsd %xmm0, 0xb8(%rsp)
callq 0xd4710
movsd %xmm0, 0xb0(%rsp)
movq 0xd0(%rsp), %rsi
movsd 0x97313(%rip), %xmm0    # 0x133008
subsd 0xb8(%rsp), %xmm0
leaq 0x80(%rsp), %rdi
callq 0x6fb80
movq 0xc8(%rsp), %rsi
movsd 0xb8(%rsp), %xmm0
leaq 0x50(%rsp), %rdi
callq 0x6fb80
movsd 0x972da(%rip), %xmm0    # 0x133008
subsd 0xb0(%rsp), %xmm0
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6fb80
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x6fa40
movq 0xc0(%rsp), %rsi
movsd 0xb8(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
callq 0x6fb80
movsd 0xb0(%rsp), %xmm0
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6fb80
movq 0x10(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x6fa40
movq 0x18(%rsp), %rax
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::FurthestPoint(gaps::R3Point const&) const
const R3Point R3Triangle::
FurthestPoint(const R3Point& point) const
{
    // Find furthest point
    RNLength furthest_dd = 0;
    R3Point furthest_point = R3zero_point;
    for (int i = 0; i < 3; i++) {
      R3TriangleVertex *vertex = v[i];
      R3Point p = vertex->Position();
      RNLength dd = R3SquaredDistance(p, point);
      if (dd > furthest_dd) {
        furthest_dd = dd;
        furthest_point = p;
      }
    }

    // Return furthest point
    return furthest_point;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x4dd417(%rip), %rsi    # 0x5794b0
callq 0x6eb90
movl $0x0, 0x44(%rsp)
cmpl $0x3, 0x44(%rsp)
jge 0x9c124
movq 0x10(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x78950
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x6eb90
movq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x86c10
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x48(%rsp), %xmm0
jbe 0x9c115
movq (%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x6f1e0
jmp 0x9c117
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x9c0a6
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Flip()
void R3Triangle::
Flip (void) 
{
    // Flip orientation of plane
    plane.Flip();

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x37b30
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Mirror(gaps::R3Plane const&)
void R3Triangle::
Mirror (const R3Plane& plane)
{
    // Mirror vertices (what if they are shared?)
    v[0]->Mirror(plane);
    v[1]->Mirror(plane);
    v[2]->Mirror(plane);

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

    // Update
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ade0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ade0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ade0
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
callq *0x250(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Transform(gaps::R3Transformation const&)
void R3Triangle::
Transform (const R3Transformation& transformation) 
{
    // Transform vertices
    v[0]->Transform(transformation);
    v[1]->Transform(transformation);
    v[2]->Transform(transformation);

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

    // Update
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ae20
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ae20
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x9ae20
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x9c85b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Reset(gaps::R3TriangleVertex*, gaps::R3TriangleVertex*, gaps::R3TriangleVertex*)
void R3Triangle::
Reset(R3TriangleVertex *v0, R3TriangleVertex *v1, R3TriangleVertex *v2)
{
    // Reset vertices
    v[0] = v0;
    v[1] = v1;
    v[2] = v2;
    
    // Update
    Update();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
callq *0x250(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Reset(gaps::R3TriangleVertex**)
void R3Triangle::
Reset(R3TriangleVertex *vertices[3])
{
    // Reset vertices
    v[0] = vertices[0];
    v[1] = vertices[1];
    v[2] = vertices[2];
    
    // Update
    Update();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
callq *0x250(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Triangle.cpp
// Function: gaps::R3Triangle::Update()
void R3Triangle::
Update(void)
{
    // Recompute plane equation
    plane = R3Plane(v[0]->Position(), v[1]->Position(), v[2]->Position()); 

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

    // Recompute flags
    UpdateFlags();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rsp)
movq 0x10(%rax), %rdi
callq 0x78950
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rdi
callq 0x78950
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x30(%rsp), %rdi
callq 0x6c5f0
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3a4d0
movq 0x28(%rsp), %rdi
addq $0x40, %rdi
leaq 0xdbe38(%rip), %rsi     # 0x1787e8
callq 0x37500
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rdi
callq 0x78950
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x444b0
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rdi
callq 0x78950
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x444b0
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, 0x20(%rsp)
movq 0x18(%rax), %rdi
callq 0x78950
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x444b0
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x248(%rax)
addq $0x58, %rsp
retq
nopl (%rax)