LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(int, double)
R3Quaternion::
R3Quaternion(int dimension, RNAngle theta)
{
    RNAngle half_theta = 0.5 * theta;
    RNScalar sine_half_theta = sin(half_theta);
    R3Vector axis = R3xyz_triad[dimension];
    v[0] = cos(half_theta);
    v[1] = axis[0] * sine_half_theta; 
    v[2] = axis[1] * sine_half_theta; 
    v[3] = axis[2] * sine_half_theta; 
    Normalize();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movsd 0xe312c(%rip), %xmm0    # 0x133010
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0x20(%rsp)
movl 0x3c(%rsp), %esi
leaq 0x128bfc(%rip), %rdi    # 0x178b08
callq 0x39fb0
movq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x6fcf0
movsd 0x28(%rsp), %xmm0
callq 0xf930
movq (%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x36c00
movq %rax, %rcx
movq (%rsp), %rax
movsd (%rcx), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x36c00
movq %rax, %rcx
movq (%rsp), %rax
movsd (%rcx), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x36c00
movq (%rsp), %rdi
movsd (%rax), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
callq 0x4f6e0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::R3Quaternion(double const*)
R3Quaternion::
R3Quaternion(const RNScalar array[4])
{
    v[0] = array[0]; 
    v[1] = array[1]; 
    v[2] = array[2];
    v[3] = array[3];
    Normalize();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rdi)
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rdi)
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
callq 0x4f6e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::operator==(gaps::R3Quaternion const&) const
const RNBoolean R3Quaternion::
operator==(const R3Quaternion& quaternion) const
{
    // Return whether quaternion is equal
    return ((v[0] == quaternion.v[0]) && 
            (v[1] == quaternion.v[1]) && 
            (v[2] == quaternion.v[2]) && 
            (v[3] == quaternion.v[3]));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movsd (%rax), %xmm0
movq -0x10(%rsp), %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50e47
jp 0x50e47
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rcx
xorl %eax, %eax
ucomisd 0x8(%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50e47
jp 0x50e47
movq -0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rcx
xorl %eax, %eax
ucomisd 0x10(%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50e47
jp 0x50e47
movq -0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rsp), %rax
ucomisd 0x18(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::operator!=(gaps::R3Quaternion const&) const
const RNBoolean R3Quaternion::
operator!=(const R3Quaternion& quaternion) const
{
    // Return whether quaternion is not equal
    return ((v[0] != quaternion.v[0]) || 
            (v[1] != quaternion.v[1]) || 
            (v[2] != quaternion.v[2]) || 
            (v[3] != quaternion.v[3]));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movsd (%rax), %xmm0
movq -0x10(%rsp), %rcx
movb $0x1, %al
ucomisd (%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50ee7
jp 0x50ee7
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rcx
movb $0x1, %al
ucomisd 0x8(%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50ee7
jp 0x50ee7
movq -0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rcx
movb $0x1, %al
ucomisd 0x10(%rcx), %xmm0
movb %al, -0x11(%rsp)
jne 0x50ee7
jp 0x50ee7
movq -0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rsp), %rax
ucomisd 0x18(%rax), %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::R3Quaternion::Flip()
void R3Quaternion::
Flip(void)
{
    // Negate all numbers (does not change rotation)
    v[0] = -v[0];
    v[1] = -v[1];
    v[2] = -v[2];
    v[3] = -v[3];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Quaternion.cpp
// Function: gaps::operator*(gaps::R3Quaternion const&, gaps::R3Vector const&)
R3Vector
operator*(const R3Quaternion& q, const R3Vector& v)
{
    // Compute quaternion representation of vector
    RNLength length = v.Length();
    if (RNIsZero(length)) return v;
    R3Quaternion vector(0, v[0] / length, v[1] / length, v[2] / length);

    // Compute quaternion representation of rotated vector
    R3Quaternion conjugate(q[0], -q[1], -q[2], -q[3]);
    R3Quaternion result = q;
    result.Multiply(vector);
    result.Multiply(conjugate);
    assert(RNIsZero(result[0]));

    // Return rotated vector
    return R3Vector(length * result[1], length * result[2], length * result[3]); 
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x6fe90
movsd %xmm0, 0xc8(%rsp)
movsd 0xc8(%rsp), %xmm0
leaq 0x126d0e(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x517f7
movq 0x58(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0x6fcf0
jmp 0x519fe
movq 0xd0(%rsp), %rdi
xorl %esi, %esi
callq 0x3a4b0
divsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xd0(%rsp), %rdi
movl $0x1, %esi
callq 0x3a4b0
divsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
movl $0x2, %esi
callq 0x3a4b0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
divsd 0xc8(%rsp), %xmm3
leaq 0xa8(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x4f680
movq 0xd8(%rsp), %rdi
xorl %esi, %esi
callq 0x51af0
movsd %xmm0, 0x28(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
callq 0x51af0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x2, %esi
callq 0x51af0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x3, %esi
callq 0x51af0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x28(%rsp), %xmm0
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
leaq 0x88(%rsp), %rdi
callq 0x4f680
movq 0xd8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x4f800
leaq 0x68(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x50f90
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x50f90
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x51b10
movsd 0x30(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
callq 0x51b10
movsd 0x38(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x3, %esi
callq 0x51b10
movsd 0x40(%rsp), %xmm2
movq 0x58(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
mulsd (%rax), %xmm2
callq 0x6fcb0
movq 0x60(%rsp), %rax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::R4Matrix(gaps::R4Matrix const&)
R4Matrix::
R4Matrix(const R4Matrix& matrix)
{
    // Assign matrix entries
    m[0][0] = matrix.m[0][0]; m[0][1] = matrix.m[0][1]; m[0][2] = matrix.m[0][2]; m[0][3] = matrix.m[0][3];
    m[1][0] = matrix.m[1][0]; m[1][1] = matrix.m[1][1]; m[1][2] = matrix.m[1][2]; m[1][3] = matrix.m[1][3];
    m[2][0] = matrix.m[2][0]; m[2][1] = matrix.m[2][1]; m[2][2] = matrix.m[2][2]; m[2][3] = matrix.m[2][3];
    m[3][0] = matrix.m[3][0]; m[3][1] = matrix.m[3][1]; m[3][2] = matrix.m[3][2]; m[3][3] = matrix.m[3][3];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rcx
movsd 0x20(%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movsd 0x28(%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x10(%rsp), %rcx
movsd 0x30(%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rsp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x10(%rsp), %rcx
movsd 0x48(%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rsp), %rcx
movsd 0x50(%rcx), %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x10(%rsp), %rcx
movsd 0x58(%rcx), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x10(%rsp), %rcx
movsd 0x60(%rcx), %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x10(%rsp), %rcx
movsd 0x68(%rcx), %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x10(%rsp), %rcx
movsd 0x70(%rcx), %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x10(%rsp), %rcx
movsd 0x78(%rcx), %xmm0
movsd %xmm0, 0x78(%rax)
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::R4Matrix(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
R4Matrix::
R4Matrix(RNScalar a00, RNScalar a01, RNScalar a02, RNScalar a03,
         RNScalar a10, RNScalar a11, RNScalar a12, RNScalar a13,
	 RNScalar a20, RNScalar a21, RNScalar a22, RNScalar a23,
	 RNScalar a30, RNScalar a31, RNScalar a32, RNScalar a33)
{
    // Assign matrix entries
    m[0][0] = a00; m[0][1] = a01; m[0][2] = a02; m[0][3] = a03;
    m[1][0] = a10; m[1][1] = a11; m[1][2] = a12; m[1][3] = a13;
    m[2][0] = a20; m[2][1] = a21; m[2][2] = a22; m[2][3] = a23;
    m[3][0] = a30; m[3][1] = a31; m[3][2] = a32; m[3][3] = a33;
}

// Assembly:
movsd 0x40(%rsp), %xmm8
movsd 0x38(%rsp), %xmm8
movsd 0x30(%rsp), %xmm8
movsd 0x28(%rsp), %xmm8
movsd 0x20(%rsp), %xmm8
movsd 0x18(%rsp), %xmm8
movsd 0x10(%rsp), %xmm8
movsd 0x8(%rsp), %xmm8
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd %xmm3, -0x28(%rsp)
movsd %xmm4, -0x30(%rsp)
movsd %xmm5, -0x38(%rsp)
movsd %xmm6, -0x40(%rsp)
movsd %xmm7, -0x48(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x48(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x58(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x60(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x70(%rax)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x78(%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::IsIsotropic() const
const RNBoolean R4Matrix::
IsIsotropic(void) const
{
    // Return whether matrix transformation is isotropic
    RNScalar d0 = m[0][0]*m[0][0] + m[1][0]*m[1][0] + m[2][0]*m[2][0];
    RNScalar d1 = m[0][1]*m[0][1] + m[1][1]*m[1][1] + m[2][1]*m[2][1];
    if (RNIsNotEqual(d0, d1)) return FALSE;
    RNScalar d2 = m[0][2]*m[0][2] + m[1][2]*m[1][2] + m[2][2]*m[2][2];
    if (RNIsNotEqual(d0, d2)) return FALSE;
    return TRUE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd (%rax), %xmm1
movsd (%rax), %xmm2
movsd 0x20(%rax), %xmm0
mulsd 0x20(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x40(%rax), %xmm0
movsd 0x40(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd 0x28(%rax), %xmm0
mulsd 0x28(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x48(%rax), %xmm0
movsd 0x48(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x126584(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm2
callq 0x55570
cmpl $0x0, %eax
je 0x51f74
movl $0x0, 0x34(%rsp)
jmp 0x51fe0
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x30(%rax), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x50(%rax), %xmm0
movsd 0x50(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
leaq 0x126520(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm2
callq 0x55570
cmpl $0x0, %eax
je 0x51fd8
movl $0x0, 0x34(%rsp)
jmp 0x51fe0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasTranslation() const
const RNBoolean R4Matrix::
HasTranslation(void) const
{
    // Return whether matrix transformation has translation
    if (RNIsNotZero(m[0][3])) return TRUE;
    if (RNIsNotZero(m[1][3])) return TRUE;
    if (RNIsNotZero(m[2][3])) return TRUE;
    return FALSE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movsd 0x18(%rax), %xmm0
leaq 0x1264d2(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x52026
movl $0x1, 0x14(%rsp)
jmp 0x5207e
movq (%rsp), %rax
movsd 0x38(%rax), %xmm0
leaq 0x1264aa(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x5204e
movl $0x1, 0x14(%rsp)
jmp 0x5207e
movq (%rsp), %rax
movsd 0x58(%rax), %xmm0
leaq 0x126482(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x52076
movl $0x1, 0x14(%rsp)
jmp 0x5207e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasScale() const
const RNBoolean R4Matrix::
HasScale(void) const
{
    // Return whether matrix transformation has scale
    RNScalar d0 = m[0][0]*m[0][0] + m[1][0]*m[1][0] + m[2][0]*m[2][0];
    if (RNIsNotEqual(d0, 1.0)) return TRUE;
    RNScalar d1 = m[0][1]*m[0][1] + m[1][1]*m[1][1] + m[2][1]*m[2][1];
    if (RNIsNotEqual(d1, 1.0)) return TRUE;
    RNScalar d2 = m[0][2]*m[0][2] + m[1][2]*m[1][2] + m[2][2]*m[2][2];
    if (RNIsNotEqual(d2, 1.0)) return TRUE;
    return FALSE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd (%rax), %xmm1
movsd (%rax), %xmm2
movsd 0x20(%rax), %xmm0
mulsd 0x20(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x40(%rax), %xmm0
movsd 0x40(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
leaq 0x1263fe(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm2
movsd 0xe0f1a(%rip), %xmm1    # 0x133008
callq 0x55570
cmpl $0x0, %eax
je 0x52105
movl $0x1, 0x34(%rsp)
jmp 0x521d9
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd 0x28(%rax), %xmm0
mulsd 0x28(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x48(%rax), %xmm0
movsd 0x48(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0x126395(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm2
movsd 0xe0eb1(%rip), %xmm1    # 0x133008
callq 0x55570
cmpl $0x0, %eax
je 0x5216b
movl $0x1, 0x34(%rsp)
jmp 0x521d9
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x30(%rax), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x50(%rax), %xmm0
movsd 0x50(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
leaq 0x12632f(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm2
movsd 0xe0e4b(%rip), %xmm1    # 0x133008
callq 0x55570
cmpl $0x0, %eax
je 0x521d1
movl $0x1, 0x34(%rsp)
jmp 0x521d9
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasRotation() const
const RNBoolean R4Matrix::
HasRotation(void) const
{
    // Return whether matrix transformation has rotation
    if (RNIsNotZero(m[0][1])) return TRUE;
    if (RNIsNotZero(m[0][2])) return TRUE;
    if (RNIsNotZero(m[1][0])) return TRUE;
    if (RNIsNotZero(m[1][2])) return TRUE;
    if (RNIsNotZero(m[2][0])) return TRUE;
    if (RNIsNotZero(m[2][1])) return TRUE;
    return FALSE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rax), %xmm0
leaq 0x1262d2(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x52229
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movq (%rsp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x1262a7(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x52254
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movq (%rsp), %rax
movsd 0x20(%rax), %xmm0
leaq 0x12627c(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x5227f
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movq (%rsp), %rax
movsd 0x30(%rax), %xmm0
leaq 0x126251(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x522a7
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movq (%rsp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x126229(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x522cf
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movq (%rsp), %rax
movsd 0x48(%rax), %xmm0
leaq 0x126201(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x555a0
cmpl $0x0, %eax
je 0x522f7
movl $0x1, 0x14(%rsp)
jmp 0x522ff
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::HasMirror() const
const RNBoolean R4Matrix::
HasMirror(void) const
{
    // Return whether matrix transformation has mirror operator
    R3Vector vx(m[0][0], m[1][0], m[2][0]);
    R3Vector vy(m[0][1], m[1][1], m[2][1]);
    R3Vector vz(m[0][2], m[1][2], m[2][2]);
    return RNIsNegative(vz.Dot(vx % vy));
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd (%rax), %xmm0
movsd 0x20(%rax), %xmm1
movsd 0x40(%rax), %xmm2
leaq 0x58(%rsp), %rdi
callq 0x6fcb0
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x28(%rax), %xmm1
movsd 0x48(%rax), %xmm2
leaq 0x40(%rsp), %rdi
callq 0x6fcb0
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x30(%rax), %xmm1
movsd 0x50(%rax), %xmm2
leaq 0x28(%rsp), %rdi
callq 0x6fcb0
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x70af0
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x702c0
leaq 0x12613f(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x38fd0
addq $0x78, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Determinant() const
const RNScalar R4Matrix::
Determinant(void) const
{
    // Return matrix determinant
    return R4MatrixDet4(
        m[0][0], m[0][1], m[0][2], m[0][3],
        m[1][0], m[1][1], m[1][2], m[1][3],
        m[2][0], m[2][1], m[2][2], m[2][3],
        m[3][0], m[3][1], m[3][2], m[3][3]);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movsd 0x30(%rax), %xmm6
movsd 0x38(%rax), %xmm7
movsd 0x40(%rax), %xmm15
movsd 0x48(%rax), %xmm14
movsd 0x50(%rax), %xmm13
movsd 0x58(%rax), %xmm12
movsd 0x60(%rax), %xmm11
movsd 0x68(%rax), %xmm10
movsd 0x70(%rax), %xmm9
movsd 0x78(%rax), %xmm8
movsd %xmm15, (%rsp)
movsd %xmm14, 0x8(%rsp)
movsd %xmm13, 0x10(%rsp)
movsd %xmm12, 0x18(%rsp)
movsd %xmm11, 0x20(%rsp)
movsd %xmm10, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x52460
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4MatrixDet4(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
RNScalar R4MatrixDet4 (
    RNScalar a, RNScalar b, RNScalar c, RNScalar d, 
    RNScalar e, RNScalar f, RNScalar g, RNScalar h, 
    RNScalar i, RNScalar j, RNScalar k, RNScalar l, 
    RNScalar m, RNScalar n, RNScalar o, RNScalar p)
{
    /* Return determinant of 4x4 matrix */
    RNScalar det = 0.0;
    det += a * R4MatrixDet3(f,g,h,j,k,l,n,o,p);
    det -= b * R4MatrixDet3(e,g,h,i,k,l,m,o,p);
    det += c * R4MatrixDet3(e,f,h,i,j,l,m,n,p);
    det -= d * R4MatrixDet3(e,f,g,i,j,k,m,n,o);
    return (det);
}

// Assembly:
subq $0x78, %rsp
movsd 0xb8(%rsp), %xmm8
movsd 0xb0(%rsp), %xmm8
movsd 0xa8(%rsp), %xmm8
movsd 0xa0(%rsp), %xmm8
movsd 0x98(%rsp), %xmm8
movsd 0x90(%rsp), %xmm8
movsd 0x88(%rsp), %xmm8
movsd 0x80(%rsp), %xmm8
movsd %xmm0, 0x70(%rsp)
movsd %xmm1, 0x68(%rsp)
movsd %xmm2, 0x60(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm4, 0x50(%rsp)
movsd %xmm5, 0x48(%rsp)
movsd %xmm6, 0x40(%rsp)
movsd %xmm7, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movsd 0x88(%rsp), %xmm3
movsd 0x90(%rsp), %xmm4
movsd 0x98(%rsp), %xmm5
movsd 0xa8(%rsp), %xmm6
movsd 0xb0(%rsp), %xmm7
movsd 0xb8(%rsp), %xmm8
movsd %xmm8, (%rsp)
callq 0x53160
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movsd 0x80(%rsp), %xmm3
movsd 0x90(%rsp), %xmm4
movsd 0x98(%rsp), %xmm5
movsd 0xa0(%rsp), %xmm6
movsd 0xb0(%rsp), %xmm7
movsd 0xb8(%rsp), %xmm8
movsd %xmm8, (%rsp)
callq 0x53160
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movsd 0x80(%rsp), %xmm3
movsd 0x88(%rsp), %xmm4
movsd 0x98(%rsp), %xmm5
movsd 0xa0(%rsp), %xmm6
movsd 0xa8(%rsp), %xmm7
movsd 0xb8(%rsp), %xmm8
movsd %xmm8, (%rsp)
callq 0x53160
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
movsd 0x80(%rsp), %xmm3
movsd 0x88(%rsp), %xmm4
movsd 0x90(%rsp), %xmm5
movsd 0xa0(%rsp), %xmm6
movsd 0xa8(%rsp), %xmm7
movsd 0xb0(%rsp), %xmm8
movsd %xmm8, (%rsp)
callq 0x53160
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Transpose() const
const R4Matrix R4Matrix::
Transpose(void) const
{
    // Return transpose of matrix
    return R4Matrix(
        m[0][0], m[1][0], m[2][0], m[3][0],
        m[0][1], m[1][1], m[2][1], m[3][1],
        m[0][2], m[1][2], m[2][2], m[3][2],
        m[0][3], m[1][3], m[2][3], m[3][3]);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x20(%rax), %xmm1
movsd 0x40(%rax), %xmm2
movsd 0x60(%rax), %xmm3
movsd 0x8(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movsd 0x48(%rax), %xmm6
movsd 0x68(%rax), %xmm7
movsd 0x10(%rax), %xmm15
movsd 0x30(%rax), %xmm14
movsd 0x50(%rax), %xmm13
movsd 0x70(%rax), %xmm12
movsd 0x18(%rax), %xmm11
movsd 0x38(%rax), %xmm10
movsd 0x58(%rax), %xmm9
movsd 0x78(%rax), %xmm8
movsd %xmm15, (%rsp)
movsd %xmm14, 0x8(%rsp)
movsd %xmm13, 0x10(%rsp)
movsd %xmm12, 0x18(%rsp)
movsd %xmm11, 0x20(%rsp)
movsd %xmm10, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Flip()
void R4Matrix::
Flip(void)
{
    // Transpose matrix
    RNScalar tmp;
    tmp = m[1][0]; m[1][0] = m[0][1]; m[0][1] = tmp;
    tmp = m[2][0]; m[2][0] = m[0][2]; m[0][2] = tmp;
    tmp = m[3][0]; m[3][0] = m[0][3]; m[0][3] = tmp;
    tmp = m[1][2]; m[1][2] = m[2][1]; m[2][1] = tmp;
    tmp = m[1][3]; m[1][3] = m[3][1]; m[3][1] = tmp;
    tmp = m[2][3]; m[2][3] = m[3][2]; m[3][2] = tmp;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x40(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x60(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x68(%rax), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rax)
movsd 0x58(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x70(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x70(%rax)
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Translate(int, double)
void R4Matrix:: 
Translate(RNAxis axis, RNScalar offset)
{
    // Translate matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XTranslate(offset); 
	break;

    case RN_YAXIS: 
	YTranslate(offset); 
	break;

    case RN_ZAXIS: 
	ZTranslate(offset); 
	break;

    default: 
	RNWarning("Matrix translate along undefined axis");
	break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x53410
jmp 0x533fa
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x53421
jmp 0x53405
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x53432
jmp 0x53443
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53280
jmp 0x53451
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x532f0
jmp 0x53451
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53360
jmp 0x53451
leaq 0xe09c4(%rip), %rdi     # 0x133e0e
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Scale(int, double)
void R4Matrix:: 
Scale(RNAxis axis, RNScalar scale)
{
    // Scale matrix along axis
    switch (axis) {
    case RN_XAXIS: 
	XScale(scale); 
	break;

    case RN_YAXIS: 
	YScale(scale); 
	break;

    case RN_ZAXIS: 
	ZScale(scale); 
	break;

    default: 
	RNWarning("Matrix scale along undefined axis");
	break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x53630
jmp 0x5361a
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x53641
jmp 0x53625
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x53652
jmp 0x53663
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53510
jmp 0x53671
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53550
jmp 0x53671
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x535a0
jmp 0x53671
leaq 0xe07ca(%rip), %rdi     # 0x133e34
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::XRotate(double)
void R4Matrix:: 
XRotate(RNAngle radians)
{
    // rotate matrix around X axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        1.0, 0.0, 0.0, 0.0,
        0.0, c,   -s,  0.0,
        0.0, s,   c,   0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movsd %xmm0, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf930
movsd %xmm0, 0xd0(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0xc8(%rsp)
movsd 0xd0(%rsp), %xmm5
movsd 0xc8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm6
movsd 0xc8(%rsp), %xmm11
movsd 0xd0(%rsp), %xmm10
leaq 0x48(%rsp), %rdi
movsd 0xdf83a(%rip), %xmm8    # 0x133008
xorps %xmm9, %xmm9
movaps %xmm8, %xmm0
movaps %xmm9, %xmm1
movaps %xmm9, %xmm2
movaps %xmm9, %xmm3
movaps %xmm9, %xmm4
movaps %xmm9, %xmm7
movsd %xmm9, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm9, 0x20(%rsp)
movsd %xmm9, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x55600
addq $0xe8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::YRotate(double)
void R4Matrix:: 
YRotate(RNAngle radians)
{
    // rotate matrix around Y axis counterclockwise
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        c,   0.0, s,   0.0,
        0.0, 1.0, 0.0, 0.0,
        -s,  0.0, c,   0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movsd %xmm0, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf930
movsd %xmm0, 0xd0(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0xc8(%rsp)
movsd 0xd0(%rsp), %xmm0
movsd 0xc8(%rsp), %xmm2
movsd 0xc8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm11
movsd 0xd0(%rsp), %xmm10
leaq 0x48(%rsp), %rdi
xorps %xmm9, %xmm9
movsd 0xdf727(%rip), %xmm8    # 0x133008
movaps %xmm9, %xmm1
movaps %xmm9, %xmm3
movaps %xmm9, %xmm4
movaps %xmm8, %xmm5
movaps %xmm9, %xmm6
movaps %xmm9, %xmm7
movsd %xmm11, (%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm9, 0x20(%rsp)
movsd %xmm9, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x55600
addq $0xe8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::ZRotate(double)
void R4Matrix:: 
ZRotate(RNAngle radians)
{
    // rotate matrix around Z axis counterclockwise 
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    R4Matrix rotation(
        c,   -s,  0.0, 0.0,
        s,   c,   0.0, 0.0,
        0.0, 0.0, 1.0, 0.0,
        0.0, 0.0, 0.0, 1.0 );
    *this *= rotation;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movsd %xmm0, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf930
movsd %xmm0, 0xd0(%rsp)
movsd 0xd8(%rsp), %xmm0
callq 0xf100
movsd %xmm0, 0xc8(%rsp)
movsd 0xd0(%rsp), %xmm0
movsd 0xc8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xc8(%rsp), %xmm4
movsd 0xd0(%rsp), %xmm5
leaq 0x48(%rsp), %rdi
xorps %xmm9, %xmm9
movsd 0xdf618(%rip), %xmm8    # 0x133008
movaps %xmm9, %xmm2
movaps %xmm9, %xmm3
movaps %xmm9, %xmm6
movaps %xmm9, %xmm7
movsd %xmm9, (%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm8, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm9, 0x20(%rsp)
movsd %xmm9, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x55600
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(int, double)
void R4Matrix:: 
Rotate(RNAxis axis, RNAngle radians)
{
    // rotate matrix around an axis counterclockwise
    switch (axis) {
    case RN_XAXIS: 
	XRotate(radians); 
	break;

    case RN_YAXIS: 
	YRotate(radians); 
	break;

    case RN_ZAXIS: 
	ZRotate(radians); 
	break;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x53aa0
jmp 0x53a8a
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x53ab1
jmp 0x53a95
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x53ac2
jmp 0x53ad3
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53730
jmp 0x53ae1
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53840
jmp 0x53ae1
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x53950
jmp 0x53ae1
leaq 0xe037c(%rip), %rdi     # 0x133e56
movb $0x0, %al
callq 0xd5010
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&)
void R4Matrix:: 
Rotate(const R3Vector& radians)
{
#if 1
    // Rotate first around X, then around Y, and finally around Z
    R4Matrix rotation = R4identity_matrix;
    rotation.ZRotate(radians.Z());
    rotation.YRotate(radians.Y());
    rotation.XRotate(radians.X());
    *this *= rotation;
#else
    // This is faster way to do same thing (not tested)
    // Note: this matrix is for pre-multiplication -- need one for postmultiplication
    R4Matrix rotation(
      cos(radians.Y())*cos(radians.Z()),  
      sin(radians.X())*sin(radians.Y())*cos(radians.Z()) - cos(radians.X())*sin(radians.Z()), 
      cos(radians.X())*sin(radians.Y())*cos(radians.Z()) + sin(radians.X())*sin(radians.Z()), 0,
      cos(radians.Y())*sin(radians.Z()),
      sin(radians.X())*sin(radians.Y())*sin(radians.Z()) + cos(radians.X())*cos(radians.Z()),
      cos(radians.X())*sin(radians.Y())*sin(radians.Z()) - sin(radians.X())*cos(radians.Z()), 0,
      -sin(radians.Y()), 
      sin(radians.X())*cos(radians.Y()),
      cos(radians.X())*cos(radians.Y()), 0,
      0, 0, 0, 1);
    *this *= rotation;
#endif
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x125111(%rip), %rsi    # 0x178c30
callq 0x51b60
movq 0x88(%rsp), %rdi
callq 0x38c40
leaq 0x8(%rsp), %rdi
callq 0x53950
movq 0x88(%rsp), %rdi
callq 0x38c30
leaq 0x8(%rsp), %rdi
callq 0x53840
movq 0x88(%rsp), %rdi
callq 0x38c20
leaq 0x8(%rsp), %rdi
callq 0x53730
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x55600
addq $0x98, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&, gaps::R3Vector const&)
void R4Matrix:: 
Rotate(const R3Vector& from, const R3Vector& to)
{
    // rotate matrix that takes direction of vector "from" -> "to"
    // This is a quickie hack -- there's got to be a better way
    RNAngle radians = R3InteriorAngle(from, to);
    R3Vector axis = from % to;
    axis.Normalize();
    Rotate(axis, radians);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x8c230
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x70af0
leaq 0x10(%rsp), %rdi
callq 0x70410
movq 0x8(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
callq 0x53b80
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Add(gaps::R4Matrix const&)
void R4Matrix:: 
Add(const R4Matrix& a)
{
    // Add matrix entry-by-entry
    m[0][0] += a.m[0][0]; m[0][1] += a.m[0][1]; m[0][2] += a.m[0][2]; m[0][3] += a.m[0][3]; 
    m[1][0] += a.m[1][0]; m[1][1] += a.m[1][1]; m[1][2] += a.m[1][2]; m[1][3] += a.m[1][3]; 
    m[2][0] += a.m[2][0]; m[2][1] += a.m[2][1]; m[2][2] += a.m[2][2]; m[2][3] += a.m[2][3]; 
    m[3][0] += a.m[3][0]; m[3][1] += a.m[3][1]; m[3][2] += a.m[3][2]; m[3][3] += a.m[3][3];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rcx
movsd 0x20(%rcx), %xmm0
addsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movsd 0x28(%rcx), %xmm0
addsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x10(%rsp), %rcx
movsd 0x30(%rcx), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rsp), %rcx
movsd 0x38(%rcx), %xmm0
addsd 0x38(%rax), %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x10(%rsp), %rcx
movsd 0x48(%rcx), %xmm0
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rsp), %rcx
movsd 0x50(%rcx), %xmm0
addsd 0x50(%rax), %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x10(%rsp), %rcx
movsd 0x58(%rcx), %xmm0
addsd 0x58(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x10(%rsp), %rcx
movsd 0x60(%rcx), %xmm0
addsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x10(%rsp), %rcx
movsd 0x68(%rcx), %xmm0
addsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x10(%rsp), %rcx
movsd 0x70(%rcx), %xmm0
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x10(%rsp), %rcx
movsd 0x78(%rcx), %xmm0
addsd 0x78(%rax), %xmm0
movsd %xmm0, 0x78(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Subtract(gaps::R4Matrix const&)
void R4Matrix::
Subtract(const R4Matrix& a)
{
    // Subtract matrix entry-by-entry
    m[0][0] -= a.m[0][0]; m[0][1] -= a.m[0][1]; m[0][2] -= a.m[0][2]; m[0][3] -= a.m[0][3]; 
    m[1][0] -= a.m[1][0]; m[1][1] -= a.m[1][1]; m[1][2] -= a.m[1][2]; m[1][3] -= a.m[1][3]; 
    m[2][0] -= a.m[2][0]; m[2][1] -= a.m[2][1]; m[2][2] -= a.m[2][2]; m[2][3] -= a.m[2][3]; 
    m[3][0] -= a.m[3][0]; m[3][1] -= a.m[3][1]; m[3][2] -= a.m[3][2]; m[3][3] -= a.m[3][3];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm1
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm1
movsd 0x10(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm1
movsd 0x18(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rcx
movsd 0x20(%rcx), %xmm1
movsd 0x20(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movsd 0x28(%rcx), %xmm1
movsd 0x28(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x10(%rsp), %rcx
movsd 0x30(%rcx), %xmm1
movsd 0x30(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rsp), %rcx
movsd 0x38(%rcx), %xmm1
movsd 0x38(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm1
movsd 0x40(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x10(%rsp), %rcx
movsd 0x48(%rcx), %xmm1
movsd 0x48(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rsp), %rcx
movsd 0x50(%rcx), %xmm1
movsd 0x50(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x10(%rsp), %rcx
movsd 0x58(%rcx), %xmm1
movsd 0x58(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x10(%rsp), %rcx
movsd 0x60(%rcx), %xmm1
movsd 0x60(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x10(%rsp), %rcx
movsd 0x68(%rcx), %xmm1
movsd 0x68(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x10(%rsp), %rcx
movsd 0x70(%rcx), %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
movq -0x10(%rsp), %rcx
movsd 0x78(%rcx), %xmm1
movsd 0x78(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::operator*=(double)
R4Matrix& R4Matrix::
operator*=(RNScalar a)
{
    // Scale matrix entry-by-entry
    m[0][0] *= a; m[0][1] *= a; m[0][2] *= a; m[0][3] *= a; 
    m[1][0] *= a; m[1][1] *= a; m[1][2] *= a; m[1][3] *= a; 
    m[2][0] *= a; m[2][1] *= a; m[2][2] *= a; m[2][3] *= a; 
    m[3][0] *= a; m[3][1] *= a; m[3][2] *= a; m[3][3] *= a;
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x38(%rax), %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x50(%rax), %xmm0
movsd %xmm0, 0x50(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x58(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
movsd -0x10(%rsp), %xmm0
mulsd 0x78(%rax), %xmm0
movsd %xmm0, 0x78(%rax)
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator+(gaps::R4Matrix const&, gaps::R4Matrix const&)
R4Matrix 
operator+(const R4Matrix& a, const R4Matrix& b) 
{
    // Sum matrix
    return R4Matrix(
  	a.m[0][0]+b.m[0][0], a.m[0][1]+b.m[0][1], a.m[0][2]+b.m[0][2], a.m[0][3]+b.m[0][3], 
  	a.m[1][0]+b.m[1][0], a.m[1][1]+b.m[1][1], a.m[1][2]+b.m[1][2], a.m[1][3]+b.m[1][3], 
  	a.m[2][0]+b.m[2][0], a.m[2][1]+b.m[2][1], a.m[2][2]+b.m[2][2], a.m[2][3]+b.m[2][3], 
  	a.m[3][0]+b.m[3][0], a.m[3][1]+b.m[3][1], a.m[3][2]+b.m[3][2], a.m[3][3]+b.m[3][3]);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movsd (%rax), %xmm0
movq 0x50(%rsp), %rax
addsd (%rax), %xmm0
movq 0x58(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x50(%rsp), %rax
addsd 0x8(%rax), %xmm1
movq 0x58(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x50(%rsp), %rax
addsd 0x10(%rax), %xmm2
movq 0x58(%rsp), %rax
movsd 0x18(%rax), %xmm3
movq 0x50(%rsp), %rax
addsd 0x18(%rax), %xmm3
movq 0x58(%rsp), %rax
movsd 0x20(%rax), %xmm4
movq 0x50(%rsp), %rax
addsd 0x20(%rax), %xmm4
movq 0x58(%rsp), %rax
movsd 0x28(%rax), %xmm5
movq 0x50(%rsp), %rax
addsd 0x28(%rax), %xmm5
movq 0x58(%rsp), %rax
movsd 0x30(%rax), %xmm6
movq 0x50(%rsp), %rax
addsd 0x30(%rax), %xmm6
movq 0x58(%rsp), %rax
movsd 0x38(%rax), %xmm7
movq 0x50(%rsp), %rax
addsd 0x38(%rax), %xmm7
movq 0x58(%rsp), %rax
movsd 0x40(%rax), %xmm15
movq 0x50(%rsp), %rax
addsd 0x40(%rax), %xmm15
movq 0x58(%rsp), %rax
movsd 0x48(%rax), %xmm14
movq 0x50(%rsp), %rax
addsd 0x48(%rax), %xmm14
movq 0x58(%rsp), %rax
movsd 0x50(%rax), %xmm13
movq 0x50(%rsp), %rax
addsd 0x50(%rax), %xmm13
movq 0x58(%rsp), %rax
movsd 0x58(%rax), %xmm12
movq 0x50(%rsp), %rax
addsd 0x58(%rax), %xmm12
movq 0x58(%rsp), %rax
movsd 0x60(%rax), %xmm11
movq 0x50(%rsp), %rax
addsd 0x60(%rax), %xmm11
movq 0x58(%rsp), %rax
movsd 0x68(%rax), %xmm10
movq 0x50(%rsp), %rax
addsd 0x68(%rax), %xmm10
movq 0x58(%rsp), %rax
movsd 0x70(%rax), %xmm9
movq 0x50(%rsp), %rax
addsd 0x70(%rax), %xmm9
movq 0x58(%rsp), %rax
movsd 0x78(%rax), %xmm8
movq 0x50(%rsp), %rax
addsd 0x78(%rax), %xmm8
movsd %xmm15, (%rsp)
movsd %xmm14, 0x8(%rsp)
movsd %xmm13, 0x10(%rsp)
movsd %xmm12, 0x18(%rsp)
movsd %xmm11, 0x20(%rsp)
movsd %xmm10, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x48(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator*(gaps::R4Matrix const&, double)
R4Matrix 
operator*(const R4Matrix& a, RNScalar b)
{
    // Scale matrix
    return R4Matrix(
  	a.m[0][0]*b, a.m[0][1]*b, a.m[0][2]*b, a.m[0][3]*b, 
  	a.m[1][0]*b, a.m[1][1]*b, a.m[1][2]*b, a.m[1][3]*b, 
  	a.m[2][0]*b, a.m[2][1]*b, a.m[2][2]*b, a.m[2][3]*b, 
  	a.m[3][0]*b, a.m[3][1]*b, a.m[3][2]*b, a.m[3][3]*b);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0x58(%rsp), %rax
movsd (%rax), %xmm0
mulsd 0x50(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd 0x8(%rax), %xmm1
mulsd 0x50(%rsp), %xmm1
movq 0x58(%rsp), %rax
movsd 0x10(%rax), %xmm2
mulsd 0x50(%rsp), %xmm2
movq 0x58(%rsp), %rax
movsd 0x18(%rax), %xmm3
mulsd 0x50(%rsp), %xmm3
movq 0x58(%rsp), %rax
movsd 0x20(%rax), %xmm4
mulsd 0x50(%rsp), %xmm4
movq 0x58(%rsp), %rax
movsd 0x28(%rax), %xmm5
mulsd 0x50(%rsp), %xmm5
movq 0x58(%rsp), %rax
movsd 0x30(%rax), %xmm6
mulsd 0x50(%rsp), %xmm6
movq 0x58(%rsp), %rax
movsd 0x38(%rax), %xmm7
mulsd 0x50(%rsp), %xmm7
movq 0x58(%rsp), %rax
movsd 0x40(%rax), %xmm15
mulsd 0x50(%rsp), %xmm15
movq 0x58(%rsp), %rax
movsd 0x48(%rax), %xmm14
mulsd 0x50(%rsp), %xmm14
movq 0x58(%rsp), %rax
movsd 0x50(%rax), %xmm13
mulsd 0x50(%rsp), %xmm13
movq 0x58(%rsp), %rax
movsd 0x58(%rax), %xmm12
mulsd 0x50(%rsp), %xmm12
movq 0x58(%rsp), %rax
movsd 0x60(%rax), %xmm11
mulsd 0x50(%rsp), %xmm11
movq 0x58(%rsp), %rax
movsd 0x68(%rax), %xmm10
mulsd 0x50(%rsp), %xmm10
movq 0x58(%rsp), %rax
movsd 0x70(%rax), %xmm9
mulsd 0x50(%rsp), %xmm9
movq 0x58(%rsp), %rax
movsd 0x78(%rax), %xmm8
mulsd 0x50(%rsp), %xmm8
movsd %xmm15, (%rsp)
movsd %xmm14, 0x8(%rsp)
movsd %xmm13, 0x10(%rsp)
movsd %xmm12, 0x18(%rsp)
movsd %xmm11, 0x20(%rsp)
movsd %xmm10, 0x28(%rsp)
movsd %xmm9, 0x30(%rsp)
movsd %xmm8, 0x38(%rsp)
callq 0x51c60
movq 0x48(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)