LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Triad::Draw() const
void R3Triad::
Draw(void) const
{
    // Draw three rays
    R3BeginLine();
    R3LoadPoint(R3zero_point);
    R3LoadPoint((R3zero_point + Axis(RN_X)));
    R3EndLine();
    R3BeginLine();
    R3LoadPoint(R3zero_point);
    R3LoadPoint((R3zero_point + Axis(RN_Y)));
    R3EndLine();
    R3BeginLine();
    R3LoadPoint(R3zero_point);
    R3LoadPoint((R3zero_point + Axis(RN_Z)));
    R3EndLine();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x38e70
leaq 0x503982(%rip), %rdi    # 0x5794b0
callq 0x38e40
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3c2c0
movq %rax, %rdx
leaq 0x38(%rsp), %rdi
leaq 0x503963(%rip), %rsi    # 0x5794b0
callq 0x6f110
leaq 0x38(%rsp), %rdi
callq 0x38e40
callq 0x38e80
callq 0x38e70
leaq 0x503943(%rip), %rdi    # 0x5794b0
callq 0x38e40
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3c2c0
movq %rax, %rdx
leaq 0x20(%rsp), %rdi
leaq 0x503921(%rip), %rsi    # 0x5794b0
callq 0x6f110
leaq 0x20(%rsp), %rdi
callq 0x38e40
callq 0x38e80
callq 0x38e70
leaq 0x503901(%rip), %rdi    # 0x5794b0
callq 0x38e40
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3c2c0
movq %rax, %rdx
leaq 0x8(%rsp), %rdi
leaq 0x5038df(%rip), %rsi    # 0x5794b0
callq 0x6f110
leaq 0x8(%rsp), %rdi
callq 0x38e40
callq 0x38e80
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3CoordSystem::Draw() const
void R3CoordSystem::
Draw(void) const
{
    // Draw three rays
    R3BeginLine();
    R3LoadPoint(Origin());
    R3LoadPoint((Origin() + Axes().Axis(RN_X)));
    R3EndLine();
    R3BeginLine();
    R3LoadPoint(Origin());
    R3LoadPoint((Origin() + Axes().Axis(RN_Y)));
    R3EndLine();
    R3BeginLine();
    R3LoadPoint(Origin());
    R3LoadPoint((Origin() + Axes().Axis(RN_Z)));
    R3EndLine();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x38e70
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq %rax, %rdi
callq 0x38e40
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x39f80
movq %rax, %rdi
xorl %esi, %esi
callq 0x3c2c0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x58(%rsp), %rdi
callq 0x6f110
leaq 0x58(%rsp), %rdi
callq 0x38e40
callq 0x38e80
callq 0x38e70
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq %rax, %rdi
callq 0x38e40
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x39f80
movq %rax, %rdi
movl $0x1, %esi
callq 0x3c2c0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x40(%rsp), %rdi
callq 0x6f110
leaq 0x40(%rsp), %rdi
callq 0x38e40
callq 0x38e80
callq 0x38e70
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq %rax, %rdi
callq 0x38e40
movq 0x18(%rsp), %rdi
callq 0x3c2b0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x39f80
movq %rax, %rdi
movl $0x2, %esi
callq 0x3c2c0
movq 0x20(%rsp), %rsi
movq %rax, %rdx
leaq 0x28(%rsp), %rdi
callq 0x6f110
leaq 0x28(%rsp), %rdi
callq 0x38e40
callq 0x38e80
addq $0x78, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Affine::Load() const
void R3Affine::
Load(void) const
{
    // Load matrix onto stack
    Matrix().Load();

    // Set mirror flag
    if (IsMirrored()) {
        R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_OPENGL)
        glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#else
	RNAbort("Not Implemented");
#endif
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e2a0
movq %rax, %rdi
callq 0x75a70
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x75d82
cmpl $0x0, 0x503929(%rip)    # 0x579680
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x503919(%rip)    # 0x579680
movl 0x503913(%rip), %ecx    # 0x579680
movl $0x901, %edi            # imm = 0x901
movl $0x900, %eax            # imm = 0x900
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xf0e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Affine::Draw() const
void R3Affine::
Draw(void) const
{
    // Multiply top of stack by matrix
    Matrix().Draw();

    // Set mirror flag - this screws up Push/Pop ???
    if (IsMirrored()) {
        R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_OPENGL)
        glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#else
	RNAbort("Not Implemented");
#endif
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e2a0
movq %rax, %rdi
callq 0x75aa0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x75df2
cmpl $0x0, 0x5038b9(%rip)    # 0x579680
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x5038a9(%rip)    # 0x579680
movl 0x5038a3(%rip), %ecx    # 0x579680
movl $0x901, %edi            # imm = 0x901
movl $0x900, %eax            # imm = 0x900
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xf0e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Affine::Push() const
void R3Affine::
Push(void) const
{
    // Push matrix onto stack
    Matrix().Push();

    // Set mirror flag
    if (IsMirrored()) {
        R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_OPENGL)
        glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#else
	RNAbort("Not Implemented");
#endif
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e2a0
movq %rax, %rdi
callq 0x75ad0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x75e62
cmpl $0x0, 0x503849(%rip)    # 0x579680
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x503839(%rip)    # 0x579680
movl 0x503833(%rip), %ecx    # 0x579680
movl $0x901, %edi            # imm = 0x901
movl $0x900, %eax            # imm = 0x900
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xf0e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Affine::Pop() const
void R3Affine::
Pop(void) const
{
    // Pop matrix off stack
    Matrix().Pop();

    // Restore mirror flag
    if (IsMirrored()) {
        R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_OPENGL)
        glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#else
	RNAbort("Not Implemented");
#endif
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e2a0
movq %rax, %rdi
callq 0x75b00
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x75ed2
cmpl $0x0, 0x5037d9(%rip)    # 0x579680
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x5037c9(%rip)    # 0x579680
movl 0x5037c3(%rip), %ecx    # 0x579680
movl $0x901, %edi            # imm = 0x901
movl $0x900, %eax            # imm = 0x900
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xf0e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Vector::Draw() const
void R3Vector::
Draw(void) const
{
    // Draw vector from (0,0,0)
    R3BeginLine();
    R3LoadPoint(R3zero_point);
    R3LoadPoint((R3zero_point + *this));
    R3EndLine();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x38e70
leaq 0x5035b2(%rip), %rdi    # 0x5794b0
callq 0x38e40
movq (%rsp), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x50359d(%rip), %rsi    # 0x5794b0
callq 0x6f110
leaq 0x8(%rsp), %rdi
callq 0x38e40
callq 0x38e80
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Point::Draw() const
void R3Point::
Draw(void) const
{
    // Draw point
    R3BeginLine();
    R3LoadPoint(v);
    R3LoadPoint(v);
    R3EndLine();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x38e70
movq 0x8(%rsp), %rdi
callq 0x3c040
movq 0x8(%rsp), %rdi
callq 0x3c040
callq 0x38e80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Line::Draw() const
void R3Line::
Draw(void) const
{
    // Draw line
    R3BeginLine();
    R3LoadPoint(Point());
    R3LoadPoint(Point() + Vector());
    R3EndLine();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x38e70
movq 0x8(%rsp), %rdi
callq 0x3c0d0
movq %rax, %rdi
callq 0x38e40
movq 0x8(%rsp), %rdi
callq 0x3c0d0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3c0f0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x6f110
leaq 0x18(%rsp), %rdi
callq 0x38e40
callq 0x38e80
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Ray::Draw() const
void R3Ray::
Draw(void) const
{
    // Draw ray
    R3BeginLine();
    R3LoadPoint(Start());
    R3LoadPoint((Start() + Vector()));
    R3EndLine();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x38e70
movq 0x8(%rsp), %rdi
callq 0x3c0c0
movq %rax, %rdi
callq 0x38e40
movq 0x8(%rsp), %rdi
callq 0x3c0c0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3c0e0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x6f110
leaq 0x18(%rsp), %rdi
callq 0x38e40
callq 0x38e80
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Span::Draw() const
void R3Span::
Draw(void) const
{
    // Draw span
    R3BeginLine();
    R3LoadPoint(Start());
    R3LoadPoint(End());
    R3EndLine();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x38e70
movq 0x8(%rsp), %rdi
callq 0x39250
movq %rax, %rdi
callq 0x38e40
movq 0x8(%rsp), %rdi
callq 0x39260
movq %rax, %rdi
callq 0x38e40
callq 0x38e80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Ellipse::Draw(gaps::RNFlags) const
void R3Ellipse::
Draw(const R3DrawFlags draw_flags) const
{
    // Push matrix
    R4Matrix matrix = R4identity_matrix;
    matrix.Transform(cs.Matrix());
    matrix.Scale(R3Vector(radii.X(), radii.Y(), 1.0));
    matrix.Push();

    // Draw unit sphere
    R3unit_circle.Draw(draw_flags);

    // Pop matrix
    matrix.Pop();
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rsi, 0x140(%rsp)
movq %rdi, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x101cad(%rip), %rsi    # 0x178c30
callq 0x51b60
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x38(%rsp), %rdi
callq 0x4e500
leaq 0xb8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4eac0
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x78aa0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
addq $0x68, %rdi
callq 0x78ab0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
movsd 0xbc023(%rip), %xmm2    # 0x133008
callq 0x6fcb0
leaq 0xb8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x536d0
leaq 0xb8(%rsp), %rdi
callq 0x75ad0
movq 0x140(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x5029ce(%rip), %rdi    # 0x5799f0
callq 0x76d20
leaq 0xb8(%rsp), %rdi
callq 0x75b00
addq $0x148, %rsp            # imm = 0x148
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Polygon::Draw(gaps::RNFlags) const
void R3Polygon::
Draw(const R3DrawFlags draw_flags) const
{
    // Draw polygon
    if (draw_flags[R3_SURFACES_DRAW_FLAG]) {
        R3BeginPolygon();
        if (draw_flags[R3_SURFACE_NORMALS_DRAW_FLAG] ||
            draw_flags[R3_VERTEX_NORMALS_DRAW_FLAG])
            R3LoadNormal(plane.Normal());
        for (int i = 0; i < npoints; i++) {
            R3LoadPoint(points[i]);
        }
        R3EndPolygon();
    }
    if (draw_flags[R3_EDGES_DRAW_FLAG]) {
        R3BeginLoop();
        for (int i = 0; i < npoints; i++) {
            R3LoadPoint(points[i]);
        }
        R3EndLoop();
    }
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x13d80
movq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
je 0x7744e
callq 0x38e90
leaq 0x28(%rsp), %rdi
movl $0x20, %esi
callq 0x13d80
movq 0x28(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
jne 0x773f9
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x13d80
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
je 0x7740e
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x13e60
movq %rax, %rdi
callq 0x38ea0
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x77449
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x1c(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x38e40
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x77416
callq 0x38ec0
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x13d80
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13d50
cmpl $0x0, %eax
je 0x774b6
callq 0x78a60
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x774b1
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x38e40
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7747e
callq 0x78a70
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Draw.cpp
// Function: gaps::R3Ellipsoid::Draw(gaps::RNFlags) const
void R3Ellipsoid::
Draw(const R3DrawFlags draw_flags) const
{
    // Push matrix
    R4Matrix matrix = R4identity_matrix;
    matrix.Transform(cs.Matrix());
    matrix.Scale(radii);
    matrix.Push();

    // Draw unit sphere
    R3unit_sphere.Draw(draw_flags);

    // Pop matrix
    matrix.Pop();
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x120(%rsp)
movq %rdi, 0x118(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x10039d(%rip), %rsi    # 0x178c30
callq 0x51b60
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x4e500
leaq 0x98(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4eac0
movq 0x8(%rsp), %rsi
addq $0x68, %rsi
leaq 0x98(%rsp), %rdi
callq 0x536d0
leaq 0x98(%rsp), %rdi
callq 0x75ad0
movq 0x120(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0xffde7(%rip), %rdi     # 0x1786e0
callq 0x785f0
leaq 0x98(%rsp), %rdi
callq 0x75b00
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Rectangle.h
// Function: gaps::R3Rectangle::Corner(int) const
inline const R3Point R3Rectangle::
Corner(RNQuadrant quadrant) const
{
    // Check if rectangle is empty
    if (IsEmpty()) return R3zero_point;

    // Return corner position
    R3Point corner = Center();
    corner += (quadrant & RN_PN_QUADRANT) ? Radius(0)*Axis(0) : -Radius(0)*Axis(0);
    corner += (quadrant & RN_NP_QUADRANT) ? Radius(1)*Axis(1) : -Radius(1)*Axis(1);
    return corner;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x78ac0
cmpl $0x0, %eax
je 0x78b3f
movq 0x28(%rsp), %rdi
leaq 0x50097b(%rip), %rsi    # 0x5794b0
callq 0x6eb90
jmp 0x78c8e
movq 0x38(%rsp), %rdi
callq 0x78df0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x6eb90
movl 0x74(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x78b95
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x78e10
movsd 0x20(%rsp), %xmm0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x13800
jmp 0x78bdd
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x78dd0
movq 0x38(%rsp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %esi, %esi
callq 0x78e10
movsd 0x18(%rsp), %xmm0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x13800
movq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6f290
movl 0x74(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x78c31
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movl $0x1, %esi
callq 0x78e10
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x13800
jmp 0x78c7f
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x78dd0
movq 0x38(%rsp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x1, %esi
callq 0x78e10
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x13800
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6f290
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Point const&, gaps::R3Ray const&, double*)
RNClassID R3Intersects(const R3Point& point, const R3Ray& ray, RNScalar *hit_t)
{
    // Check if ray contains point
    if (R3Contains(ray, point)) {
	// Point lies on ray
	if (hit_t) *hit_t = ray.T(point);
	return R3_POINT_CLASS_ID;
    }
    else {
	// Point is not on ray
	return RN_NULL_CLASS_ID;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x82b60
cmpl $0x0, %eax
je 0x78f11
cmpq $0x0, 0x8(%rsp)
je 0x78f07
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6e550
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x24(%rsp)
jmp 0x78f19
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Point const&, gaps::R3Span const&, double*)
RNClassID R3Intersects(const R3Point& point, const R3Span& span, RNScalar *hit_t)
{
    // Check if span contains point
    if (R3Contains(span, point)) {
	// Point lies on span
	if (hit_t) *hit_t = span.T(point);
	return R3_POINT_CLASS_ID;
    }
    else {
	// Point is not on span
	return RN_NULL_CLASS_ID;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x82f00
cmpl $0x0, %eax
je 0x78f81
cmpq $0x0, 0x8(%rsp)
je 0x78f77
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6d920
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x24(%rsp)
jmp 0x78f89
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Line const&, gaps::R3Span const&, gaps::R3Point*, double*)
RNClassID R3Intersects(const R3Line& line, const R3Span& span, 
    R3Point *hit_point, RNScalar *hit_t)
{
    // Intersect line with span's ray
    RNScalar s;
    switch (R3Intersects(line, span.Ray(), hit_point, &s)) {
    case RN_NULL_CLASS_ID:
	// Span and line do not intersect
	return RN_NULL_CLASS_ID;

    case R3_RAY_CLASS_ID:
	// Line contains span
	return R3_SPAN_CLASS_ID;

    case R3_POINT_CLASS_ID: 
	// Check if intersection point is on span
	if (RNIsGreater(s, span.Length())) {
	    // Span's ray intersects line beyond span endpoint
	    return RN_NULL_CLASS_ID;
	}
	else {
	    // Span and line intersect at point
	    if (hit_t) *hit_t = s;
	    return R3_POINT_CLASS_ID;
	}
	break;

    default:
	RNAbort("Illegal intersection");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x81b20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x795b0
movl %eax, %ecx
movl %ecx, 0x14(%rsp)
testl %eax, %eax
je 0x79905
jmp 0x798ef
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x7991f
jmp 0x798fa
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0x79912
jmp 0x7997c
movl $0x0, 0x44(%rsp)
jmp 0x799a0
movl $0x4, 0x44(%rsp)
jmp 0x799a0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x37a50
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xfeb9d(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x7995b
movl $0x0, 0x44(%rsp)
jmp 0x799a0
cmpq $0x0, 0x20(%rsp)
je 0x79972
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x44(%rsp)
jmp 0x799a0
leaq 0xbbff1(%rip), %rdi     # 0x135974
movb $0x0, %al
callq 0xd4e20
leaq 0xbbff8(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Line const&, gaps::R3Plane const&, gaps::R3Point*)
RNClassID R3Intersects(const R3Line& line, const R3Plane& plane, 
    R3Point *hit_point)
{
    // Compute dot product of line vector and plane normal
    RNScalar denom = plane.Normal().Dot(line.Vector());

    // Check if line and plane are parallel
    if (RNIsZero(denom)) {
	// Check if line lies in plane	
	if (R3Contains(plane, line.Point())) {
	    // Line lies in plane
	    return R3_LINE_CLASS_ID;
	}
	else {
	    // Line is parallel to plane, but not in it
	    return RN_NULL_CLASS_ID;
	}
    }
    else {
	// Line and plane are not parallel - they must intersect at a point
	if (hit_point) {
	    RNScalar t = -(R3SignedDistance(plane, line.Point())) / denom;
	    *hit_point = line.Point() + line.Vector() * t;
	}
	return R3_POINT_CLASS_ID;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x13e60
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0f0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
leaq 0xfeae1(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x79a53
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x83240
cmpl $0x0, %eax
je 0x79a43
movl $0x2, 0x84(%rsp)
jmp 0x79afd
movl $0x0, 0x84(%rsp)
jmp 0x79afd
cmpq $0x0, 0x68(%rsp)
je 0x79af2
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x86f90
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0d0
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0f0
movq %rax, %rsi
movsd 0x58(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x70b80
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x6f110
movq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6f1e0
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Line const&, gaps::R3Triangle const&, gaps::R3Point*)
RNClassID R3Intersects(const R3Line& line, const R3Triangle& triangle, 
    R3Point *hit_point)
{
    // Find intersection of line and plane
    R3Point p;
    switch (R3Intersects(line, triangle.Plane(), &p)) {
    case RN_NULL_CLASS_ID:
	// Line does not intersect triangle plane
	return RN_NULL_CLASS_ID;
	
    case R3_POINT_CLASS_ID:
	// Line intersects triangle plane in a single point
	// Check whether triangle contains intersection point
	if (!R3Contains(triangle, p)) return RN_NULL_CLASS_ID;
	if (hit_point) *hit_point = p;
	return R3_POINT_CLASS_ID;

    case R3_LINE_CLASS_ID: 
	// Line lies in triangle plane 
	// Intersect line and triangle in 2D
        // RNAbort("Case not implemented");
	return R3_SPAN_CLASS_ID;

    default:
	RNAbort("Invalid intersection result");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6eb40
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x81b30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rsi
callq 0x799b0
movl %eax, %ecx
movl %ecx, 0x1c(%rsp)
testl %eax, %eax
je 0x79b7a
jmp 0x79b64
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0x79b84
jmp 0x79b6f
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0x79bc3
jmp 0x79bcd
movl $0x0, 0x54(%rsp)
jmp 0x79bf1
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x836e0
cmpl $0x0, %eax
jne 0x79ba2
movl $0x0, 0x54(%rsp)
jmp 0x79bf1
cmpq $0x0, 0x38(%rsp)
je 0x79bb9
movq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6f1e0
movl $0x1, 0x54(%rsp)
jmp 0x79bf1
movl $0x4, 0x54(%rsp)
jmp 0x79bf1
leaq 0xbbdcb(%rip), %rdi     # 0x13599f
movb $0x0, %al
callq 0xd4e20
leaq 0xbbda7(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Line const&, gaps::R3Halfspace const&, gaps::R3Ray*)
RNClassID R3Intersects(const R3Line& line, const R3Halfspace& halfspace, 
    R3Ray *result)
{
    // Compute dot product of line vector and halfspace plane normal
    RNScalar denom = halfspace.Plane().Normal().Dot(line.Vector());

    // Check if line and halfspace plane are parallel
    if (RNIsZero(denom)) {
	// Check if line lies in halfspace
	if (R3Contains(halfspace, line.Point())) {
	    // Line lies in halfspace
	    return R3_LINE_CLASS_ID;
	}
	else {
	    // Line is parallel to halfspace plane, but not in halfspace
	    return RN_NULL_CLASS_ID;
	}
    }
    else {
	// Line and halfspace plane are not parallel - intersection must be a ray
	if (result) {
	    RNScalar t = -(R3SignedDistance(halfspace.Plane(), line.Point())) / denom;
	    R3Point point = line.Point() + line.Vector() * t;
	    R3Vector vector = (RNIsPositive(denom)) ? line.Vector() : -(line.Vector());
	    *result = R3Ray(point, vector);
	}
	return R3_RAY_CLASS_ID;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x78920
movq %rax, %rdi
callq 0x13e60
movq %rax, 0x18(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3c0f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
leaq 0xfe874(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x79cc6
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3c0d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x844d0
cmpl $0x0, %eax
je 0x79cb6
movl $0x2, 0xc4(%rsp)
jmp 0x79dfe
movl $0x0, 0xc4(%rsp)
jmp 0x79dfe
cmpq $0x0, 0xa8(%rsp)
je 0x79df3
movq 0xb0(%rsp), %rdi
callq 0x78920
movq %rax, (%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3c0d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x86f90
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0x98(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3c0d0
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3c0f0
movq %rax, %rsi
movsd 0x98(%rsp), %xmm0
leaq 0x68(%rsp), %rdi
callq 0x70b80
movq 0x8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x6f110
movsd 0xa0(%rsp), %xmm0
leaq 0xfe75c(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
cmpl $0x0, %eax
je 0x79dae
movq 0xb8(%rsp), %rdi
callq 0x3c0f0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x6fcf0
jmp 0x79dc8
movq 0xb8(%rsp), %rdi
callq 0x3c0f0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x70fa0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdx
xorl %ecx, %ecx
callq 0x6e410
movq 0xa8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3c110
movl $0x3, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Plane const&, gaps::R3Point*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Plane& plane, 
    R3Point *hit_point, RNScalar *hit_t)
{
    // Compute dot product of ray vector and plane normal
    RNScalar denom = plane.Normal().Dot(ray.Vector());

    // Check if ray and plane are parallel
    if (RNIsZero(denom)) {
	// Check if ray lies in plane	
	if (R3Contains(plane, ray.Start())) {
	    // Ray lies in plane
	    return R3_RAY_CLASS_ID;
	}
	else {
	    // Ray is parallel to plane, but not in it
	    return RN_NULL_CLASS_ID;
	}
    }
    else {
	// Ray and plane are not parallel - compute parametric value on ray
	RNScalar s = -(R3SignedDistance(plane, ray.Start())) / denom;
	if (RNIsNegative(s)) {
	    // Ray is directed away from plane
	    return RN_NULL_CLASS_ID;
	}
	else {
	    // Ray is not parallel to plane and is pointing at plane - it must intersect
	    if (hit_point) *hit_point = ray.Start() + ray.Vector() * s;
	    if (hit_t) *hit_t = s;
	    return R3_POINT_CLASS_ID;
	}
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0x13e60
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0e0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
leaq 0xfd5fc(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x7af38
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x83240
cmpl $0x0, %eax
je 0x7af28
movl $0x3, 0x84(%rsp)
jmp 0x7b01b
movl $0x0, 0x84(%rsp)
jmp 0x7b01b
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x86f90
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
leaq 0xfd557(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
cmpl $0x0, %eax
je 0x7afa4
movl $0x0, 0x84(%rsp)
jmp 0x7b01b
cmpq $0x0, 0x68(%rsp)
je 0x7aff9
movq 0x78(%rsp), %rdi
callq 0x3c0c0
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
callq 0x3c0e0
movq %rax, %rsi
movsd 0x50(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
callq 0x70b80
movq (%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x6f110
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6f1e0
cmpq $0x0, 0x60(%rsp)
je 0x7b010
movsd 0x50(%rsp), %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Halfspace const&, gaps::R3Point*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Halfspace& halfspace, 
    R3Point *hit_point, RNScalar *hit_t)
{
    // Check if halfspace contains point
    RNBoolean pinside = R3Contains(halfspace, ray.Start());

    // Check whether vectors point in same direction
    RNBoolean vinside = RNIsPositive(halfspace.Normal().Dot(ray.Vector()));

    // Classify ray with respect to halfspace
    if (pinside) {
	// Start point of ray is inside halfspace
	if (hit_point) *hit_point = ray.Start();
	if (hit_t) *hit_t = 0.0;
	if (vinside) return R3_RAY_CLASS_ID;
	else return R3_SPAN_CLASS_ID;
    }
    else {
	if (vinside) return R3Intersects(ray, halfspace.Plane(), hit_point, hit_t);
	else return RN_NULL_CLASS_ID;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3c0c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x844d0
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x81c10
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3c0e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
leaq 0xfd446(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm1
callq 0x36d50
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x7b0fc
cmpq $0x0, 0x28(%rsp)
je 0x7b0cd
movq 0x38(%rsp), %rdi
callq 0x3c0c0
movq %rax, %rsi
movq 0x28(%rsp), %rdi
callq 0x6f1e0
cmpq $0x0, 0x20(%rsp)
je 0x7b0e1
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
cmpl $0x0, 0x18(%rsp)
je 0x7b0f2
movl $0x3, 0x44(%rsp)
jmp 0x7b13a
movl $0x4, 0x44(%rsp)
jmp 0x7b13a
cmpl $0x0, 0x18(%rsp)
je 0x7b132
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x78920
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x7ae90
movl %eax, 0x44(%rsp)
jmp 0x7b13a
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Triangle const&, gaps::R3Point*, gaps::R3Vector*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Triangle& triangle, 
    R3Point *hit_point, R3Vector *hit_normal, RNScalar *hit_t)
{
    // Find intersection of ray and plane
    R3Point p1;
    RNScalar t1;
    switch (R3Intersects(ray, triangle.Plane(), &p1, &t1)) {
    case RN_NULL_CLASS_ID:
	// Ray does not intersect triangle plane
	return RN_NULL_CLASS_ID;
	
    case R3_POINT_CLASS_ID:
	// Ray intersects triangle plane in a single point
	// Check whether triangle contains intersection point
	if (!R3Contains(triangle, p1)) return RN_NULL_CLASS_ID;
	if (hit_point) *hit_point = p1;
	if (hit_normal) *hit_normal = triangle.Normal();
	if (hit_t) *hit_t = t1;
	return R3_POINT_CLASS_ID;

    case R3_RAY_CLASS_ID: 
	// Ray lies in triangle plane 
	// Intersect ray and triangle in 2D
	// RNAbort("Case not implemented");
	// return R3_SPAN_CLASS_ID;
	return RN_NULL_CLASS_ID;

    default:
	RNAbort("Invalid intersection result");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6eb40
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x81b30
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rsi
leaq 0x18(%rsp), %rcx
callq 0x7ae90
movl %eax, %ecx
movl %ecx, 0x14(%rsp)
testl %eax, %eax
je 0x7b1ce
jmp 0x7b1b1
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x7b1db
jmp 0x7b1bc
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0x7b253
jmp 0x7b25d
movl $0x0, 0x64(%rsp)
jmp 0x7b281
movq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x836e0
cmpl $0x0, %eax
jne 0x7b1fc
movl $0x0, 0x64(%rsp)
jmp 0x7b281
cmpq $0x0, 0x48(%rsp)
je 0x7b213
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6f1e0
cmpq $0x0, 0x40(%rsp)
je 0x7b232
movq 0x50(%rsp), %rdi
callq 0x78960
movq %rax, %rsi
movq 0x40(%rsp), %rdi
callq 0x70970
cmpq $0x0, 0x38(%rsp)
je 0x7b249
movsd 0x18(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x64(%rsp)
jmp 0x7b281
movl $0x0, 0x64(%rsp)
jmp 0x7b281
leaq 0xba73b(%rip), %rdi     # 0x13599f
movb $0x0, %al
callq 0xd4e20
leaq 0xba717(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3TriangleArray const&, gaps::R3Point*, gaps::R3Vector*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3TriangleArray& array,
    R3Point *hit_point, R3Vector *hit_normal, RNScalar *hit_t)
{
    // This could be more efficient ???
    // Sort intersections with front-facing planes 
    //   before do any point-in-triangle operations

    // Check bounding volume for intersection 
    if (!R3Intersects(ray, array.Box())) 
	return RN_NULL_CLASS_ID;

    // Check each triangle for intersection
    RNClassID status = RN_NULL_CLASS_ID;
    RNScalar min_t = FLT_MAX;
    for (int i = 0; i < array.NTriangles(); i++) {
        R3Point point;
        R3Vector normal;
	RNScalar t;
        if (R3Intersects(ray, *(array.Triangle(i)), &point, &normal, &t) == R3_POINT_CLASS_ID) {
	    if (t < min_t) {
	        status = R3_POINT_CLASS_ID;
	        if (hit_point) *hit_point = point;
	        if (hit_normal) *hit_normal = normal;
	        min_t = t;
	    }
	}
    }

    // Update hit t
    if (hit_t) *hit_t = min_t;

    // Return whether hit any triangle
    return status;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x81c20
movq 0x10(%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x7b430
cmpl $0x0, %eax
jne 0x7b2fd
movl $0x0, 0x94(%rsp)
jmp 0x7b419
movl $0x0, 0x64(%rsp)
movsd 0xb7d13(%rip), %xmm0    # 0x133020
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x80(%rsp), %rdi
callq 0x81c30
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x7b3f7
leaq 0x38(%rsp), %rdi
callq 0x6eb40
leaq 0x20(%rsp), %rdi
callq 0x6fca0
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x81c50
movq (%rsp), %rdi
movq %rax, %rsi
leaq 0x38(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x7b150
cmpl $0x1, %eax
jne 0x7b3e5
movsd 0x18(%rsp), %xmm1
movsd 0x58(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7b3e3
movl $0x1, 0x64(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x7b3c0
movq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6f1e0
cmpq $0x0, 0x70(%rsp)
je 0x7b3d7
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x70970
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
jmp 0x7b3e5
jmp 0x7b3e7
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x7b31b
cmpq $0x0, 0x68(%rsp)
je 0x7b40e
movsd 0x58(%rsp), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x64(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Ellipse const&, gaps::R3Point*, gaps::R3Vector*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Ellipse& ellipse, 
    R3Point *hit_point, R3Vector *hit_normal, RNScalar *hit_t)
{
    // Check for empty ellipse
    if (ellipse.IsEmpty()) return RN_NULL_CLASS_ID;
    
    // Find intersection of ray and plane
    R3Point p1;
    RNScalar t1;
    switch (R3Intersects(ray, ellipse.Plane(), &p1, &t1)) {
    case RN_NULL_CLASS_ID:
	// Ray does not intersect ellipse plane
	return RN_NULL_CLASS_ID;
	
    case R3_POINT_CLASS_ID:
    {
	// Ray intersects ellipse plane in a single point
	// Check whether ellipse contains intersection point
        if (!R3Contains(ellipse, p1)) return RN_NULL_CLASS_ID;
  	if (hit_point) *hit_point = p1;
	if (hit_normal) *hit_normal = ellipse.Normal();
	if (hit_t) *hit_t = t1;
	return R3_POINT_CLASS_ID;
    }

    case R3_RAY_CLASS_ID: 
	// Ray lies in ellipse plane 
	// Intersect ray and ellipse in 2D
        // RNAbort("Case not implemented");
	return R3_SPAN_CLASS_ID;

    default:
	RNAbort("Invalid intersection result");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0x81cc0
cmpl $0x0, %eax
je 0x7bef8
movl $0x0, 0x94(%rsp)
jmp 0x7c035
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6eb40
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x81d20
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x7ae90
movl %eax, %ecx
movl %ecx, 0x24(%rsp)
testl %eax, %eax
je 0x7bf6d
jmp 0x7bf50
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x7bf7d
jmp 0x7bf5b
movl 0x24(%rsp), %eax
subl $0x3, %eax
je 0x7c001
jmp 0x7c00e
movl $0x0, 0x94(%rsp)
jmp 0x7c035
movq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x84130
cmpl $0x0, %eax
jne 0x7bfa4
movl $0x0, 0x94(%rsp)
jmp 0x7c035
cmpq $0x0, 0x78(%rsp)
je 0x7bfbb
movq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6f1e0
cmpq $0x0, 0x70(%rsp)
je 0x7bfdd
movq 0x80(%rsp), %rdi
callq 0x81d80
movq %rax, %rsi
movq 0x70(%rsp), %rdi
callq 0x70970
cmpq $0x0, 0x68(%rsp)
je 0x7bff4
movsd 0x48(%rsp), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x94(%rsp)
jmp 0x7c035
movl $0x4, 0x94(%rsp)
jmp 0x7c035
leaq 0xb998a(%rip), %rdi     # 0x13599f
movb $0x0, %al
callq 0xd4e20
leaq 0xb9966(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Rectangle const&, gaps::R3Point*, gaps::R3Vector*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Rectangle& rectangle, 
    R3Point *hit_point, R3Vector *hit_normal, RNScalar *hit_t)
{
    // Check for empty rectangle
    if (rectangle.IsEmpty()) return RN_NULL_CLASS_ID;
    
    // Find intersection of ray and plane
    R3Point p1;
    RNScalar t1;
    switch (R3Intersects(ray, rectangle.Plane(), &p1, &t1)) {
    case RN_NULL_CLASS_ID:
	// Ray does not intersect rectangle plane
	return RN_NULL_CLASS_ID;
	
    case R3_POINT_CLASS_ID:
    {
	// Ray intersects rectangle plane in a single point
	// Check whether rectangle contains intersection point
        if (!R3Contains(rectangle, p1)) return RN_NULL_CLASS_ID;
  	if (hit_point) *hit_point = p1;
	if (hit_normal) *hit_normal = rectangle.Normal();
	if (hit_t) *hit_t = t1;
	return R3_POINT_CLASS_ID;
    }

    case R3_RAY_CLASS_ID: 
	// Ray lies in rectangle plane 
	// Intersect ray and rectangle in 2D
        // RNAbort("Case not implemented");
	return R3_SPAN_CLASS_ID;

    default:
	RNAbort("Invalid intersection result");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0x78ac0
cmpl $0x0, %eax
je 0x7c098
movl $0x0, 0x94(%rsp)
jmp 0x7c1d5
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6eb40
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x81db0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x7ae90
movl %eax, %ecx
movl %ecx, 0x24(%rsp)
testl %eax, %eax
je 0x7c10d
jmp 0x7c0f0
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x7c11d
jmp 0x7c0fb
movl 0x24(%rsp), %eax
subl $0x3, %eax
je 0x7c1a1
jmp 0x7c1ae
movl $0x0, 0x94(%rsp)
jmp 0x7c1d5
movq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x84310
cmpl $0x0, %eax
jne 0x7c144
movl $0x0, 0x94(%rsp)
jmp 0x7c1d5
cmpq $0x0, 0x78(%rsp)
je 0x7c15b
movq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6f1e0
cmpq $0x0, 0x70(%rsp)
je 0x7c17d
movq 0x80(%rsp), %rdi
callq 0x78ca0
movq %rax, %rsi
movq 0x70(%rsp), %rdi
callq 0x70970
cmpq $0x0, 0x68(%rsp)
je 0x7c194
movsd 0x48(%rsp), %xmm0
movq 0x68(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x94(%rsp)
jmp 0x7c1d5
movl $0x4, 0x94(%rsp)
jmp 0x7c1d5
leaq 0xb97ea(%rip), %rdi     # 0x13599f
movb $0x0, %al
callq 0xd4e20
leaq 0xb97c6(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Ray const&, gaps::R3Frustum const&, gaps::R3Point*, gaps::R3Vector*, double*)
RNClassID R3Intersects(const R3Ray& ray, const R3Frustum& frustum,
    R3Point *hit_point, R3Vector *hit_normal, RNScalar *hit_t)
{
    // Check if frustum contains ray start
    if (R3Contains(frustum, ray.Start())) {
       if (hit_point) *hit_point = ray.Start();
       if (hit_normal) *hit_normal = R3zero_vector;
       if (hit_t) *hit_t = 0;
    }
  
    // Not implemented
    RNAbort("Not implemented");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3c0c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x86480
cmpl $0x0, %eax
je 0x7e361
cmpq $0x0, 0x20(%rsp)
je 0x7e332
movq 0x30(%rsp), %rdi
callq 0x3c0c0
movq %rax, %rsi
movq 0x20(%rsp), %rdi
callq 0x6f1e0
cmpq $0x0, 0x18(%rsp)
je 0x7e34b
movq 0x18(%rsp), %rdi
leaq 0x4fb25a(%rip), %rsi    # 0x5795a0
callq 0x70970
cmpq $0x0, 0x10(%rsp)
je 0x7e35f
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x7e361
leaq 0xb4f56(%rip), %rdi     # 0x1332be
movb $0x0, %al
callq 0xd4e20
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Isect.cpp
// Function: gaps::R3Intersects(gaps::R3Span const&, gaps::R3Span const&, gaps::R3Point*, double*, double*)
RNClassID R3Intersects(const R3Span& span1, const R3Span& span2, 
    R3Point *hit_point, RNScalar *hit_t1, RNScalar *hit_t2)
{
    // Intersect span1 with span2's ray
    RNScalar s1, s2;
    switch (R3Intersects(span1, span2.Ray(), hit_point, &s1, &s2)) {
    case RN_NULL_CLASS_ID:
	// Spans do not intersect
	return RN_NULL_CLASS_ID;

    case R3_SPAN_CLASS_ID:
	// Span1 lies on span2's ray -- check if they overlap ???
	if ((R3Contains(span2, span1.Start())) || (R3Contains(span2, span1.End()))) {
	    // Spans are on same line, and overlap
	    return R3_SPAN_CLASS_ID;
	}
	else {
	    // Spans are on same line, but do not overlap
	    return RN_NULL_CLASS_ID;
	}
	break;

    case R3_POINT_CLASS_ID: 
	// Check if intersection point is on span
	if (RNIsGreater(s1, span1.Length())) {
	    // Span's ray intersects plane beyond span endpoint
	    return RN_NULL_CLASS_ID;
	}
	else {
	    // Span and plane intersect at point
	    if (hit_t1) *hit_t1 = s1;
	    if (hit_t2) *hit_t2 = s2;
	    return R3_POINT_CLASS_ID;
	}
	break;

    default:
	RNAbort("Illegal intersection");
	break;
    }

    // Should never get here
    RNAbort("Should never get here");
    return RN_NULL_CLASS_ID;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x81b20
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x81e70
movl %eax, %ecx
movl %ecx, 0x24(%rsp)
testl %eax, %eax
je 0x7e446
jmp 0x7e429
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x7e4b9
jmp 0x7e438
movl 0x24(%rsp), %eax
subl $0x4, %eax
je 0x7e453
jmp 0x7e52d
movl $0x0, 0x64(%rsp)
jmp 0x7e551
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39250
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x82f00
cmpl $0x0, %eax
jne 0x7e49f
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39260
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x82f00
cmpl $0x0, %eax
je 0x7e4ac
movl $0x4, 0x64(%rsp)
jmp 0x7e551
movl $0x0, 0x64(%rsp)
jmp 0x7e551
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x37a50
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0xfa003(%rip), %rax     # 0x1784e0
movsd (%rax), %xmm2
callq 0x3c090
cmpl $0x0, %eax
je 0x7e4f5
movl $0x0, 0x64(%rsp)
jmp 0x7e551
cmpq $0x0, 0x40(%rsp)
je 0x7e50c
movsd 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x7e523
movsd 0x28(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x64(%rsp)
jmp 0x7e551
leaq 0xb7440(%rip), %rdi     # 0x135974
movb $0x0, %al
callq 0xd4e20
leaq 0xb7447(%rip), %rdi     # 0x135989
movb $0x0, %al
callq 0xd4e20
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)