int FastCalcRMSDAndRotation(float *rot, float *A, float *rmsd, float E0,
                            int len, float minScore) {
  float Sxx, Sxy, Sxz, Syx, Syy, Syz, Szx, Szy, Szz;
  float Szz2, Syy2, Sxx2, Sxy2, Syz2, Sxz2, Syx2, Szy2, Szx2, SyzSzymSyySzz2,
      Sxx2Syy2Szz2Syz2Szy2, Sxy2Sxz2Syx2Szx2, SxzpSzx, SyzpSzy, SxypSyx,
      SyzmSzy, SxzmSzx, SxymSyx, SxxpSyy, SxxmSyy;
  float C[4];
  int i;
  float mxEigenV;
  float oldg = 0.0;
  float b, a, delta, rms, qsqr;
  float q1, q2, q3, q4, normq;
  float a11, a12, a13, a14, a21, a22, a23, a24;
  float a31, a32, a33, a34, a41, a42, a43, a44;
  float a2, x2, y2, z2;
  float xy, az, zx, ay, yz, ax;
  float a3344_4334, a3244_4234, a3243_4233, a3143_4133, a3144_4134, a3142_4132;
  float precision = 1e-14;
  Sxx = A[0];
  Sxy = A[1];
  Sxz = A[2];
  Syx = A[3];
  Syy = A[4];
  Syz = A[5];
  Szx = A[6];
  Szy = A[7];
  Szz = A[8];
  Sxx2 = Sxx * Sxx;
  Syy2 = Syy * Syy;
  Szz2 = Szz * Szz;
  Sxy2 = Sxy * Sxy;
  Syz2 = Syz * Syz;
  Sxz2 = Sxz * Sxz;
  Syx2 = Syx * Syx;
  Szy2 = Szy * Szy;
  Szx2 = Szx * Szx;
  SyzSzymSyySzz2 = 2.0 * (Syz * Szy - Syy * Szz);
  Sxx2Syy2Szz2Syz2Szy2 = Syy2 + Szz2 - Sxx2 + Syz2 + Szy2;
  C[2] = -2.0 * (Sxx2 + Syy2 + Szz2 + Sxy2 + Syx2 + Sxz2 + Szx2 + Syz2 + Szy2);
  C[1] = 8.0 * (Sxx * Syz * Szy + Syy * Szx * Sxz + Szz * Sxy * Syx -
                Sxx * Syy * Szz - Syz * Szx * Sxy - Szy * Syx * Sxz);
  SxzpSzx = Sxz + Szx;
  SyzpSzy = Syz + Szy;
  SxypSyx = Sxy + Syx;
  SyzmSzy = Syz - Szy;
  SxzmSzx = Sxz - Szx;
  SxymSyx = Sxy - Syx;
  SxxpSyy = Sxx + Syy;
  SxxmSyy = Sxx - Syy;
  Sxy2Sxz2Syx2Szx2 = Sxy2 + Sxz2 - Syx2 - Szx2;
  C[0] = Sxy2Sxz2Syx2Szx2 * Sxy2Sxz2Syx2Szx2 +
         (Sxx2Syy2Szz2Syz2Szy2 + SyzSzymSyySzz2) *
             (Sxx2Syy2Szz2Syz2Szy2 - SyzSzymSyySzz2) +
         (-(SxzpSzx) * (SyzmSzy) + (SxymSyx) * (SxxmSyy - Szz)) *
             (-(SxzmSzx) * (SyzpSzy) + (SxymSyx) * (SxxmSyy + Szz)) +
         (-(SxzpSzx) * (SyzpSzy) - (SxypSyx) * (SxxpSyy - Szz)) *
             (-(SxzmSzx) * (SyzmSzy) - (SxypSyx) * (SxxpSyy + Szz)) +
         (+(SxypSyx) * (SyzpSzy) + (SxzpSzx) * (SxxmSyy + Szz)) *
             (-(SxymSyx) * (SyzmSzy) + (SxzpSzx) * (SxxpSyy + Szz)) +
         (+(SxypSyx) * (SyzmSzy) + (SxzmSzx) * (SxxmSyy - Szz)) *
             (-(SxymSyx) * (SyzpSzy) + (SxzmSzx) * (SxxpSyy - Szz));
  mxEigenV = E0;
  for (i = 0; i < 50; ++i) {
    oldg = mxEigenV;
    x2 = mxEigenV * mxEigenV;
    b = (x2 + C[2]) * mxEigenV;
    a = b + C[1];
    delta = ((a * mxEigenV + C[0]) / (2.0 * x2 * mxEigenV + b + a));
    mxEigenV -= delta;
    if (fabs(mxEigenV - oldg) < fabs((1e-6) * mxEigenV))
      break;
  }
  rms = sqrt(2.0 * (E0 - mxEigenV) / len);
  (*rmsd) = rms;
  if (minScore > 0)
    if (rms < minScore)
      return -1;
  a11 = SxxpSyy + Szz - mxEigenV;
  a12 = SyzmSzy;
  a13 = -SxzmSzx;
  a14 = SxymSyx;
  a21 = SyzmSzy;
  a22 = SxxmSyy - Szz - mxEigenV;
  a23 = SxypSyx;
  a24 = SxzpSzx;
  a31 = a13;
  a32 = a23;
  a33 = Syy - Sxx - Szz - mxEigenV;
  a34 = SyzpSzy;
  a41 = a14;
  a42 = a24;
  a43 = a34;
  a44 = Szz - SxxpSyy - mxEigenV;
  a3344_4334 = a33 * a44 - a43 * a34;
  a3244_4234 = a32 * a44 - a42 * a34;
  a3243_4233 = a32 * a43 - a42 * a33;
  a3143_4133 = a31 * a43 - a41 * a33;
  a3144_4134 = a31 * a44 - a41 * a34;
  a3142_4132 = a31 * a42 - a41 * a32;
  q1 = a22 * a3344_4334 - a23 * a3244_4234 + a24 * a3243_4233;
  q2 = -a21 * a3344_4334 + a23 * a3144_4134 - a24 * a3143_4133;
  q3 = a21 * a3244_4234 - a22 * a3144_4134 + a24 * a3142_4132;
  q4 = -a21 * a3243_4233 + a22 * a3143_4133 - a23 * a3142_4132;
  qsqr = q1 * q1 + q2 * q2 + q3 * q3 + q4 * q4;
  if (qsqr < precision) {
    q1 = a12 * a3344_4334 - a13 * a3244_4234 + a14 * a3243_4233;
    q2 = -a11 * a3344_4334 + a13 * a3144_4134 - a14 * a3143_4133;
    q3 = a11 * a3244_4234 - a12 * a3144_4134 + a14 * a3142_4132;
    q4 = -a11 * a3243_4233 + a12 * a3143_4133 - a13 * a3142_4132;
    qsqr = q1 * q1 + q2 * q2 + q3 * q3 + q4 * q4;
    if (qsqr < precision) {
      float a1324_1423 = a13 * a24 - a14 * a23,
            a1224_1422 = a12 * a24 - a14 * a22;
      float a1223_1322 = a12 * a23 - a13 * a22,
            a1124_1421 = a11 * a24 - a14 * a21;
      float a1123_1321 = a11 * a23 - a13 * a21,
            a1122_1221 = a11 * a22 - a12 * a21;
      q1 = a42 * a1324_1423 - a43 * a1224_1422 + a44 * a1223_1322;
      q2 = -a41 * a1324_1423 + a43 * a1124_1421 - a44 * a1123_1321;
      q3 = a41 * a1224_1422 - a42 * a1124_1421 + a44 * a1122_1221;
      q4 = -a41 * a1223_1322 + a42 * a1123_1321 - a43 * a1122_1221;
      qsqr = q1 * q1 + q2 * q2 + q3 * q3 + q4 * q4;
      if (qsqr < precision) {
        q1 = a32 * a1324_1423 - a33 * a1224_1422 + a34 * a1223_1322;
        q2 = -a31 * a1324_1423 + a33 * a1124_1421 - a34 * a1123_1321;
        q3 = a31 * a1224_1422 - a32 * a1124_1421 + a34 * a1122_1221;
        q4 = -a31 * a1223_1322 + a32 * a1123_1321 - a33 * a1122_1221;
        qsqr = q1 * q1 + q2 * q2 + q3 * q3 + q4 * q4;
      }
    }
  }
  normq = sqrt(qsqr);
  q1 /= normq;
  q2 /= normq;
  q3 /= normq;
  q4 /= normq;
  a2 = q1 * q1;
  x2 = q2 * q2;
  y2 = q3 * q3;
  z2 = q4 * q4;
  xy = q2 * q3;
  az = q1 * q4;
  zx = q4 * q2;
  ay = q1 * q3;
  yz = q3 * q4;
  ax = q1 * q2;
  rot[0] = a2 + x2 - y2 - z2;
  rot[1] = 2 * (xy + az);
  rot[2] = 2 * (zx - ay);
  rot[3] = 2 * (xy - az);
  rot[4] = a2 - x2 + y2 - z2;
  rot[5] = 2 * (yz + ax);
  rot[6] = 2 * (zx + ay);
  rot[7] = 2 * (yz - ax);
  rot[8] = a2 - x2 - y2 + z2;
  return (0);
}


x86 assembly (clang, -O0):
<FastCalcRMSDAndRotation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %ecx,-0x28(%rbp)
movss  %xmm1,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  0x1ed9(%rip),%xmm0
movss  %xmm0,-0x168(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1d88(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1d1c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x30(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c4f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x38(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x30(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x30(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
addss  -0x78(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm3
subss  -0x78(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x90(%rbp),%xmm3
ff
movss  -0x98(%rbp),%xmm2
ff
movss  -0xa0(%rbp),%xmm4
ff
subss  -0x50(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x88(%rbp),%xmm4
ff
movss  -0x98(%rbp),%xmm3
ff
movss  -0xa0(%rbp),%xmm5
ff
addss  -0x50(%rbp),%xmm5
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x88(%rbp),%xmm3
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x9c(%rbp),%xmm4
ff
subss  -0x50(%rbp),%xmm4
mulss  %xmm4,%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x90(%rbp),%xmm4
ff
movss  -0x8c(%rbp),%xmm3
ff
movss  -0x9c(%rbp),%xmm5
ff
addss  -0x50(%rbp),%xmm5
mulss  %xmm5,%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm3
ff
movss  -0x84(%rbp),%xmm2
ff
movss  -0xa0(%rbp),%xmm4
ff
addss  -0x50(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x90(%rbp),%xmm4
ff
movss  -0x84(%rbp),%xmm3
ff
movss  -0x9c(%rbp),%xmm5
ff
addss  -0x50(%rbp),%xmm5
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm3
ff
movss  -0x94(%rbp),%xmm2
ff
movss  -0xa0(%rbp),%xmm4
ff
subss  -0x50(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  -0x88(%rbp),%xmm4
ff
movss  -0x94(%rbp),%xmm3
ff
movss  -0x9c(%rbp),%xmm5
ff
subss  -0x50(%rbp),%xmm5
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xb4(%rbp)
cmpl   $0x32,-0xb4(%rbp)
jge    1832 <FastCalcRMSDAndRotation+0x722>
movss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
mulss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
addss  -0xa8(%rbp),%xmm0
ff
mulss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
addss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xb0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x12c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm2
movsd  0x18a8(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0xb8(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm3
movss  -0xc0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movss  -0xc4(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xc8(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x184d(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm2
movsd  0x181d(%rip),%xmm0
mulsd  %xmm2,%xmm0
movaps 0x182a(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1819 <FastCalcRMSDAndRotation+0x709>
jmp    1832 <FastCalcRMSDAndRotation+0x722>
jmp    181e <FastCalcRMSDAndRotation+0x70e>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    16c3 <FastCalcRMSDAndRotation+0x5b3>
movss  -0x24(%rbp),%xmm0
subss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x17c5(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    18b1 <FastCalcRMSDAndRotation+0x7a1>
movss  -0xcc(%rbp),%xmm1
ff
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    18ac <FastCalcRMSDAndRotation+0x79c>
movl   $0xffffffff,-0x4(%rbp)
jmp    2739 <FastCalcRMSDAndRotation+0x1629>
jmp    18b1 <FastCalcRMSDAndRotation+0x7a1>
movss  -0x9c(%rbp),%xmm0
ff
addss  -0x50(%rbp),%xmm0
subss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
subss  -0x50(%rbp),%xmm0
subss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x104(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x40(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
subss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x120(%rbp)
ff
movss  -0x50(%rbp),%xmm0
subss  -0x9c(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
movss  -0x120(%rbp),%xmm1
ff
mulss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
movss  -0x11c(%rbp),%xmm1
ff
mulss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0x120(%rbp),%xmm2
ff
movss  -0x11c(%rbp),%xmm1
ff
mulss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movss  -0x120(%rbp),%xmm2
ff
movss  -0x118(%rbp),%xmm1
ff
mulss  -0x110(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x15c(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movss  -0x124(%rbp),%xmm2
ff
movss  -0x118(%rbp),%xmm1
ff
mulss  -0x114(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x160(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm2
ff
movss  -0x118(%rbp),%xmm1
ff
mulss  -0x10c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x164(%rbp)
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0x150(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x154(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x104(%rbp),%xmm0
ff
movss  -0x158(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x150(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x160(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x104(%rbp),%xmm0
ff
movss  -0x15c(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xf8(%rbp),%xmm1
ff
movss  -0x154(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm0
ff
mulss  -0x160(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x104(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x158(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm0
ff
mulss  -0x15c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0xd8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x168(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    245d <FastCalcRMSDAndRotation+0x134d>
movss  -0xec(%rbp),%xmm1
ff
movss  -0x150(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm0
ff
mulss  -0x154(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x158(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x150(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm0
ff
mulss  -0x160(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x15c(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xe8(%rbp),%xmm1
ff
movss  -0x154(%rbp),%xmm2
ff
movss  -0xec(%rbp),%xmm0
ff
mulss  -0x160(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x158(%rbp),%xmm2
ff
movss  -0xec(%rbp),%xmm0
ff
mulss  -0x15c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0xd8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x168(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    2458 <FastCalcRMSDAndRotation+0x1348>
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
movss  -0xf4(%rbp),%xmm1
ff
mulss  -0x100(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
movss  -0xf4(%rbp),%xmm1
ff
mulss  -0xfc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x170(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x100(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm1
ff
mulss  -0xfc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x174(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
movss  -0xf4(%rbp),%xmm1
ff
mulss  -0xf8(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x178(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x100(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm1
ff
mulss  -0xf8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x17c(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm2
ff
movss  -0xec(%rbp),%xmm1
ff
mulss  -0xf8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x180(%rbp)
ff
movss  -0x11c(%rbp),%xmm1
ff
movss  -0x16c(%rbp),%xmm2
ff
movss  -0x120(%rbp),%xmm0
ff
mulss  -0x170(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x124(%rbp),%xmm0
ff
movss  -0x174(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x16c(%rbp),%xmm2
ff
movss  -0x120(%rbp),%xmm0
ff
mulss  -0x178(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x124(%rbp),%xmm0
ff
movss  -0x17c(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x118(%rbp),%xmm1
ff
movss  -0x170(%rbp),%xmm2
ff
movss  -0x11c(%rbp),%xmm0
ff
mulss  -0x178(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x124(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x174(%rbp),%xmm2
ff
movss  -0x11c(%rbp),%xmm0
ff
mulss  -0x17c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x120(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0xd8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x168(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    2453 <FastCalcRMSDAndRotation+0x1343>
movss  -0x10c(%rbp),%xmm1
ff
movss  -0x16c(%rbp),%xmm2
ff
movss  -0x110(%rbp),%xmm0
ff
mulss  -0x170(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x114(%rbp),%xmm0
ff
movss  -0x174(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x16c(%rbp),%xmm2
ff
movss  -0x110(%rbp),%xmm0
ff
mulss  -0x178(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x114(%rbp),%xmm0
ff
movss  -0x17c(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x108(%rbp),%xmm1
ff
movss  -0x170(%rbp),%xmm2
ff
movss  -0x10c(%rbp),%xmm0
ff
mulss  -0x178(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x114(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x174(%rbp),%xmm2
ff
movss  -0x10c(%rbp),%xmm0
ff
mulss  -0x17c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x110(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0xd8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xe0(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
jmp    2458 <FastCalcRMSDAndRotation+0x1348>
jmp    245d <FastCalcRMSDAndRotation+0x134d>
movss  -0xd0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xd8(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xe0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0x128(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
mulss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
mulss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
mulss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
mulss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
mulss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
mulss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x128(%rbp),%xmm0
ff
addss  -0x12c(%rbp),%xmm0
ff
subss  -0x130(%rbp),%xmm0
ff
subss  -0x134(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x138(%rbp),%xmm1
ff
addss  -0x13c(%rbp),%xmm1
ff
movss  0xa0a(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x140(%rbp),%xmm1
ff
subss  -0x144(%rbp),%xmm1
ff
movss  0x9e5(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x138(%rbp),%xmm1
ff
subss  -0x13c(%rbp),%xmm1
ff
movss  0x9c0(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x128(%rbp),%xmm0
ff
subss  -0x12c(%rbp),%xmm0
ff
addss  -0x130(%rbp),%xmm0
ff
subss  -0x134(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x148(%rbp),%xmm1
ff
addss  -0x14c(%rbp),%xmm1
ff
movss  0x972(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x140(%rbp),%xmm1
ff
addss  -0x144(%rbp),%xmm1
ff
movss  0x94d(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x148(%rbp),%xmm1
ff
subss  -0x14c(%rbp),%xmm1
ff
movss  0x928(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x128(%rbp),%xmm0
ff
subss  -0x12c(%rbp),%xmm0
ff
subss  -0x130(%rbp),%xmm0
ff
addss  -0x134(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FastCalcRMSDAndRotation>:
push   %r14
push   %rbx
sub    $0x148,%rsp
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x60(%rsp)
mov    %rdx,%rbx
mov    %rdi,%r14
movss  (%rsi),%xmm2
movss  %xmm2,0x20(%rsp)
movss  0x4(%rsi),%xmm6
movss  0x8(%rsi),%xmm0
movss  0x10(%rsi),%xmm3
movsd  0x14(%rsi),%xmm8
movss  0x1c(%rsi),%xmm10
movss  0x20(%rsi),%xmm1
mulss  %xmm2,%xmm2
movaps %xmm3,%xmm15
movaps %xmm3,%xmm7
mulss  %xmm3,%xmm15
movaps %xmm1,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm6,%xmm4
mulss  %xmm6,%xmm4
movss  %xmm4,0x10(%rsp)
movaps %xmm8,%xmm5
mulss  %xmm8,%xmm5
movaps %xmm1,%xmm4
movaps %xmm1,0xc0(%rsp)
mulss  %xmm7,%xmm4
movaps %xmm7,%xmm11
movaps %xmm8,%xmm7
mulss  %xmm10,%xmm7
subss  %xmm4,%xmm7
movaps %xmm7,0x50(%rsp)
movaps %xmm15,%xmm7
addss  %xmm3,%xmm7
subss  %xmm2,%xmm7
addss  %xmm2,%xmm15
movaps %xmm0,%xmm14
mulss  %xmm0,%xmm14
addss  %xmm3,%xmm15
movaps %xmm8,%xmm12
shufps $0x55,%xmm8,%xmm12
movaps %xmm6,%xmm2
movaps %xmm6,%xmm9
mulss  %xmm1,%xmm9
movss  0xc(%rsi),%xmm4
mulss  %xmm4,%xmm9
movaps %xmm12,%xmm13
mulss  %xmm8,%xmm13
mulss  %xmm6,%xmm13
movaps %xmm6,%xmm1
addss  %xmm4,%xmm1
movaps %xmm1,0xa0(%rsp)
subss  %xmm4,%xmm2
movaps %xmm2,0xe0(%rsp)
movaps %xmm4,%xmm6
mulss  %xmm4,%xmm4
movaps %xmm11,%xmm2
movaps %xmm11,%xmm3
mulss  %xmm12,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm10,%xmm6
mulss  %xmm0,%xmm6
movaps %xmm10,%xmm1
unpcklps %xmm0,%xmm1
subss  %xmm12,%xmm0
movaps %xmm0,0x30(%rsp)
mulss  %xmm12,%xmm12
addss  %xmm5,%xmm7
movss  0x10(%rsp),%xmm11
addss  %xmm11,%xmm15
addss  %xmm4,%xmm15
addss  %xmm14,%xmm15
addss  %xmm12,%xmm15
addss  %xmm5,%xmm15
movss  0x20(%rsp),%xmm0
movaps %xmm0,%xmm5
mulss  %xmm8,%xmm5
mulss  %xmm10,%xmm5
addps  %xmm8,%xmm1
subss  %xmm10,%xmm8
movaps %xmm8,0xb0(%rsp)
mulss  %xmm10,%xmm10
addss  %xmm10,%xmm7
addss  %xmm10,%xmm15
addss  %xmm3,%xmm5
addss  %xmm5,%xmm9
movaps %xmm2,%xmm5
movaps %xmm2,%xmm3
mulss  %xmm0,%xmm3
movaps 0xc0(%rsp),%xmm8
mulss  %xmm8,%xmm3
subss  %xmm3,%xmm9
subss  %xmm13,%xmm9
subss  %xmm6,%xmm9
addss  %xmm11,%xmm14
subss  %xmm4,%xmm14
movaps 0x50(%rsp),%xmm2
addss  %xmm2,%xmm2
subss  %xmm12,%xmm14
movaps %xmm8,%xmm12
movaps %xmm2,%xmm3
addss  %xmm7,%xmm3
subss  %xmm2,%xmm7
movaps %xmm1,0x90(%rsp)
movaps %xmm1,%xmm11
shufps $0x55,%xmm1,%xmm11
mulss  %xmm3,%xmm7
movaps %xmm0,%xmm8
subss  %xmm5,%xmm8
movaps %xmm5,%xmm10
mulss  %xmm14,%xmm14
addss  %xmm7,%xmm14
movaps %xmm8,%xmm2
subss  %xmm12,%xmm2
movaps %xmm2,0x10(%rsp)
movaps 0xe0(%rsp),%xmm6
movaps %xmm6,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm11,%xmm5
movaps 0xb0(%rsp),%xmm13
mulss  %xmm13,%xmm5
subss  %xmm5,%xmm3
addss  %xmm12,%xmm8
mulss  %xmm8,%xmm6
movaps 0x30(%rsp),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm14,%xmm6
movaps %xmm0,%xmm1
movaps %xmm10,%xmm0
movaps %xmm10,0x50(%rsp)
addss  %xmm10,%xmm1
movaps 0xc70(%rip),%xmm0
movaps %xmm11,%xmm7
xorps  %xmm0,%xmm7
movaps %xmm1,%xmm14
subss  %xmm12,%xmm14
movaps %xmm14,%xmm5
movaps 0xa0(%rsp),%xmm2
mulss  %xmm2,%xmm5
movaps %xmm7,0x100(%rsp)
movaps 0x90(%rsp),%xmm10
mulss  %xmm10,%xmm7
subss  %xmm5,%xmm7
xorps  %xmm0,%xmm4
movss  %xmm1,0x4c(%rsp)
addss  %xmm12,%xmm1
movaps %xmm1,%xmm5
mulss  %xmm2,%xmm5
movaps %xmm4,0xd0(%rsp)
mulss  %xmm13,%xmm4
subss  %xmm5,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm6,%xmm4
mulss  %xmm11,%xmm8
movaps %xmm2,%xmm5
mulss  %xmm10,%xmm5
addss  %xmm8,%xmm5
movaps %xmm11,0x110(%rsp)
movaps %xmm11,%xmm6
movaps %xmm1,0x130(%rsp)
mulss  %xmm1,%xmm6
movaps 0xe0(%rsp),%xmm3
movaps %xmm3,%xmm7
mulss  %xmm13,%xmm7
subss  %xmm7,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
movaps 0x30(%rsp),%xmm1
mulss  %xmm1,%xmm14
movaps %xmm3,%xmm4
movaps %xmm3,%xmm5
mulss  %xmm10,%xmm4
subss  %xmm4,%xmm14
movaps %xmm1,%xmm4
mulss  0x10(%rsp),%xmm4
movaps %xmm2,%xmm1
mulss  %xmm13,%xmm1
movaps %xmm1,0x120(%rsp)
addss  %xmm1,%xmm4
mulss  %xmm4,%xmm14
addss  %xmm6,%xmm14
addss  %xmm15,%xmm15
mulss  0xb62(%rip),%xmm9
xorps  %xmm0,%xmm2
movaps %xmm2,0xf0(%rsp)
movaps %xmm5,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x80(%rsp)
mov    $0x31,%eax
movaps %xmm10,0x70(%rsp)
movss  0x60(%rsp),%xmm0
movaps 0xb50(%rip),%xmm8
movsd  0xb67(%rip),%xmm10
movapd 0xb4e(%rip),%xmm11
movaps %xmm0,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm3,%xmm1
movaps %xmm3,%xmm7
mulss  %xmm3,%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
subss  %xmm15,%xmm7
mulss  %xmm3,%xmm7
movaps %xmm9,%xmm4
addss  %xmm7,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm4,%xmm5
mulss  %xmm3,%xmm4
addss  %xmm14,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm2,%xmm2
xorps  %xmm6,%xmm6
cvtss2sd %xmm3,%xmm6
mulsd  %xmm2,%xmm6
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
addsd  %xmm6,%xmm2
addsd  %xmm5,%xmm2
divsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
subss  %xmm2,%xmm3
movaps %xmm3,%xmm2
subss  %xmm1,%xmm2
andps  %xmm8,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
mulsd  %xmm10,%xmm2
andpd  %xmm11,%xmm2
sub    $0x1,%eax
setb   %dl
ucomisd %xmm1,%xmm2
ja     158a <FastCalcRMSDAndRotation+0x46a>
test   %dl,%dl
je     14f0 <FastCalcRMSDAndRotation+0x3d0>
subss  %xmm3,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movss  %xmm3,0x8(%rsp)
jb     15b7 <FastCalcRMSDAndRotation+0x497>
sqrtsd %xmm0,%xmm0
jmp    15c2 <FastCalcRMSDAndRotation+0x4a2>
call   1040 <sqrt@plt>
movss  0x8(%rsp),%xmm3
movaps 0x50(%rsp),%xmm4
movaps 0x10(%rsp),%xmm15
movaps 0x80(%rsp),%xmm10
movss  0xc(%rsp),%xmm2
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
xorpd  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jbe    15fb <FastCalcRMSDAndRotation+0x4db>
mov    $0xffffffff,%eax
ucomiss %xmm0,%xmm2
ja     1bcd <FastCalcRMSDAndRotation+0xaad>
subss  %xmm3,%xmm15
subss  0x20(%rsp),%xmm4
movaps 0xc0(%rsp),%xmm5
subss  %xmm5,%xmm4
subss  %xmm3,%xmm4
subss  0x4c(%rsp),%xmm5
subss  %xmm3,%xmm5
movaps 0x70(%rsp),%xmm1
movaps 0x9e4(%rip),%xmm2
xorps  %xmm2,%xmm1
movaps 0x90(%rsp),%xmm12
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
movaps %xmm1,0x70(%rsp)
movaps 0x100(%rsp),%xmm9
unpcklps %xmm9,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm4,%xmm0
movaps 0xa0(%rsp),%xmm8
unpcklps %xmm8,%xmm0
movaps %xmm5,%xmm13
shufps $0x0,%xmm5,%xmm13
mulps  %xmm0,%xmm13
addps  %xmm1,%xmm13
movaps %xmm13,%xmm14
shufps $0x55,%xmm13,%xmm14
movaps %xmm4,0x50(%rsp)
movaps %xmm4,%xmm1
mulss  %xmm9,%xmm1
movaps %xmm8,%xmm4
mulss  %xmm12,%xmm4
addss  %xmm1,%xmm4
movaps %xmm12,%xmm1
mulss  %xmm10,%xmm1
movaps 0xd0(%rsp),%xmm6
movaps %xmm6,%xmm7
movaps %xmm5,0xc0(%rsp)
mulss  %xmm5,%xmm7
addss  %xmm1,%xmm7
movaps %xmm10,%xmm1
shufps $0x0,%xmm10,%xmm1
mulps  %xmm0,%xmm1
shufps $0x0,%xmm6,%xmm6
mulps  %xmm12,%xmm6
addps  %xmm1,%xmm6
movaps %xmm6,%xmm11
shufps $0x55,%xmm6,%xmm11
movaps %xmm14,%xmm0
movaps 0xf0(%rsp),%xmm1
mulss  %xmm1,%xmm0
movaps %xmm15,%xmm3
mulss  %xmm13,%xmm3
addss  %xmm0,%xmm3
movaps 0x110(%rsp),%xmm10
mulss  %xmm4,%xmm10
addss  %xmm3,%xmm10
movaps 0xb0(%rsp),%xmm5
movaps %xmm5,%xmm3
xorps  %xmm2,%xmm3
xorps  %xmm15,%xmm2
shufps $0x0,%xmm7,%xmm7
movaps %xmm8,%xmm0
unpcklps %xmm2,%xmm0
mulps  %xmm7,%xmm0
movaps %xmm3,%xmm8
unpcklps %xmm5,%xmm3
mulps  %xmm13,%xmm3
addps  %xmm0,%xmm3
movss  %xmm9,%xmm12
mulps  %xmm6,%xmm12
addps  %xmm3,%xmm12
movaps %xmm15,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm5,%xmm3
mulss  %xmm4,%xmm3
subss  %xmm3,%xmm0
movaps %xmm1,%xmm5
movaps %xmm11,0x60(%rsp)
mulss  %xmm11,%xmm5
addss  %xmm0,%xmm5
movaps %xmm12,%xmm0
mulss  %xmm12,%xmm0
movaps %xmm10,0x10(%rsp)
mulss  %xmm10,%xmm10
addss  %xmm0,%xmm10
movaps %xmm12,0x20(%rsp)
movaps %xmm12,%xmm1
shufps $0x55,%xmm12,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm10,%xmm1
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
movss  0x851(%rip),%xmm11
ucomiss %xmm0,%xmm11
movaps 0x130(%rsp),%xmm10
jbe    1ac7 <FastCalcRMSDAndRotation+0x9a7>
subss  0x8(%rsp),%xmm10
movaps 0x30(%rsp),%xmm9
mulss  %xmm9,%xmm14
movaps 0xb0(%rsp),%xmm12
movaps %xmm12,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm14,%xmm0
movaps 0xe0(%rsp),%xmm2
movaps %xmm2,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
movaps 0x807(%rip),%xmm0
xorps  %xmm10,%xmm0
movaps %xmm8,%xmm1
movaps 0xd0(%rsp),%xmm3
movlhps %xmm3,%xmm1
shufps $0xe2,%xmm3,%xmm1
mulps  %xmm1,%xmm7
unpcklps %xmm10,%xmm0
mulps  %xmm13,%xmm0
addps  %xmm7,%xmm0
movaps 0x80(%rsp),%xmm1
movlhps %xmm1,%xmm2
shufps $0xe2,%xmm1,%xmm2
movaps %xmm6,%xmm3
movaps %xmm2,%xmm7
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
mulss  %xmm12,%xmm6
mulss  %xmm10,%xmm4
subss  %xmm4,%xmm6
mulss  0x60(%rsp),%xmm9
addss  %xmm6,%xmm9
movaps %xmm3,0x20(%rsp)
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm5,0x10(%rsp)
movaps %xmm5,%xmm2
movaps %xmm9,%xmm5
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movaps %xmm9,%xmm0
mulss  %xmm9,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm0,%xmm11
jbe    1ac7 <FastCalcRMSDAndRotation+0x9a7>
movaps %xmm15,%xmm0
movaps 0x80(%rsp),%xmm2
mulss  %xmm2,%xmm0
movaps 0xb0(%rsp),%xmm3
movaps %xmm3,%xmm12
movaps 0x110(%rsp),%xmm6
mulss  %xmm6,%xmm12
addss  %xmm0,%xmm12
movaps 0x30(%rsp),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm15,%xmm0
movaps 0x120(%rsp),%xmm14
addss  %xmm0,%xmm14
movaps %xmm3,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm10,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm0,%xmm4
movaps %xmm1,%xmm0
unpcklps %xmm8,%xmm0
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm0
shufps $0x0,%xmm10,%xmm10
movaps 0xa0(%rsp),%xmm1
movlhps %xmm1,%xmm15
shufps $0xe2,%xmm1,%xmm15
mulps  %xmm10,%xmm15
addps  %xmm0,%xmm15
movaps %xmm12,%xmm0
movaps 0x70(%rsp),%xmm10
mulss  %xmm10,%xmm0
movaps %xmm6,%xmm1
movaps 0x60(%rsp),%xmm13
mulss  %xmm13,%xmm1
addss  %xmm0,%xmm1
movaps 0xc0(%rsp),%xmm5
movaps %xmm5,%xmm3
mulss  %xmm14,%xmm3
addss  %xmm1,%xmm3
shufps $0x0,%xmm4,%xmm4
movaps 0x90(%rsp),%xmm0
movaps 0x100(%rsp),%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
mulps  %xmm4,%xmm1
unpcklps %xmm12,%xmm13
mulps  %xmm13,%xmm7
addps  %xmm1,%xmm7
movaps 0x67a(%rip),%xmm0
xorps  %xmm5,%xmm0
unpcklps %xmm5,%xmm0
movaps %xmm15,%xmm9
shufps $0x55,%xmm15,%xmm9
mulps  %xmm15,%xmm0
addps  %xmm7,%xmm0
mulss  %xmm15,%xmm6
mulss  %xmm14,%xmm2
addss  %xmm6,%xmm2
movaps %xmm10,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm2,%xmm5
movaps %xmm0,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm3,0x10(%rsp)
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movaps %xmm0,0x20(%rsp)
movaps %xmm0,%xmm6
shufps $0x55,%xmm0,%xmm6
mulss  %xmm6,%xmm6
addss  %xmm1,%xmm6
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
ucomiss %xmm0,%xmm11
jbe    1ac7 <FastCalcRMSDAndRotation+0x9a7>
movaps %xmm14,%xmm7
movaps 0x50(%rsp),%xmm6
mulss  %xmm6,%xmm12
movaps 0xa0(%rsp),%xmm10
movaps 0x60(%rsp),%xmm8
mulss  %xmm10,%xmm8
subss  %xmm12,%xmm8
movaps 0x90(%rsp),%xmm1
movaps %xmm1,%xmm2
mulss  %xmm14,%xmm2
addss  %xmm8,%xmm2
movaps %xmm6,%xmm0
unpcklps 0xf0(%rsp),%xmm0
mulps  %xmm0,%xmm4
movaps 0x30(%rsp),%xmm5
movaps 0xd0(%rsp),%xmm0
movlhps %xmm5,%xmm0
shufps $0xe2,%xmm5,%xmm0
mulps  %xmm13,%xmm0
addps  %xmm4,%xmm0
movaps 0x70(%rsp),%xmm3
unpcklps %xmm1,%xmm3
mulps  %xmm15,%xmm3
addps  %xmm0,%xmm3
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
mulss  %xmm10,%xmm15
mulss  %xmm14,%xmm5
addss  %xmm15,%xmm5
mulss  %xmm6,%xmm9
subss  %xmm9,%xmm5
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm2,0x10(%rsp)
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
movaps %xmm3,0x20(%rsp)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1ad5 <FastCalcRMSDAndRotation+0x9b5>
sqrtss %xmm0,%xmm0
jmp    1ae4 <FastCalcRMSDAndRotation+0x9c4>
movaps %xmm5,0x30(%rsp)
call   1030 <sqrtf@plt>
movaps 0x30(%rsp),%xmm5
movaps 0x10(%rsp),%xmm7
divss  %xmm0,%xmm7
divss  %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm0
movaps 0x20(%rsp),%xmm8
divps  %xmm0,%xmm8
movaps %xmm8,%xmm1
shufps $0x15,%xmm8,%xmm1
movaps %xmm7,%xmm2
mulss  %xmm7,%xmm2
movaps %xmm8,%xmm4
mulss  %xmm8,%xmm4
movaps %xmm5,%xmm9
movaps %xmm8,%xmm3
shufps $0x4,%xmm5,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm7,%xmm1
unpcklps %xmm2,%xmm1
addss  %xmm4,%xmm2
unpcklps %xmm4,%xmm5
subps  %xmm5,%xmm1
movaps %xmm1,%xmm0
movaps %xmm3,%xmm4
movaps %xmm3,%xmm6
subps  %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm3
subss  %xmm3,%xmm2
mulss  %xmm9,%xmm9
subss  %xmm9,%xmm2
movss  %xmm2,(%r14)
shufps $0x0,%xmm7,%xmm7
movlhps %xmm8,%xmm5
mulps  %xmm7,%xmm5
shufps $0x1,%xmm5,%xmm0
shufps $0xe2,%xmm5,%xmm0
addps  %xmm0,%xmm4
movaps %xmm4,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%r14)
subps  %xmm0,%xmm6
movaps %xmm6,%xmm2
shufps $0xff,%xmm6,%xmm2
addss  %xmm2,%xmm2
movss  %xmm2,0x8(%r14)
movaps %xmm4,%xmm2
movss  %xmm6,%xmm2
unpcklps %xmm9,%xmm3
addps  %xmm2,%xmm2
subps  %xmm3,%xmm4
shufps $0x1,%xmm2,%xmm4
shufps $0xe2,%xmm2,%xmm4
movups %xmm4,0xc(%r14)
movhlps %xmm6,%xmm6
addss  %xmm6,%xmm6
movss  %xmm6,0x1c(%r14)
shufps $0x55,%xmm1,%xmm1
addss  %xmm9,%xmm1
movss  %xmm1,0x20(%r14)
xor    %eax,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @FastCalcRMSDAndRotation(float* %0, float* %1, float* %2, float %3, i32 %4, float %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float
%12 = alloca i32
%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 float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca [4 x float]
%44 = alloca i32
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
%57 = alloca float
%58 = alloca float
%59 = alloca float
%60 = alloca float
%61 = alloca float
%62 = alloca float
%63 = alloca float
%64 = alloca float
%65 = alloca float
%66 = alloca float
%67 = alloca float
%68 = alloca float
%69 = alloca float
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float
%74 = alloca float
%75 = alloca float
%76 = alloca float
%77 = alloca float
%78 = alloca float
%79 = alloca float
%80 = alloca float
%81 = alloca float
%82 = alloca float
%83 = alloca float
%84 = alloca float
%85 = alloca float
%86 = alloca float
%87 = alloca float
%88 = alloca float
%89 = alloca float
%90 = alloca float
%91 = alloca float
%92 = alloca float
%93 = alloca float
%94 = alloca float
%95 = alloca float
store float* %0, float** %8
store float* %1, float** %9
store float* %2, float** %10
store float %3, float* %11
store i32 %4, i32* %12
store float %5, float* %13
store float 0.000000e+00, float* %46
store float 0x3D06849B80000000, float* %89
%96 = load float*, float** %9
%97 = getelementptr inbounds float, float* %96, i64 0
%98 = load float, float* %97
store float %98, float* %14
%99 = load float*, float** %9
%100 = getelementptr inbounds float, float* %99, i64 1
%101 = load float, float* %100
store float %101, float* %15
%102 = load float*, float** %9
%103 = getelementptr inbounds float, float* %102, i64 2
%104 = load float, float* %103
store float %104, float* %16
%105 = load float*, float** %9
%106 = getelementptr inbounds float, float* %105, i64 3
%107 = load float, float* %106
store float %107, float* %17
%108 = load float*, float** %9
%109 = getelementptr inbounds float, float* %108, i64 4
%110 = load float, float* %109
store float %110, float* %18
%111 = load float*, float** %9
%112 = getelementptr inbounds float, float* %111, i64 5
%113 = load float, float* %112
store float %113, float* %19
%114 = load float*, float** %9
%115 = getelementptr inbounds float, float* %114, i64 6
%116 = load float, float* %115
store float %116, float* %20
%117 = load float*, float** %9
%118 = getelementptr inbounds float, float* %117, i64 7
%119 = load float, float* %118
store float %119, float* %21
%120 = load float*, float** %9
%121 = getelementptr inbounds float, float* %120, i64 8
%122 = load float, float* %121
store float %122, float* %22
%123 = load float, float* %14
%124 = load float, float* %14
%125 = fmul float %123, %124
store float %125, float* %25
%126 = load float, float* %18
%127 = load float, float* %18
%128 = fmul float %126, %127
store float %128, float* %24
%129 = load float, float* %22
%130 = load float, float* %22
%131 = fmul float %129, %130
store float %131, float* %23
%132 = load float, float* %15
%133 = load float, float* %15
%134 = fmul float %132, %133
store float %134, float* %26
%135 = load float, float* %19
%136 = load float, float* %19
%137 = fmul float %135, %136
store float %137, float* %27
%138 = load float, float* %16
%139 = load float, float* %16
%140 = fmul float %138, %139
store float %140, float* %28
%141 = load float, float* %17
%142 = load float, float* %17
%143 = fmul float %141, %142
store float %143, float* %29
%144 = load float, float* %21
%145 = load float, float* %21
%146 = fmul float %144, %145
store float %146, float* %30
%147 = load float, float* %20
%148 = load float, float* %20
%149 = fmul float %147, %148
store float %149, float* %31
%150 = load float, float* %19
%151 = load float, float* %21
%152 = load float, float* %18
%153 = load float, float* %22
%154 = fmul float %152, %153
%155 = fneg float %154
%156 = call float @llvm.fmuladd.f32(float %150, float %151, float %155)
%157 = fpext float %156 to double
%158 = fmul double 2.000000e+00, %157
%159 = fptrunc double %158 to float
store float %159, float* %32
%160 = load float, float* %24
%161 = load float, float* %23
%162 = fadd float %160, %161
%163 = load float, float* %25
%164 = fsub float %162, %163
%165 = load float, float* %27
%166 = fadd float %164, %165
%167 = load float, float* %30
%168 = fadd float %166, %167
store float %168, float* %33
%169 = load float, float* %25
%170 = load float, float* %24
%171 = fadd float %169, %170
%172 = load float, float* %23
%173 = fadd float %171, %172
%174 = load float, float* %26
%175 = fadd float %173, %174
%176 = load float, float* %29
%177 = fadd float %175, %176
%178 = load float, float* %28
%179 = fadd float %177, %178
%180 = load float, float* %31
%181 = fadd float %179, %180
%182 = load float, float* %27
%183 = fadd float %181, %182
%184 = load float, float* %30
%185 = fadd float %183, %184
%186 = fpext float %185 to double
%187 = fmul double -2.000000e+00, %186
%188 = fptrunc double %187 to float
%189 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 2
store float %188, float* %189
%190 = load float, float* %14
%191 = load float, float* %19
%192 = fmul float %190, %191
%193 = load float, float* %21
%194 = load float, float* %18
%195 = load float, float* %20
%196 = fmul float %194, %195
%197 = load float, float* %16
%198 = fmul float %196, %197
%199 = call float @llvm.fmuladd.f32(float %192, float %193, float %198)
%200 = load float, float* %22
%201 = load float, float* %15
%202 = fmul float %200, %201
%203 = load float, float* %17
%204 = call float @llvm.fmuladd.f32(float %202, float %203, float %199)
%205 = load float, float* %14
%206 = load float, float* %18
%207 = fmul float %205, %206
%208 = load float, float* %22
%209 = fneg float %207
%210 = call float @llvm.fmuladd.f32(float %209, float %208, float %204)
%211 = load float, float* %19
%212 = load float, float* %20
%213 = fmul float %211, %212
%214 = load float, float* %15
%215 = fneg float %213
%216 = call float @llvm.fmuladd.f32(float %215, float %214, float %210)
%217 = load float, float* %21
%218 = load float, float* %17
%219 = fmul float %217, %218
%220 = load float, float* %16
%221 = fneg float %219
%222 = call float @llvm.fmuladd.f32(float %221, float %220, float %216)
%223 = fpext float %222 to double
%224 = fmul double 8.000000e+00, %223
%225 = fptrunc double %224 to float
%226 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 1
store float %225, float* %226
%227 = load float, float* %16
%228 = load float, float* %20
%229 = fadd float %227, %228
store float %229, float* %35
%230 = load float, float* %19
%231 = load float, float* %21
%232 = fadd float %230, %231
store float %232, float* %36
%233 = load float, float* %15
%234 = load float, float* %17
%235 = fadd float %233, %234
store float %235, float* %37
%236 = load float, float* %19
%237 = load float, float* %21
%238 = fsub float %236, %237
store float %238, float* %38
%239 = load float, float* %16
%240 = load float, float* %20
%241 = fsub float %239, %240
store float %241, float* %39
%242 = load float, float* %15
%243 = load float, float* %17
%244 = fsub float %242, %243
store float %244, float* %40
%245 = load float, float* %14
%246 = load float, float* %18
%247 = fadd float %245, %246
store float %247, float* %41
%248 = load float, float* %14
%249 = load float, float* %18
%250 = fsub float %248, %249
store float %250, float* %42
%251 = load float, float* %26
%252 = load float, float* %28
%253 = fadd float %251, %252
%254 = load float, float* %29
%255 = fsub float %253, %254
%256 = load float, float* %31
%257 = fsub float %255, %256
store float %257, float* %34
%258 = load float, float* %34
%259 = load float, float* %34
%260 = load float, float* %33
%261 = load float, float* %32
%262 = fadd float %260, %261
%263 = load float, float* %33
%264 = load float, float* %32
%265 = fsub float %263, %264
%266 = fmul float %262, %265
%267 = call float @llvm.fmuladd.f32(float %258, float %259, float %266)
%268 = load float, float* %35
%269 = fneg float %268
%270 = load float, float* %38
%271 = load float, float* %40
%272 = load float, float* %42
%273 = load float, float* %22
%274 = fsub float %272, %273
%275 = fmul float %271, %274
%276 = call float @llvm.fmuladd.f32(float %269, float %270, float %275)
%277 = load float, float* %39
%278 = fneg float %277
%279 = load float, float* %36
%280 = load float, float* %40
%281 = load float, float* %42
%282 = load float, float* %22
%283 = fadd float %281, %282
%284 = fmul float %280, %283
%285 = call float @llvm.fmuladd.f32(float %278, float %279, float %284)
%286 = call float @llvm.fmuladd.f32(float %276, float %285, float %267)
%287 = load float, float* %35
%288 = fneg float %287
%289 = load float, float* %36
%290 = load float, float* %37
%291 = load float, float* %41
%292 = load float, float* %22
%293 = fsub float %291, %292
%294 = fmul float %290, %293
%295 = fneg float %294
%296 = call float @llvm.fmuladd.f32(float %288, float %289, float %295)
%297 = load float, float* %39
%298 = fneg float %297
%299 = load float, float* %38
%300 = load float, float* %37
%301 = load float, float* %41
%302 = load float, float* %22
%303 = fadd float %301, %302
%304 = fmul float %300, %303
%305 = fneg float %304
%306 = call float @llvm.fmuladd.f32(float %298, float %299, float %305)
%307 = call float @llvm.fmuladd.f32(float %296, float %306, float %286)
%308 = load float, float* %37
%309 = load float, float* %36
%310 = load float, float* %35
%311 = load float, float* %42
%312 = load float, float* %22
%313 = fadd float %311, %312
%314 = fmul float %310, %313
%315 = call float @llvm.fmuladd.f32(float %308, float %309, float %314)
%316 = load float, float* %40
%317 = fneg float %316
%318 = load float, float* %38
%319 = load float, float* %35
%320 = load float, float* %41
%321 = load float, float* %22
%322 = fadd float %320, %321
%323 = fmul float %319, %322
%324 = call float @llvm.fmuladd.f32(float %317, float %318, float %323)
%325 = call float @llvm.fmuladd.f32(float %315, float %324, float %307)
%326 = load float, float* %37
%327 = load float, float* %38
%328 = load float, float* %39
%329 = load float, float* %42
%330 = load float, float* %22
%331 = fsub float %329, %330
%332 = fmul float %328, %331
%333 = call float @llvm.fmuladd.f32(float %326, float %327, float %332)
%334 = load float, float* %40
%335 = fneg float %334
%336 = load float, float* %36
%337 = load float, float* %39
%338 = load float, float* %41
%339 = load float, float* %22
%340 = fsub float %338, %339
%341 = fmul float %337, %340
%342 = call float @llvm.fmuladd.f32(float %335, float %336, float %341)
%343 = call float @llvm.fmuladd.f32(float %333, float %342, float %325)
%344 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 0
store float %343, float* %344
%345 = load float, float* %11
store float %345, float* %45
store i32 0, i32* %44
br label %346
346: ; preds = %398, %6
%347 = load i32, i32* %44
%348 = icmp slt i32 %347, 50
br i1 %348, label %349, label %401
349: ; preds = %346
%350 = load float, float* %45
store float %350, float* %46
%351 = load float, float* %45
%352 = load float, float* %45
%353 = fmul float %351, %352
store float %353, float* %74
%354 = load float, float* %74
%355 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 2
%356 = load float, float* %355
%357 = fadd float %354, %356
%358 = load float, float* %45
%359 = fmul float %357, %358
store float %359, float* %47
%360 = load float, float* %47
%361 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 1
%362 = load float, float* %361
%363 = fadd float %360, %362
store float %363, float* %48
%364 = load float, float* %48
%365 = load float, float* %45
%366 = getelementptr inbounds [4 x float], [4 x float]* %43, i64 0, i64 0
%367 = load float, float* %366
%368 = call float @llvm.fmuladd.f32(float %364, float %365, float %367)
%369 = fpext float %368 to double
%370 = load float, float* %74
%371 = fpext float %370 to double
%372 = fmul double 2.000000e+00, %371
%373 = load float, float* %45
%374 = fpext float %373 to double
%375 = load float, float* %47
%376 = fpext float %375 to double
%377 = call double @llvm.fmuladd.f64(double %372, double %374, double %376)
%378 = load float, float* %48
%379 = fpext float %378 to double
%380 = fadd double %377, %379
%381 = fdiv double %369, %380
%382 = fptrunc double %381 to float
store float %382, float* %49
%383 = load float, float* %49
%384 = load float, float* %45
%385 = fsub float %384, %383
store float %385, float* %45
%386 = load float, float* %45
%387 = load float, float* %46
%388 = fsub float %386, %387
%389 = fpext float %388 to double
%390 = call double @llvm.fabs.f64(double %389)
%391 = load float, float* %45
%392 = fpext float %391 to double
%393 = fmul double 0x3EB0C6F7A0B5ED8D, %392
%394 = call double @llvm.fabs.f64(double %393)
%395 = fcmp olt double %390, %394
br i1 %395, label %396, label %397
396: ; preds = %349
br label %401
397: ; preds = %349
br label %398
398: ; preds = %397
%399 = load i32, i32* %44
%400 = add nsw i32 %399, 1
store i32 %400, i32* %44
br label %346
401: ; preds = %396, %346
%402 = load float, float* %11
%403 = load float, float* %45
%404 = fsub float %402, %403
%405 = fpext float %404 to double
%406 = fmul double 2.000000e+00, %405
%407 = load i32, i32* %12
%408 = sitofp i32 %407 to double
%409 = fdiv double %406, %408
%410 = call double @sqrt(double %409)
%411 = fptrunc double %410 to float
store float %411, float* %50
%412 = load float, float* %50
%413 = load float*, float** %10
store float %412, float* %413
%414 = load float, float* %13
%415 = fcmp ogt float %414, 0.000000e+00
br i1 %415, label %416, label %422
416: ; preds = %401
%417 = load float, float* %50
%418 = load float, float* %13
%419 = fcmp olt float %417, %418
br i1 %419, label %420, label %421
420: ; preds = %416
store i32 -1, i32* %7
br label %882
421: ; preds = %416
br label %422
422: ; preds = %421, %401
%423 = load float, float* %41
%424 = load float, float* %22
%425 = fadd float %423, %424
%426 = load float, float* %45
%427 = fsub float %425, %426
store float %427, float* %57
%428 = load float, float* %38
store float %428, float* %58
%429 = load float, float* %39
%430 = fneg float %429
store float %430, float* %59
%431 = load float, float* %40
store float %431, float* %60
%432 = load float, float* %38
store float %432, float* %61
%433 = load float, float* %42
%434 = load float, float* %22
%435 = fsub float %433, %434
%436 = load float, float* %45
%437 = fsub float %435, %436
store float %437, float* %62
%438 = load float, float* %37
store float %438, float* %63
%439 = load float, float* %35
store float %439, float* %64
%440 = load float, float* %59
store float %440, float* %65
%441 = load float, float* %63
store float %441, float* %66
%442 = load float, float* %18
%443 = load float, float* %14
%444 = fsub float %442, %443
%445 = load float, float* %22
%446 = fsub float %444, %445
%447 = load float, float* %45
%448 = fsub float %446, %447
store float %448, float* %67
%449 = load float, float* %36
store float %449, float* %68
%450 = load float, float* %60
store float %450, float* %69
%451 = load float, float* %64
store float %451, float* %70
%452 = load float, float* %68
store float %452, float* %71
%453 = load float, float* %22
%454 = load float, float* %41
%455 = fsub float %453, %454
%456 = load float, float* %45
%457 = fsub float %455, %456
store float %457, float* %72
%458 = load float, float* %67
%459 = load float, float* %72
%460 = load float, float* %71
%461 = load float, float* %68
%462 = fmul float %460, %461
%463 = fneg float %462
%464 = call float @llvm.fmuladd.f32(float %458, float %459, float %463)
store float %464, float* %83
%465 = load float, float* %66
%466 = load float, float* %72
%467 = load float, float* %70
%468 = load float, float* %68
%469 = fmul float %467, %468
%470 = fneg float %469
%471 = call float @llvm.fmuladd.f32(float %465, float %466, float %470)
store float %471, float* %84
%472 = load float, float* %66
%473 = load float, float* %71
%474 = load float, float* %70
%475 = load float, float* %67
%476 = fmul float %474, %475
%477 = fneg float %476
%478 = call float @llvm.fmuladd.f32(float %472, float %473, float %477)
store float %478, float* %85
%479 = load float, float* %65
%480 = load float, float* %71
%481 = load float, float* %69
%482 = load float, float* %67
%483 = fmul float %481, %482
%484 = fneg float %483
%485 = call float @llvm.fmuladd.f32(float %479, float %480, float %484)
store float %485, float* %86
%486 = load float, float* %65
%487 = load float, float* %72
%488 = load float, float* %69
%489 = load float, float* %68
%490 = fmul float %488, %489
%491 = fneg float %490
%492 = call float @llvm.fmuladd.f32(float %486, float %487, float %491)
store float %492, float* %87
%493 = load float, float* %65
%494 = load float, float* %70
%495 = load float, float* %69
%496 = load float, float* %66
%497 = fmul float %495, %496
%498 = fneg float %497
%499 = call float @llvm.fmuladd.f32(float %493, float %494, float %498)
store float %499, float* %88
%500 = load float, float* %62
%501 = load float, float* %83
%502 = load float, float* %63
%503 = load float, float* %84
%504 = fmul float %502, %503
%505 = fneg float %504
%506 = call float @llvm.fmuladd.f32(float %500, float %501, float %505)
%507 = load float, float* %64
%508 = load float, float* %85
%509 = call float @llvm.fmuladd.f32(float %507, float %508, float %506)
store float %509, float* %52
%510 = load float, float* %61
%511 = fneg float %510
%512 = load float, float* %83
%513 = load float, float* %63
%514 = load float, float* %87
%515 = fmul float %513, %514
%516 = call float @llvm.fmuladd.f32(float %511, float %512, float %515)
%517 = load float, float* %64
%518 = load float, float* %86
%519 = fneg float %517
%520 = call float @llvm.fmuladd.f32(float %519, float %518, float %516)
store float %520, float* %53
%521 = load float, float* %61
%522 = load float, float* %84
%523 = load float, float* %62
%524 = load float, float* %87
%525 = fmul float %523, %524
%526 = fneg float %525
%527 = call float @llvm.fmuladd.f32(float %521, float %522, float %526)
%528 = load float, float* %64
%529 = load float, float* %88
%530 = call float @llvm.fmuladd.f32(float %528, float %529, float %527)
store float %530, float* %54
%531 = load float, float* %61
%532 = fneg float %531
%533 = load float, float* %85
%534 = load float, float* %62
%535 = load float, float* %86
%536 = fmul float %534, %535
%537 = call float @llvm.fmuladd.f32(float %532, float %533, float %536)
%538 = load float, float* %63
%539 = load float, float* %88
%540 = fneg float %538
%541 = call float @llvm.fmuladd.f32(float %540, float %539, float %537)
store float %541, float* %55
%542 = load float, float* %52
%543 = load float, float* %52
%544 = load float, float* %53
%545 = load float, float* %53
%546 = fmul float %544, %545
%547 = call float @llvm.fmuladd.f32(float %542, float %543, float %546)
%548 = load float, float* %54
%549 = load float, float* %54
%550 = call float @llvm.fmuladd.f32(float %548, float %549, float %547)
%551 = load float, float* %55
%552 = load float, float* %55
%553 = call float @llvm.fmuladd.f32(float %551, float %552, float %550)
store float %553, float* %51
%554 = load float, float* %51
%555 = load float, float* %89
%556 = fcmp olt float %554, %555
br i1 %556, label %557, label %772
557: ; preds = %422
%558 = load float, float* %58
%559 = load float, float* %83
%560 = load float, float* %59
%561 = load float, float* %84
%562 = fmul float %560, %561
%563 = fneg float %562
%564 = call float @llvm.fmuladd.f32(float %558, float %559, float %563)
%565 = load float, float* %60
%566 = load float, float* %85
%567 = call float @llvm.fmuladd.f32(float %565, float %566, float %564)
store float %567, float* %52
%568 = load float, float* %57
%569 = fneg float %568
%570 = load float, float* %83
%571 = load float, float* %59
%572 = load float, float* %87
%573 = fmul float %571, %572
%574 = call float @llvm.fmuladd.f32(float %569, float %570, float %573)
%575 = load float, float* %60
%576 = load float, float* %86
%577 = fneg float %575
%578 = call float @llvm.fmuladd.f32(float %577, float %576, float %574)
store float %578, float* %53
%579 = load float, float* %57
%580 = load float, float* %84
%581 = load float, float* %58
%582 = load float, float* %87
%583 = fmul float %581, %582
%584 = fneg float %583
%585 = call float @llvm.fmuladd.f32(float %579, float %580, float %584)
%586 = load float, float* %60
%587 = load float, float* %88
%588 = call float @llvm.fmuladd.f32(float %586, float %587, float %585)
store float %588, float* %54
%589 = load float, float* %57
%590 = fneg float %589
%591 = load float, float* %85
%592 = load float, float* %58
%593 = load float, float* %86
%594 = fmul float %592, %593
%595 = call float @llvm.fmuladd.f32(float %590, float %591, float %594)
%596 = load float, float* %59
%597 = load float, float* %88
%598 = fneg float %596
%599 = call float @llvm.fmuladd.f32(float %598, float %597, float %595)
store float %599, float* %55
%600 = load float, float* %52
%601 = load float, float* %52
%602 = load float, float* %53
%603 = load float, float* %53
%604 = fmul float %602, %603
%605 = call float @llvm.fmuladd.f32(float %600, float %601, float %604)
%606 = load float, float* %54
%607 = load float, float* %54
%608 = call float @llvm.fmuladd.f32(float %606, float %607, float %605)
%609 = load float, float* %55
%610 = load float, float* %55
%611 = call float @llvm.fmuladd.f32(float %609, float %610, float %608)
store float %611, float* %51
%612 = load float, float* %51
%613 = load float, float* %89
%614 = fcmp olt float %612, %613
br i1 %614, label %615, label %771
615: ; preds = %557
%616 = load float, float* %59
%617 = load float, float* %64
%618 = load float, float* %60
%619 = load float, float* %63
%620 = fmul float %618, %619
%621 = fneg float %620
%622 = call float @llvm.fmuladd.f32(float %616, float %617, float %621)
store float %622, float* %90
%623 = load float, float* %58
%624 = load float, float* %64
%625 = load float, float* %60
%626 = load float, float* %62
%627 = fmul float %625, %626
%628 = fneg float %627
%629 = call float @llvm.fmuladd.f32(float %623, float %624, float %628)
store float %629, float* %91
%630 = load float, float* %58
%631 = load float, float* %63
%632 = load float, float* %59
%633 = load float, float* %62
%634 = fmul float %632, %633
%635 = fneg float %634
%636 = call float @llvm.fmuladd.f32(float %630, float %631, float %635)
store float %636, float* %92
%637 = load float, float* %57
%638 = load float, float* %64
%639 = load float, float* %60
%640 = load float, float* %61
%641 = fmul float %639, %640
%642 = fneg float %641
%643 = call float @llvm.fmuladd.f32(float %637, float %638, float %642)
store float %643, float* %93
%644 = load float, float* %57
%645 = load float, float* %63
%646 = load float, float* %59
%647 = load float, float* %61
%648 = fmul float %646, %647
%649 = fneg float %648
%650 = call float @llvm.fmuladd.f32(float %644, float %645, float %649)
store float %650, float* %94
%651 = load float, float* %57
%652 = load float, float* %62
%653 = load float, float* %58
%654 = load float, float* %61
%655 = fmul float %653, %654
%656 = fneg float %655
%657 = call float @llvm.fmuladd.f32(float %651, float %652, float %656)
store float %657, float* %95
%658 = load float, float* %70
%659 = load float, float* %90
%660 = load float, float* %71
%661 = load float, float* %91
%662 = fmul float %660, %661
%663 = fneg float %662
%664 = call float @llvm.fmuladd.f32(float %658, float %659, float %663)
%665 = load float, float* %72
%666 = load float, float* %92
%667 = call float @llvm.fmuladd.f32(float %665, float %666, float %664)
store float %667, float* %52
%668 = load float, float* %69
%669 = fneg float %668
%670 = load float, float* %90
%671 = load float, float* %71
%672 = load float, float* %93
%673 = fmul float %671, %672
%674 = call float @llvm.fmuladd.f32(float %669, float %670, float %673)
%675 = load float, float* %72
%676 = load float, float* %94
%677 = fneg float %675
%678 = call float @llvm.fmuladd.f32(float %677, float %676, float %674)
store float %678, float* %53
%679 = load float, float* %69
%680 = load float, float* %91
%681 = load float, float* %70
%682 = load float, float* %93
%683 = fmul float %681, %682
%684 = fneg float %683
%685 = call float @llvm.fmuladd.f32(float %679, float %680, float %684)
%686 = load float, float* %72
%687 = load float, float* %95
%688 = call float @llvm.fmuladd.f32(float %686, float %687, float %685)
store float %688, float* %54
%689 = load float, float* %69
%690 = fneg float %689
%691 = load float, float* %92
%692 = load float, float* %70
%693 = load float, float* %94
%694 = fmul float %692, %693
%695 = call float @llvm.fmuladd.f32(float %690, float %691, float %694)
%696 = load float, float* %71
%697 = load float, float* %95
%698 = fneg float %696
%699 = call float @llvm.fmuladd.f32(float %698, float %697, float %695)
store float %699, float* %55
%700 = load float, float* %52
%701 = load float, float* %52
%702 = load float, float* %53
%703 = load float, float* %53
%704 = fmul float %702, %703
%705 = call float @llvm.fmuladd.f32(float %700, float %701, float %704)
%706 = load float, float* %54
%707 = load float, float* %54
%708 = call float @llvm.fmuladd.f32(float %706, float %707, float %705)
%709 = load float, float* %55
%710 = load float, float* %55
%711 = call float @llvm.fmuladd.f32(float %709, float %710, float %708)
store float %711, float* %51
%712 = load float, float* %51
%713 = load float, float* %89
%714 = fcmp olt float %712, %713
br i1 %714, label %715, label %770
715: ; preds = %615
%716 = load float, float* %66
%717 = load float, float* %90
%718 = load float, float* %67
%719 = load float, float* %91
%720 = fmul float %718, %719
%721 = fneg float %720
%722 = call float @llvm.fmuladd.f32(float %716, float %717, float %721)
%723 = load float, float* %68
%724 = load float, float* %92
%725 = call float @llvm.fmuladd.f32(float %723, float %724, float %722)
store float %725, float* %52
%726 = load float, float* %65
%727 = fneg float %726
%728 = load float, float* %90
%729 = load float, float* %67
%730 = load float, float* %93
%731 = fmul float %729, %730
%732 = call float @llvm.fmuladd.f32(float %727, float %728, float %731)
%733 = load float, float* %68
%734 = load float, float* %94
%735 = fneg float %733
%736 = call float @llvm.fmuladd.f32(float %735, float %734, float %732)
store float %736, float* %53
%737 = load float, float* %65
%738 = load float, float* %91
%739 = load float, float* %66
%740 = load float, float* %93
%741 = fmul float %739, %740
%742 = fneg float %741
%743 = call float @llvm.fmuladd.f32(float %737, float %738, float %742)
%744 = load float, float* %68
%745 = load float, float* %95
%746 = call float @llvm.fmuladd.f32(float %744, float %745, float %743)
store float %746, float* %54
%747 = load float, float* %65
%748 = fneg float %747
%749 = load float, float* %92
%750 = load float, float* %66
%751 = load float, float* %94
%752 = fmul float %750, %751
%753 = call float @llvm.fmuladd.f32(float %748, float %749, float %752)
%754 = load float, float* %67
%755 = load float, float* %95
%756 = fneg float %754
%757 = call float @llvm.fmuladd.f32(float %756, float %755, float %753)
store float %757, float* %55
%758 = load float, float* %52
%759 = load float, float* %52
%760 = load float, float* %53
%761 = load float, float* %53
%762 = fmul float %760, %761
%763 = call float @llvm.fmuladd.f32(float %758, float %759, float %762)
%764 = load float, float* %54
%765 = load float, float* %54
%766 = call float @llvm.fmuladd.f32(float %764, float %765, float %763)
%767 = load float, float* %55
%768 = load float, float* %55
%769 = call float @llvm.fmuladd.f32(float %767, float %768, float %766)
store float %769, float* %51
br label %770
770: ; preds = %715, %615
br label %771
771: ; preds = %770, %557
br label %772
772: ; preds = %771, %422
%773 = load float, float* %51
%774 = fpext float %773 to double
%775 = call double @sqrt(double %774)
%776 = fptrunc double %775 to float
store float %776, float* %56
%777 = load float, float* %56
%778 = load float, float* %52
%779 = fdiv float %778, %777
store float %779, float* %52
%780 = load float, float* %56
%781 = load float, float* %53
%782 = fdiv float %781, %780
store float %782, float* %53
%783 = load float, float* %56
%784 = load float, float* %54
%785 = fdiv float %784, %783
store float %785, float* %54
%786 = load float, float* %56
%787 = load float, float* %55
%788 = fdiv float %787, %786
store float %788, float* %55
%789 = load float, float* %52
%790 = load float, float* %52
%791 = fmul float %789, %790
store float %791, float* %73
%792 = load float, float* %53
%793 = load float, float* %53
%794 = fmul float %792, %793
store float %794, float* %74
%795 = load float, float* %54
%796 = load float, float* %54
%797 = fmul float %795, %796
store float %797, float* %75
%798 = load float, float* %55
%799 = load float, float* %55
%800 = fmul float %798, %799
store float %800, float* %76
%801 = load float, float* %53
%802 = load float, float* %54
%803 = fmul float %801, %802
store float %803, float* %77
%804 = load float, float* %52
%805 = load float, float* %55
%806 = fmul float %804, %805
store float %806, float* %78
%807 = load float, float* %55
%808 = load float, float* %53
%809 = fmul float %807, %808
store float %809, float* %79
%810 = load float, float* %52
%811 = load float, float* %54
%812 = fmul float %810, %811
store float %812, float* %80
%813 = load float, float* %54
%814 = load float, float* %55
%815 = fmul float %813, %814
store float %815, float* %81
%816 = load float, float* %52
%817 = load float, float* %53
%818 = fmul float %816, %817
store float %818, float* %82
%819 = load float, float* %73
%820 = load float, float* %74
%821 = fadd float %819, %820
%822 = load float, float* %75
%823 = fsub float %821, %822
%824 = load float, float* %76
%825 = fsub float %823, %824
%826 = load float*, float** %8
%827 = getelementptr inbounds float, float* %826, i64 0
store float %825, float* %827
%828 = load float, float* %77
%829 = load float, float* %78
%830 = fadd float %828, %829
%831 = fmul float 2.000000e+00, %830
%832 = load float*, float** %8
%833 = getelementptr inbounds float, float* %832, i64 1
store float %831, float* %833
%834 = load float, float* %79
%835 = load float, float* %80
%836 = fsub float %834, %835
%837 = fmul float 2.000000e+00, %836
%838 = load float*, float** %8
%839 = getelementptr inbounds float, float* %838, i64 2
store float %837, float* %839
%840 = load float, float* %77
%841 = load float, float* %78
%842 = fsub float %840, %841
%843 = fmul float 2.000000e+00, %842
%844 = load float*, float** %8
%845 = getelementptr inbounds float, float* %844, i64 3
store float %843, float* %845
%846 = load float, float* %73
%847 = load float, float* %74
%848 = fsub float %846, %847
%849 = load float, float* %75
%850 = fadd float %848, %849
%851 = load float, float* %76
%852 = fsub float %850, %851
%853 = load float*, float** %8
%854 = getelementptr inbounds float, float* %853, i64 4
store float %852, float* %854
%855 = load float, float* %81
%856 = load float, float* %82
%857 = fadd float %855, %856
%858 = fmul float 2.000000e+00, %857
%859 = load float*, float** %8
%860 = getelementptr inbounds float, float* %859, i64 5
store float %858, float* %860
%861 = load float, float* %79
%862 = load float, float* %80
%863 = fadd float %861, %862
%864 = fmul float 2.000000e+00, %863
%865 = load float*, float** %8
%866 = getelementptr inbounds float, float* %865, i64 6
store float %864, float* %866
%867 = load float, float* %81
%868 = load float, float* %82
%869 = fsub float %867, %868
%870 = fmul float 2.000000e+00, %869
%871 = load float*, float** %8
%872 = getelementptr inbounds float, float* %871, i64 7
store float %870, float* %872
%873 = load float, float* %73
%874 = load float, float* %74
%875 = fsub float %873, %874
%876 = load float, float* %75
%877 = fsub float %875, %876
%878 = load float, float* %76
%879 = fadd float %877, %878
%880 = load float*, float** %8
%881 = getelementptr inbounds float, float* %880, i64 8
store float %879, float* %881
store i32 0, i32* %7
br label %882
882: ; preds = %772, %420
%883 = load i32, i32* %7
ret i32 %883
}

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