void VectorMatrixInverse(void *DstMatrix, const void *SrcMatrix) {
  typedef float Float4x4[4][4];
  const Float4x4 M;
  Float4x4 Result;
  float Det[4];
  Float4x4 Tmp;
  memcpy((void *)M, SrcMatrix, sizeof(Float4x4));
  Tmp[0][0] = M[2][2] * M[3][3] - M[2][3] * M[3][2];
  Tmp[0][1] = M[1][2] * M[3][3] - M[1][3] * M[3][2];
  Tmp[0][2] = M[1][2] * M[2][3] - M[1][3] * M[2][2];
  Tmp[1][0] = M[2][2] * M[3][3] - M[2][3] * M[3][2];
  Tmp[1][1] = M[0][2] * M[3][3] - M[0][3] * M[3][2];
  Tmp[1][2] = M[0][2] * M[2][3] - M[0][3] * M[2][2];
  Tmp[2][0] = M[1][2] * M[3][3] - M[1][3] * M[3][2];
  Tmp[2][1] = M[0][2] * M[3][3] - M[0][3] * M[3][2];
  Tmp[2][2] = M[0][2] * M[1][3] - M[0][3] * M[1][2];
  Tmp[3][0] = M[1][2] * M[2][3] - M[1][3] * M[2][2];
  Tmp[3][1] = M[0][2] * M[2][3] - M[0][3] * M[2][2];
  Tmp[3][2] = M[0][2] * M[1][3] - M[0][3] * M[1][2];
  Det[0] = M[1][1] * Tmp[0][0] - M[2][1] * Tmp[0][1] + M[3][1] * Tmp[0][2];
  Det[1] = M[0][1] * Tmp[1][0] - M[2][1] * Tmp[1][1] + M[3][1] * Tmp[1][2];
  Det[2] = M[0][1] * Tmp[2][0] - M[1][1] * Tmp[2][1] + M[3][1] * Tmp[2][2];
  Det[3] = M[0][1] * Tmp[3][0] - M[1][1] * Tmp[3][1] + M[2][1] * Tmp[3][2];
  float Determinant =
      M[0][0] * Det[0] - M[1][0] * Det[1] + M[2][0] * Det[2] - M[3][0] * Det[3];
  const float RDet = 1.0f / Determinant;
  Result[0][0] = RDet * Det[0];
  Result[0][1] = -RDet * Det[1];
  Result[0][2] = RDet * Det[2];
  Result[0][3] = -RDet * Det[3];
  Result[1][0] =
      -RDet * (M[1][0] * Tmp[0][0] - M[2][0] * Tmp[0][1] + M[3][0] * Tmp[0][2]);
  Result[1][1] =
      RDet * (M[0][0] * Tmp[1][0] - M[2][0] * Tmp[1][1] + M[3][0] * Tmp[1][2]);
  Result[1][2] =
      -RDet * (M[0][0] * Tmp[2][0] - M[1][0] * Tmp[2][1] + M[3][0] * Tmp[2][2]);
  Result[1][3] =
      RDet * (M[0][0] * Tmp[3][0] - M[1][0] * Tmp[3][1] + M[2][0] * Tmp[3][2]);
  Result[2][0] = RDet * (M[1][0] * (M[2][1] * M[3][3] - M[2][3] * M[3][1]) -
                         M[2][0] * (M[1][1] * M[3][3] - M[1][3] * M[3][1]) +
                         M[3][0] * (M[1][1] * M[2][3] - M[1][3] * M[2][1]));
  Result[2][1] = -RDet * (M[0][0] * (M[2][1] * M[3][3] - M[2][3] * M[3][1]) -
                          M[2][0] * (M[0][1] * M[3][3] - M[0][3] * M[3][1]) +
                          M[3][0] * (M[0][1] * M[2][3] - M[0][3] * M[2][1]));
  Result[2][2] = RDet * (M[0][0] * (M[1][1] * M[3][3] - M[1][3] * M[3][1]) -
                         M[1][0] * (M[0][1] * M[3][3] - M[0][3] * M[3][1]) +
                         M[3][0] * (M[0][1] * M[1][3] - M[0][3] * M[1][1]));
  Result[2][3] = -RDet * (M[0][0] * (M[1][1] * M[2][3] - M[1][3] * M[2][1]) -
                          M[1][0] * (M[0][1] * M[2][3] - M[0][3] * M[2][1]) +
                          M[2][0] * (M[0][1] * M[1][3] - M[0][3] * M[1][1]));
  Result[3][0] = -RDet * (M[1][0] * (M[2][1] * M[3][2] - M[2][2] * M[3][1]) -
                          M[2][0] * (M[1][1] * M[3][2] - M[1][2] * M[3][1]) +
                          M[3][0] * (M[1][1] * M[2][2] - M[1][2] * M[2][1]));
  Result[3][1] = RDet * (M[0][0] * (M[2][1] * M[3][2] - M[2][2] * M[3][1]) -
                         M[2][0] * (M[0][1] * M[3][2] - M[0][2] * M[3][1]) +
                         M[3][0] * (M[0][1] * M[2][2] - M[0][2] * M[2][1]));
  Result[3][2] = -RDet * (M[0][0] * (M[1][1] * M[3][2] - M[1][2] * M[3][1]) -
                          M[1][0] * (M[0][1] * M[3][2] - M[0][2] * M[3][1]) +
                          M[3][0] * (M[0][1] * M[1][2] - M[0][2] * M[1][1]));
  Result[3][3] = RDet * (M[0][0] * (M[1][1] * M[2][2] - M[1][2] * M[2][1]) -
                         M[1][0] * (M[0][1] * M[2][2] - M[0][2] * M[2][1]) +
                         M[2][0] * (M[0][1] * M[1][2] - M[0][2] * M[1][1]));
  memcpy(DstMatrix, &Result, 16 * sizeof(float));
}


x86 assembly (clang, -O0):
<VectorMatrixInverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
movss  -0x28(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x28(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x3c(%rbp),%xmm1
movss  -0xe0(%rbp),%xmm2
ff
movss  -0x2c(%rbp),%xmm0
mulss  -0xdc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0xd8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x4c(%rbp),%xmm1
movss  -0xd0(%rbp),%xmm2
ff
movss  -0x2c(%rbp),%xmm0
mulss  -0xcc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0xc8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x4c(%rbp),%xmm1
movss  -0xc0(%rbp),%xmm2
ff
movss  -0x3c(%rbp),%xmm0
mulss  -0xbc(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
movss  -0xb8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x4c(%rbp),%xmm1
movss  -0xb0(%rbp),%xmm2
ff
movss  -0x3c(%rbp),%xmm0
mulss  -0xac(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x40(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  0xad9(%rip),%xmm0
divss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0xe0(%rbp),%xmm3
ff
movss  -0x30(%rbp),%xmm1
mulss  -0xdc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0xd8(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0xd0(%rbp),%xmm3
ff
movss  -0x30(%rbp),%xmm1
mulss  -0xcc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0xc8(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0xc0(%rbp),%xmm3
ff
movss  -0x40(%rbp),%xmm1
mulss  -0xbc(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0xb8(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0xb0(%rbp),%xmm3
ff
movss  -0x40(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x30(%rbp),%xmm1
movss  -0xa8(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x40(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm3
movss  -0x14(%rbp),%xmm4
movss  -0x24(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x30(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm4
movss  -0x14(%rbp),%xmm6
movss  -0x34(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm3
movss  -0x24(%rbp),%xmm5
movss  -0x34(%rbp),%xmm4
mulss  -0x2c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm3
movss  -0x14(%rbp),%xmm4
movss  -0x24(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x30(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x14(%rbp),%xmm6
movss  -0x44(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x24(%rbp),%xmm5
movss  -0x44(%rbp),%xmm4
mulss  -0x2c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x14(%rbp),%xmm4
movss  -0x34(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x40(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x14(%rbp),%xmm6
movss  -0x44(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x34(%rbp),%xmm5
movss  -0x44(%rbp),%xmm4
mulss  -0x3c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x24(%rbp),%xmm4
movss  -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x40(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x24(%rbp),%xmm6
movss  -0x44(%rbp),%xmm5
mulss  -0x2c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x30(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x34(%rbp),%xmm5
movss  -0x44(%rbp),%xmm4
mulss  -0x3c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x28(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x30(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm4
movss  -0x18(%rbp),%xmm6
movss  -0x38(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm5
movss  -0x38(%rbp),%xmm4
mulss  -0x2c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x28(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x30(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x18(%rbp),%xmm6
movss  -0x48(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm5
movss  -0x48(%rbp),%xmm4
mulss  -0x2c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
movss  -0x38(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x40(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x18(%rbp),%xmm6
movss  -0x48(%rbp),%xmm5
mulss  -0x1c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x38(%rbp),%xmm5
movss  -0x48(%rbp),%xmm4
mulss  -0x3c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm4
movss  -0x38(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  -0x40(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm4
movss  -0x28(%rbp),%xmm6
movss  -0x48(%rbp),%xmm5
mulss  -0x2c(%rbp),%xmm5
movd   %xmm5,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x30(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm3
movss  -0x38(%rbp),%xmm5
movss  -0x48(%rbp),%xmm4
mulss  -0x3c(%rbp),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<VectorMatrixInverse>:
sub    $0x88,%rsp
movss  0x24(%rsi),%xmm14
movss  0x28(%rsi),%xmm7
movss  0x2c(%rsi),%xmm9
movss  0x38(%rsi),%xmm1
movss  0x3c(%rsi),%xmm5
movaps %xmm1,%xmm13
movaps %xmm1,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm7,%xmm4
mulss  %xmm5,%xmm4
movaps %xmm5,%xmm6
movaps %xmm5,-0x80(%rsp)
subss  %xmm0,%xmm4
movaps %xmm4,-0x70(%rsp)
unpcklps %xmm7,%xmm13
movss  0x1c(%rsi),%xmm0
movaps %xmm9,%xmm12
unpcklps %xmm0,%xmm12
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,%xmm11
movaps %xmm0,0x10(%rsp)
movss  0x18(%rsi),%xmm5
movaps %xmm7,%xmm4
unpcklps %xmm5,%xmm4
movaps %xmm4,-0x20(%rsp)
shufps $0x0,%xmm5,%xmm5
movaps %xmm5,0x70(%rsp)
movaps %xmm6,%xmm4
unpcklps %xmm9,%xmm4
mulps  %xmm4,%xmm5
movss  0x14(%rsi),%xmm3
movaps %xmm14,%xmm0
unpcklps %xmm3,%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm14,%xmm10
shufps $0x0,%xmm3,%xmm10
movaps %xmm3,%xmm8
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm4
movaps %xmm4,0x50(%rsp)
mulps  %xmm13,%xmm3
movaps %xmm3,0x40(%rsp)
mulps  %xmm11,%xmm13
subps  %xmm13,%xmm5
movss  0x34(%rsi),%xmm3
movaps %xmm3,%xmm6
unpcklps %xmm14,%xmm6
movaps %xmm14,%xmm15
mulss  %xmm1,%xmm14
movaps %xmm14,0x30(%rsp)
movss  0x8(%rsi),%xmm11
movaps %xmm11,%xmm0
movaps -0x80(%rsp),%xmm4
mulss  %xmm4,%xmm0
movss  0x4(%rsi),%xmm13
unpcklps %xmm13,%xmm8
mulss  %xmm4,%xmm15
mulss  %xmm13,%xmm4
movaps %xmm4,-0x80(%rsp)
movaps %xmm13,%xmm4
mulss  %xmm1,%xmm13
movss  0xc(%rsi),%xmm14
mulss  %xmm14,%xmm1
subss  %xmm1,%xmm0
movaps %xmm14,%xmm2
shufps $0x0,%xmm14,%xmm2
mulss  %xmm3,%xmm9
movaps %xmm9,-0x40(%rsp)
mulss  %xmm3,%xmm14
movaps %xmm14,-0x30(%rsp)
mulss  %xmm3,%xmm7
movaps %xmm7,-0x10(%rsp)
mulss  %xmm11,%xmm3
movaps %xmm3,0x20(%rsp)
shufps $0x0,%xmm11,%xmm11
movaps %xmm11,(%rsp)
movaps %xmm11,%xmm1
mulps  %xmm12,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm12
movaps %xmm12,-0x50(%rsp)
movaps -0x20(%rsp),%xmm12
mulps  %xmm12,%xmm4
mulps  %xmm2,%xmm12
movaps %xmm2,%xmm14
subps  %xmm12,%xmm1
movaps %xmm5,%xmm9
unpcklps %xmm0,%xmm9
movaps -0x70(%rsp),%xmm3
shufps $0x40,%xmm5,%xmm3
movaps %xmm3,-0x70(%rsp)
shufps $0xc5,%xmm1,%xmm5
shufps $0x58,%xmm1,%xmm5
movlhps %xmm0,%xmm1
shufps $0x24,%xmm1,%xmm9
mulps  %xmm9,%xmm10
shufps $0x54,%xmm8,%xmm8
mulps  %xmm3,%xmm8
subps  %xmm10,%xmm8
movaps %xmm6,%xmm11
movaps %xmm6,-0x60(%rsp)
movaps %xmm6,%xmm7
shufps $0x40,%xmm6,%xmm7
mulps  %xmm5,%xmm7
movaps %xmm5,%xmm10
addps  %xmm8,%xmm7
movaps %xmm7,%xmm3
shufps $0x55,%xmm7,%xmm3
movd   0x20(%rsi),%xmm6
movd   0x10(%rsi),%xmm0
movdqa %xmm6,%xmm1
punpckldq %xmm0,%xmm1
movdqa 0xd03(%rip),%xmm8
pxor   %xmm8,%xmm1
pshufd $0x55,%xmm1,%xmm5
mulss  %xmm3,%xmm5
movaps %xmm7,%xmm3
unpckhpd %xmm7,%xmm3
mulss  %xmm6,%xmm3
movaps %xmm7,%xmm12
shufps $0xff,%xmm7,%xmm12
movss  0x30(%rsi),%xmm1
mulss  %xmm1,%xmm12
unpcklps %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm6
movss  (%rsi),%xmm2
unpcklps %xmm2,%xmm0
mulss  %xmm7,%xmm2
addss  %xmm5,%xmm2
addss  %xmm2,%xmm3
subss  %xmm12,%xmm3
movss  0xcc0(%rip),%xmm2
divss  %xmm3,%xmm2
mulps  %xmm6,%xmm9
shufps $0x54,%xmm0,%xmm0
movaps -0x70(%rsp),%xmm3
mulps  %xmm0,%xmm3
subps  %xmm9,%xmm3
shufps $0x40,%xmm1,%xmm1
mulps  %xmm1,%xmm10
addps  %xmm3,%xmm10
pxor   %xmm2,%xmm8
movdqa %xmm2,%xmm12
punpckldq %xmm8,%xmm12
punpckldq %xmm2,%xmm8
subss  -0x40(%rsp),%xmm15
movaps 0x10(%rsp),%xmm3
mulps  %xmm11,%xmm3
movaps 0x50(%rsp),%xmm2
subps  %xmm3,%xmm2
movaps -0x80(%rsp),%xmm5
subss  -0x30(%rsp),%xmm5
movaps 0x60(%rsp),%xmm11
mulps  %xmm11,%xmm14
movaps -0x50(%rsp),%xmm3
subps  %xmm14,%xmm3
movaps %xmm3,%xmm9
movlhps %xmm5,%xmm9
movlhps %xmm2,%xmm5
shufps $0x22,%xmm9,%xmm5
mulps  %xmm6,%xmm5
shufps $0x40,%xmm2,%xmm15
mulps  %xmm0,%xmm15
subps  %xmm5,%xmm15
shufps $0xc5,%xmm3,%xmm2
shufps $0x58,%xmm3,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm15,%xmm2
punpcklqdq %xmm12,%xmm12
mulps  %xmm12,%xmm7
mulps  %xmm12,%xmm2
movaps %xmm2,%xmm9
movaps 0x30(%rsp),%xmm3
subss  -0x10(%rsp),%xmm3
movaps -0x60(%rsp),%xmm2
mulps  0x70(%rsp),%xmm2
movaps 0x40(%rsp),%xmm5
subps  %xmm2,%xmm5
subss  0x20(%rsp),%xmm13
mulps  (%rsp),%xmm11
subps  %xmm11,%xmm4
movaps %xmm4,%xmm2
movlhps %xmm13,%xmm2
movlhps %xmm5,%xmm13
shufps $0x22,%xmm2,%xmm13
mulps  %xmm6,%xmm13
movaps %xmm3,%xmm2
shufps $0x40,%xmm5,%xmm2
mulps  %xmm0,%xmm2
subps  %xmm13,%xmm2
shufps $0xc5,%xmm4,%xmm5
shufps $0x58,%xmm4,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm2,%xmm5
punpcklqdq %xmm8,%xmm8
mulps  %xmm8,%xmm10
mulps  %xmm8,%xmm5
movups %xmm7,(%rdi)
movups %xmm10,0x10(%rdi)
movups %xmm9,0x20(%rdi)
movups %xmm5,0x30(%rdi)
add    $0x88,%rsp
ret

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

LLVM IR (-O2):
define void @VectorMatrixInverse(i8* nocapture writeonly %0, i8* nocapture %1) {
%3 = bitcast i8* %1 to float*
%4 = load float, float* %3
%5 = getelementptr inbounds i8, i8* %1, i64 4
%6 = bitcast i8* %5 to float*
%7 = load float, float* %6
%8 = getelementptr inbounds i8, i8* %1, i64 8
%9 = bitcast i8* %8 to float*
%10 = load float, float* %9
%11 = getelementptr inbounds i8, i8* %1, i64 12
%12 = bitcast i8* %11 to float*
%13 = load float, float* %12
%14 = getelementptr inbounds i8, i8* %1, i64 16
%15 = bitcast i8* %14 to float*
%16 = load float, float* %15
%17 = getelementptr inbounds i8, i8* %1, i64 20
%18 = bitcast i8* %17 to float*
%19 = load float, float* %18
%20 = getelementptr inbounds i8, i8* %1, i64 24
%21 = bitcast i8* %20 to float*
%22 = load float, float* %21
%23 = getelementptr inbounds i8, i8* %1, i64 28
%24 = bitcast i8* %23 to float*
%25 = load float, float* %24
%26 = getelementptr inbounds i8, i8* %1, i64 32
%27 = bitcast i8* %26 to float*
%28 = load float, float* %27
%29 = getelementptr inbounds i8, i8* %1, i64 36
%30 = bitcast i8* %29 to float*
%31 = load float, float* %30
%32 = getelementptr inbounds i8, i8* %1, i64 40
%33 = bitcast i8* %32 to float*
%34 = load float, float* %33
%35 = getelementptr inbounds i8, i8* %1, i64 44
%36 = bitcast i8* %35 to float*
%37 = load float, float* %36
%38 = getelementptr inbounds i8, i8* %1, i64 48
%39 = bitcast i8* %38 to float*
%40 = load float, float* %39
%41 = getelementptr inbounds i8, i8* %1, i64 52
%42 = bitcast i8* %41 to float*
%43 = load float, float* %42
%44 = getelementptr inbounds i8, i8* %1, i64 56
%45 = bitcast i8* %44 to float*
%46 = load float, float* %45
%47 = getelementptr inbounds i8, i8* %1, i64 60
%48 = bitcast i8* %47 to float*
%49 = load float, float* %48
%50 = fneg float %37
%51 = fmul float %46, %50
%52 = tail call float @llvm.fmuladd.f32(float %34, float %49, float %51)
%53 = fneg float %25
%54 = insertelement <2 x float> poison, float %46, i64 0
%55 = insertelement <2 x float> %54, float %34, i64 1
%56 = insertelement <2 x float> poison, float %53, i64 0
%57 = shufflevector <2 x float> %56, <2 x float> poison, <2 x i32> zeroinitializer
%58 = fmul <2 x float> %55, %57
%59 = insertelement <2 x float> poison, float %22, i64 0
%60 = shufflevector <2 x float> %59, <2 x float> poison, <2 x i32> zeroinitializer
%61 = insertelement <2 x float> poison, float %49, i64 0
%62 = insertelement <2 x float> %61, float %37, i64 1
%63 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %60, <2 x float> %62, <2 x float> %58)
%64 = fneg float %13
%65 = fmul float %46, %64
%66 = tail call float @llvm.fmuladd.f32(float %10, float %49, float %65)
%67 = insertelement <2 x float> poison, float %34, i64 0
%68 = insertelement <2 x float> %67, float %22, i64 1
%69 = insertelement <2 x float> poison, float %64, i64 0
%70 = shufflevector <2 x float> %69, <2 x float> poison, <2 x i32> zeroinitializer
%71 = fmul <2 x float> %68, %70
%72 = insertelement <2 x float> poison, float %10, i64 0
%73 = shufflevector <2 x float> %72, <2 x float> poison, <2 x i32> zeroinitializer
%74 = insertelement <2 x float> poison, float %37, i64 0
%75 = insertelement <2 x float> %74, float %25, i64 1
%76 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %73, <2 x float> %75, <2 x float> %71)
%77 = shufflevector <2 x float> %76, <2 x float> poison, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%78 = shufflevector <2 x float> %76, <2 x float> poison, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%79 = shufflevector <2 x float> %76, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%80 = insertelement <2 x float> poison, float %31, i64 0
%81 = insertelement <2 x float> %80, float %19, i64 1
%82 = fneg <2 x float> %81
%83 = shufflevector <2 x float> %82, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%84 = extractelement <2 x float> %63, i64 0
%85 = insertelement <4 x float> poison, float %84, i64 0
%86 = insertelement <4 x float> %85, float %66, i64 1
%87 = insertelement <4 x float> %86, float %66, i64 2
%88 = shufflevector <4 x float> %87, <4 x float> %79, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%89 = fmul <4 x float> %88, %83
%90 = insertelement <4 x float> poison, float %19, i64 0
%91 = insertelement <4 x float> %90, float %7, i64 1
%92 = shufflevector <4 x float> %91, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%93 = insertelement <4 x float> poison, float %52, i64 0
%94 = shufflevector <4 x float> %93, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
%95 = shufflevector <2 x float> %63, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%96 = shufflevector <4 x float> %94, <4 x float> %95, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%97 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %92, <4 x float> %96, <4 x float> %89)
%98 = insertelement <4 x float> poison, float %43, i64 0
%99 = insertelement <4 x float> %98, float %31, i64 1
%100 = shufflevector <4 x float> %99, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 0, i32 1>
%101 = shufflevector <2 x float> %63, <2 x float> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
%102 = shufflevector <4 x float> %101, <4 x float> %78, <4 x i32> <i32 0, i32 4, i32 undef, i32 undef>
%103 = shufflevector <4 x float> %102, <4 x float> %79, <4 x i32> <i32 0, i32 1, i32 5, i32 5>
%104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %100, <4 x float> %103, <4 x float> %97)
%105 = extractelement <4 x float> %104, i64 1
%106 = insertelement <2 x float> poison, float %28, i64 0
%107 = insertelement <2 x float> %106, float %16, i64 1
%108 = fneg <2 x float> %107
%109 = shufflevector <2 x float> %108, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%110 = extractelement <2 x float> %108, i64 1
%111 = fmul float %105, %110
%112 = extractelement <4 x float> %104, i64 0
%113 = tail call float @llvm.fmuladd.f32(float %4, float %112, float %111)
%114 = extractelement <4 x float> %104, i64 2
%115 = tail call float @llvm.fmuladd.f32(float %28, float %114, float %113)
%116 = fneg float %40
%117 = extractelement <4 x float> %104, i64 3
%118 = tail call float @llvm.fmuladd.f32(float %116, float %117, float %115)
%119 = fdiv float 1.000000e+00, %118
%120 = fneg float %119
%121 = insertelement <4 x float> poison, float %119, i64 0
%122 = insertelement <4 x float> %121, float %120, i64 1
%123 = shufflevector <4 x float> %122, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%124 = fmul <4 x float> %104, %123
%125 = fmul <4 x float> %88, %109
%126 = insertelement <4 x float> poison, float %16, i64 0
%127 = insertelement <4 x float> %126, float %4, i64 1
%128 = shufflevector <4 x float> %127, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%129 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> %96, <4 x float> %125)
%130 = insertelement <4 x float> poison, float %40, i64 0
%131 = insertelement <4 x float> %130, float %28, i64 1
%132 = shufflevector <4 x float> %131, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 0, i32 1>
%133 = shufflevector <2 x float> %76, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%134 = shufflevector <4 x float> %101, <4 x float> %133, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%135 = shufflevector <4 x float> %134, <4 x float> %77, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
%136 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %132, <4 x float> %135, <4 x float> %129)
%137 = insertelement <4 x float> poison, float %120, i64 0
%138 = insertelement <4 x float> %137, float %119, i64 1
%139 = shufflevector <4 x float> %138, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%140 = fmul <4 x float> %136, %139
%141 = fmul float %43, %50
%142 = tail call float @llvm.fmuladd.f32(float %31, float %49, float %141)
%143 = insertelement <2 x float> poison, float %43, i64 0
%144 = insertelement <2 x float> %143, float %31, i64 1
%145 = fmul <2 x float> %144, %57
%146 = insertelement <2 x float> poison, float %19, i64 0
%147 = shufflevector <2 x float> %146, <2 x float> poison, <2 x i32> zeroinitializer
%148 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %147, <2 x float> %62, <2 x float> %145)
%149 = fmul float %43, %64
%150 = tail call float @llvm.fmuladd.f32(float %7, float %49, float %149)
%151 = fmul <2 x float> %81, %70
%152 = insertelement <2 x float> poison, float %7, i64 0
%153 = shufflevector <2 x float> %152, <2 x float> poison, <2 x i32> zeroinitializer
%154 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %153, <2 x float> %75, <2 x float> %151)
%155 = shufflevector <2 x float> %154, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%156 = extractelement <2 x float> %148, i64 0
%157 = insertelement <4 x float> poison, float %156, i64 0
%158 = insertelement <4 x float> %157, float %150, i64 1
%159 = insertelement <4 x float> %158, float %150, i64 2
%160 = shufflevector <4 x float> %159, <4 x float> %155, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%161 = shufflevector <2 x float> %108, <2 x float> undef, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%162 = fmul <4 x float> %160, %161
%163 = insertelement <4 x float> poison, float %142, i64 0
%164 = shufflevector <4 x float> %163, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
%165 = shufflevector <2 x float> %148, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%166 = shufflevector <4 x float> %164, <4 x float> %165, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%167 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> %166, <4 x float> %162)
%168 = shufflevector <2 x float> %148, <2 x float> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
%169 = shufflevector <2 x float> %154, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%170 = shufflevector <4 x float> %168, <4 x float> %169, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%171 = shufflevector <4 x float> %170, <4 x float> %155, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
%172 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %132, <4 x float> %171, <4 x float> %167)
%173 = fmul <4 x float> %172, %123
%174 = fneg float %34
%175 = fmul float %43, %174
%176 = tail call float @llvm.fmuladd.f32(float %31, float %46, float %175)
%177 = fneg float %22
%178 = insertelement <2 x float> poison, float %177, i64 0
%179 = shufflevector <2 x float> %178, <2 x float> poison, <2 x i32> zeroinitializer
%180 = fmul <2 x float> %144, %179
%181 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %147, <2 x float> %55, <2 x float> %180)
%182 = fneg float %10
%183 = fmul float %43, %182
%184 = tail call float @llvm.fmuladd.f32(float %7, float %46, float %183)
%185 = insertelement <2 x float> poison, float %182, i64 0
%186 = shufflevector <2 x float> %185, <2 x float> poison, <2 x i32> zeroinitializer
%187 = fmul <2 x float> %81, %186
%188 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %153, <2 x float> %68, <2 x float> %187)
%189 = shufflevector <2 x float> %188, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%190 = extractelement <2 x float> %181, i64 0
%191 = insertelement <4 x float> poison, float %190, i64 0
%192 = insertelement <4 x float> %191, float %184, i64 1
%193 = insertelement <4 x float> %192, float %184, i64 2
%194 = shufflevector <4 x float> %193, <4 x float> %189, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%195 = fmul <4 x float> %194, %161
%196 = insertelement <4 x float> poison, float %176, i64 0
%197 = shufflevector <4 x float> %196, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
%198 = shufflevector <2 x float> %181, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%199 = shufflevector <4 x float> %197, <4 x float> %198, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%200 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> %199, <4 x float> %195)
%201 = shufflevector <2 x float> %181, <2 x float> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
%202 = shufflevector <2 x float> %188, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%203 = shufflevector <4 x float> %201, <4 x float> %202, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%204 = shufflevector <4 x float> %203, <4 x float> %189, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
%205 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %132, <4 x float> %204, <4 x float> %200)
%206 = fmul <4 x float> %205, %139
%207 = bitcast i8* %0 to <4 x float>*
store <4 x float> %124, <4 x float>* %207
%208 = getelementptr inbounds i8, i8* %0, i64 16
%209 = bitcast i8* %208 to <4 x float>*
store <4 x float> %140, <4 x float>* %209
%210 = getelementptr inbounds i8, i8* %0, i64 32
%211 = bitcast i8* %210 to <4 x float>*
store <4 x float> %173, <4 x float>* %211
%212 = getelementptr inbounds i8, i8* %0, i64 48
%213 = bitcast i8* %212 to <4 x float>*
store <4 x float> %206, <4 x float>* %213
ret void
}