LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe860
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movaps 0x7459c(%rip), %xmm1    # 0xa2020
xorps %xmm0, %xmm1
leaq 0x98(%rsp), %rdx
movsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rdx)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movsd %xmm0, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdx)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x28(%rdx)
movups %xmm0, 0x30(%rdx)
movlps %xmm1, 0x40(%rdx)
movq %rax, 0x48(%rdx)
movsd %xmm2, 0x50(%rdx)
movups %xmm0, 0x58(%rdx)
movups %xmm0, 0x68(%rdx)
movq %rcx, 0x78(%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e5ab
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movaps 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movaps 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movaps 0x60(%r14), %xmm0
movups %xmm0, 0x60(%rbx)
movaps 0x70(%r14), %xmm0
movups %xmm0, 0x70(%rbx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xe860
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0xe0f0
movaps 0x744ba(%rip), %xmm1    # 0xa2020
xorps %xmm0, %xmm1
leaq 0x98(%rsp), %rdx
movsd 0x8(%rsp), %xmm2
movsd %xmm2, (%rdx)
movlps %xmm1, 0x8(%rdx)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdx)
movsd %xmm0, 0x20(%rdx)
movsd %xmm2, 0x28(%rdx)
movups %xmm1, 0x30(%rdx)
movups %xmm1, 0x40(%rdx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x50(%rdx)
movups %xmm1, 0x58(%rdx)
movups %xmm1, 0x68(%rdx)
movq %rax, 0x78(%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e5ab
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movaps 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movaps 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movaps 0x60(%r14), %xmm0
movups %xmm0, 0x60(%rbx)
movaps 0x70(%r14), %xmm0
movups %xmm0, 0x70(%rbx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r15
movq %rdi, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x80(%rsp), %r14
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movq %rax, 0x28(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movq %rax, 0x50(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movq %rax, 0x78(%r14)
movsd 0x10(%rsi), %xmm0
movq %r14, %rdi
callq 0x2db38
movsd 0x8(%r15), %xmm0
movq %r14, %rdi
callq 0x2da56
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x2d97a
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e5ab
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r15), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x30(%r15), %xmm0
movups %xmm0, 0x30(%rbx)
movaps 0x40(%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movaps 0x50(%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movaps 0x60(%r15), %xmm0
movups %xmm0, 0x60(%rbx)
movaps 0x70(%r15), %xmm0
movups %xmm0, 0x70(%rbx)
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::R4Matrix::Rotate(gaps::R3Vector const&, double)
void R4Matrix:: 
Rotate(const R3Vector& axis, RNAngle radians)
{
    // rotate matrix for arbitrary axis counterclockwise
    // From Graphics Gems I, p. 466
    RNCoord x = axis.X();
    RNCoord y = axis.Y();
    RNCoord z = axis.Z();
    RNScalar c = cos(radians);
    RNScalar s = sin(radians);
    RNScalar t = 1.0 - c;
    R4Matrix rotation(
        t*x*x + c, t*x*y - s*z, t*x*z + s*y, 0.0,
        t*x*y + s*z, t*y*y + c, t*y*z - s*x, 0.0,
        t*x*z - s*y, t*y*z + s*x, t*z*z + c, 0.0,
        0.0, 0.0, 0.0, 1.0);
    *this *= rotation;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movaps %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, %xmm0
callq 0xe860
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe0f0
movsd 0x742d2(%rip), %xmm6    # 0xa2038
movapd 0x10(%rsp), %xmm4
subsd %xmm4, %xmm6
movapd 0x20(%rsp), %xmm8
movapd %xmm8, %xmm2
mulsd %xmm0, %xmm2
movapd 0x74298(%rip), %xmm1    # 0xa2020
movapd %xmm2, %xmm3
xorpd %xmm1, %xmm3
movapd %xmm4, %xmm5
movapd %xmm4, %xmm11
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
movapd 0x30(%rsp), %xmm4
movapd %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
movapd %xmm3, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm4, %xmm0
movapd %xmm4, %xmm12
movapd %xmm8, %xmm4
mulsd %xmm6, %xmm4
mulsd %xmm8, %xmm4
movapd %xmm8, %xmm10
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm12, %xmm6
movapd %xmm6, %xmm8
mulsd %xmm10, %xmm8
mulpd %xmm6, %xmm3
movapd %xmm6, %xmm9
unpckhpd %xmm6, %xmm9            # xmm9 = xmm9[1],xmm6[1]
mulsd %xmm10, %xmm9
unpcklpd %xmm10, %xmm10          # xmm10 = xmm10[0,0]
mulpd %xmm6, %xmm10
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm12, %xmm6
xorpd %xmm7, %xmm1
addsd %xmm11, %xmm4
xorl %eax, %eax
leaq 0x40(%rsp), %rdx
movq %rax, 0x18(%rdx)
addpd %xmm5, %xmm6
addsd %xmm7, %xmm8
unpcklpd %xmm11, %xmm2           # xmm2 = xmm2[0],xmm11[0]
addpd %xmm2, %xmm3
subsd %xmm0, %xmm9
movapd %xmm6, (%rdx)
movsd %xmm8, 0x10(%rdx)
movapd %xmm3, 0x20(%rdx)
movsd %xmm9, 0x30(%rdx)
movq %rax, 0x38(%rdx)
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd %xmm1, %xmm10
movapd %xmm10, 0x40(%rdx)
movsd %xmm4, 0x50(%rdx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x58(%rdx)
movupd %xmm0, 0x68(%rdx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rdx)
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e5ab
movaps (%r14), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movaps 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movaps 0x40(%r14), %xmm0
movups %xmm0, 0x40(%rbx)
movaps 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movaps 0x60(%r14), %xmm0
movups %xmm0, 0x60(%rbx)
movaps 0x70(%r14), %xmm0
movups %xmm0, 0x70(%rbx)
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4c77b
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3de12
movq %r12, %rdi
callq 0x3d7e0
movq %r15, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x2dd1e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movsd (%rsi), %xmm0
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
addsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rsi), %xmm0
addsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rsi), %xmm0
addsd 0x28(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rsi), %xmm0
addsd 0x30(%rdi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rsi), %xmm0
addsd 0x38(%rdi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x40(%rsi), %xmm0
addsd 0x40(%rdi), %xmm0
movsd %xmm0, 0x40(%rdi)
movsd 0x48(%rsi), %xmm0
addsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x50(%rsi), %xmm0
addsd 0x50(%rdi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rsi), %xmm0
addsd 0x58(%rdi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rsi), %xmm0
addsd 0x60(%rdi), %xmm0
movsd %xmm0, 0x60(%rdi)
movsd 0x68(%rsi), %xmm0
addsd 0x68(%rdi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x70(%rsi), %xmm0
addsd 0x70(%rdi), %xmm0
movsd %xmm0, 0x70(%rdi)
movsd 0x78(%rsi), %xmm0
addsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x78(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
subsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
subsd 0x8(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x10(%rdi), %xmm0
subsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rdi), %xmm0
subsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rdi), %xmm0
subsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rdi), %xmm0
subsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rdi), %xmm0
subsd 0x30(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rdi), %xmm0
subsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x40(%rdi), %xmm0
subsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%rdi)
movsd 0x48(%rdi), %xmm0
subsd 0x48(%rsi), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x50(%rdi), %xmm0
subsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rdi), %xmm0
subsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rdi), %xmm0
subsd 0x60(%rsi), %xmm0
movsd %xmm0, 0x60(%rdi)
movsd 0x68(%rdi), %xmm0
subsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x70(%rdi), %xmm0
subsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x70(%rdi)
movsd 0x78(%rdi), %xmm0
subsd 0x78(%rsi), %xmm0
movsd %xmm0, 0x78(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rax
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd (%rdi), %xmm1
movupd 0x10(%rdi), %xmm2
movupd 0x20(%rdi), %xmm3
movupd 0x30(%rdi), %xmm4
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
mulpd %xmm0, %xmm2
movupd %xmm2, 0x10(%rdi)
mulpd %xmm0, %xmm3
movupd %xmm3, 0x20(%rdi)
mulpd %xmm0, %xmm4
movupd %xmm4, 0x30(%rdi)
movupd 0x40(%rdi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x40(%rdi)
movupd 0x50(%rdi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x50(%rdi)
movupd 0x60(%rdi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x60(%rdi)
movupd 0x70(%rdi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator-(gaps::R4Matrix const&)
R4Matrix 
operator-(const R4Matrix& a)
{
    // Negate matrix
    return R4Matrix(
   	-a.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]);
}

// Assembly:
movq %rdi, %rax
movups (%rsi), %xmm0
movaps 0x73ce7(%rip), %xmm1    # 0xa2020
xorps %xmm1, %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x20(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x30(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x30(%rdi)
movups 0x40(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x40(%rdi)
movups 0x50(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x50(%rdi)
movups 0x60(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x60(%rdi)
movups 0x70(%rsi), %xmm0
xorps %xmm1, %xmm0
movups %xmm0, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movupd (%rsi), %xmm0
movupd (%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movupd 0x10(%rsi), %xmm0
movupd 0x10(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd 0x20(%rsi), %xmm0
movupd 0x20(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x20(%rdi)
movupd 0x30(%rsi), %xmm0
movupd 0x30(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x30(%rdi)
movupd 0x40(%rsi), %xmm0
movupd 0x40(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x40(%rdi)
movupd 0x50(%rsi), %xmm0
movupd 0x50(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x50(%rdi)
movupd 0x60(%rsi), %xmm0
movupd 0x60(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x60(%rdi)
movupd 0x70(%rsi), %xmm0
movupd 0x70(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movupd (%rsi), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movupd 0x10(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd 0x20(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x20(%rdi)
movupd 0x30(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x30(%rdi)
movupd 0x40(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x40(%rdi)
movupd 0x50(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x50(%rdi)
movupd 0x60(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x60(%rdi)
movupd 0x70(%rsi), %xmm1
mulpd %xmm0, %xmm1
movupd %xmm1, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator*(gaps::R4Matrix const&, gaps::R4Matrix const&)
R4Matrix 
operator*(const R4Matrix& a, const R4Matrix& b) 
{
    R4Matrix result;
    int r, c;

    // Multiply matrix
    for (r=0; r<4; r++)
	for (c=0; c<4; c++)
	    result.m[r][c] = a.m[r][0] * b.m[0][c] + a.m[r][1] * b.m[1][c] +
		             a.m[r][2] * b.m[2][c] + a.m[r][3] * b.m[3][c];

    // Return result
    return result;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
movq %rcx, %r8
shlq $0x5, %r8
movsd (%rsi,%r8), %xmm0
movsd 0x8(%rsi,%r8), %xmm1
movsd 0x10(%rsi,%r8), %xmm2
movsd 0x18(%rsi,%r8), %xmm3
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
xorl %r8d, %r8d
movupd (%rdx,%r8,8), %xmm4
mulpd %xmm0, %xmm4
movupd 0x20(%rdx,%r8,8), %xmm5
mulpd %xmm1, %xmm5
addpd %xmm4, %xmm5
movupd 0x40(%rdx,%r8,8), %xmm4
mulpd %xmm2, %xmm4
addpd %xmm5, %xmm4
movupd 0x60(%rdx,%r8,8), %xmm5
mulpd %xmm3, %xmm5
addpd %xmm4, %xmm5
movupd %xmm5, (%rdi,%r8,8)
addq $0x2, %r8
cmpq $0x4, %r8
jne 0x2e5e5
incq %rcx
addq $0x20, %rdi
cmpq $0x4, %rcx
jne 0x2e5b0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator*(gaps::R4Matrix const&, gaps::R3Vector const&)
R3Vector
operator*(const R4Matrix& a, const R3Vector& v)
{
    // Multiply matrix by vector
    RNCoord x = a.m[0][0] * v.X() + a.m[0][1] * v.Y() + a.m[0][2] * v.Z();
    RNCoord y = a.m[1][0] * v.X() + a.m[1][1] * v.Y() + a.m[1][2] * v.Z();
    RNCoord z = a.m[2][0] * v.X() + a.m[2][1] * v.Y() + a.m[2][2] * v.Z();
    return R3Vector(x, y, z);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm4
movsd 0x8(%rsi), %xmm0
mulsd %xmm4, %xmm0
movsd (%rsi), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdx), %xmm2
movsd 0x10(%rsi), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x28(%rsi), %xmm1
mulsd %xmm4, %xmm1
movsd 0x20(%rsi), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x30(%rsi), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x48(%rsi), %xmm4
mulsd 0x40(%rsi), %xmm3
addsd %xmm4, %xmm3
mulsd 0x50(%rsi), %xmm2
addsd %xmm3, %xmm2
callq 0x3d4be
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R4Matrix.cpp
// Function: gaps::operator*(gaps::R4Matrix const&, gaps::R3Point const&)
R3Point 
operator*(const R4Matrix& a, const R3Point& p)
{
    // Multiply matrix by point
    RNCoord x = a.m[0][0] * p.X() + a.m[0][1] * p.Y() + a.m[0][2] * p.Z() + a.m[0][3];
    RNCoord y = a.m[1][0] * p.X() + a.m[1][1] * p.Y() + a.m[1][2] * p.Z() + a.m[1][3];
    RNCoord z = a.m[2][0] * p.X() + a.m[2][1] * p.Y() + a.m[2][2] * p.Z() + a.m[2][3];
    return R3Point(x, y, z);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm4
movsd 0x8(%rsi), %xmm0
mulsd %xmm4, %xmm0
movsd (%rsi), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdx), %xmm2
movsd 0x10(%rsi), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x18(%rsi), %xmm0
movsd 0x28(%rsi), %xmm1
mulsd %xmm4, %xmm1
movsd 0x20(%rsi), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x30(%rsi), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
addsd 0x38(%rsi), %xmm1
mulsd 0x48(%rsi), %xmm4
mulsd 0x40(%rsi), %xmm3
mulsd 0x50(%rsi), %xmm2
addsd %xmm4, %xmm3
addsd %xmm3, %xmm2
addsd 0x58(%rsi), %xmm2
callq 0x3ca26
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::R3Grid(int, int, int)
R3Grid::
R3Grid(int xresolution, int yresolution, int zresolution)
{
  // Set grid resolution
  grid_resolution[0] = xresolution;
  grid_resolution[1] = yresolution;
  grid_resolution[2] = zresolution;
  grid_row_size = xresolution;
  grid_sheet_size = grid_row_size * yresolution;
  grid_size = grid_sheet_size * zresolution;

  // Allocate grid values
  if (grid_size == 0) grid_values = NULL;
  else grid_values = new RNScalar [ grid_size ];
  assert(!grid_size || grid_values);

  // Set all values to zero
  for (int i = 0; i < grid_size; i++) grid_values[i] = 0;

  // Set transformations
  grid_to_world_transform = R3identity_affine;
  world_to_grid_transform = R3identity_affine;
  world_to_grid_scale_factor = 1.0;
  grid_to_world_scale_factor = 1.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0x2a1e0
leaq 0x110(%rbx), %r14
movq %r14, %rdi
callq 0x2a1e0
movl %r12d, 0x238(%rbx)
movl %ebp, 0x23c(%rbx)
movl %r15d, 0x240(%rbx)
movl %r12d, 0x244(%rbx)
imull %r12d, %ebp
movl %ebp, 0x248(%rbx)
imull %r15d, %ebp
movl %ebp, 0x24c(%rbx)
testl %ebp, %ebp
je 0x2e7c1
movslq %ebp, %rax
shlq $0x3, %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
jmp 0x2e7c3
xorl %eax, %eax
movq %rax, 0x230(%rbx)
testl %ebp, %ebp
jle 0x2e7e2
movq 0x230(%rbx), %rdi
movl %ebp, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xe260
leaq 0x8(%rbx), %rdi
leaq 0xb7813(%rip), %r12     # 0xe6000
leaq 0x8(%r12), %r15
movq %r15, %rsi
callq 0x2e19e
movl $0x88, %esi
leaq (%rbx,%rsi), %rdi
addq 0xb67d6(%rip), %rsi     # 0xe4fe0
callq 0x2e19e
movq 0x108(%r12), %rax
movq %rax, 0x108(%rbx)
leaq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0x2e19e
leaq 0x198(%rbx), %rdi
movl $0x88, %esi
addq 0xb67a0(%rip), %rsi     # 0xe4fe0
callq 0x2e19e
movq 0x108(%r12), %rax
movq %rax, 0x218(%rbx)
movaps 0x74705(%rip), %xmm0    # 0xa2f60
movups %xmm0, 0x220(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x2e87b
movq %rax, %r15
movq %r14, %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0x2a27c
movq %r15, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::R3Grid(int, int, int, gaps::R3Box const&)
R3Grid::
R3Grid(int xresolution, int yresolution, int zresolution, const R3Box& bbox)
{
  // Set grid resolution
  grid_resolution[0] = xresolution;
  grid_resolution[1] = yresolution;
  grid_resolution[2] = zresolution;
  grid_row_size = xresolution;
  grid_sheet_size = grid_row_size * yresolution;
  grid_size = grid_sheet_size * zresolution;

  // Allocate grid values
  if (grid_size == 0) grid_values = NULL;
  else grid_values = new RNScalar [ grid_size ];
  assert(!grid_size || grid_values);

  // Set all values to zero
  for (int i = 0; i < grid_size; i++) grid_values[i] = 0;

  // Set transformations
  SetWorldToGridTransformation(bbox);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
callq 0x2a1e0
leaq 0x110(%rbx), %r14
movq %r14, %rdi
callq 0x2a1e0
movl %r13d, 0x238(%rbx)
movl %ebp, 0x23c(%rbx)
movl %r12d, 0x240(%rbx)
movl %r13d, 0x244(%rbx)
imull %r13d, %ebp
movl %ebp, 0x248(%rbx)
imull %r12d, %ebp
movl %ebp, 0x24c(%rbx)
testl %ebp, %ebp
je 0x2e907
movslq %ebp, %rax
shlq $0x3, %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
jmp 0x2e909
xorl %eax, %eax
movq %rax, 0x230(%rbx)
testl %ebp, %ebp
jle 0x2e928
movq 0x230(%rbx), %rdi
movl %ebp, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xe260
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e962
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x2e952
movq %rax, %r15
movq %r14, %rdi
callq 0x2a27c
movq %rbx, %rdi
callq 0x2a27c
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::operator=(gaps::R3Grid const&)
R3Grid& R3Grid::
operator=(const R3Grid& grid) 
{
  // Delete old grid values
  if (grid_values) {
    if (grid_size != grid.grid_size) {
      delete [] grid_values;
      grid_values = NULL;
    }
  }

  // Allocate new grid values
  if (!grid_values && (grid.grid_size > 0)) {
    grid_values = new RNScalar [ grid.grid_size ];
    assert(grid_values);
  }

  // Copy grid resolution
  grid_resolution[0] = grid.grid_resolution[0];
  grid_resolution[1] = grid.grid_resolution[1];
  grid_resolution[2] = grid.grid_resolution[2];
  grid_row_size = grid.grid_row_size;
  grid_sheet_size = grid.grid_sheet_size;
  grid_size = grid.grid_size;

  // Copy grid values
  for (int i = 0; i < grid_size; i++) {
    grid_values[i] = grid.grid_values[i];
  }

  // Copy transforms
  grid_to_world_transform = grid.grid_to_world_transform;
  world_to_grid_transform = grid.world_to_grid_transform;
  world_to_grid_scale_factor = grid.world_to_grid_scale_factor;
  grid_to_world_scale_factor = grid.grid_to_world_scale_factor;

  // Return this
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x230(%rdi), %rdi
testq %rdi, %rdi
je 0x2f01b
movl 0x24c(%rbx), %eax
cmpl 0x24c(%r14), %eax
je 0x2f01b
callq 0xe5b0
movq $0x0, 0x230(%rbx)
cmpq $0x0, 0x230(%rbx)
jne 0x2f041
movslq 0x24c(%r14), %rdi
testq %rdi, %rdi
jle 0x2f041
shlq $0x3, %rdi
callq 0xe030
movq %rax, 0x230(%rbx)
movl 0x238(%r14), %eax
movl %eax, 0x238(%rbx)
movl 0x23c(%r14), %eax
movl %eax, 0x23c(%rbx)
movl 0x240(%r14), %eax
movl %eax, 0x240(%rbx)
movq 0x244(%r14), %rax
movq %rax, 0x244(%rbx)
movslq 0x24c(%r14), %rax
movl %eax, 0x24c(%rbx)
testq %rax, %rax
jle 0x2f0aa
movq 0x230(%r14), %rcx
movq 0x230(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x2f098
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x2e19e
movl $0x88, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x2e19e
movq 0x108(%r14), %rax
movq %rax, 0x108(%rbx)
movl $0x118, %esi            # imm = 0x118
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x2e19e
movl $0x198, %esi            # imm = 0x198
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x2e19e
movq 0x218(%r14), %rax
movq %rax, 0x218(%rbx)
movups 0x220(%r14), %xmm0
movups %xmm0, 0x220(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Percentile(double) const
RNScalar R3Grid::
Percentile(RNScalar percentile) const
{
  // Return value at given percentile 
  if (grid_size == 0) return 0.0;
  RNScalar *tmp_values = new RNScalar [ grid_size ];
  for (int i = 0; i < grid_size; i++) tmp_values[i] = grid_values[i];
  qsort(tmp_values, grid_size, sizeof(RNScalar), RNCompareScalars);
  int percentile_index = percentile * grid_size;
  RNScalar value = tmp_values[percentile_index];
  delete [] tmp_values;
  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movslq 0x24c(%rdi), %r14
testq %r14, %r14
je 0x2f2bb
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
leaq (,%r14,8), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
movq %rax, %r15
testl %r14d, %r14d
jle 0x2f271
movq 0x230(%rbx), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x2f25e
leaq 0x433f1(%rip), %rcx     # 0x72669
movl $0x8, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xe880
xorps %xmm0, %xmm0
cvtsi2sdl 0x24c(%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
cltq
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xe5b0
movsd 0x8(%rsp), %xmm0
jmp 0x2f2be
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Range() const
RNInterval R3Grid::
Range(void) const
{
  // Find smallest and largest values
  RNScalar minimum = FLT_MAX;
  RNScalar maximum = -FLT_MAX;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (*grid_valuep < minimum) minimum = *grid_valuep;
    if (*grid_valuep > maximum) maximum = *grid_valuep;
    grid_valuep++;
  }
  return RNInterval(minimum, maximum);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x24c(%rsi), %eax
testl %eax, %eax
jle 0x2f311
movq 0x230(%rsi), %rcx
movsd 0x72d5b(%rip), %xmm3    # 0xa2040
movsd 0x739d3(%rip), %xmm2    # 0xa2cc0
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
movapd %xmm1, %xmm0
minsd %xmm3, %xmm0
maxsd %xmm2, %xmm1
incq %rdx
movapd %xmm1, %xmm2
movapd %xmm0, %xmm3
cmpl %edx, %eax
jne 0x2f2ef
jmp 0x2f321
movsd 0x739a7(%rip), %xmm1    # 0xa2cc0
movsd 0x72d1f(%rip), %xmm0    # 0xa2040
movq %rbx, %rdi
callq 0x72556
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L1Norm() const
RNScalar R3Grid::
L1Norm(void) const
{
  // Return L1 norm of grid
  RNScalar sum = 0.0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    sum += *(grid_valuep++);
  return sum;
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x2f352
movq 0x230(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
cmpl %edx, %eax
jne 0x2f345
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L2NormSquared() const
RNScalar R3Grid::
L2NormSquared(void) const
{
  // Return L2 norm of grid
  RNScalar sum = 0.0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = *(grid_valuep++);
    sum += value * value;
  }
  return sum;
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x2f382
movq 0x230(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpl %edx, %eax
jne 0x2f36d
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Cardinality() const
int R3Grid::
Cardinality(void) const
{
  // Return number of non-zero grid values
  int count = 0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = *(grid_valuep++);
    if (value == 0.0) continue;
    count++;
  }
  return count;
}

// Assembly:
movl 0x24c(%rdi), %ecx
testl %ecx, %ecx
jle 0x2f3b8
movq 0x230(%rdi), %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rdx,%rsi,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rdi
subl %edi, %eax
incq %rsi
cmpl %esi, %ecx
jne 0x2f39f
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::GridCentroid() const
R3Point R3Grid::
GridCentroid(void) const
{
  // Compute weighted sum
  RNScalar total_value = 0;
  R3Point centroid(0,0,0);
  RNScalar *grid_valuesp = grid_values;
  for (int k = 0; k < grid_resolution[2]; k++) {
    for (int j = 0; j < grid_resolution[1]; j++) {
      for (int i = 0; i < grid_resolution[0]; i++) {
        R3Vector position(i, j, k);
        RNScalar value = *(grid_valuesp++);
        centroid += value * position;
        total_value += value;
      }
    }
  }

  // Divide by total value
  if (total_value > 0) centroid /= total_value;

  // Return centroid
  return centroid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3ca26
cmpl $0x0, 0x240(%r14)
xorpd %xmm0, %xmm0
jle 0x2faef
movq 0x230(%r14), %r13
xorl %eax, %eax
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r12
cmpl $0x0, 0x23c(%r14)
movl %eax, (%rsp)
jle 0x2fadd
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
xorl %eax, %eax
movsd %xmm1, 0x8(%rsp)
cmpl $0x0, 0x238(%r14)
movl %eax, 0x4(%rsp)
jle 0x2faca
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd %xmm2, 0x10(%rsp)
xorl %ebp, %ebp
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %r15, %rdi
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x3d4be
movsd (%r13), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x8, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x3de8e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ce0e
movsd 0x20(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
incl %ebp
cmpl 0x238(%r14), %ebp
jl 0x2fa6c
movl 0x4(%rsp), %eax
incl %eax
cmpl 0x23c(%r14), %eax
jl 0x2fa4f
movl (%rsp), %eax
incl %eax
cmpl 0x240(%r14), %eax
jl 0x2fa2f
ucomisd 0x726f1(%rip), %xmm0    # 0xa21e8
jbe 0x2fb01
movq %rbx, %rdi
callq 0x3d3e4
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Abs()
void R3Grid::
Abs(void) 
{
  // Take the absolute value of every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = fabs(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x302b7
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movaps 0x71fcc(%rip), %xmm0    # 0xa2270
movsd (%rcx,%rdx,8), %xmm1
andps %xmm0, %xmm1
movlps %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x302a4
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Sqrt()
void R3Grid::
Sqrt(void) 
{
  // Take sqrt of every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = sqrt(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
cmpl $0x0, 0x24c(%rdi)
jle 0x30309
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x230(%rdi), %r14
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movsd (%r14,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x302e9
sqrtsd %xmm0, %xmm0
jmp 0x302f2
callq 0xe340
xorpd %xmm1, %xmm1
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpl 0x24c(%rbx), %r15d
jl 0x302d7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Square()
void R3Grid::
Square(void) 
{
  // Square every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = (*grid_valuep) * (*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x30332
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x3031d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Negate()
void R3Grid::
Negate(void) 
{
  // Negate every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = -(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x30361
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movaps 0x71cd2(%rip), %xmm0    # 0xa2020
movsd (%rcx,%rdx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x3034e
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Invert()
void R3Grid::
Invert(void) 
{
  // Invert every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (RNIsNotZero(*grid_valuep, 1.0E-20)) *grid_valuep = 1.0/(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x303b4
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movapd 0x71ef3(%rip), %xmm0    # 0xa2270
movsd 0x72c1b(%rip), %xmm1    # 0xa2fa0
movsd 0x71cab(%rip), %xmm2    # 0xa2038
movsd (%rcx,%rdx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jbe 0x303ad
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x3038d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Transpose()
void R3Grid::
Transpose(void)
{
  // Transpose values
  R3Grid copy(*this);
  int xres = XResolution();
  int yres = YResolution();
  int zres = ZResolution();
  for (int iz = 0; iz < zres; iz++) {
    for (int iy = 0; iy < yres; iy++) {
      for (int ix = 0; ix < xres; ix++) {
        RNScalar value = copy.GridValue(xres-1 - ix, yres-1 - iy, zres-1 - iz);
        SetGridValue(ix, iy, iz, value);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2f120
movl 0x240(%rbx), %eax
movq %rax, 0x10(%rsp)
testl %eax, %eax
jle 0x3049e
movl 0x238(%rbx), %esi
movl 0x23c(%rbx), %edx
leal -0x1(%rsi), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
leal -0x1(%rax), %edi
leal -0x1(%rdx), %eax
movl %eax, 0x8(%rsp)
xorl %r9d, %r9d
testl %edx, %edx
jle 0x3048e
movq 0x248(%rsp), %r10
movl 0x25c(%rsp), %r11d
movq 0x230(%rbx), %r14
movl 0x244(%rbx), %ebp
movl 0x260(%rsp), %eax
imull %edi, %eax
addl 0xc(%rsp), %eax
movl 0x8(%rsp), %r15d
imull %r11d, %r15d
addl %eax, %r15d
movl 0x248(%rbx), %r12d
imull %r9d, %r12d
xorl %r13d, %r13d
movq %rsi, %rcx
movl %r12d, %r8d
movl %r15d, %eax
testl %esi, %esi
jle 0x30480
cltq
movsd (%r10,%rax,8), %xmm0
movslq %r8d, %r8
movsd %xmm0, (%r14,%r8,8)
decl %eax
incl %r8d
decq %rcx
jne 0x30465
incl %r13d
subl %r11d, %r15d
addl %ebp, %r12d
cmpl %edx, %r13d
jne 0x30458
incl %r9d
decl %edi
cmpl 0x10(%rsp), %r9d
jne 0x3040f
leaq 0x18(%rsp), %rdi
callq 0x2f17c
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Divide(double)
void R3Grid::
Divide(RNScalar value) 
{
  // Just checking
  if (RNIsZero(value, 1.0E-20)) return;

  // Multiply by recipricol
  Multiply(1.0 / value);
}

// Assembly:
movapd 0x71d1a(%rip), %xmm1    # 0xa2270
andpd %xmm0, %xmm1
movsd 0x72a3e(%rip), %xmm2    # 0xa2fa0
ucomisd %xmm1, %xmm2
jae 0x3059c
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x3059c
movsd 0x71abe(%rip), %xmm1    # 0xa2038
divsd %xmm0, %xmm1
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x30587
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Threshold(double, double, double)
void R3Grid::
Threshold(RNScalar threshold, RNScalar low, RNScalar high) 
{
  // Set grid value to low (high) if less/equal (greater) than threshold
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (*grid_valuep <= threshold) {
      if (low != R3_GRID_KEEP_VALUE) *grid_valuep = low;
    }
    else {
      if (high != R3_GRID_KEEP_VALUE) *grid_valuep = high;
    }
    grid_valuep++;
  }
}

// Assembly:
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x30be8
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movsd 0x723e9(%rip), %xmm3    # 0xa2fa8
ucomisd (%rcx,%rdx,8), %xmm0
jae 0x30bd0
ucomisd %xmm3, %xmm2
movapd %xmm2, %xmm4
jmp 0x30bd8
ucomisd %xmm3, %xmm1
movapd %xmm1, %xmm4
jne 0x30bdc
jnp 0x30be1
movsd %xmm4, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x30bbf
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Erode(double)
void R3Grid::
Erode(RNLength grid_distance) 
{
  // Keep only voxels at least distance from some zero voxel
  Threshold(1.0E-20, 1, 0);
  SquaredDistanceTransform();
  Threshold(grid_distance * grid_distance, 0, 1);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl 0x24c(%rdi), %eax
testl %eax, %eax
jle 0x30c35
movq 0x230(%rbx), %rcx
xorl %edx, %edx
movsd 0x7238d(%rip), %xmm0    # 0xa2fa0
movsd 0x7141d(%rip), %xmm1    # 0xa2038
movsd (%rcx,%rdx,8), %xmm2
cmpnlesd %xmm0, %xmm2
andnpd %xmm1, %xmm2
movlpd %xmm2, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x30c1b
movq %rbx, %rdi
callq 0x305f6
movl 0x24c(%rbx), %eax
testl %eax, %eax
movsd 0x8(%rsp), %xmm2
jle 0x30c7c
mulsd %xmm2, %xmm2
movq 0x230(%rbx), %rcx
xorl %edx, %edx
movsd 0x713d6(%rip), %xmm0    # 0xa2038
movsd (%rcx,%rdx,8), %xmm1
cmpnlesd %xmm2, %xmm1
andpd %xmm0, %xmm1
movlpd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x30c62
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::GradientMagnitude()
void R3Grid::
GradientMagnitude(void)
{
  // Compute magnitude of gradient
  R3Grid gx(*this); gx.Gradient(RN_X);
  R3Grid gy(*this); gy.Gradient(RN_Y);
  R3Grid gz(*this); gz.Gradient(RN_Z);
  for (int i = 0; i < grid_size; i++) {
    RNScalar x = gx.GridValue(i);
    RNScalar y = gy.GridValue(i);
    RNScalar z = gz.GridValue(i);
    grid_values[i] = sqrt(x*x + y*y + z*z);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x6f8, %rsp            # imm = 0x6F8
movq %rdi, %rbx
leaq 0x4a8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f120
leaq 0x716d9(%rip), %rsi     # 0xa30c0
movq %r14, %rdi
callq 0x31670
leaq 0x258(%rsp), %rdi
movq %rbx, %rsi
callq 0x2f120
leaq 0x7179a(%rip), %rsi     # 0xa31a0
leaq 0x258(%rsp), %rdi
callq 0x31670
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2f120
leaq 0x71859(%rip), %rsi     # 0xa3280
leaq 0x8(%rsp), %rdi
callq 0x31670
cmpl $0x0, 0x24c(%rbx)
jle 0x31ab0
xorl %r14d, %r14d
xorpd %xmm3, %xmm3
movq 0x6d8(%rsp), %rax
movsd (%rax,%r14,8), %xmm1
movq 0x488(%rsp), %rax
movsd (%rax,%r14,8), %xmm2
movq 0x238(%rsp), %rax
movsd (%rax,%r14,8), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x31a8b
sqrtsd %xmm0, %xmm0
jmp 0x31a94
callq 0xe340
xorpd %xmm3, %xmm3
movq 0x230(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movslq 0x24c(%rbx), %rax
cmpq %rax, %r14
jl 0x31a41
leaq 0x8(%rsp), %rdi
callq 0x2f17c
leaq 0x258(%rsp), %rdi
callq 0x2f17c
leaq 0x4a8(%rsp), %rdi
callq 0x2f17c
addq $0x6f8, %rsp            # imm = 0x6F8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f17c
jmp 0x31af3
jmp 0x31af0
movq %rax, %rbx
leaq 0x258(%rsp), %rdi
callq 0x2f17c
jmp 0x31b07
jmp 0x31b04
movq %rax, %rbx
leaq 0x4a8(%rsp), %rdi
callq 0x2f17c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::MaskNonMinima(double)
void R3Grid::
MaskNonMinima(RNLength grid_radius)
{
  // Create grid with local minima
  R3Grid copy(*this);
  copy.MinFilter(grid_radius);

  // Mask values that are not minima
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] > copy.grid_values[i]) grid_values[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f120
xorps %xmm1, %xmm1
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x31b5c
movslq 0x24c(%rbx), %rax
testq %rax, %rax
jle 0x31f91
movq 0x230(%rbx), %rcx
movq 0x238(%rsp), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
ucomisd (%rdx,%rsi,8), %xmm0
jbe 0x31f89
movq $0x0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x31f75
leaq 0x8(%rsp), %rdi
callq 0x2f17c
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f17c
movq %rbx, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::MaskNonMaxima(double)
void R3Grid::
MaskNonMaxima(RNLength grid_radius)
{
  // Create grid with local maxima
  R3Grid copy(*this);
  copy.MaxFilter(grid_radius);

  // Mask values that are not maxima
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] < copy.grid_values[i]) grid_values[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f120
movsd 0x70052(%rip), %xmm1    # 0xa2038
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x31b5c
movslq 0x24c(%rbx), %rax
testq %rax, %rax
jle 0x3202c
movq 0x230(%rbx), %rcx
movq 0x238(%rsp), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
ucomisd (%rcx,%rsi,8), %xmm0
jbe 0x32024
movq $0x0, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x32010
leaq 0x8(%rsp), %rdi
callq 0x2f17c
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f17c
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Clear(double)
void R3Grid::
Clear(RNScalar value) 
{
  // Set all grid values to value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    *(grid_valuep++) = value;
}

// Assembly:
movslq 0x24c(%rdi), %rdx
testq %rdx, %rdx
jle 0x32541
movq 0x230(%rdi), %rax
leal 0x1(%rdx), %ecx
andl $-0x2, %ecx
decq %rdx
movq %rdx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
xorl %edx, %edx
movdqa 0x6fdae(%rip), %xmm2    # 0xa2280
movdqa 0x6fdb6(%rip), %xmm3    # 0xa2290
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x32523
movsd %xmm0, (%rax,%rdx,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x32538
movsd %xmm0, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x324e2
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Substitute(double, double)
void R3Grid::
Substitute(RNScalar old_value, RNScalar new_value) 
{
  // Replace all instances of old_value with new_value
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] == old_value) {
      grid_values[i] = new_value;
    }
  }
}

// Assembly:
movslq 0x24c(%rdi), %rax
testq %rax, %rax
jle 0x32571
movq 0x230(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x32569
jp 0x32569
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x32557
retq