float rmsd2FromMandG(const float M[9], const float G_x, const float G_y,
                     const int numAtoms) {
  const int m = 3;
  float k00 = M[0 + 0 * m] + M[1 + 1 * m] + M[2 + 2 * m];
  float k01 = M[1 + 2 * m] - M[2 + 1 * m];
  float k02 = M[2 + 0 * m] - M[0 + 2 * m];
  float k03 = M[0 + 1 * m] - M[1 + 0 * m];
  float k11 = M[0 + 0 * m] - M[1 + 1 * m] - M[2 + 2 * m];
  float k12 = M[0 + 1 * m] + M[1 + 0 * m];
  float k13 = M[2 + 0 * m] + M[0 + 2 * m];
  float k22 = -M[0 + 0 * m] + M[1 + 1 * m] - M[2 + 2 * m];
  float k23 = M[1 + 2 * m] + M[2 + 1 * m];
  float k33 = -M[0 + 0 * m] - M[1 + 1 * m] + M[2 + 2 * m];
  float detM = 0.0f, detK = 0.0f;
  float C_2, C_1, C_0;
  float lambda = (G_x + G_y) / 2.0f;
  float rmsd2, ls_rmsd2;
  C_2 = 0.0f;
  for (int i = 0; i < m * m; i++) {
    C_2 += M[i] * M[i];
  }
  C_2 *= -2.0f;
  detM = M[0] * (M[4] * M[8] - M[5] * M[7]) +
         M[3] * (M[7] * M[2] - M[8] * M[1]) +
         M[6] * (M[1] * M[5] - M[2] * M[4]);
  detK = k01 * k01 * k23 * k23 - k22 * k33 * k01 * k01 +
         2 * k33 * k01 * k02 * k12 - 2 * k01 * k02 * k13 * k23 -
         2 * k01 * k03 * k12 * k23 + 2 * k22 * k01 * k03 * k13 +
         k02 * k02 * k13 * k13 - k11 * k33 * k02 * k02 -
         2 * k02 * k03 * k12 * k13 + 2 * k11 * k02 * k03 * k23 +
         k03 * k03 * k12 * k12 - k11 * k22 * k03 * k03 - k00 * k33 * k12 * k12 +
         2 * k00 * k12 * k13 * k23 - k00 * k22 * k13 * k13 -
         k00 * k11 * k23 * k23 + k00 * k11 * k22 * k33;
  C_1 = -8.0f * detM;
  C_0 = detK;
  lambda = DirectSolve(lambda, C_0, C_1, C_2);
  rmsd2 = (G_x + G_y - 2.0f * lambda) / numAtoms;
  ls_rmsd2 = 0.0f;
  if (rmsd2 > 0.0f)
    ls_rmsd2 = rmsd2;
  return ls_rmsd2;
}


x86 assembly (clang, -O0):
<rmsd2FromMandG>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x3,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x14(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x18(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x20(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x20(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0xc(%rbp),%xmm0
addss  -0x10(%rbp),%xmm0
movss  0xd8e(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x9,-0x64(%rbp)
jge    12ce <rmsd2FromMandG+0x1be>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    128a <rmsd2FromMandG+0x17a>
movss  0xd32(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm3
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm3
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm5
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm4
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm4
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulss  0x10(%rax),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x20(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x38(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xbfd(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xbd9(%rip),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xba8(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xb77(%rip),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0xb0e(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xadd(%rip),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xa4b(%rip),%xmm1
mulss  -0x1c(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x9b8(%rip),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x50(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x4c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1030 <DirectSolve@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0xc(%rbp),%xmm0
addss  -0x10(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    16dc <rmsd2FromMandG+0x5cc>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rmsd2FromMandG>:
push   %rbx
sub    $0x10,%rsp
mov    %esi,%ebx
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x4(%rsp)
movss  0x10(%rdi),%xmm10
movss  0x20(%rdi),%xmm4
movss  0x1c(%rdi),%xmm0
movss  0x14(%rdi),%xmm11
movss  0x8(%rdi),%xmm5
movss  0xc(%rdi),%xmm14
movss  (%rdi),%xmm3
movss  0x4(%rdi),%xmm15
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
xorps  %xmm2,%xmm2
addss  %xmm2,%xmm1
movaps %xmm15,%xmm2
mulss  %xmm15,%xmm2
addss  %xmm1,%xmm2
movaps %xmm5,%xmm1
movaps %xmm5,%xmm6
movss  %xmm5,0x8(%rsp)
mulss  %xmm5,%xmm1
addss  %xmm2,%xmm1
movaps %xmm14,%xmm2
mulss  %xmm14,%xmm2
addss  %xmm1,%xmm2
movaps %xmm10,%xmm8
mulss  %xmm10,%xmm8
addss  %xmm2,%xmm8
movaps %xmm0,%xmm1
movaps %xmm0,%xmm2
movaps %xmm0,%xmm5
mulss  %xmm11,%xmm5
movaps %xmm10,%xmm7
mulss  %xmm4,%xmm7
subss  %xmm5,%xmm7
movaps %xmm0,%xmm13
mulss  %xmm6,%xmm0
movaps 0xe3f(%rip),%xmm6
xorps  %xmm3,%xmm6
movaps %xmm10,%xmm9
subss  %xmm3,%xmm9
mulss  %xmm3,%xmm7
movaps %xmm3,%xmm12
subss  %xmm10,%xmm3
subss  %xmm4,%xmm9
subss  %xmm10,%xmm6
addss  %xmm4,%xmm6
addss  %xmm10,%xmm12
addss  %xmm4,%xmm12
subss  %xmm4,%xmm3
movss  %xmm4,(%rsp)
mulss  %xmm15,%xmm4
subss  %xmm4,%xmm0
mulss  %xmm14,%xmm0
movaps %xmm14,%xmm5
addss  %xmm15,%xmm14
subss  %xmm11,%xmm2
subss  %xmm15,%xmm5
addss  %xmm11,%xmm13
mulss  %xmm11,%xmm15
mulss  %xmm11,%xmm11
addss  %xmm8,%xmm11
movss  0x8(%rsp),%xmm8
mulss  %xmm8,%xmm10
subss  %xmm10,%xmm15
movaps %xmm8,%xmm10
movss  0x18(%rdi),%xmm4
subss  %xmm4,%xmm10
addss  %xmm4,%xmm8
mulss  %xmm4,%xmm15
mulss  %xmm4,%xmm4
addss  %xmm11,%xmm4
mulss  %xmm1,%xmm1
addss  %xmm4,%xmm1
movss  (%rsp),%xmm4
mulss  %xmm4,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%rsp)
movss  0x4(%rsp),%xmm11
addss  0xc(%rsp),%xmm11
movss  %xmm11,0x4(%rsp)
addss  %xmm0,%xmm7
addss  %xmm7,%xmm15
movaps %xmm6,%xmm0
mulss  %xmm9,%xmm0
mulss  %xmm2,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm13,%xmm1
mulss  %xmm13,%xmm1
subss  %xmm0,%xmm1
movaps %xmm6,%xmm4
addss  %xmm6,%xmm4
mulss  %xmm2,%xmm4
mulss  %xmm10,%xmm4
mulss  %xmm14,%xmm4
addss  %xmm1,%xmm4
movaps %xmm9,%xmm1
addss  %xmm9,%xmm1
mulss  %xmm2,%xmm1
movss  0xd27(%rip),%xmm0
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm7
mulss  %xmm10,%xmm7
mulss  %xmm8,%xmm7
mulss  %xmm13,%xmm7
addss  %xmm4,%xmm7
mulss  %xmm5,%xmm2
mulss  %xmm14,%xmm2
mulss  %xmm13,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm5,%xmm1
mulss  %xmm8,%xmm1
addss  %xmm2,%xmm1
movaps %xmm6,%xmm2
movss  (%rsp),%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm3,%xmm2
mulss  %xmm10,%xmm2
mulss  %xmm10,%xmm2
mulss  %xmm10,%xmm0
movaps %xmm3,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm10,%xmm4
mulss  %xmm10,%xmm10
mulss  %xmm8,%xmm10
mulss  %xmm8,%xmm10
addss  %xmm1,%xmm10
subss  %xmm2,%xmm10
mulss  %xmm5,%xmm0
mulss  %xmm14,%xmm0
mulss  %xmm8,%xmm0
addss  %xmm10,%xmm0
mulss  %xmm5,%xmm4
mulss  %xmm13,%xmm4
addss  %xmm0,%xmm4
movaps %xmm9,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm5,%xmm5
mulss  %xmm14,%xmm5
mulss  %xmm14,%xmm5
addss  %xmm4,%xmm5
subss  %xmm0,%xmm5
mulss  %xmm12,%xmm3
movaps %xmm13,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm9,%xmm3
mulss  %xmm6,%xmm3
mulss  %xmm12,%xmm6
mulss  %xmm14,%xmm6
mulss  %xmm14,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm12,%xmm9
addss  %xmm12,%xmm12
mulss  %xmm14,%xmm12
mulss  %xmm8,%xmm12
mulss  %xmm13,%xmm12
addss  %xmm5,%xmm12
mulss  %xmm8,%xmm9
mulss  %xmm8,%xmm9
subss  %xmm9,%xmm12
mulss  %xmm13,%xmm0
subss  %xmm0,%xmm12
addss  %xmm12,%xmm3
movss  0xbf3(%rip),%xmm0
mulss  %xmm11,%xmm0
mulss  0xbed(%rip),%xmm15
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm15,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
mov    $0x4,%al
call   1030 <DirectSolve@plt>
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
addss  %xmm2,%xmm2
movss  0x4(%rsp),%xmm0
subss  %xmm2,%xmm0
divss  %xmm1,%xmm0
maxss  0xba8(%rip),%xmm0
add    $0x10,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define float @rmsd2FromMandG(float* %0, float %1, float %2, i32 %3) {
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca i32
store float* %0, float** %5
store float %1, float* %6
store float %2, float* %7
store i32 %3, i32* %8
store i32 3, i32* %9
%29 = load float*, float** %5
%30 = getelementptr inbounds float, float* %29, i64 0
%31 = load float, float* %30
%32 = load float*, float** %5
%33 = getelementptr inbounds float, float* %32, i64 4
%34 = load float, float* %33
%35 = fadd float %31, %34
%36 = load float*, float** %5
%37 = getelementptr inbounds float, float* %36, i64 8
%38 = load float, float* %37
%39 = fadd float %35, %38
store float %39, float* %10
%40 = load float*, float** %5
%41 = getelementptr inbounds float, float* %40, i64 7
%42 = load float, float* %41
%43 = load float*, float** %5
%44 = getelementptr inbounds float, float* %43, i64 5
%45 = load float, float* %44
%46 = fsub float %42, %45
store float %46, float* %11
%47 = load float*, float** %5
%48 = getelementptr inbounds float, float* %47, i64 2
%49 = load float, float* %48
%50 = load float*, float** %5
%51 = getelementptr inbounds float, float* %50, i64 6
%52 = load float, float* %51
%53 = fsub float %49, %52
store float %53, float* %12
%54 = load float*, float** %5
%55 = getelementptr inbounds float, float* %54, i64 3
%56 = load float, float* %55
%57 = load float*, float** %5
%58 = getelementptr inbounds float, float* %57, i64 1
%59 = load float, float* %58
%60 = fsub float %56, %59
store float %60, float* %13
%61 = load float*, float** %5
%62 = getelementptr inbounds float, float* %61, i64 0
%63 = load float, float* %62
%64 = load float*, float** %5
%65 = getelementptr inbounds float, float* %64, i64 4
%66 = load float, float* %65
%67 = fsub float %63, %66
%68 = load float*, float** %5
%69 = getelementptr inbounds float, float* %68, i64 8
%70 = load float, float* %69
%71 = fsub float %67, %70
store float %71, float* %14
%72 = load float*, float** %5
%73 = getelementptr inbounds float, float* %72, i64 3
%74 = load float, float* %73
%75 = load float*, float** %5
%76 = getelementptr inbounds float, float* %75, i64 1
%77 = load float, float* %76
%78 = fadd float %74, %77
store float %78, float* %15
%79 = load float*, float** %5
%80 = getelementptr inbounds float, float* %79, i64 2
%81 = load float, float* %80
%82 = load float*, float** %5
%83 = getelementptr inbounds float, float* %82, i64 6
%84 = load float, float* %83
%85 = fadd float %81, %84
store float %85, float* %16
%86 = load float*, float** %5
%87 = getelementptr inbounds float, float* %86, i64 0
%88 = load float, float* %87
%89 = fneg float %88
%90 = load float*, float** %5
%91 = getelementptr inbounds float, float* %90, i64 4
%92 = load float, float* %91
%93 = fadd float %89, %92
%94 = load float*, float** %5
%95 = getelementptr inbounds float, float* %94, i64 8
%96 = load float, float* %95
%97 = fsub float %93, %96
store float %97, float* %17
%98 = load float*, float** %5
%99 = getelementptr inbounds float, float* %98, i64 7
%100 = load float, float* %99
%101 = load float*, float** %5
%102 = getelementptr inbounds float, float* %101, i64 5
%103 = load float, float* %102
%104 = fadd float %100, %103
store float %104, float* %18
%105 = load float*, float** %5
%106 = getelementptr inbounds float, float* %105, i64 0
%107 = load float, float* %106
%108 = fneg float %107
%109 = load float*, float** %5
%110 = getelementptr inbounds float, float* %109, i64 4
%111 = load float, float* %110
%112 = fsub float %108, %111
%113 = load float*, float** %5
%114 = getelementptr inbounds float, float* %113, i64 8
%115 = load float, float* %114
%116 = fadd float %112, %115
store float %116, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
%117 = load float, float* %6
%118 = load float, float* %7
%119 = fadd float %117, %118
%120 = fdiv float %119, 2.000000e+00
store float %120, float* %25
store float 0.000000e+00, float* %22
store i32 0, i32* %28
br label %121
121: ; preds = %137, %4
%122 = load i32, i32* %28
%123 = icmp slt i32 %122, 9
br i1 %123, label %124, label %140
124: ; preds = %121
%125 = load float*, float** %5
%126 = load i32, i32* %28
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
%129 = load float, float* %128
%130 = load float*, float** %5
%131 = load i32, i32* %28
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
%134 = load float, float* %133
%135 = load float, float* %22
%136 = call float @llvm.fmuladd.f32(float %129, float %134, float %135)
store float %136, float* %22
br label %137
137: ; preds = %124
%138 = load i32, i32* %28
%139 = add nsw i32 %138, 1
store i32 %139, i32* %28
br label %121
140: ; preds = %121
%141 = load float, float* %22
%142 = fmul float %141, -2.000000e+00
store float %142, float* %22
%143 = load float*, float** %5
%144 = getelementptr inbounds float, float* %143, i64 0
%145 = load float, float* %144
%146 = load float*, float** %5
%147 = getelementptr inbounds float, float* %146, i64 4
%148 = load float, float* %147
%149 = load float*, float** %5
%150 = getelementptr inbounds float, float* %149, i64 8
%151 = load float, float* %150
%152 = load float*, float** %5
%153 = getelementptr inbounds float, float* %152, i64 5
%154 = load float, float* %153
%155 = load float*, float** %5
%156 = getelementptr inbounds float, float* %155, i64 7
%157 = load float, float* %156
%158 = fmul float %154, %157
%159 = fneg float %158
%160 = call float @llvm.fmuladd.f32(float %148, float %151, float %159)
%161 = load float*, float** %5
%162 = getelementptr inbounds float, float* %161, i64 3
%163 = load float, float* %162
%164 = load float*, float** %5
%165 = getelementptr inbounds float, float* %164, i64 7
%166 = load float, float* %165
%167 = load float*, float** %5
%168 = getelementptr inbounds float, float* %167, i64 2
%169 = load float, float* %168
%170 = load float*, float** %5
%171 = getelementptr inbounds float, float* %170, i64 8
%172 = load float, float* %171
%173 = load float*, float** %5
%174 = getelementptr inbounds float, float* %173, i64 1
%175 = load float, float* %174
%176 = fmul float %172, %175
%177 = fneg float %176
%178 = call float @llvm.fmuladd.f32(float %166, float %169, float %177)
%179 = fmul float %163, %178
%180 = call float @llvm.fmuladd.f32(float %145, float %160, float %179)
%181 = load float*, float** %5
%182 = getelementptr inbounds float, float* %181, i64 6
%183 = load float, float* %182
%184 = load float*, float** %5
%185 = getelementptr inbounds float, float* %184, i64 1
%186 = load float, float* %185
%187 = load float*, float** %5
%188 = getelementptr inbounds float, float* %187, i64 5
%189 = load float, float* %188
%190 = load float*, float** %5
%191 = getelementptr inbounds float, float* %190, i64 2
%192 = load float, float* %191
%193 = load float*, float** %5
%194 = getelementptr inbounds float, float* %193, i64 4
%195 = load float, float* %194
%196 = fmul float %192, %195
%197 = fneg float %196
%198 = call float @llvm.fmuladd.f32(float %186, float %189, float %197)
%199 = call float @llvm.fmuladd.f32(float %183, float %198, float %180)
store float %199, float* %20
%200 = load float, float* %11
%201 = load float, float* %11
%202 = fmul float %200, %201
%203 = load float, float* %18
%204 = fmul float %202, %203
%205 = load float, float* %18
%206 = load float, float* %17
%207 = load float, float* %19
%208 = fmul float %206, %207
%209 = load float, float* %11
%210 = fmul float %208, %209
%211 = load float, float* %11
%212 = fmul float %210, %211
%213 = fneg float %212
%214 = call float @llvm.fmuladd.f32(float %204, float %205, float %213)
%215 = load float, float* %19
%216 = fmul float 2.000000e+00, %215
%217 = load float, float* %11
%218 = fmul float %216, %217
%219 = load float, float* %12
%220 = fmul float %218, %219
%221 = load float, float* %15
%222 = call float @llvm.fmuladd.f32(float %220, float %221, float %214)
%223 = load float, float* %11
%224 = fmul float 2.000000e+00, %223
%225 = load float, float* %12
%226 = fmul float %224, %225
%227 = load float, float* %16
%228 = fmul float %226, %227
%229 = load float, float* %18
%230 = fneg float %228
%231 = call float @llvm.fmuladd.f32(float %230, float %229, float %222)
%232 = load float, float* %11
%233 = fmul float 2.000000e+00, %232
%234 = load float, float* %13
%235 = fmul float %233, %234
%236 = load float, float* %15
%237 = fmul float %235, %236
%238 = load float, float* %18
%239 = fneg float %237
%240 = call float @llvm.fmuladd.f32(float %239, float %238, float %231)
%241 = load float, float* %17
%242 = fmul float 2.000000e+00, %241
%243 = load float, float* %11
%244 = fmul float %242, %243
%245 = load float, float* %13
%246 = fmul float %244, %245
%247 = load float, float* %16
%248 = call float @llvm.fmuladd.f32(float %246, float %247, float %240)
%249 = load float, float* %12
%250 = load float, float* %12
%251 = fmul float %249, %250
%252 = load float, float* %16
%253 = fmul float %251, %252
%254 = load float, float* %16
%255 = call float @llvm.fmuladd.f32(float %253, float %254, float %248)
%256 = load float, float* %14
%257 = load float, float* %19
%258 = fmul float %256, %257
%259 = load float, float* %12
%260 = fmul float %258, %259
%261 = load float, float* %12
%262 = fneg float %260
%263 = call float @llvm.fmuladd.f32(float %262, float %261, float %255)
%264 = load float, float* %12
%265 = fmul float 2.000000e+00, %264
%266 = load float, float* %13
%267 = fmul float %265, %266
%268 = load float, float* %15
%269 = fmul float %267, %268
%270 = load float, float* %16
%271 = fneg float %269
%272 = call float @llvm.fmuladd.f32(float %271, float %270, float %263)
%273 = load float, float* %14
%274 = fmul float 2.000000e+00, %273
%275 = load float, float* %12
%276 = fmul float %274, %275
%277 = load float, float* %13
%278 = fmul float %276, %277
%279 = load float, float* %18
%280 = call float @llvm.fmuladd.f32(float %278, float %279, float %272)
%281 = load float, float* %13
%282 = load float, float* %13
%283 = fmul float %281, %282
%284 = load float, float* %15
%285 = fmul float %283, %284
%286 = load float, float* %15
%287 = call float @llvm.fmuladd.f32(float %285, float %286, float %280)
%288 = load float, float* %14
%289 = load float, float* %17
%290 = fmul float %288, %289
%291 = load float, float* %13
%292 = fmul float %290, %291
%293 = load float, float* %13
%294 = fneg float %292
%295 = call float @llvm.fmuladd.f32(float %294, float %293, float %287)
%296 = load float, float* %10
%297 = load float, float* %19
%298 = fmul float %296, %297
%299 = load float, float* %15
%300 = fmul float %298, %299
%301 = load float, float* %15
%302 = fneg float %300
%303 = call float @llvm.fmuladd.f32(float %302, float %301, float %295)
%304 = load float, float* %10
%305 = fmul float 2.000000e+00, %304
%306 = load float, float* %15
%307 = fmul float %305, %306
%308 = load float, float* %16
%309 = fmul float %307, %308
%310 = load float, float* %18
%311 = call float @llvm.fmuladd.f32(float %309, float %310, float %303)
%312 = load float, float* %10
%313 = load float, float* %17
%314 = fmul float %312, %313
%315 = load float, float* %16
%316 = fmul float %314, %315
%317 = load float, float* %16
%318 = fneg float %316
%319 = call float @llvm.fmuladd.f32(float %318, float %317, float %311)
%320 = load float, float* %10
%321 = load float, float* %14
%322 = fmul float %320, %321
%323 = load float, float* %18
%324 = fmul float %322, %323
%325 = load float, float* %18
%326 = fneg float %324
%327 = call float @llvm.fmuladd.f32(float %326, float %325, float %319)
%328 = load float, float* %10
%329 = load float, float* %14
%330 = fmul float %328, %329
%331 = load float, float* %17
%332 = fmul float %330, %331
%333 = load float, float* %19
%334 = call float @llvm.fmuladd.f32(float %332, float %333, float %327)
store float %334, float* %21
%335 = load float, float* %20
%336 = fmul float -8.000000e+00, %335
store float %336, float* %23
%337 = load float, float* %21
store float %337, float* %24
%338 = load float, float* %25
%339 = fpext float %338 to double
%340 = load float, float* %24
%341 = fpext float %340 to double
%342 = load float, float* %23
%343 = fpext float %342 to double
%344 = load float, float* %22
%345 = fpext float %344 to double
%346 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @DirectSolve to i32 (double, double, double, double, ...)*)(double %339, double %341, double %343, double %345)
%347 = sitofp i32 %346 to float
store float %347, float* %25
%348 = load float, float* %6
%349 = load float, float* %7
%350 = fadd float %348, %349
%351 = load float, float* %25
%352 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %351, float %350)
%353 = load i32, i32* %8
%354 = sitofp i32 %353 to float
%355 = fdiv float %352, %354
store float %355, float* %26
store float 0.000000e+00, float* %27
%356 = load float, float* %26
%357 = fcmp ogt float %356, 0.000000e+00
br i1 %357, label %358, label %360
358: ; preds = %140
%359 = load float, float* %26
store float %359, float* %27
br label %360
360: ; preds = %358, %140
%361 = load float, float* %27
ret float %361
}

LLVM IR (-O2):
define float @rmsd2FromMandG(float* nocapture %0, float %1, float %2, i32 %3) {
%5 = load float, float* %0
%6 = getelementptr inbounds float, float* %0, i64 4
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %0, i64 8
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 7
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 5
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %0, i64 2
%15 = load float, float* %14
%16 = getelementptr inbounds float, float* %0, i64 6
%17 = load float, float* %16
%18 = getelementptr inbounds float, float* %0, i64 3
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 1
%21 = load float, float* %20
%22 = fsub float %5, %7
%23 = fadd float %19, %21
%24 = fneg float %5
%25 = fsub float %7, %5
%26 = fsub float %25, %9
%27 = fsub float %24, %7
%28 = fadd float %27, %9
%29 = tail call float @llvm.fmuladd.f32(float %5, float %5, float 0.000000e+00)
%30 = tail call float @llvm.fmuladd.f32(float %21, float %21, float %29)
%31 = tail call float @llvm.fmuladd.f32(float %15, float %15, float %30)
%32 = tail call float @llvm.fmuladd.f32(float %19, float %19, float %31)
%33 = tail call float @llvm.fmuladd.f32(float %7, float %7, float %32)
%34 = tail call float @llvm.fmuladd.f32(float %13, float %13, float %33)
%35 = tail call float @llvm.fmuladd.f32(float %17, float %17, float %34)
%36 = tail call float @llvm.fmuladd.f32(float %11, float %11, float %35)
%37 = tail call float @llvm.fmuladd.f32(float %9, float %9, float %36)
%38 = fadd float %5, %7
%39 = fadd float %38, %9
%40 = fsub float %11, %13
%41 = fsub float %15, %17
%42 = fsub float %19, %21
%43 = fsub float %22, %9
%44 = fadd float %15, %17
%45 = fadd float %11, %13
%46 = fadd float %1, %2
%47 = fmul float %46, 5.000000e-01
%48 = fmul float %37, -2.000000e+00
%49 = fneg float %13
%50 = fmul float %11, %49
%51 = tail call float @llvm.fmuladd.f32(float %7, float %9, float %50)
%52 = fneg float %9
%53 = fmul float %21, %52
%54 = tail call float @llvm.fmuladd.f32(float %11, float %15, float %53)
%55 = fmul float %19, %54
%56 = tail call float @llvm.fmuladd.f32(float %5, float %51, float %55)
%57 = fneg float %15
%58 = fmul float %7, %57
%59 = tail call float @llvm.fmuladd.f32(float %21, float %13, float %58)
%60 = tail call float @llvm.fmuladd.f32(float %17, float %59, float %56)
%61 = fmul float %40, %40
%62 = fmul float %45, %61
%63 = fneg float %26
%64 = fmul float %28, %63
%65 = fmul float %64, %40
%66 = fmul float %40, %65
%67 = tail call float @llvm.fmuladd.f32(float %62, float %45, float %66)
%68 = fmul float %28, 2.000000e+00
%69 = fmul float %68, %40
%70 = fmul float %69, %41
%71 = tail call float @llvm.fmuladd.f32(float %70, float %23, float %67)
%72 = fmul float %40, -2.000000e+00
%73 = fmul float %72, %41
%74 = fmul float %44, %73
%75 = tail call float @llvm.fmuladd.f32(float %74, float %45, float %71)
%76 = fmul float %72, %42
%77 = fmul float %23, %76
%78 = tail call float @llvm.fmuladd.f32(float %77, float %45, float %75)
%79 = fmul float %26, 2.000000e+00
%80 = fmul float %79, %40
%81 = fmul float %80, %42
%82 = tail call float @llvm.fmuladd.f32(float %81, float %44, float %78)
%83 = fmul float %41, %41
%84 = fmul float %44, %83
%85 = tail call float @llvm.fmuladd.f32(float %84, float %44, float %82)
%86 = fneg float %43
%87 = fmul float %28, %86
%88 = fmul float %87, %41
%89 = tail call float @llvm.fmuladd.f32(float %88, float %41, float %85)
%90 = fmul float %41, -2.000000e+00
%91 = fmul float %90, %42
%92 = fmul float %23, %91
%93 = tail call float @llvm.fmuladd.f32(float %92, float %44, float %89)
%94 = fmul float %43, 2.000000e+00
%95 = fmul float %94, %41
%96 = fmul float %95, %42
%97 = tail call float @llvm.fmuladd.f32(float %96, float %45, float %93)
%98 = fmul float %42, %42
%99 = fmul float %23, %98
%100 = tail call float @llvm.fmuladd.f32(float %99, float %23, float %97)
%101 = fmul float %26, %86
%102 = fmul float %101, %42
%103 = tail call float @llvm.fmuladd.f32(float %102, float %42, float %100)
%104 = fneg float %39
%105 = fmul float %28, %104
%106 = fmul float %105, %23
%107 = tail call float @llvm.fmuladd.f32(float %106, float %23, float %103)
%108 = fmul float %39, 2.000000e+00
%109 = fmul float %108, %23
%110 = fmul float %44, %109
%111 = tail call float @llvm.fmuladd.f32(float %110, float %45, float %107)
%112 = fmul float %26, %104
%113 = fmul float %112, %44
%114 = tail call float @llvm.fmuladd.f32(float %113, float %44, float %111)
%115 = fmul float %39, %43
%116 = fneg float %115
%117 = fmul float %45, %116
%118 = tail call float @llvm.fmuladd.f32(float %117, float %45, float %114)
%119 = fmul float %26, %115
%120 = tail call float @llvm.fmuladd.f32(float %119, float %28, float %118)
%121 = fmul float %60, -8.000000e+00
%122 = fpext float %47 to double
%123 = fpext float %120 to double
%124 = fpext float %121 to double
%125 = fpext float %48 to double
%126 = tail call i32 (double, double, double, double, ...) bitcast (i32 (...)* @DirectSolve to i32 (double, double, double, double, ...)*)(double %122, double %123, double %124, double %125)
%127 = sitofp i32 %126 to float
%128 = tail call float @llvm.fmuladd.f32(float %127, float -2.000000e+00, float %46)
%129 = sitofp i32 %3 to float
%130 = fdiv float %128, %129
%131 = fcmp ogt float %130, 0.000000e+00
%132 = select i1 %131, float %130, float 0.000000e+00
ret float %132
}