void inverseComposePoint(const float m_coord_x, const float m_coord_y,
                         const float m_coord_z, const float m_quat_r,
                         const float m_quat_x, const float m_quat_y,
                         const float m_quat_z, const float gx, const float gy,
                         const float gz, float lx[1], float ly[1], float lz[1],
                         float out_jacobian_df_dpoint[3][3],
                         float out_jacobian_df_dpose[3][7]) {
  const float qr = m_quat_r;
  const float qx = m_quat_x;
  const float qy = m_quat_y;
  const float qz = m_quat_z;
  const float qx2 = qx * qx;
  const float qy2 = qy * qy;
  const float qz2 = qz * qz;
  const float Ax = 2 * (gx - m_coord_x);
  const float Ay = 2 * (gy - m_coord_y);
  const float Az = 2 * (gz - m_coord_z);
  out_jacobian_df_dpoint[0][0] = 1 - 2 * (qy2 + qz2);
  out_jacobian_df_dpoint[0][1] = 2 * (-qr * qz + qx * qy);
  out_jacobian_df_dpoint[0][2] = 2 * (qx * qz + qr * qy);
  out_jacobian_df_dpoint[1][0] = 2 * (qx * qy + qr * qz);
  out_jacobian_df_dpoint[1][1] = 1 - 2 * (qx2 + qz2);
  out_jacobian_df_dpoint[1][2] = 2 * (-qr * qx + qy * qz);
  out_jacobian_df_dpoint[2][0] = 2 * (-qr * qy + qx * qz);
  out_jacobian_df_dpoint[2][1] = 2 * (qy * qz + qr * qx);
  out_jacobian_df_dpoint[2][2] = 1 - 2 * (qx2 + qy2);
  float normSqr = qr * qr + qx * qx + qy * qy + qz * qz;
  const float n = inverseSqrt(normSqr * normSqr * normSqr);
  out_jacobian_df_dpose[0][0] = 2 * qy2 + 2 * qz2 - 1;
  out_jacobian_df_dpose[0][1] = -2 * qr * qz - 2 * qx * qy;
  out_jacobian_df_dpose[0][2] = 2 * qr * qy - 2 * qx * qz;
  out_jacobian_df_dpose[0][3] =
      n * ((-qy * Az + qz * Ay) * (qx * qx + qy * qy + qz * qz) +
           (qy * Ay + qz * Az) * (-qx * qr) +
           (qx * Ay - 2 * qy * Ax - qr * Az) * (-qy * qr) +
           (qx * Az + qr * Ay - 2 * qz * Ax) * (-qz * qr));
  out_jacobian_df_dpose[0][4] =
      n * ((-qy * Az + qz * Ay) * (-qr * qx) +
           (qy * Ay + qz * Az) * (qr * qr + qy * qy + qz * qz) +
           (qx * Ay - 2 * qy * Ax - qr * Az) * (-qy * qx) +
           (qx * Az + qr * Ay - 2 * qz * Ax) * (-qz * qx));
  out_jacobian_df_dpose[0][5] =
      n *
      ((-qy * Az + qz * Ay) * (-qr * qy) + (qy * Ay + qz * Az) * (-qx * qy) +
       (qx * Ay - 2 * qy * Ax - qr * Az) * (qr * qr + qx * qx + qz * qz) +
       (qx * Az + qr * Ay - 2 * qz * Ax) * (-qz * qy));
  out_jacobian_df_dpose[0][6] =
      n *
      ((-qy * Az + qz * Ay) * (-qr * qz) + (qy * Ay + qz * Az) * (-qx * qz) +
       (qx * Ay - 2 * qy * Ax - qr * Az) * (-qy * qz) +
       (qx * Az + qr * Ay - 2 * qz * Ax) * (qr * qr + qx * qx + qy * qy));
  out_jacobian_df_dpose[1][0] = 2 * qr * qz - 2 * qx * qy;
  out_jacobian_df_dpose[1][1] = 2 * qx2 + 2 * qz2 - 1;
  out_jacobian_df_dpose[1][2] = -2 * qr * qx - 2 * qy * qz;
  out_jacobian_df_dpose[1][3] =
      n * ((qx * Az - qz * Ax) * (qx * qx + qy * qy + qz * qz) +
           (qy * Ax - 2 * qx * Ay + qr * Az) * (-qx * qr) +
           (qx * Ax + qz * Az) * (-qy * qr) +
           (qy * Az - 2 * qz * Ay - qr * Ax) * (-qz * qr));
  out_jacobian_df_dpose[1][4] =
      n * ((qx * Az - qz * Ax) * (-qr * qx) +
           (qy * Ax - 2 * qx * Ay + qr * Az) * (qr * qr + qy * qy + qz * qz) +
           (qx * Ax + qz * Az) * (-qy * qx) +
           (qy * Az - 2 * qz * Ay - qr * Ax) * (-qz * qx));
  out_jacobian_df_dpose[1][5] =
      n * ((qx * Az - qz * Ax) * (-qr * qy) +
           (qy * Ax - 2 * qx * Ay + qr * Az) * (-qx * qy) +
           (qx * Ax + qz * Az) * (qr * qr + qx * qx + qz * qz) +
           (qy * Az - 2 * qz * Ay - qr * Ax) * (-qz * qy));
  out_jacobian_df_dpose[1][6] =
      n * ((qx * Az - qz * Ax) * (-qr * qz) +
           (qy * Ax - 2 * qx * Ay + qr * Az) * (-qx * qz) +
           (qx * Ax + qz * Az) * (-qy * qz) +
           (qy * Az - 2 * qz * Ay - qr * Ax) * (qr * qr + qx * qx + qy * qy));
  out_jacobian_df_dpose[2][0] = -2 * qr * qy - 2 * qx * qz;
  out_jacobian_df_dpose[2][1] = 2 * qr * qx - 2 * qy * qz;
  out_jacobian_df_dpose[2][2] = 2 * qx2 + 2 * qy2 - 1;
  out_jacobian_df_dpose[2][3] =
      n * ((qy * Ax - qx * Ay) * (qx * qx + qy * qy + qz * qz) +
           (qz * Ax - qr * Ay - 2 * qx * Az) * (-qx * qr) +
           (qr * Ax + qz * Ay - 2 * qy * Az) * (-qy * qr) +
           (qx * Ax + qy * Ay) * (-qz * qr));
  out_jacobian_df_dpose[2][4] =
      n * ((qy * Ax - qx * Ay) * (-qr * qx) +
           (qz * Ax - qr * Ay - 2 * qx * Az) * (qr * qr + qy * qy + qz * qz) +
           (qr * Ax + qz * Ay - 2 * qy * Az) * (-qy * qx) +
           (qx * Ax + qy * Ay) * (-qz * qx));
  out_jacobian_df_dpose[2][5] =
      n * ((qy * Ax - qx * Ay) * (-qr * qy) +
           (qz * Ax - qr * Ay - 2 * qx * Az) * (-qx * qy) +
           (qr * Ax + qz * Ay - 2 * qy * Az) * (qr * qr + qx * qx + qz * qz) +
           (qx * Ax + qy * Ay) * (-qz * qy));
  out_jacobian_df_dpose[2][6] =
      n * ((qy * Ax - qx * Ay) * (-qr * qz) +
           (qz * Ax - qr * Ay - 2 * qx * Az) * (-qx * qz) +
           (qr * Ax + qz * Ay - 2 * qy * Az) * (-qy * qz) +
           (qx * Ax + qy * Ay) * (qr * qr + qx * qx + qy * qy));
  const float t2 = -qr * qx;
  const float t3 = -qr * qy;
  const float t4 = -qr * qz;
  const float t5 = -qx * qx;
  const float t6 = qx * qy;
  const float t7 = qx * qz;
  const float t8 = -qy * qy;
  const float t9 = qy * qz;
  const float t10 = -qz * qz;
  *lx = 2 * ((t8 + t10) * (gx - m_coord_x) + (t6 - t4) * (gy - m_coord_y) +
             (t3 + t7) * (gz - m_coord_z)) +
        (gx - m_coord_x);
  *ly = 2 * ((t4 + t6) * (gx - m_coord_x) + (t5 + t10) * (gy - m_coord_y) +
             (t9 - t2) * (gz - m_coord_z)) +
        (gy - m_coord_y);
  *lz = 2 * ((t7 - t3) * (gx - m_coord_x) + (t2 + t9) * (gy - m_coord_y) +
             (t5 + t8) * (gz - m_coord_z)) +
        (gz - m_coord_z);
}


x86 assembly (clang, -O0):
<inverseComposePoint>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movss  0x18(%rbp),%xmm8
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  %xmm4,-0x14(%rbp)
movss  %xmm5,-0x18(%rbp)
movss  %xmm6,-0x1c(%rbp)
movss  %xmm7,-0x20(%rbp)
mov    %rdi,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x20(%rbp),%xmm1
subss  -0x4(%rbp),%xmm1
movss  0x1e36(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  0x10(%rbp),%xmm1
subss  -0x8(%rbp),%xmm1
movss  0x1e1b(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  0x18(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
movss  0x1e00(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x60(%rbp),%xmm1
addss  -0x64(%rbp),%xmm1
addss  %xmm1,%xmm1
movss  0x1de5(%rip),%xmm0
subss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x50(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1da4(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1d73(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x50(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1d42(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm1
addss  -0x64(%rbp),%xmm1
addss  %xmm1,%xmm1
movss  0x1d23(%rip),%xmm0
subss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1ce1(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x50(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1ca3(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1c72(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x5c(%rbp),%xmm1
addss  -0x60(%rbp),%xmm1
addss  %xmm1,%xmm1
movss  0x1c53(%rip),%xmm0
subss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <inverseSqrt@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x60(%rbp),%xmm0
movss  0x1bcd(%rip),%xmm1
mulss  -0x64(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x1bbc(%rip),%xmm1
subss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  0x1bac(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  0x1b92(%rip),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  0x1b62(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  0x1b50(%rip),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x50(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm5
movss  -0x58(%rbp),%xmm4
mulss  -0x70(%rbp),%xmm4
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x4c(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm3
movss  -0x6c(%rbp),%xmm4
movss  0x1a7b(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0x19fa(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm5
movss  -0x58(%rbp),%xmm4
mulss  -0x70(%rbp),%xmm4
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x4c(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm6
movss  -0x54(%rbp),%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movss  -0x58(%rbp),%xmm4
movss  -0x58(%rbp),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm3
movss  -0x6c(%rbp),%xmm4
movss  0x1902(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0x1881(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm5
movss  -0x58(%rbp),%xmm4
mulss  -0x70(%rbp),%xmm4
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm3
movss  -0x6c(%rbp),%xmm4
movss  0x17a0(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0x1708(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm5
movss  -0x58(%rbp),%xmm4
mulss  -0x70(%rbp),%xmm4
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm3
movss  -0x6c(%rbp),%xmm4
movss  0x1627(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  0x15a6(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x54(%rbp),%xmm3
movss  -0x54(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  0x153c(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  0x152a(%rip),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x5c(%rbp),%xmm0
movss  0x14f5(%rip),%xmm1
mulss  -0x64(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0x14e4(%rip),%xmm1
subss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  0x14d3(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  0x14b9(%rip),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x50(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x54(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  0x1423(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x4c(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm3
mulss  -0x70(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x54(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  0x1382(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x4c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
movss  -0x54(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  0x12c1(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x4c(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm6
movss  -0x54(%rbp),%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movss  -0x58(%rbp),%xmm4
movss  -0x58(%rbp),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm3
mulss  -0x70(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x54(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  0x1209(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x4c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
movss  -0x54(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  0x1148(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm3
mulss  -0x70(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x54(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  0x1090(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x4c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x68(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
movss  -0x54(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  0xfcf(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm3
mulss  -0x70(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x54(%rbp),%xmm3
movss  -0x70(%rbp),%xmm4
movss  0xf2e(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x4c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x54(%rbp),%xmm3
movss  -0x54(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  0xead(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  0xe93(%rip),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  0xe63(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  0xe51(%rip),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x3c(%rax)
movss  -0x5c(%rbp),%xmm0
movss  0xe1c(%rip),%xmm1
mulss  -0x60(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0xe0b(%rip),%xmm1
subss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x40(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
movss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x50(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x58(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  0xd6d(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x4c(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0xd07(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x6c(%rbp),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x4c(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x44(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
movss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  0xc0b(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x4c(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm6
movss  -0x54(%rbp),%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movss  -0x58(%rbp),%xmm4
movss  -0x58(%rbp),%xmm6
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0xb8e(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x6c(%rbp),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x48(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
movss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  0xa92(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x54(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0xa2c(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x6c(%rbp),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x58(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x54(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4c(%rax)
movss  -0x78(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
movss  -0x50(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
movss  -0x68(%rbp),%xmm5
movss  -0x4c(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movss  0x919(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm5
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  -0x50(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x68(%rbp),%xmm4
movss  -0x58(%rbp),%xmm2
mulss  -0x6c(%rbp),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x8b3(%rip),%xmm2
mulss  -0x54(%rbp),%xmm2
movss  -0x70(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  -0x54(%rbp),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  -0x58(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x50(%rbp),%xmm1
movss  -0x68(%rbp),%xmm4
movss  -0x54(%rbp),%xmm3
mulss  -0x6c(%rbp),%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x4c(%rbp),%xmm5
movss  -0x50(%rbp),%xmm3
mulss  -0x50(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x54(%rbp),%xmm3
movss  -0x54(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x50(%rax)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x50(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x50(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x54(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x94(%rbp),%xmm1
ff
addss  -0x9c(%rbp),%xmm1
ff
movss  -0x20(%rbp),%xmm2
subss  -0x4(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x84(%rbp),%xmm0
ff
movss  0x10(%rbp),%xmm3
subss  -0x8(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
movss  0x18(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
subss  -0x4(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x84(%rbp),%xmm1
ff
addss  -0x8c(%rbp),%xmm1
ff
movss  -0x20(%rbp),%xmm2
subss  -0x4(%rbp),%xmm2
movss  -0x88(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  0x10(%rbp),%xmm3
subss  -0x8(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x98(%rbp),%xmm0
ff
subss  -0x7c(%rbp),%xmm0
movss  0x18(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rbp),%xmm1
subss  -0x8(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x90(%rbp),%xmm1
ff
subss  -0x80(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
subss  -0x4(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm0
addss  -0x98(%rbp),%xmm0
ff
movss  0x10(%rbp),%xmm3
subss  -0x8(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
movss  0x18(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x18(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inverseComposePoint>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r8,%rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
movaps %xmm6,%xmm13
movaps %xmm3,%xmm14
movss  0x2d8(%rsp),%xmm10
movss  0x2d0(%rsp),%xmm3
movaps %xmm4,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm6,%xmm11
movaps %xmm5,%xmm6
mulss  %xmm5,%xmm6
movaps %xmm6,%xmm12
movaps %xmm13,%xmm8
mulss  %xmm13,%xmm8
subss  %xmm0,%xmm7
movss  %xmm7,0xc(%rsp)
subss  %xmm1,%xmm3
movaps %xmm3,%xmm9
movss  %xmm3,0x18(%rsp)
subss  %xmm2,%xmm10
movss  %xmm10,0x1c(%rsp)
movaps %xmm6,%xmm1
addss  %xmm8,%xmm1
addss  %xmm1,%xmm1
movss  0xe63(%rip),%xmm15
movaps %xmm15,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rcx)
movaps %xmm4,%xmm3
movaps %xmm5,%xmm6
mulss  %xmm5,%xmm3
movaps %xmm14,%xmm1
mulss  %xmm13,%xmm1
movaps %xmm3,%xmm2
movaps %xmm3,%xmm7
movaps %xmm3,0x290(%rsp)
subss  %xmm1,%xmm2
addss  %xmm2,%xmm2
movss  %xmm2,0x4(%rcx)
movaps %xmm14,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm5,0x110(%rsp)
movaps %xmm4,%xmm5
movaps %xmm4,0xd0(%rsp)
mulss  %xmm13,%xmm5
movaps %xmm13,0xc0(%rsp)
movaps %xmm5,%xmm3
movaps %xmm5,0x100(%rsp)
addss  %xmm2,%xmm3
addss  %xmm3,%xmm3
movss  %xmm3,0x8(%rcx)
addss  %xmm7,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,0xc(%rcx)
movaps %xmm11,%xmm1
movaps %xmm8,0x20(%rsp)
addss  %xmm8,%xmm1
addss  %xmm1,%xmm1
movaps %xmm15,%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,0x10(%rcx)
movaps %xmm14,%xmm3
xorps  0xdc0(%rip),%xmm3
movaps %xmm3,0xb0(%rsp)
mulss  %xmm13,%xmm6
mulss  %xmm4,%xmm3
movaps %xmm3,0x120(%rsp)
addss  %xmm6,%xmm3
movaps %xmm3,0x280(%rsp)
movaps %xmm6,0x270(%rsp)
movaps %xmm3,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,0x14(%rcx)
movaps %xmm5,%xmm1
subss  %xmm2,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,0x18(%rcx)
movaps %xmm14,0x60(%rsp)
movaps %xmm14,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm6,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,0x1c(%rcx)
movaps %xmm11,0x250(%rsp)
movaps %xmm11,%xmm1
movaps %xmm12,0x70(%rsp)
addss  %xmm12,%xmm1
movaps %xmm1,0x50(%rsp)
addss  %xmm1,%xmm1
subss  %xmm1,%xmm15
movss  %xmm15,0x20(%rcx)
mulss  %xmm14,%xmm14
movaps %xmm14,0x30(%rsp)
addss  %xmm11,%xmm14
movaps %xmm14,0x40(%rsp)
movaps %xmm12,%xmm1
addss  %xmm14,%xmm1
movaps %xmm1,0x130(%rsp)
addss  %xmm1,%xmm8
movaps %xmm8,%xmm1
mulss  %xmm8,%xmm1
mulss  %xmm8,%xmm1
movss  0xc(%rsp),%xmm0
addss  %xmm0,%xmm0
movss  %xmm0,0xa0(%rsp)
addss  %xmm9,%xmm9
movss  %xmm9,0x8(%rsp)
addss  %xmm10,%xmm10
movss  %xmm10,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mov    $0x1,%al
call   1030 <inverseSqrt@plt>
movaps 0x20(%rsp),%xmm1
addss  %xmm1,%xmm1
movaps %xmm1,0x240(%rsp)
movaps 0x70(%rsp),%xmm0
addss  %xmm0,%xmm0
movaps %xmm0,0x260(%rsp)
addss  %xmm1,%xmm0
movss  0xc83(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%rbx)
movss  0xc77(%rip),%xmm0
movaps 0x60(%rsp),%xmm11
movaps %xmm11,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm1,0x230(%rsp)
movaps 0xd0(%rsp),%xmm14
movaps %xmm14,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm0,%xmm3
movaps %xmm2,%xmm4
movaps %xmm2,%xmm5
movaps %xmm2,0xf0(%rsp)
movaps 0x110(%rsp),%xmm6
mulss  %xmm6,%xmm4
movaps %xmm4,0x210(%rsp)
movaps %xmm1,%xmm0
movaps 0xc0(%rsp),%xmm1
mulss  %xmm1,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x4(%rbx)
movaps %xmm11,%xmm0
addss  %xmm11,%xmm0
movaps %xmm0,0x200(%rsp)
mulss  %xmm1,%xmm5
movaps %xmm5,0x220(%rsp)
mulss  %xmm6,%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,0x8(%rbx)
movss  0x8(%rsp),%xmm4
movaps %xmm4,%xmm13
mulss  %xmm1,%xmm13
movaps %xmm6,%xmm0
movss  0x10(%rsp),%xmm8
mulss  %xmm8,%xmm0
movaps %xmm6,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm2,0x80(%rsp)
movss  0xa0(%rsp),%xmm15
mulss  %xmm15,%xmm2
movaps %xmm2,0x90(%rsp)
mulss  %xmm1,%xmm3
movaps %xmm3,%xmm10
mulss  %xmm15,%xmm10
movaps %xmm1,%xmm9
mulss  %xmm15,%xmm1
movaps %xmm1,0x1f0(%rsp)
movaps %xmm6,%xmm1
mulss  %xmm15,%xmm1
movaps %xmm1,0x1e0(%rsp)
movaps %xmm14,%xmm1
mulss  %xmm15,%xmm1
movaps %xmm1,0xe0(%rsp)
mulss  %xmm4,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm11,%xmm15
subss  %xmm15,%xmm3
movaps %xmm3,0xa0(%rsp)
addss  %xmm13,%xmm15
movaps %xmm13,%xmm2
subss  %xmm0,%xmm2
movaps %xmm11,%xmm7
mulss  %xmm11,%xmm4
movss  %xmm4,0x14(%rsp)
movaps %xmm14,%xmm0
movaps %xmm8,%xmm11
mulss  %xmm8,%xmm0
movaps %xmm0,0x190(%rsp)
addss  %xmm4,%xmm0
addss  %xmm0,%xmm10
movaps %xmm10,0x180(%rsp)
movaps 0x30(%rsp),%xmm8
addss  0x70(%rsp),%xmm8
movaps %xmm6,%xmm13
movaps 0xaf9(%rip),%xmm1
xorps  %xmm1,%xmm13
movaps %xmm7,%xmm10
movaps %xmm7,%xmm12
unpcklps %xmm14,%xmm10
pshufd $0x0,%xmm13,%xmm0
mulps  %xmm0,%xmm10
movaps 0x50(%rsp),%xmm5
movaps 0x20(%rsp),%xmm0
addss  %xmm0,%xmm5
movaps %xmm5,0x50(%rsp)
addss  %xmm0,%xmm8
movaps %xmm8,0x30(%rsp)
movaps 0x40(%rsp),%xmm3
addss  %xmm0,%xmm3
movaps %xmm3,0x40(%rsp)
movaps %xmm14,%xmm3
xorps  %xmm1,%xmm3
movaps %xmm9,%xmm7
xorps  %xmm9,%xmm1
movaps %xmm1,0x20(%rsp)
unpcklps %xmm6,%xmm14
pshufd $0x0,%xmm1,%xmm0
mulps  %xmm0,%xmm14
pshufd $0x0,0xb0(%rsp),%xmm4
movaps %xmm6,%xmm0
unpcklps %xmm9,%xmm0
mulps  %xmm0,%xmm4
pshufd $0x0,%xmm3,%xmm9
movaps %xmm3,0x70(%rsp)
mulps  %xmm0,%xmm9
movaps %xmm11,%xmm1
mulss  %xmm7,%xmm11
mulss  0x8(%rsp),%xmm6
movaps %xmm6,0x170(%rsp)
addss  %xmm11,%xmm6
mulss  %xmm12,%xmm3
movaps %xmm3,0xb0(%rsp)
unpcklps %xmm8,%xmm3
movlhps %xmm9,%xmm3
movaps %xmm3,0x1d0(%rsp)
shufps $0x0,%xmm6,%xmm6
mulps  %xmm3,%xmm6
shufps $0x0,%xmm2,%xmm2
movaps %xmm5,%xmm3
movaps 0x120(%rsp),%xmm5
unpcklps %xmm5,%xmm3
movlhps %xmm4,%xmm3
movaps %xmm4,%xmm8
movaps %xmm3,0x1c0(%rsp)
mulps  %xmm3,%xmm2
addps  %xmm6,%xmm2
movaps 0x80(%rsp),%xmm12
movaps %xmm12,0x1b0(%rsp)
mulss  %xmm1,%xmm12
movaps %xmm1,%xmm6
addss  %xmm15,%xmm12
movaps %xmm12,%xmm15
movaps %xmm13,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm12,%xmm3
movaps %xmm12,0x80(%rsp)
mulss  %xmm0,%xmm15
movaps 0x40(%rsp),%xmm1
movlhps %xmm1,%xmm0
mulss  %xmm10,%xmm3
movaps %xmm3,0x1a0(%rsp)
shufps $0xd4,%xmm10,%xmm1
shufps $0x52,%xmm10,%xmm1
movaps %xmm1,0x40(%rsp)
shufps $0x24,%xmm0,%xmm10
movaps %xmm10,0x150(%rsp)
movaps 0xd0(%rsp),%xmm1
movss  0x8(%rsp),%xmm3
mulss  %xmm3,%xmm1
movaps 0x90(%rsp),%xmm4
addss  %xmm1,%xmm4
movaps 0x20(%rsp),%xmm0
movaps 0x60(%rsp),%xmm12
mulss  %xmm12,%xmm0
movaps %xmm6,%xmm7
mulss  %xmm6,%xmm12
movaps %xmm12,0x140(%rsp)
subss  %xmm12,%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm10,%xmm4
addps  %xmm2,%xmm4
movaps 0x953(%rip),%xmm2
unpcklps %xmm0,%xmm2
movaps %xmm2,0x60(%rsp)
movaps %xmm0,%xmm2
movaps %xmm14,0x160(%rsp)
movlhps %xmm14,%xmm2
movaps 0x130(%rsp),%xmm0
shufps $0xd4,%xmm14,%xmm0
shufps $0x28,%xmm0,%xmm2
movaps %xmm2,0x90(%rsp)
movaps 0x180(%rsp),%xmm12
shufps $0x0,%xmm12,%xmm12
mulps  %xmm2,%xmm12
addps  %xmm4,%xmm12
movaps 0xf0(%rsp),%xmm2
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
movaps 0x1e0(%rsp),%xmm6
addss  %xmm6,%xmm4
subss  %xmm1,%xmm6
movaps 0x1f0(%rsp),%xmm1
movaps 0x190(%rsp),%xmm3
subss  %xmm1,%xmm3
subss  0x14(%rsp),%xmm1
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
movaps %xmm2,0xf0(%rsp)
movaps 0xe0(%rsp),%xmm1
addss  %xmm1,%xmm11
addss  0x170(%rsp),%xmm1
movaps %xmm1,%xmm10
movaps 0x50(%rsp),%xmm0
mulss  %xmm6,%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x30(%rsp),%xmm1
unpcklps %xmm9,%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm5,%xmm14
unpcklps %xmm8,%xmm14
shufps $0x55,%xmm9,%xmm9
mulss  %xmm2,%xmm9
movaps %xmm8,%xmm7
movaps 0x100(%rsp),%xmm0
addss  %xmm0,%xmm7
subss  %xmm8,%xmm0
movaps %xmm0,0x100(%rsp)
shufps $0x55,%xmm8,%xmm8
movaps %xmm6,%xmm1
movaps %xmm6,%xmm5
mulss  %xmm8,%xmm1
addss  %xmm9,%xmm1
addss  %xmm1,%xmm15
movaps 0x250(%rsp),%xmm9
movaps %xmm9,%xmm6
movaps %xmm10,%xmm0
unpcklps %xmm10,%xmm9
movaps %xmm9,%xmm10
xorps  %xmm9,%xmm9
cvtsi2ss %eax,%xmm9
mulss  0x130(%rsp),%xmm0
addss  %xmm15,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm0,0xe0(%rsp)
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm12
movups %xmm12,0xc(%rbx)
movaps 0x200(%rsp),%xmm12
movaps %xmm12,%xmm15
movaps 0xc0(%rsp),%xmm1
mulss  %xmm1,%xmm15
addss  0x210(%rsp),%xmm15
movss  %xmm15,0x1c(%rbx)
addss  %xmm6,%xmm6
addss  0x240(%rsp),%xmm6
movss  0x79e(%rip),%xmm2
addss  %xmm2,%xmm6
movss  %xmm6,0x20(%rbx)
movaps 0x1b0(%rsp),%xmm15
mulss  %xmm1,%xmm15
movaps 0x230(%rsp),%xmm2
movaps %xmm2,%xmm6
movaps 0xd0(%rsp),%xmm1
mulss  %xmm1,%xmm6
addss  %xmm15,%xmm6
movss  %xmm6,0x24(%rbx)
addss  0x140(%rsp),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  0x1d0(%rsp),%xmm4
shufps $0x0,%xmm3,%xmm3
mulps  0x1c0(%rsp),%xmm3
addps  %xmm4,%xmm3
shufps $0x0,%xmm11,%xmm11
mulps  0x150(%rsp),%xmm11
addps  %xmm3,%xmm11
movaps 0xa0(%rsp),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  0x90(%rsp),%xmm0
addps  %xmm11,%xmm0
mulps  %xmm9,%xmm0
movups %xmm0,0x28(%rbx)
movaps 0x110(%rsp),%xmm3
mulss  %xmm3,%xmm2
addss  0x220(%rsp),%xmm2
movss  %xmm2,0x38(%rbx)
mulss  %xmm1,%xmm12
movaps %xmm1,%xmm2
addss  %xmm15,%xmm12
movss  %xmm12,0x3c(%rbx)
movaps 0xb0(%rsp),%xmm1
movaps 0xf0(%rsp),%xmm4
mulss  %xmm4,%xmm1
movaps 0x50(%rsp),%xmm0
addss  %xmm1,%xmm0
movaps 0x1a0(%rsp),%xmm1
addss  %xmm0,%xmm1
movaps %xmm4,%xmm0
unpcklps %xmm4,%xmm0
mulps  0x30(%rsp),%xmm0
unpcklps %xmm5,%xmm5
mulps  %xmm5,%xmm14
addps  %xmm0,%xmm14
movaps 0x80(%rsp),%xmm0
unpcklps %xmm0,%xmm0
movaps 0x40(%rsp),%xmm4
mulps  %xmm0,%xmm4
addps  %xmm14,%xmm4
movaps 0x60(%rsp),%xmm0
unpcklpd 0x160(%rsp),%xmm0
shufps $0x54,%xmm10,%xmm10
mulps  %xmm10,%xmm0
movaps %xmm0,%xmm5
movaps 0x260(%rsp),%xmm0
unpcklps %xmm1,%xmm0
movlhps %xmm4,%xmm0
addps  %xmm5,%xmm0
movss  0x65a(%rip),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm9,%xmm0
movss  %xmm1,%xmm0
movups %xmm0,0x40(%rbx)
movaps 0xe0(%rsp),%xmm0
movss  %xmm0,0x50(%rbx)
movaps 0x70(%rsp),%xmm5
mulss  %xmm2,%xmm5
mulss  %xmm3,%xmm13
movaps 0x20(%rsp),%xmm6
mulss  0xc0(%rsp),%xmm6
movaps %xmm13,%xmm0
addss  %xmm6,%xmm0
movaps 0x290(%rsp),%xmm4
movaps %xmm4,%xmm1
subss  %xmm8,%xmm1
movss  0x18(%rsp),%xmm3
mulss  %xmm3,%xmm1
movss  0xc(%rsp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x1c(%rsp),%xmm1
mulss  %xmm1,%xmm7
addss  %xmm0,%xmm7
addss  %xmm7,%xmm7
addss  %xmm2,%xmm7
movss  %xmm7,(%r12)
addss  %xmm4,%xmm8
addss  %xmm5,%xmm6
mulss  %xmm3,%xmm6
mulss  %xmm2,%xmm8
addss  %xmm6,%xmm8
movaps 0x270(%rsp),%xmm0
subss  0x120(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  %xmm8,%xmm0
addss  %xmm0,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%r15)
movaps 0x280(%rsp),%xmm4
mulss  %xmm3,%xmm4
movaps 0x100(%rsp),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
addss  %xmm5,%xmm13
mulss  %xmm1,%xmm13
addss  %xmm0,%xmm13
addss  %xmm13,%xmm13
addss  %xmm1,%xmm13
movss  %xmm13,(%r14)
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @inverseComposePoint(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9, float* %10, float* %11, float* %12, [3 x float]* %13, [7 x float]* %14) {
%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 [3 x float]*
%30 = alloca [7 x 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 float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca float
store float %0, float* %16
store float %1, float* %17
store float %2, float* %18
store float %3, float* %19
store float %4, float* %20
store float %5, float* %21
store float %6, float* %22
store float %7, float* %23
store float %8, float* %24
store float %9, float* %25
store float* %10, float** %26
store float* %11, float** %27
store float* %12, float** %28
store [3 x float]* %13, [3 x float]** %29
store [7 x float]* %14, [7 x float]** %30
%52 = load float, float* %19
store float %52, float* %31
%53 = load float, float* %20
store float %53, float* %32
%54 = load float, float* %21
store float %54, float* %33
%55 = load float, float* %22
store float %55, float* %34
%56 = load float, float* %32
%57 = load float, float* %32
%58 = fmul float %56, %57
store float %58, float* %35
%59 = load float, float* %33
%60 = load float, float* %33
%61 = fmul float %59, %60
store float %61, float* %36
%62 = load float, float* %34
%63 = load float, float* %34
%64 = fmul float %62, %63
store float %64, float* %37
%65 = load float, float* %23
%66 = load float, float* %16
%67 = fsub float %65, %66
%68 = fmul float 2.000000e+00, %67
store float %68, float* %38
%69 = load float, float* %24
%70 = load float, float* %17
%71 = fsub float %69, %70
%72 = fmul float 2.000000e+00, %71
store float %72, float* %39
%73 = load float, float* %25
%74 = load float, float* %18
%75 = fsub float %73, %74
%76 = fmul float 2.000000e+00, %75
store float %76, float* %40
%77 = load float, float* %36
%78 = load float, float* %37
%79 = fadd float %77, %78
%80 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %79, float 1.000000e+00)
%81 = load [3 x float]*, [3 x float]** %29
%82 = getelementptr inbounds [3 x float], [3 x float]* %81, i64 0
%83 = getelementptr inbounds [3 x float], [3 x float]* %82, i64 0, i64 0
store float %80, float* %83
%84 = load float, float* %31
%85 = fneg float %84
%86 = load float, float* %34
%87 = load float, float* %32
%88 = load float, float* %33
%89 = fmul float %87, %88
%90 = call float @llvm.fmuladd.f32(float %85, float %86, float %89)
%91 = fmul float 2.000000e+00, %90
%92 = load [3 x float]*, [3 x float]** %29
%93 = getelementptr inbounds [3 x float], [3 x float]* %92, i64 0
%94 = getelementptr inbounds [3 x float], [3 x float]* %93, i64 0, i64 1
store float %91, float* %94
%95 = load float, float* %32
%96 = load float, float* %34
%97 = load float, float* %31
%98 = load float, float* %33
%99 = fmul float %97, %98
%100 = call float @llvm.fmuladd.f32(float %95, float %96, float %99)
%101 = fmul float 2.000000e+00, %100
%102 = load [3 x float]*, [3 x float]** %29
%103 = getelementptr inbounds [3 x float], [3 x float]* %102, i64 0
%104 = getelementptr inbounds [3 x float], [3 x float]* %103, i64 0, i64 2
store float %101, float* %104
%105 = load float, float* %32
%106 = load float, float* %33
%107 = load float, float* %31
%108 = load float, float* %34
%109 = fmul float %107, %108
%110 = call float @llvm.fmuladd.f32(float %105, float %106, float %109)
%111 = fmul float 2.000000e+00, %110
%112 = load [3 x float]*, [3 x float]** %29
%113 = getelementptr inbounds [3 x float], [3 x float]* %112, i64 1
%114 = getelementptr inbounds [3 x float], [3 x float]* %113, i64 0, i64 0
store float %111, float* %114
%115 = load float, float* %35
%116 = load float, float* %37
%117 = fadd float %115, %116
%118 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %117, float 1.000000e+00)
%119 = load [3 x float]*, [3 x float]** %29
%120 = getelementptr inbounds [3 x float], [3 x float]* %119, i64 1
%121 = getelementptr inbounds [3 x float], [3 x float]* %120, i64 0, i64 1
store float %118, float* %121
%122 = load float, float* %31
%123 = fneg float %122
%124 = load float, float* %32
%125 = load float, float* %33
%126 = load float, float* %34
%127 = fmul float %125, %126
%128 = call float @llvm.fmuladd.f32(float %123, float %124, float %127)
%129 = fmul float 2.000000e+00, %128
%130 = load [3 x float]*, [3 x float]** %29
%131 = getelementptr inbounds [3 x float], [3 x float]* %130, i64 1
%132 = getelementptr inbounds [3 x float], [3 x float]* %131, i64 0, i64 2
store float %129, float* %132
%133 = load float, float* %31
%134 = fneg float %133
%135 = load float, float* %33
%136 = load float, float* %32
%137 = load float, float* %34
%138 = fmul float %136, %137
%139 = call float @llvm.fmuladd.f32(float %134, float %135, float %138)
%140 = fmul float 2.000000e+00, %139
%141 = load [3 x float]*, [3 x float]** %29
%142 = getelementptr inbounds [3 x float], [3 x float]* %141, i64 2
%143 = getelementptr inbounds [3 x float], [3 x float]* %142, i64 0, i64 0
store float %140, float* %143
%144 = load float, float* %33
%145 = load float, float* %34
%146 = load float, float* %31
%147 = load float, float* %32
%148 = fmul float %146, %147
%149 = call float @llvm.fmuladd.f32(float %144, float %145, float %148)
%150 = fmul float 2.000000e+00, %149
%151 = load [3 x float]*, [3 x float]** %29
%152 = getelementptr inbounds [3 x float], [3 x float]* %151, i64 2
%153 = getelementptr inbounds [3 x float], [3 x float]* %152, i64 0, i64 1
store float %150, float* %153
%154 = load float, float* %35
%155 = load float, float* %36
%156 = fadd float %154, %155
%157 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %156, float 1.000000e+00)
%158 = load [3 x float]*, [3 x float]** %29
%159 = getelementptr inbounds [3 x float], [3 x float]* %158, i64 2
%160 = getelementptr inbounds [3 x float], [3 x float]* %159, i64 0, i64 2
store float %157, float* %160
%161 = load float, float* %31
%162 = load float, float* %31
%163 = load float, float* %32
%164 = load float, float* %32
%165 = fmul float %163, %164
%166 = call float @llvm.fmuladd.f32(float %161, float %162, float %165)
%167 = load float, float* %33
%168 = load float, float* %33
%169 = call float @llvm.fmuladd.f32(float %167, float %168, float %166)
%170 = load float, float* %34
%171 = load float, float* %34
%172 = call float @llvm.fmuladd.f32(float %170, float %171, float %169)
store float %172, float* %41
%173 = load float, float* %41
%174 = load float, float* %41
%175 = fmul float %173, %174
%176 = load float, float* %41
%177 = fmul float %175, %176
%178 = fpext float %177 to double
%179 = call i32 (double, ...) bitcast (i32 (...)* @inverseSqrt to i32 (double, ...)*)(double %178)
%180 = sitofp i32 %179 to float
store float %180, float* %42
%181 = load float, float* %36
%182 = load float, float* %37
%183 = fmul float 2.000000e+00, %182
%184 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %181, float %183)
%185 = fsub float %184, 1.000000e+00
%186 = load [7 x float]*, [7 x float]** %30
%187 = getelementptr inbounds [7 x float], [7 x float]* %186, i64 0
%188 = getelementptr inbounds [7 x float], [7 x float]* %187, i64 0, i64 0
store float %185, float* %188
%189 = load float, float* %31
%190 = fmul float -2.000000e+00, %189
%191 = load float, float* %34
%192 = load float, float* %32
%193 = fmul float 2.000000e+00, %192
%194 = load float, float* %33
%195 = fmul float %193, %194
%196 = fneg float %195
%197 = call float @llvm.fmuladd.f32(float %190, float %191, float %196)
%198 = load [7 x float]*, [7 x float]** %30
%199 = getelementptr inbounds [7 x float], [7 x float]* %198, i64 0
%200 = getelementptr inbounds [7 x float], [7 x float]* %199, i64 0, i64 1
store float %197, float* %200
%201 = load float, float* %31
%202 = fmul float 2.000000e+00, %201
%203 = load float, float* %33
%204 = load float, float* %32
%205 = fmul float 2.000000e+00, %204
%206 = load float, float* %34
%207 = fmul float %205, %206
%208 = fneg float %207
%209 = call float @llvm.fmuladd.f32(float %202, float %203, float %208)
%210 = load [7 x float]*, [7 x float]** %30
%211 = getelementptr inbounds [7 x float], [7 x float]* %210, i64 0
%212 = getelementptr inbounds [7 x float], [7 x float]* %211, i64 0, i64 2
store float %209, float* %212
%213 = load float, float* %42
%214 = load float, float* %33
%215 = fneg float %214
%216 = load float, float* %40
%217 = load float, float* %34
%218 = load float, float* %39
%219 = fmul float %217, %218
%220 = call float @llvm.fmuladd.f32(float %215, float %216, float %219)
%221 = load float, float* %32
%222 = load float, float* %32
%223 = load float, float* %33
%224 = load float, float* %33
%225 = fmul float %223, %224
%226 = call float @llvm.fmuladd.f32(float %221, float %222, float %225)
%227 = load float, float* %34
%228 = load float, float* %34
%229 = call float @llvm.fmuladd.f32(float %227, float %228, float %226)
%230 = load float, float* %33
%231 = load float, float* %39
%232 = load float, float* %34
%233 = load float, float* %40
%234 = fmul float %232, %233
%235 = call float @llvm.fmuladd.f32(float %230, float %231, float %234)
%236 = load float, float* %32
%237 = fneg float %236
%238 = load float, float* %31
%239 = fmul float %237, %238
%240 = fmul float %235, %239
%241 = call float @llvm.fmuladd.f32(float %220, float %229, float %240)
%242 = load float, float* %32
%243 = load float, float* %39
%244 = load float, float* %33
%245 = fmul float 2.000000e+00, %244
%246 = load float, float* %38
%247 = fmul float %245, %246
%248 = fneg float %247
%249 = call float @llvm.fmuladd.f32(float %242, float %243, float %248)
%250 = load float, float* %31
%251 = load float, float* %40
%252 = fneg float %250
%253 = call float @llvm.fmuladd.f32(float %252, float %251, float %249)
%254 = load float, float* %33
%255 = fneg float %254
%256 = load float, float* %31
%257 = fmul float %255, %256
%258 = call float @llvm.fmuladd.f32(float %253, float %257, float %241)
%259 = load float, float* %32
%260 = load float, float* %40
%261 = load float, float* %31
%262 = load float, float* %39
%263 = fmul float %261, %262
%264 = call float @llvm.fmuladd.f32(float %259, float %260, float %263)
%265 = load float, float* %34
%266 = fmul float 2.000000e+00, %265
%267 = load float, float* %38
%268 = fneg float %266
%269 = call float @llvm.fmuladd.f32(float %268, float %267, float %264)
%270 = load float, float* %34
%271 = fneg float %270
%272 = load float, float* %31
%273 = fmul float %271, %272
%274 = call float @llvm.fmuladd.f32(float %269, float %273, float %258)
%275 = fmul float %213, %274
%276 = load [7 x float]*, [7 x float]** %30
%277 = getelementptr inbounds [7 x float], [7 x float]* %276, i64 0
%278 = getelementptr inbounds [7 x float], [7 x float]* %277, i64 0, i64 3
store float %275, float* %278
%279 = load float, float* %42
%280 = load float, float* %33
%281 = fneg float %280
%282 = load float, float* %40
%283 = load float, float* %34
%284 = load float, float* %39
%285 = fmul float %283, %284
%286 = call float @llvm.fmuladd.f32(float %281, float %282, float %285)
%287 = load float, float* %31
%288 = fneg float %287
%289 = load float, float* %32
%290 = fmul float %288, %289
%291 = load float, float* %33
%292 = load float, float* %39
%293 = load float, float* %34
%294 = load float, float* %40
%295 = fmul float %293, %294
%296 = call float @llvm.fmuladd.f32(float %291, float %292, float %295)
%297 = load float, float* %31
%298 = load float, float* %31
%299 = load float, float* %33
%300 = load float, float* %33
%301 = fmul float %299, %300
%302 = call float @llvm.fmuladd.f32(float %297, float %298, float %301)
%303 = load float, float* %34
%304 = load float, float* %34
%305 = call float @llvm.fmuladd.f32(float %303, float %304, float %302)
%306 = fmul float %296, %305
%307 = call float @llvm.fmuladd.f32(float %286, float %290, float %306)
%308 = load float, float* %32
%309 = load float, float* %39
%310 = load float, float* %33
%311 = fmul float 2.000000e+00, %310
%312 = load float, float* %38
%313 = fmul float %311, %312
%314 = fneg float %313
%315 = call float @llvm.fmuladd.f32(float %308, float %309, float %314)
%316 = load float, float* %31
%317 = load float, float* %40
%318 = fneg float %316
%319 = call float @llvm.fmuladd.f32(float %318, float %317, float %315)
%320 = load float, float* %33
%321 = fneg float %320
%322 = load float, float* %32
%323 = fmul float %321, %322
%324 = call float @llvm.fmuladd.f32(float %319, float %323, float %307)
%325 = load float, float* %32
%326 = load float, float* %40
%327 = load float, float* %31
%328 = load float, float* %39
%329 = fmul float %327, %328
%330 = call float @llvm.fmuladd.f32(float %325, float %326, float %329)
%331 = load float, float* %34
%332 = fmul float 2.000000e+00, %331
%333 = load float, float* %38
%334 = fneg float %332
%335 = call float @llvm.fmuladd.f32(float %334, float %333, float %330)
%336 = load float, float* %34
%337 = fneg float %336
%338 = load float, float* %32
%339 = fmul float %337, %338
%340 = call float @llvm.fmuladd.f32(float %335, float %339, float %324)
%341 = fmul float %279, %340
%342 = load [7 x float]*, [7 x float]** %30
%343 = getelementptr inbounds [7 x float], [7 x float]* %342, i64 0
%344 = getelementptr inbounds [7 x float], [7 x float]* %343, i64 0, i64 4
store float %341, float* %344
%345 = load float, float* %42
%346 = load float, float* %33
%347 = fneg float %346
%348 = load float, float* %40
%349 = load float, float* %34
%350 = load float, float* %39
%351 = fmul float %349, %350
%352 = call float @llvm.fmuladd.f32(float %347, float %348, float %351)
%353 = load float, float* %31
%354 = fneg float %353
%355 = load float, float* %33
%356 = fmul float %354, %355
%357 = load float, float* %33
%358 = load float, float* %39
%359 = load float, float* %34
%360 = load float, float* %40
%361 = fmul float %359, %360
%362 = call float @llvm.fmuladd.f32(float %357, float %358, float %361)
%363 = load float, float* %32
%364 = fneg float %363
%365 = load float, float* %33
%366 = fmul float %364, %365
%367 = fmul float %362, %366
%368 = call float @llvm.fmuladd.f32(float %352, float %356, float %367)
%369 = load float, float* %32
%370 = load float, float* %39
%371 = load float, float* %33
%372 = fmul float 2.000000e+00, %371
%373 = load float, float* %38
%374 = fmul float %372, %373
%375 = fneg float %374
%376 = call float @llvm.fmuladd.f32(float %369, float %370, float %375)
%377 = load float, float* %31
%378 = load float, float* %40
%379 = fneg float %377
%380 = call float @llvm.fmuladd.f32(float %379, float %378, float %376)
%381 = load float, float* %31
%382 = load float, float* %31
%383 = load float, float* %32
%384 = load float, float* %32
%385 = fmul float %383, %384
%386 = call float @llvm.fmuladd.f32(float %381, float %382, float %385)
%387 = load float, float* %34
%388 = load float, float* %34
%389 = call float @llvm.fmuladd.f32(float %387, float %388, float %386)
%390 = call float @llvm.fmuladd.f32(float %380, float %389, float %368)
%391 = load float, float* %32
%392 = load float, float* %40
%393 = load float, float* %31
%394 = load float, float* %39
%395 = fmul float %393, %394
%396 = call float @llvm.fmuladd.f32(float %391, float %392, float %395)
%397 = load float, float* %34
%398 = fmul float 2.000000e+00, %397
%399 = load float, float* %38
%400 = fneg float %398
%401 = call float @llvm.fmuladd.f32(float %400, float %399, float %396)
%402 = load float, float* %34
%403 = fneg float %402
%404 = load float, float* %33
%405 = fmul float %403, %404
%406 = call float @llvm.fmuladd.f32(float %401, float %405, float %390)
%407 = fmul float %345, %406
%408 = load [7 x float]*, [7 x float]** %30
%409 = getelementptr inbounds [7 x float], [7 x float]* %408, i64 0
%410 = getelementptr inbounds [7 x float], [7 x float]* %409, i64 0, i64 5
store float %407, float* %410
%411 = load float, float* %42
%412 = load float, float* %33
%413 = fneg float %412
%414 = load float, float* %40
%415 = load float, float* %34
%416 = load float, float* %39
%417 = fmul float %415, %416
%418 = call float @llvm.fmuladd.f32(float %413, float %414, float %417)
%419 = load float, float* %31
%420 = fneg float %419
%421 = load float, float* %34
%422 = fmul float %420, %421
%423 = load float, float* %33
%424 = load float, float* %39
%425 = load float, float* %34
%426 = load float, float* %40
%427 = fmul float %425, %426
%428 = call float @llvm.fmuladd.f32(float %423, float %424, float %427)
%429 = load float, float* %32
%430 = fneg float %429
%431 = load float, float* %34
%432 = fmul float %430, %431
%433 = fmul float %428, %432
%434 = call float @llvm.fmuladd.f32(float %418, float %422, float %433)
%435 = load float, float* %32
%436 = load float, float* %39
%437 = load float, float* %33
%438 = fmul float 2.000000e+00, %437
%439 = load float, float* %38
%440 = fmul float %438, %439
%441 = fneg float %440
%442 = call float @llvm.fmuladd.f32(float %435, float %436, float %441)
%443 = load float, float* %31
%444 = load float, float* %40
%445 = fneg float %443
%446 = call float @llvm.fmuladd.f32(float %445, float %444, float %442)
%447 = load float, float* %33
%448 = fneg float %447
%449 = load float, float* %34
%450 = fmul float %448, %449
%451 = call float @llvm.fmuladd.f32(float %446, float %450, float %434)
%452 = load float, float* %32
%453 = load float, float* %40
%454 = load float, float* %31
%455 = load float, float* %39
%456 = fmul float %454, %455
%457 = call float @llvm.fmuladd.f32(float %452, float %453, float %456)
%458 = load float, float* %34
%459 = fmul float 2.000000e+00, %458
%460 = load float, float* %38
%461 = fneg float %459
%462 = call float @llvm.fmuladd.f32(float %461, float %460, float %457)
%463 = load float, float* %31
%464 = load float, float* %31
%465 = load float, float* %32
%466 = load float, float* %32
%467 = fmul float %465, %466
%468 = call float @llvm.fmuladd.f32(float %463, float %464, float %467)
%469 = load float, float* %33
%470 = load float, float* %33
%471 = call float @llvm.fmuladd.f32(float %469, float %470, float %468)
%472 = call float @llvm.fmuladd.f32(float %462, float %471, float %451)
%473 = fmul float %411, %472
%474 = load [7 x float]*, [7 x float]** %30
%475 = getelementptr inbounds [7 x float], [7 x float]* %474, i64 0
%476 = getelementptr inbounds [7 x float], [7 x float]* %475, i64 0, i64 6
store float %473, float* %476
%477 = load float, float* %31
%478 = fmul float 2.000000e+00, %477
%479 = load float, float* %34
%480 = load float, float* %32
%481 = fmul float 2.000000e+00, %480
%482 = load float, float* %33
%483 = fmul float %481, %482
%484 = fneg float %483
%485 = call float @llvm.fmuladd.f32(float %478, float %479, float %484)
%486 = load [7 x float]*, [7 x float]** %30
%487 = getelementptr inbounds [7 x float], [7 x float]* %486, i64 1
%488 = getelementptr inbounds [7 x float], [7 x float]* %487, i64 0, i64 0
store float %485, float* %488
%489 = load float, float* %35
%490 = load float, float* %37
%491 = fmul float 2.000000e+00, %490
%492 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %489, float %491)
%493 = fsub float %492, 1.000000e+00
%494 = load [7 x float]*, [7 x float]** %30
%495 = getelementptr inbounds [7 x float], [7 x float]* %494, i64 1
%496 = getelementptr inbounds [7 x float], [7 x float]* %495, i64 0, i64 1
store float %493, float* %496
%497 = load float, float* %31
%498 = fmul float -2.000000e+00, %497
%499 = load float, float* %32
%500 = load float, float* %33
%501 = fmul float 2.000000e+00, %500
%502 = load float, float* %34
%503 = fmul float %501, %502
%504 = fneg float %503
%505 = call float @llvm.fmuladd.f32(float %498, float %499, float %504)
%506 = load [7 x float]*, [7 x float]** %30
%507 = getelementptr inbounds [7 x float], [7 x float]* %506, i64 1
%508 = getelementptr inbounds [7 x float], [7 x float]* %507, i64 0, i64 2
store float %505, float* %508
%509 = load float, float* %42
%510 = load float, float* %32
%511 = load float, float* %40
%512 = load float, float* %34
%513 = load float, float* %38
%514 = fmul float %512, %513
%515 = fneg float %514
%516 = call float @llvm.fmuladd.f32(float %510, float %511, float %515)
%517 = load float, float* %32
%518 = load float, float* %32
%519 = load float, float* %33
%520 = load float, float* %33
%521 = fmul float %519, %520
%522 = call float @llvm.fmuladd.f32(float %517, float %518, float %521)
%523 = load float, float* %34
%524 = load float, float* %34
%525 = call float @llvm.fmuladd.f32(float %523, float %524, float %522)
%526 = load float, float* %33
%527 = load float, float* %38
%528 = load float, float* %32
%529 = fmul float 2.000000e+00, %528
%530 = load float, float* %39
%531 = fmul float %529, %530
%532 = fneg float %531
%533 = call float @llvm.fmuladd.f32(float %526, float %527, float %532)
%534 = load float, float* %31
%535 = load float, float* %40
%536 = call float @llvm.fmuladd.f32(float %534, float %535, float %533)
%537 = load float, float* %32
%538 = fneg float %537
%539 = load float, float* %31
%540 = fmul float %538, %539
%541 = fmul float %536, %540
%542 = call float @llvm.fmuladd.f32(float %516, float %525, float %541)
%543 = load float, float* %32
%544 = load float, float* %38
%545 = load float, float* %34
%546 = load float, float* %40
%547 = fmul float %545, %546
%548 = call float @llvm.fmuladd.f32(float %543, float %544, float %547)
%549 = load float, float* %33
%550 = fneg float %549
%551 = load float, float* %31
%552 = fmul float %550, %551
%553 = call float @llvm.fmuladd.f32(float %548, float %552, float %542)
%554 = load float, float* %33
%555 = load float, float* %40
%556 = load float, float* %34
%557 = fmul float 2.000000e+00, %556
%558 = load float, float* %39
%559 = fmul float %557, %558
%560 = fneg float %559
%561 = call float @llvm.fmuladd.f32(float %554, float %555, float %560)
%562 = load float, float* %31
%563 = load float, float* %38
%564 = fneg float %562
%565 = call float @llvm.fmuladd.f32(float %564, float %563, float %561)
%566 = load float, float* %34
%567 = fneg float %566
%568 = load float, float* %31
%569 = fmul float %567, %568
%570 = call float @llvm.fmuladd.f32(float %565, float %569, float %553)
%571 = fmul float %509, %570
%572 = load [7 x float]*, [7 x float]** %30
%573 = getelementptr inbounds [7 x float], [7 x float]* %572, i64 1
%574 = getelementptr inbounds [7 x float], [7 x float]* %573, i64 0, i64 3
store float %571, float* %574
%575 = load float, float* %42
%576 = load float, float* %32
%577 = load float, float* %40
%578 = load float, float* %34
%579 = load float, float* %38
%580 = fmul float %578, %579
%581 = fneg float %580
%582 = call float @llvm.fmuladd.f32(float %576, float %577, float %581)
%583 = load float, float* %31
%584 = fneg float %583
%585 = load float, float* %32
%586 = fmul float %584, %585
%587 = load float, float* %33
%588 = load float, float* %38
%589 = load float, float* %32
%590 = fmul float 2.000000e+00, %589
%591 = load float, float* %39
%592 = fmul float %590, %591
%593 = fneg float %592
%594 = call float @llvm.fmuladd.f32(float %587, float %588, float %593)
%595 = load float, float* %31
%596 = load float, float* %40
%597 = call float @llvm.fmuladd.f32(float %595, float %596, float %594)
%598 = load float, float* %31
%599 = load float, float* %31
%600 = load float, float* %33
%601 = load float, float* %33
%602 = fmul float %600, %601
%603 = call float @llvm.fmuladd.f32(float %598, float %599, float %602)
%604 = load float, float* %34
%605 = load float, float* %34
%606 = call float @llvm.fmuladd.f32(float %604, float %605, float %603)
%607 = fmul float %597, %606
%608 = call float @llvm.fmuladd.f32(float %582, float %586, float %607)
%609 = load float, float* %32
%610 = load float, float* %38
%611 = load float, float* %34
%612 = load float, float* %40
%613 = fmul float %611, %612
%614 = call float @llvm.fmuladd.f32(float %609, float %610, float %613)
%615 = load float, float* %33
%616 = fneg float %615
%617 = load float, float* %32
%618 = fmul float %616, %617
%619 = call float @llvm.fmuladd.f32(float %614, float %618, float %608)
%620 = load float, float* %33
%621 = load float, float* %40
%622 = load float, float* %34
%623 = fmul float 2.000000e+00, %622
%624 = load float, float* %39
%625 = fmul float %623, %624
%626 = fneg float %625
%627 = call float @llvm.fmuladd.f32(float %620, float %621, float %626)
%628 = load float, float* %31
%629 = load float, float* %38
%630 = fneg float %628
%631 = call float @llvm.fmuladd.f32(float %630, float %629, float %627)
%632 = load float, float* %34
%633 = fneg float %632
%634 = load float, float* %32
%635 = fmul float %633, %634
%636 = call float @llvm.fmuladd.f32(float %631, float %635, float %619)
%637 = fmul float %575, %636
%638 = load [7 x float]*, [7 x float]** %30
%639 = getelementptr inbounds [7 x float], [7 x float]* %638, i64 1
%640 = getelementptr inbounds [7 x float], [7 x float]* %639, i64 0, i64 4
store float %637, float* %640
%641 = load float, float* %42
%642 = load float, float* %32
%643 = load float, float* %40
%644 = load float, float* %34
%645 = load float, float* %38
%646 = fmul float %644, %645
%647 = fneg float %646
%648 = call float @llvm.fmuladd.f32(float %642, float %643, float %647)
%649 = load float, float* %31
%650 = fneg float %649
%651 = load float, float* %33
%652 = fmul float %650, %651
%653 = load float, float* %33
%654 = load float, float* %38
%655 = load float, float* %32
%656 = fmul float 2.000000e+00, %655
%657 = load float, float* %39
%658 = fmul float %656, %657
%659 = fneg float %658
%660 = call float @llvm.fmuladd.f32(float %653, float %654, float %659)
%661 = load float, float* %31
%662 = load float, float* %40
%663 = call float @llvm.fmuladd.f32(float %661, float %662, float %660)
%664 = load float, float* %32
%665 = fneg float %664
%666 = load float, float* %33
%667 = fmul float %665, %666
%668 = fmul float %663, %667
%669 = call float @llvm.fmuladd.f32(float %648, float %652, float %668)
%670 = load float, float* %32
%671 = load float, float* %38
%672 = load float, float* %34
%673 = load float, float* %40
%674 = fmul float %672, %673
%675 = call float @llvm.fmuladd.f32(float %670, float %671, float %674)
%676 = load float, float* %31
%677 = load float, float* %31
%678 = load float, float* %32
%679 = load float, float* %32
%680 = fmul float %678, %679
%681 = call float @llvm.fmuladd.f32(float %676, float %677, float %680)
%682 = load float, float* %34
%683 = load float, float* %34
%684 = call float @llvm.fmuladd.f32(float %682, float %683, float %681)
%685 = call float @llvm.fmuladd.f32(float %675, float %684, float %669)
%686 = load float, float* %33
%687 = load float, float* %40
%688 = load float, float* %34
%689 = fmul float 2.000000e+00, %688
%690 = load float, float* %39
%691 = fmul float %689, %690
%692 = fneg float %691
%693 = call float @llvm.fmuladd.f32(float %686, float %687, float %692)
%694 = load float, float* %31
%695 = load float, float* %38
%696 = fneg float %694
%697 = call float @llvm.fmuladd.f32(float %696, float %695, float %693)
%698 = load float, float* %34
%699 = fneg float %698
%700 = load float, float* %33
%701 = fmul float %699, %700
%702 = call float @llvm.fmuladd.f32(float %697, float %701, float %685)
%703 = fmul float %641, %702
%704 = load [7 x float]*, [7 x float]** %30
%705 = getelementptr inbounds [7 x float], [7 x float]* %704, i64 1
%706 = getelementptr inbounds [7 x float], [7 x float]* %705, i64 0, i64 5
store float %703, float* %706
%707 = load float, float* %42
%708 = load float, float* %32
%709 = load float, float* %40
%710 = load float, float* %34
%711 = load float, float* %38
%712 = fmul float %710, %711
%713 = fneg float %712
%714 = call float @llvm.fmuladd.f32(float %708, float %709, float %713)
%715 = load float, float* %31
%716 = fneg float %715
%717 = load float, float* %34
%718 = fmul float %716, %717
%719 = load float, float* %33
%720 = load float, float* %38
%721 = load float, float* %32
%722 = fmul float 2.000000e+00, %721
%723 = load float, float* %39
%724 = fmul float %722, %723
%725 = fneg float %724
%726 = call float @llvm.fmuladd.f32(float %719, float %720, float %725)
%727 = load float, float* %31
%728 = load float, float* %40
%729 = call float @llvm.fmuladd.f32(float %727, float %728, float %726)
%730 = load float, float* %32
%731 = fneg float %730
%732 = load float, float* %34
%733 = fmul float %731, %732
%734 = fmul float %729, %733
%735 = call float @llvm.fmuladd.f32(float %714, float %718, float %734)
%736 = load float, float* %32
%737 = load float, float* %38
%738 = load float, float* %34
%739 = load float, float* %40
%740 = fmul float %738, %739
%741 = call float @llvm.fmuladd.f32(float %736, float %737, float %740)
%742 = load float, float* %33
%743 = fneg float %742
%744 = load float, float* %34
%745 = fmul float %743, %744
%746 = call float @llvm.fmuladd.f32(float %741, float %745, float %735)
%747 = load float, float* %33
%748 = load float, float* %40
%749 = load float, float* %34
%750 = fmul float 2.000000e+00, %749
%751 = load float, float* %39
%752 = fmul float %750, %751
%753 = fneg float %752
%754 = call float @llvm.fmuladd.f32(float %747, float %748, float %753)
%755 = load float, float* %31
%756 = load float, float* %38
%757 = fneg float %755
%758 = call float @llvm.fmuladd.f32(float %757, float %756, float %754)
%759 = load float, float* %31
%760 = load float, float* %31
%761 = load float, float* %32
%762 = load float, float* %32
%763 = fmul float %761, %762
%764 = call float @llvm.fmuladd.f32(float %759, float %760, float %763)
%765 = load float, float* %33
%766 = load float, float* %33
%767 = call float @llvm.fmuladd.f32(float %765, float %766, float %764)
%768 = call float @llvm.fmuladd.f32(float %758, float %767, float %746)
%769 = fmul float %707, %768
%770 = load [7 x float]*, [7 x float]** %30
%771 = getelementptr inbounds [7 x float], [7 x float]* %770, i64 1
%772 = getelementptr inbounds [7 x float], [7 x float]* %771, i64 0, i64 6
store float %769, float* %772
%773 = load float, float* %31
%774 = fmul float -2.000000e+00, %773
%775 = load float, float* %33
%776 = load float, float* %32
%777 = fmul float 2.000000e+00, %776
%778 = load float, float* %34
%779 = fmul float %777, %778
%780 = fneg float %779
%781 = call float @llvm.fmuladd.f32(float %774, float %775, float %780)
%782 = load [7 x float]*, [7 x float]** %30
%783 = getelementptr inbounds [7 x float], [7 x float]* %782, i64 2
%784 = getelementptr inbounds [7 x float], [7 x float]* %783, i64 0, i64 0
store float %781, float* %784
%785 = load float, float* %31
%786 = fmul float 2.000000e+00, %785
%787 = load float, float* %32
%788 = load float, float* %33
%789 = fmul float 2.000000e+00, %788
%790 = load float, float* %34
%791 = fmul float %789, %790
%792 = fneg float %791
%793 = call float @llvm.fmuladd.f32(float %786, float %787, float %792)
%794 = load [7 x float]*, [7 x float]** %30
%795 = getelementptr inbounds [7 x float], [7 x float]* %794, i64 2
%796 = getelementptr inbounds [7 x float], [7 x float]* %795, i64 0, i64 1
store float %793, float* %796
%797 = load float, float* %35
%798 = load float, float* %36
%799 = fmul float 2.000000e+00, %798
%800 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %797, float %799)
%801 = fsub float %800, 1.000000e+00
%802 = load [7 x float]*, [7 x float]** %30
%803 = getelementptr inbounds [7 x float], [7 x float]* %802, i64 2
%804 = getelementptr inbounds [7 x float], [7 x float]* %803, i64 0, i64 2
store float %801, float* %804
%805 = load float, float* %42
%806 = load float, float* %33
%807 = load float, float* %38
%808 = load float, float* %32
%809 = load float, float* %39
%810 = fmul float %808, %809
%811 = fneg float %810
%812 = call float @llvm.fmuladd.f32(float %806, float %807, float %811)
%813 = load float, float* %32
%814 = load float, float* %32
%815 = load float, float* %33
%816 = load float, float* %33
%817 = fmul float %815, %816
%818 = call float @llvm.fmuladd.f32(float %813, float %814, float %817)
%819 = load float, float* %34
%820 = load float, float* %34
%821 = call float @llvm.fmuladd.f32(float %819, float %820, float %818)
%822 = load float, float* %34
%823 = load float, float* %38
%824 = load float, float* %31
%825 = load float, float* %39
%826 = fmul float %824, %825
%827 = fneg float %826
%828 = call float @llvm.fmuladd.f32(float %822, float %823, float %827)
%829 = load float, float* %32
%830 = fmul float 2.000000e+00, %829
%831 = load float, float* %40
%832 = fneg float %830
%833 = call float @llvm.fmuladd.f32(float %832, float %831, float %828)
%834 = load float, float* %32
%835 = fneg float %834
%836 = load float, float* %31
%837 = fmul float %835, %836
%838 = fmul float %833, %837
%839 = call float @llvm.fmuladd.f32(float %812, float %821, float %838)
%840 = load float, float* %31
%841 = load float, float* %38
%842 = load float, float* %34
%843 = load float, float* %39
%844 = fmul float %842, %843
%845 = call float @llvm.fmuladd.f32(float %840, float %841, float %844)
%846 = load float, float* %33
%847 = fmul float 2.000000e+00, %846
%848 = load float, float* %40
%849 = fneg float %847
%850 = call float @llvm.fmuladd.f32(float %849, float %848, float %845)
%851 = load float, float* %33
%852 = fneg float %851
%853 = load float, float* %31
%854 = fmul float %852, %853
%855 = call float @llvm.fmuladd.f32(float %850, float %854, float %839)
%856 = load float, float* %32
%857 = load float, float* %38
%858 = load float, float* %33
%859 = load float, float* %39
%860 = fmul float %858, %859
%861 = call float @llvm.fmuladd.f32(float %856, float %857, float %860)
%862 = load float, float* %34
%863 = fneg float %862
%864 = load float, float* %31
%865 = fmul float %863, %864
%866 = call float @llvm.fmuladd.f32(float %861, float %865, float %855)
%867 = fmul float %805, %866
%868 = load [7 x float]*, [7 x float]** %30
%869 = getelementptr inbounds [7 x float], [7 x float]* %868, i64 2
%870 = getelementptr inbounds [7 x float], [7 x float]* %869, i64 0, i64 3
store float %867, float* %870
%871 = load float, float* %42
%872 = load float, float* %33
%873 = load float, float* %38
%874 = load float, float* %32
%875 = load float, float* %39
%876 = fmul float %874, %875
%877 = fneg float %876
%878 = call float @llvm.fmuladd.f32(float %872, float %873, float %877)
%879 = load float, float* %31
%880 = fneg float %879
%881 = load float, float* %32
%882 = fmul float %880, %881
%883 = load float, float* %34
%884 = load float, float* %38
%885 = load float, float* %31
%886 = load float, float* %39
%887 = fmul float %885, %886
%888 = fneg float %887
%889 = call float @llvm.fmuladd.f32(float %883, float %884, float %888)
%890 = load float, float* %32
%891 = fmul float 2.000000e+00, %890
%892 = load float, float* %40
%893 = fneg float %891
%894 = call float @llvm.fmuladd.f32(float %893, float %892, float %889)
%895 = load float, float* %31
%896 = load float, float* %31
%897 = load float, float* %33
%898 = load float, float* %33
%899 = fmul float %897, %898
%900 = call float @llvm.fmuladd.f32(float %895, float %896, float %899)
%901 = load float, float* %34
%902 = load float, float* %34
%903 = call float @llvm.fmuladd.f32(float %901, float %902, float %900)
%904 = fmul float %894, %903
%905 = call float @llvm.fmuladd.f32(float %878, float %882, float %904)
%906 = load float, float* %31
%907 = load float, float* %38
%908 = load float, float* %34
%909 = load float, float* %39
%910 = fmul float %908, %909
%911 = call float @llvm.fmuladd.f32(float %906, float %907, float %910)
%912 = load float, float* %33
%913 = fmul float 2.000000e+00, %912
%914 = load float, float* %40
%915 = fneg float %913
%916 = call float @llvm.fmuladd.f32(float %915, float %914, float %911)
%917 = load float, float* %33
%918 = fneg float %917
%919 = load float, float* %32
%920 = fmul float %918, %919
%921 = call float @llvm.fmuladd.f32(float %916, float %920, float %905)
%922 = load float, float* %32
%923 = load float, float* %38
%924 = load float, float* %33
%925 = load float, float* %39
%926 = fmul float %924, %925
%927 = call float @llvm.fmuladd.f32(float %922, float %923, float %926)
%928 = load float, float* %34
%929 = fneg float %928
%930 = load float, float* %32
%931 = fmul float %929, %930
%932 = call float @llvm.fmuladd.f32(float %927, float %931, float %921)
%933 = fmul float %871, %932
%934 = load [7 x float]*, [7 x float]** %30
%935 = getelementptr inbounds [7 x float], [7 x float]* %934, i64 2
%936 = getelementptr inbounds [7 x float], [7 x float]* %935, i64 0, i64 4
store float %933, float* %936
%937 = load float, float* %42
%938 = load float, float* %33
%939 = load float, float* %38
%940 = load float, float* %32
%941 = load float, float* %39
%942 = fmul float %940, %941
%943 = fneg float %942
%944 = call float @llvm.fmuladd.f32(float %938, float %939, float %943)
%945 = load float, float* %31
%946 = fneg float %945
%947 = load float, float* %33
%948 = fmul float %946, %947
%949 = load float, float* %34
%950 = load float, float* %38
%951 = load float, float* %31
%952 = load float, float* %39
%953 = fmul float %951, %952
%954 = fneg float %953
%955 = call float @llvm.fmuladd.f32(float %949, float %950, float %954)
%956 = load float, float* %32
%957 = fmul float 2.000000e+00, %956
%958 = load float, float* %40
%959 = fneg float %957
%960 = call float @llvm.fmuladd.f32(float %959, float %958, float %955)
%961 = load float, float* %32
%962 = fneg float %961
%963 = load float, float* %33
%964 = fmul float %962, %963
%965 = fmul float %960, %964
%966 = call float @llvm.fmuladd.f32(float %944, float %948, float %965)
%967 = load float, float* %31
%968 = load float, float* %38
%969 = load float, float* %34
%970 = load float, float* %39
%971 = fmul float %969, %970
%972 = call float @llvm.fmuladd.f32(float %967, float %968, float %971)
%973 = load float, float* %33
%974 = fmul float 2.000000e+00, %973
%975 = load float, float* %40
%976 = fneg float %974
%977 = call float @llvm.fmuladd.f32(float %976, float %975, float %972)
%978 = load float, float* %31
%979 = load float, float* %31
%980 = load float, float* %32
%981 = load float, float* %32
%982 = fmul float %980, %981
%983 = call float @llvm.fmuladd.f32(float %978, float %979, float %982)
%984 = load float, float* %34
%985 = load float, float* %34
%986 = call float @llvm.fmuladd.f32(float %984, float %985, float %983)
%987 = call float @llvm.fmuladd.f32(float %977, float %986, float %966)
%988 = load float, float* %32
%989 = load float, float* %38
%990 = load float, float* %33
%991 = load float, float* %39
%992 = fmul float %990, %991
%993 = call float @llvm.fmuladd.f32(float %988, float %989, float %992)
%994 = load float, float* %34
%995 = fneg float %994
%996 = load float, float* %33
%997 = fmul float %995, %996
%998 = call float @llvm.fmuladd.f32(float %993, float %997, float %987)
%999 = fmul float %937, %998
%1000 = load [7 x float]*, [7 x float]** %30
%1001 = getelementptr inbounds [7 x float], [7 x float]* %1000, i64 2
%1002 = getelementptr inbounds [7 x float], [7 x float]* %1001, i64 0, i64 5
store float %999, float* %1002
%1003 = load float, float* %42
%1004 = load float, float* %33
%1005 = load float, float* %38
%1006 = load float, float* %32
%1007 = load float, float* %39
%1008 = fmul float %1006, %1007
%1009 = fneg float %1008
%1010 = call float @llvm.fmuladd.f32(float %1004, float %1005, float %1009)
%1011 = load float, float* %31
%1012 = fneg float %1011
%1013 = load float, float* %34
%1014 = fmul float %1012, %1013
%1015 = load float, float* %34
%1016 = load float, float* %38
%1017 = load float, float* %31
%1018 = load float, float* %39
%1019 = fmul float %1017, %1018
%1020 = fneg float %1019
%1021 = call float @llvm.fmuladd.f32(float %1015, float %1016, float %1020)
%1022 = load float, float* %32
%1023 = fmul float 2.000000e+00, %1022
%1024 = load float, float* %40
%1025 = fneg float %1023
%1026 = call float @llvm.fmuladd.f32(float %1025, float %1024, float %1021)
%1027 = load float, float* %32
%1028 = fneg float %1027
%1029 = load float, float* %34
%1030 = fmul float %1028, %1029
%1031 = fmul float %1026, %1030
%1032 = call float @llvm.fmuladd.f32(float %1010, float %1014, float %1031)
%1033 = load float, float* %31
%1034 = load float, float* %38
%1035 = load float, float* %34
%1036 = load float, float* %39
%1037 = fmul float %1035, %1036
%1038 = call float @llvm.fmuladd.f32(float %1033, float %1034, float %1037)
%1039 = load float, float* %33
%1040 = fmul float 2.000000e+00, %1039
%1041 = load float, float* %40
%1042 = fneg float %1040
%1043 = call float @llvm.fmuladd.f32(float %1042, float %1041, float %1038)
%1044 = load float, float* %33
%1045 = fneg float %1044
%1046 = load float, float* %34
%1047 = fmul float %1045, %1046
%1048 = call float @llvm.fmuladd.f32(float %1043, float %1047, float %1032)
%1049 = load float, float* %32
%1050 = load float, float* %38
%1051 = load float, float* %33
%1052 = load float, float* %39
%1053 = fmul float %1051, %1052
%1054 = call float @llvm.fmuladd.f32(float %1049, float %1050, float %1053)
%1055 = load float, float* %31
%1056 = load float, float* %31
%1057 = load float, float* %32
%1058 = load float, float* %32
%1059 = fmul float %1057, %1058
%1060 = call float @llvm.fmuladd.f32(float %1055, float %1056, float %1059)
%1061 = load float, float* %33
%1062 = load float, float* %33
%1063 = call float @llvm.fmuladd.f32(float %1061, float %1062, float %1060)
%1064 = call float @llvm.fmuladd.f32(float %1054, float %1063, float %1048)
%1065 = fmul float %1003, %1064
%1066 = load [7 x float]*, [7 x float]** %30
%1067 = getelementptr inbounds [7 x float], [7 x float]* %1066, i64 2
%1068 = getelementptr inbounds [7 x float], [7 x float]* %1067, i64 0, i64 6
store float %1065, float* %1068
%1069 = load float, float* %31
%1070 = fneg float %1069
%1071 = load float, float* %32
%1072 = fmul float %1070, %1071
store float %1072, float* %43
%1073 = load float, float* %31
%1074 = fneg float %1073
%1075 = load float, float* %33
%1076 = fmul float %1074, %1075
store float %1076, float* %44
%1077 = load float, float* %31
%1078 = fneg float %1077
%1079 = load float, float* %34
%1080 = fmul float %1078, %1079
store float %1080, float* %45
%1081 = load float, float* %32
%1082 = fneg float %1081
%1083 = load float, float* %32
%1084 = fmul float %1082, %1083
store float %1084, float* %46
%1085 = load float, float* %32
%1086 = load float, float* %33
%1087 = fmul float %1085, %1086
store float %1087, float* %47
%1088 = load float, float* %32
%1089 = load float, float* %34
%1090 = fmul float %1088, %1089
store float %1090, float* %48
%1091 = load float, float* %33
%1092 = fneg float %1091
%1093 = load float, float* %33
%1094 = fmul float %1092, %1093
store float %1094, float* %49
%1095 = load float, float* %33
%1096 = load float, float* %34
%1097 = fmul float %1095, %1096
store float %1097, float* %50
%1098 = load float, float* %34
%1099 = fneg float %1098
%1100 = load float, float* %34
%1101 = fmul float %1099, %1100
store float %1101, float* %51
%1102 = load float, float* %49
%1103 = load float, float* %51
%1104 = fadd float %1102, %1103
%1105 = load float, float* %23
%1106 = load float, float* %16
%1107 = fsub float %1105, %1106
%1108 = load float, float* %47
%1109 = load float, float* %45
%1110 = fsub float %1108, %1109
%1111 = load float, float* %24
%1112 = load float, float* %17
%1113 = fsub float %1111, %1112
%1114 = fmul float %1110, %1113
%1115 = call float @llvm.fmuladd.f32(float %1104, float %1107, float %1114)
%1116 = load float, float* %44
%1117 = load float, float* %48
%1118 = fadd float %1116, %1117
%1119 = load float, float* %25
%1120 = load float, float* %18
%1121 = fsub float %1119, %1120
%1122 = call float @llvm.fmuladd.f32(float %1118, float %1121, float %1115)
%1123 = load float, float* %23
%1124 = load float, float* %16
%1125 = fsub float %1123, %1124
%1126 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %1122, float %1125)
%1127 = load float*, float** %26
store float %1126, float* %1127
%1128 = load float, float* %45
%1129 = load float, float* %47
%1130 = fadd float %1128, %1129
%1131 = load float, float* %23
%1132 = load float, float* %16
%1133 = fsub float %1131, %1132
%1134 = load float, float* %46
%1135 = load float, float* %51
%1136 = fadd float %1134, %1135
%1137 = load float, float* %24
%1138 = load float, float* %17
%1139 = fsub float %1137, %1138
%1140 = fmul float %1136, %1139
%1141 = call float @llvm.fmuladd.f32(float %1130, float %1133, float %1140)
%1142 = load float, float* %50
%1143 = load float, float* %43
%1144 = fsub float %1142, %1143
%1145 = load float, float* %25
%1146 = load float, float* %18
%1147 = fsub float %1145, %1146
%1148 = call float @llvm.fmuladd.f32(float %1144, float %1147, float %1141)
%1149 = load float, float* %24
%1150 = load float, float* %17
%1151 = fsub float %1149, %1150
%1152 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %1148, float %1151)
%1153 = load float*, float** %27
store float %1152, float* %1153
%1154 = load float, float* %48
%1155 = load float, float* %44
%1156 = fsub float %1154, %1155
%1157 = load float, float* %23
%1158 = load float, float* %16
%1159 = fsub float %1157, %1158
%1160 = load float, float* %43
%1161 = load float, float* %50
%1162 = fadd float %1160, %1161
%1163 = load float, float* %24
%1164 = load float, float* %17
%1165 = fsub float %1163, %1164
%1166 = fmul float %1162, %1165
%1167 = call float @llvm.fmuladd.f32(float %1156, float %1159, float %1166)
%1168 = load float, float* %46
%1169 = load float, float* %49
%1170 = fadd float %1168, %1169
%1171 = load float, float* %25
%1172 = load float, float* %18
%1173 = fsub float %1171, %1172
%1174 = call float @llvm.fmuladd.f32(float %1170, float %1173, float %1167)
%1175 = load float, float* %25
%1176 = load float, float* %18
%1177 = fsub float %1175, %1176
%1178 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %1174, float %1177)
%1179 = load float*, float** %28
store float %1178, float* %1179
ret void
}

LLVM IR (-O2):
define void @inverseComposePoint(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9, float* nocapture writeonly %10, float* nocapture writeonly %11, float* nocapture writeonly %12, [3 x float]* nocapture writeonly %13, [7 x float]* writeonly %14) {
%16 = fmul float %4, %4
%17 = fmul float %5, %5
%18 = fmul float %6, %6
%19 = fsub float %7, %0
%20 = fmul float %19, 2.000000e+00
%21 = fsub float %8, %1
%22 = fmul float %21, 2.000000e+00
%23 = fsub float %9, %2
%24 = fmul float %23, 2.000000e+00
%25 = fadd float %17, %18
%26 = tail call float @llvm.fmuladd.f32(float %25, float -2.000000e+00, float 1.000000e+00)
%27 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float %26, float* %27
%28 = fneg float %3
%29 = fmul float %4, %5
%30 = tail call float @llvm.fmuladd.f32(float %28, float %6, float %29)
%31 = fmul float %30, 2.000000e+00
%32 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float %31, float* %32
%33 = fmul float %3, %5
%34 = tail call float @llvm.fmuladd.f32(float %4, float %6, float %33)
%35 = fmul float %34, 2.000000e+00
%36 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float %35, float* %36
%37 = fmul float %3, %6
%38 = tail call float @llvm.fmuladd.f32(float %4, float %5, float %37)
%39 = fmul float %38, 2.000000e+00
%40 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 1, i64 0
store float %39, float* %40
%41 = fadd float %16, %18
%42 = tail call float @llvm.fmuladd.f32(float %41, float -2.000000e+00, float 1.000000e+00)
%43 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 1, i64 1
store float %42, float* %43
%44 = fmul float %5, %6
%45 = tail call float @llvm.fmuladd.f32(float %28, float %4, float %44)
%46 = fmul float %45, 2.000000e+00
%47 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 1, i64 2
store float %46, float* %47
%48 = fmul float %4, %6
%49 = tail call float @llvm.fmuladd.f32(float %28, float %5, float %48)
%50 = fmul float %49, 2.000000e+00
%51 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 2, i64 0
store float %50, float* %51
%52 = fmul float %3, %4
%53 = tail call float @llvm.fmuladd.f32(float %5, float %6, float %52)
%54 = fmul float %53, 2.000000e+00
%55 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 2, i64 1
store float %54, float* %55
%56 = fadd float %16, %17
%57 = tail call float @llvm.fmuladd.f32(float %56, float -2.000000e+00, float 1.000000e+00)
%58 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 2, i64 2
store float %57, float* %58
%59 = tail call float @llvm.fmuladd.f32(float %3, float %3, float %16)
%60 = tail call float @llvm.fmuladd.f32(float %5, float %5, float %59)
%61 = tail call float @llvm.fmuladd.f32(float %6, float %6, float %60)
%62 = fmul float %61, %61
%63 = fmul float %61, %62
%64 = fpext float %63 to double
%65 = tail call i32 (double, ...) bitcast (i32 (...)* @inverseSqrt to i32 (double, ...)*)(double %64)
%66 = sitofp i32 %65 to float
%67 = fmul float %18, 2.000000e+00
%68 = tail call float @llvm.fmuladd.f32(float %17, float 2.000000e+00, float %67)
%69 = fadd float %68, -1.000000e+00
%70 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 0, i64 0
store float %69, float* %70
%71 = fmul float %3, -2.000000e+00
%72 = fmul float %4, -2.000000e+00
%73 = fmul float %72, %5
%74 = tail call float @llvm.fmuladd.f32(float %71, float %6, float %73)
%75 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 0, i64 1
store float %74, float* %75
%76 = fmul float %3, 2.000000e+00
%77 = fmul float %72, %6
%78 = tail call float @llvm.fmuladd.f32(float %76, float %5, float %77)
%79 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 0, i64 2
store float %78, float* %79
%80 = fneg float %5
%81 = fmul float %22, %6
%82 = tail call float @llvm.fmuladd.f32(float %80, float %24, float %81)
%83 = tail call float @llvm.fmuladd.f32(float %4, float %4, float %17)
%84 = tail call float @llvm.fmuladd.f32(float %6, float %6, float %83)
%85 = fmul float %24, %6
%86 = tail call float @llvm.fmuladd.f32(float %5, float %22, float %85)
%87 = fneg float %4
%88 = fmul float %87, %3
%89 = fmul float %5, -2.000000e+00
%90 = fmul float %89, %20
%91 = tail call float @llvm.fmuladd.f32(float %4, float %22, float %90)
%92 = tail call float @llvm.fmuladd.f32(float %28, float %24, float %91)
%93 = fmul float %22, %3
%94 = tail call float @llvm.fmuladd.f32(float %4, float %24, float %93)
%95 = fmul float %6, -2.000000e+00
%96 = tail call float @llvm.fmuladd.f32(float %95, float %20, float %94)
%97 = fneg float %6
%98 = fmul float %97, %3
%99 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 0, i64 3
%100 = fmul float %28, %4
%101 = tail call float @llvm.fmuladd.f32(float %3, float %3, float %17)
%102 = tail call float @llvm.fmuladd.f32(float %6, float %6, float %101)
%103 = insertelement <2 x float> poison, float %80, i64 0
%104 = shufflevector <2 x float> %103, <2 x float> poison, <2 x i32> zeroinitializer
%105 = insertelement <2 x float> poison, float %3, i64 0
%106 = insertelement <2 x float> %105, float %4, i64 1
%107 = fmul <2 x float> %104, %106
%108 = tail call float @llvm.fmuladd.f32(float %6, float %6, float %59)
%109 = insertelement <2 x float> poison, float %97, i64 0
%110 = shufflevector <2 x float> %109, <2 x float> poison, <2 x i32> zeroinitializer
%111 = insertelement <2 x float> poison, float %4, i64 0
%112 = insertelement <2 x float> %111, float %5, i64 1
%113 = fmul <2 x float> %110, %112
%114 = insertelement <2 x float> poison, float %28, i64 0
%115 = shufflevector <2 x float> %114, <2 x float> poison, <2 x i32> zeroinitializer
%116 = insertelement <2 x float> poison, float %5, i64 0
%117 = insertelement <2 x float> %116, float %6, i64 1
%118 = fmul <2 x float> %115, %117
%119 = insertelement <2 x float> poison, float %87, i64 0
%120 = shufflevector <2 x float> %119, <2 x float> poison, <2 x i32> zeroinitializer
%121 = fmul <2 x float> %120, %117
%122 = insertelement <4 x float> poison, float %88, i64 0
%123 = insertelement <4 x float> %122, float %102, i64 1
%124 = shufflevector <2 x float> %121, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%125 = shufflevector <4 x float> %123, <4 x float> %124, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%126 = insertelement <4 x float> poison, float %86, i64 0
%127 = shufflevector <4 x float> %126, <4 x float> poison, <4 x i32> zeroinitializer
%128 = fmul <4 x float> %125, %127
%129 = insertelement <4 x float> poison, float %82, i64 0
%130 = shufflevector <4 x float> %129, <4 x float> poison, <4 x i32> zeroinitializer
%131 = insertelement <4 x float> poison, float %84, i64 0
%132 = insertelement <4 x float> %131, float %100, i64 1
%133 = shufflevector <2 x float> %118, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%134 = shufflevector <4 x float> %132, <4 x float> %133, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%135 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %130, <4 x float> %134, <4 x float> %128)
%136 = fmul float %80, %6
%137 = insertelement <4 x float> poison, float %92, i64 0
%138 = shufflevector <4 x float> %137, <4 x float> poison, <4 x i32> zeroinitializer
%139 = shufflevector <2 x float> %107, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%140 = insertelement <4 x float> %139, float %108, i64 2
%141 = insertelement <4 x float> %140, float %136, i64 3
%142 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %138, <4 x float> %141, <4 x float> %135)
%143 = insertelement <4 x float> poison, float %96, i64 0
%144 = shufflevector <4 x float> %143, <4 x float> poison, <4 x i32> zeroinitializer
%145 = insertelement <4 x float> poison, float %98, i64 0
%146 = shufflevector <2 x float> %113, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%147 = shufflevector <4 x float> %145, <4 x float> %146, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%148 = insertelement <4 x float> %147, float %60, i64 3
%149 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %144, <4 x float> %148, <4 x float> %142)
%150 = insertelement <4 x float> poison, float %66, i64 0
%151 = shufflevector <4 x float> %150, <4 x float> poison, <4 x i32> zeroinitializer
%152 = fmul <4 x float> %149, %151
%153 = bitcast float* %99 to <4 x float>*
store <4 x float> %152, <4 x float>* %153
%154 = tail call float @llvm.fmuladd.f32(float %76, float %6, float %73)
%155 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 1, i64 0
store float %154, float* %155
%156 = tail call float @llvm.fmuladd.f32(float %16, float 2.000000e+00, float %67)
%157 = fadd float %156, -1.000000e+00
%158 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 1, i64 1
store float %157, float* %158
%159 = fmul float %89, %6
%160 = tail call float @llvm.fmuladd.f32(float %71, float %4, float %159)
%161 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 1, i64 2
store float %160, float* %161
%162 = fneg float %20
%163 = fmul float %162, %6
%164 = tail call float @llvm.fmuladd.f32(float %4, float %24, float %163)
%165 = fmul float %72, %22
%166 = tail call float @llvm.fmuladd.f32(float %5, float %20, float %165)
%167 = tail call float @llvm.fmuladd.f32(float %3, float %24, float %166)
%168 = tail call float @llvm.fmuladd.f32(float %4, float %20, float %85)
%169 = fmul float %95, %22
%170 = tail call float @llvm.fmuladd.f32(float %5, float %24, float %169)
%171 = tail call float @llvm.fmuladd.f32(float %28, float %20, float %170)
%172 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 1, i64 3
%173 = insertelement <4 x float> poison, float %167, i64 0
%174 = shufflevector <4 x float> %173, <4 x float> poison, <4 x i32> zeroinitializer
%175 = fmul <4 x float> %125, %174
%176 = insertelement <4 x float> poison, float %164, i64 0
%177 = shufflevector <4 x float> %176, <4 x float> poison, <4 x i32> zeroinitializer
%178 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %177, <4 x float> %134, <4 x float> %175)
%179 = insertelement <4 x float> poison, float %168, i64 0
%180 = shufflevector <4 x float> %179, <4 x float> poison, <4 x i32> zeroinitializer
%181 = extractelement <2 x float> %107, i64 0
%182 = insertelement <4 x float> poison, float %181, i64 0
%183 = extractelement <2 x float> %107, i64 1
%184 = insertelement <4 x float> %182, float %183, i64 1
%185 = insertelement <4 x float> %184, float %108, i64 2
%186 = insertelement <4 x float> %185, float %136, i64 3
%187 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %180, <4 x float> %186, <4 x float> %178)
%188 = insertelement <4 x float> poison, float %171, i64 0
%189 = shufflevector <4 x float> %188, <4 x float> poison, <4 x i32> zeroinitializer
%190 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %189, <4 x float> %148, <4 x float> %187)
%191 = fmul <4 x float> %190, %151
%192 = bitcast float* %172 to <4 x float>*
store <4 x float> %191, <4 x float>* %192
%193 = tail call float @llvm.fmuladd.f32(float %71, float %5, float %77)
%194 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 2, i64 0
store float %193, float* %194
%195 = tail call float @llvm.fmuladd.f32(float %76, float %4, float %159)
%196 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 2, i64 1
store float %195, float* %196
%197 = fmul float %17, 2.000000e+00
%198 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 2, i64 2
%199 = fneg float %22
%200 = fmul float %199, %4
%201 = tail call float @llvm.fmuladd.f32(float %5, float %20, float %200)
%202 = fneg float %93
%203 = tail call float @llvm.fmuladd.f32(float %6, float %20, float %202)
%204 = tail call float @llvm.fmuladd.f32(float %72, float %24, float %203)
%205 = fmul float %88, %204
%206 = tail call float @llvm.fmuladd.f32(float %201, float %84, float %205)
%207 = tail call float @llvm.fmuladd.f32(float %3, float %20, float %81)
%208 = tail call float @llvm.fmuladd.f32(float %89, float %24, float %207)
%209 = tail call float @llvm.fmuladd.f32(float %208, float %181, float %206)
%210 = fmul float %22, %5
%211 = tail call float @llvm.fmuladd.f32(float %4, float %20, float %210)
%212 = insertelement <2 x float> poison, float %102, i64 0
%213 = shufflevector <2 x float> %212, <2 x float> %121, <2 x i32> <i32 0, i32 2>
%214 = insertelement <2 x float> poison, float %204, i64 0
%215 = shufflevector <2 x float> %214, <2 x float> poison, <2 x i32> zeroinitializer
%216 = fmul <2 x float> %213, %215
%217 = extractelement <2 x float> %118, i64 0
%218 = insertelement <2 x float> poison, float %201, i64 0
%219 = shufflevector <2 x float> %218, <2 x float> poison, <2 x i32> zeroinitializer
%220 = insertelement <2 x float> poison, float %100, i64 0
%221 = shufflevector <2 x float> %220, <2 x float> %118, <2 x i32> <i32 0, i32 2>
%222 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %219, <2 x float> %221, <2 x float> %216)
%223 = insertelement <2 x float> poison, float %208, i64 0
%224 = shufflevector <2 x float> %223, <2 x float> poison, <2 x i32> zeroinitializer
%225 = insertelement <2 x float> poison, float %183, i64 0
%226 = insertelement <2 x float> %225, float %108, i64 1
%227 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %224, <2 x float> %226, <2 x float> %222)
%228 = insertelement <4 x float> poison, float %16, i64 0
%229 = insertelement <4 x float> %228, float %211, i64 1
%230 = shufflevector <4 x float> %229, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%231 = insertelement <4 x float> <float 2.000000e+00, float poison, float poison, float poison>, float %98, i64 1
%232 = shufflevector <4 x float> %231, <4 x float> %146, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%233 = insertelement <4 x float> poison, float %197, i64 0
%234 = insertelement <4 x float> %233, float %209, i64 1
%235 = shufflevector <2 x float> %227, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%236 = shufflevector <4 x float> %234, <4 x float> %235, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%237 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %230, <4 x float> %232, <4 x float> %236)
%238 = insertelement <4 x float> <float -1.000000e+00, float poison, float poison, float poison>, float %66, i64 1
%239 = shufflevector <4 x float> %238, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%240 = fadd <4 x float> %237, %239
%241 = fmul <4 x float> %237, %239
%242 = shufflevector <4 x float> %240, <4 x float> %241, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
%243 = bitcast float* %198 to <4 x float>*
store <4 x float> %242, <4 x float>* %243
%244 = extractelement <2 x float> %121, i64 1
%245 = fmul float %244, %204
%246 = extractelement <2 x float> %118, i64 1
%247 = tail call float @llvm.fmuladd.f32(float %201, float %246, float %245)
%248 = tail call float @llvm.fmuladd.f32(float %208, float %136, float %247)
%249 = tail call float @llvm.fmuladd.f32(float %211, float %60, float %248)
%250 = fmul float %249, %66
%251 = getelementptr inbounds [7 x float], [7 x float]* %14, i64 2, i64 6
store float %250, float* %251
%252 = fmul float %87, %4
%253 = fmul float %80, %5
%254 = fmul float %97, %6
%255 = fadd float %253, %254
%256 = fsub float %29, %246
%257 = fmul float %256, %21
%258 = tail call float @llvm.fmuladd.f32(float %255, float %19, float %257)
%259 = fadd float %217, %48
%260 = tail call float @llvm.fmuladd.f32(float %259, float %23, float %258)
%261 = tail call float @llvm.fmuladd.f32(float %260, float 2.000000e+00, float %19)
store float %261, float* %10
%262 = fadd float %29, %246
%263 = fadd float %252, %254
%264 = fmul float %263, %21
%265 = tail call float @llvm.fmuladd.f32(float %262, float %19, float %264)
%266 = fsub float %44, %100
%267 = tail call float @llvm.fmuladd.f32(float %266, float %23, float %265)
%268 = tail call float @llvm.fmuladd.f32(float %267, float 2.000000e+00, float %21)
store float %268, float* %11
%269 = fsub float %48, %217
%270 = fadd float %100, %44
%271 = fmul float %270, %21
%272 = tail call float @llvm.fmuladd.f32(float %269, float %19, float %271)
%273 = fadd float %252, %253
%274 = tail call float @llvm.fmuladd.f32(float %273, float %23, float %272)
%275 = tail call float @llvm.fmuladd.f32(float %274, float 2.000000e+00, float %23)
store float %275, float* %12
ret void
}