void invert4x4(const float *src, float *dst) {
  float det;
  dst[0] = +src[5] * src[10] * src[15] - src[5] * src[11] * src[14] -
           src[9] * src[6] * src[15] + src[9] * src[7] * src[14] +
           src[13] * src[6] * src[11] - src[13] * src[7] * src[10];
  dst[1] = -src[1] * src[10] * src[15] + src[1] * src[11] * src[14] +
           src[9] * src[2] * src[15] - src[9] * src[3] * src[14] -
           src[13] * src[2] * src[11] + src[13] * src[3] * src[10];
  dst[2] = +src[1] * src[6] * src[15] - src[1] * src[7] * src[14] -
           src[5] * src[2] * src[15] + src[5] * src[3] * src[14] +
           src[13] * src[2] * src[7] - src[13] * src[3] * src[6];
  dst[3] = -src[1] * src[6] * src[11] + src[1] * src[7] * src[10] +
           src[5] * src[2] * src[11] - src[5] * src[3] * src[10] -
           src[9] * src[2] * src[7] + src[9] * src[3] * src[6];
  dst[4] = -src[4] * src[10] * src[15] + src[4] * src[11] * src[14] +
           src[8] * src[6] * src[15] - src[8] * src[7] * src[14] -
           src[12] * src[6] * src[11] + src[12] * src[7] * src[10];
  dst[5] = +src[0] * src[10] * src[15] - src[0] * src[11] * src[14] -
           src[8] * src[2] * src[15] + src[8] * src[3] * src[14] +
           src[12] * src[2] * src[11] - src[12] * src[3] * src[10];
  dst[6] = -src[0] * src[6] * src[15] + src[0] * src[7] * src[14] +
           src[4] * src[2] * src[15] - src[4] * src[3] * src[14] -
           src[12] * src[2] * src[7] + src[12] * src[3] * src[6];
  dst[7] = +src[0] * src[6] * src[11] - src[0] * src[7] * src[10] -
           src[4] * src[2] * src[11] + src[4] * src[3] * src[10] +
           src[8] * src[2] * src[7] - src[8] * src[3] * src[6];
  dst[8] = +src[4] * src[9] * src[15] - src[4] * src[11] * src[13] -
           src[8] * src[5] * src[15] + src[8] * src[7] * src[13] +
           src[12] * src[5] * src[11] - src[12] * src[7] * src[9];
  dst[9] = -src[0] * src[9] * src[15] + src[0] * src[11] * src[13] +
           src[8] * src[1] * src[15] - src[8] * src[3] * src[13] -
           src[12] * src[1] * src[11] + src[12] * src[3] * src[9];
  dst[10] = +src[0] * src[5] * src[15] - src[0] * src[7] * src[13] -
            src[4] * src[1] * src[15] + src[4] * src[3] * src[13] +
            src[12] * src[1] * src[7] - src[12] * src[3] * src[5];
  dst[11] = -src[0] * src[5] * src[11] + src[0] * src[7] * src[9] +
            src[4] * src[1] * src[11] - src[4] * src[3] * src[9] -
            src[8] * src[1] * src[7] + src[8] * src[3] * src[5];
  dst[12] = -src[4] * src[9] * src[14] + src[4] * src[10] * src[13] +
            src[8] * src[5] * src[14] - src[8] * src[6] * src[13] -
            src[12] * src[5] * src[10] + src[12] * src[6] * src[9];
  dst[13] = +src[0] * src[9] * src[14] - src[0] * src[10] * src[13] -
            src[8] * src[1] * src[14] + src[8] * src[2] * src[13] +
            src[12] * src[1] * src[10] - src[12] * src[2] * src[9];
  dst[14] = -src[0] * src[5] * src[14] + src[0] * src[6] * src[13] +
            src[4] * src[1] * src[14] - src[4] * src[2] * src[13] -
            src[12] * src[1] * src[6] + src[12] * src[2] * src[5];
  dst[15] = +src[0] * src[5] * src[10] - src[0] * src[6] * src[9] -
            src[4] * src[1] * src[10] + src[4] * src[2] * src[9] +
            src[8] * src[1] * src[6] - src[8] * src[2] * src[5];
  det = +src[0] * dst[0] + src[1] * dst[4] + src[2] * dst[8] + src[3] * dst[12];
  det = 1.0f / det;
  dst[0] *= det;
  dst[1] *= det;
  dst[2] *= det;
  dst[3] *= det;
  dst[4] *= det;
  dst[5] *= det;
  dst[6] *= det;
  dst[7] *= det;
  dst[8] *= det;
  dst[9] *= det;
  dst[10] *= det;
  dst[11] *= det;
  dst[12] *= det;
  dst[13] *= det;
  dst[14] *= det;
  dst[15] *= det;
}


x86 assembly (clang, -O0):
<invert4x4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x24(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xefc(%rip),%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x20(%rax),%xmm0
movss  %xmm0,0x20(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
movss  %xmm0,0x24(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
movss  %xmm0,0x28(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm0
movss  %xmm0,0x2c(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x30(%rax),%xmm0
movss  %xmm0,0x30(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm0
movss  %xmm0,0x34(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm0
movss  %xmm0,0x38(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x3c(%rax),%xmm0
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert4x4>:
movss  0x28(%rdi),%xmm0
movss  0x14(%rdi),%xmm1
movss  0x18(%rdi),%xmm7
movss  0x3c(%rdi),%xmm2
movss  0x2c(%rdi),%xmm4
movss  0x38(%rdi),%xmm3
movaps %xmm7,%xmm5
movss  0x34(%rdi),%xmm6
mulss  %xmm6,%xmm7
mulss  %xmm4,%xmm7
mulss  %xmm1,%xmm4
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm4
mulss  %xmm2,%xmm1
subss  %xmm4,%xmm1
movss  0x24(%rdi),%xmm4
mulss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm5,%xmm1
movss  0x1c(%rdi),%xmm2
mulss  %xmm2,%xmm4
mulss  %xmm3,%xmm4
addss  %xmm1,%xmm4
addss  %xmm4,%xmm7
mulss  %xmm6,%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm7
movaps %xmm7,-0x18(%rsp)
movss  %xmm7,(%rsi)
movss  0x28(%rdi),%xmm2
movss  0x4(%rdi),%xmm1
movss  0x8(%rdi),%xmm0
movss  0x24(%rdi),%xmm3
movaps %xmm3,%xmm4
movss  0xc(%rdi),%xmm7
mulss  %xmm7,%xmm3
movss  0x34(%rdi),%xmm8
mulss  %xmm8,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm1,%xmm2
movss  0x3c(%rdi),%xmm6
movss  0x2c(%rdi),%xmm9
mulss  %xmm9,%xmm1
movss  0x38(%rdi),%xmm5
mulss  %xmm5,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm8,%xmm0
mulss  %xmm9,%xmm0
subss  %xmm0,%xmm4
addss  %xmm4,%xmm7
movaps %xmm7,-0x28(%rsp)
movss  %xmm7,0x4(%rsi)
movss  0x18(%rdi),%xmm0
movss  0x4(%rdi),%xmm1
movss  0x8(%rdi),%xmm7
movss  0x3c(%rdi),%xmm2
movss  0x1c(%rdi),%xmm3
movss  0x38(%rdi),%xmm4
movaps %xmm7,%xmm5
movss  0x34(%rdi),%xmm6
mulss  %xmm6,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm1,%xmm3
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm3
mulss  %xmm2,%xmm1
subss  %xmm3,%xmm1
movss  0x14(%rdi),%xmm3
mulss  %xmm3,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm5,%xmm1
movss  0xc(%rdi),%xmm2
mulss  %xmm2,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
addss  %xmm3,%xmm7
mulss  %xmm6,%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm7
movaps %xmm7,-0x38(%rsp)
movss  %xmm7,0x8(%rsi)
movss  0x18(%rdi),%xmm2
movss  0x4(%rdi),%xmm1
movss  0x8(%rdi),%xmm0
movss  0x14(%rdi),%xmm3
movaps %xmm3,%xmm4
movss  0xc(%rdi),%xmm7
mulss  %xmm7,%xmm3
movss  0x24(%rdi),%xmm8
mulss  %xmm8,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm1,%xmm2
movss  0x2c(%rdi),%xmm6
movss  0x1c(%rdi),%xmm9
mulss  %xmm9,%xmm1
movss  0x28(%rdi),%xmm5
mulss  %xmm5,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm8,%xmm0
mulss  %xmm9,%xmm0
subss  %xmm0,%xmm4
addss  %xmm4,%xmm7
movaps %xmm7,-0x48(%rsp)
movss  %xmm7,0xc(%rsi)
movss  0x28(%rdi),%xmm2
movss  0x10(%rdi),%xmm1
movss  0x18(%rdi),%xmm0
movss  0x20(%rdi),%xmm3
movaps %xmm3,%xmm4
movss  0x1c(%rdi),%xmm15
mulss  %xmm15,%xmm3
movss  0x30(%rdi),%xmm11
mulss  %xmm11,%xmm15
mulss  %xmm2,%xmm15
mulss  %xmm1,%xmm2
movss  0x3c(%rdi),%xmm6
movss  0x2c(%rdi),%xmm7
mulss  %xmm7,%xmm1
movss  0x38(%rdi),%xmm5
mulss  %xmm5,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm11,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm4
addss  %xmm4,%xmm15
movss  %xmm15,0x10(%rsi)
movss  0x28(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x8(%rdi),%xmm7
movss  0x3c(%rdi),%xmm2
movss  0x2c(%rdi),%xmm3
movss  0x38(%rdi),%xmm4
movaps %xmm7,%xmm5
movss  0x30(%rdi),%xmm6
mulss  %xmm6,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm1,%xmm3
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm3
mulss  %xmm2,%xmm1
subss  %xmm3,%xmm1
movss  0x20(%rdi),%xmm3
mulss  %xmm3,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm5,%xmm1
movss  0xc(%rdi),%xmm2
mulss  %xmm2,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
addss  %xmm3,%xmm7
mulss  %xmm6,%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm7
movaps %xmm7,-0x58(%rsp)
movss  %xmm7,0x14(%rsi)
movss  0x18(%rdi),%xmm2
movss  (%rdi),%xmm1
movss  0x8(%rdi),%xmm0
movss  0x10(%rdi),%xmm3
movaps %xmm3,%xmm4
movss  0xc(%rdi),%xmm7
mulss  %xmm7,%xmm3
movss  0x30(%rdi),%xmm14
mulss  %xmm14,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm1,%xmm2
movss  0x3c(%rdi),%xmm6
movss  0x1c(%rdi),%xmm8
mulss  %xmm8,%xmm1
movss  0x38(%rdi),%xmm5
mulss  %xmm5,%xmm1
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm14,%xmm0
mulss  %xmm8,%xmm0
subss  %xmm0,%xmm4
addss  %xmm4,%xmm7
movaps %xmm7,-0x68(%rsp)
movss  %xmm7,0x18(%rsi)
movss  0x18(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x8(%rdi),%xmm7
movss  0x2c(%rdi),%xmm2
movss  0x1c(%rdi),%xmm3
movss  0x28(%rdi),%xmm4
movaps %xmm7,%xmm5
movss  0x20(%rdi),%xmm6
mulss  %xmm6,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm1,%xmm3
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm3
mulss  %xmm2,%xmm1
subss  %xmm3,%xmm1
movss  0x10(%rdi),%xmm3
mulss  %xmm3,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm5,%xmm1
movss  0xc(%rdi),%xmm2
mulss  %xmm2,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm1,%xmm3
addss  %xmm3,%xmm7
mulss  %xmm6,%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm7
movaps %xmm7,-0x78(%rsp)
movss  %xmm7,0x1c(%rsi)
movss  0x24(%rdi),%xmm0
movss  0x10(%rdi),%xmm1
movss  0x14(%rdi),%xmm11
movss  0x3c(%rdi),%xmm3
movss  0x2c(%rdi),%xmm5
movss  0x34(%rdi),%xmm4
movaps %xmm11,%xmm6
movss  0x30(%rdi),%xmm7
mulss  %xmm7,%xmm11
mulss  %xmm5,%xmm11
mulss  %xmm1,%xmm5
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm5
mulss  %xmm3,%xmm1
subss  %xmm5,%xmm1
movss  0x20(%rdi),%xmm5
mulss  %xmm5,%xmm6
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm1
movss  0x1c(%rdi),%xmm3
mulss  %xmm3,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm5
addss  %xmm5,%xmm11
mulss  %xmm7,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm11
movss  %xmm11,0x20(%rsi)
movss  0x24(%rdi),%xmm1
movss  (%rdi),%xmm0
movss  0x20(%rdi),%xmm3
movaps %xmm3,%xmm4
movss  0xc(%rdi),%xmm14
mulss  %xmm14,%xmm3
movss  0x30(%rdi),%xmm5
mulss  %xmm5,%xmm14
mulss  %xmm1,%xmm14
mulss  %xmm0,%xmm1
movss  0x2c(%rdi),%xmm6
mulss  %xmm6,%xmm0
movss  0x34(%rdi),%xmm7
mulss  %xmm7,%xmm0
movss  0x3c(%rdi),%xmm2
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm0
movss  0x4(%rdi),%xmm1
mulss  %xmm1,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm7,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm5,%xmm1
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
addss  %xmm4,%xmm14
movss  %xmm14,0x24(%rsi)
movss  0x14(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x4(%rdi),%xmm12
movss  0x1c(%rdi),%xmm2
movaps %xmm12,%xmm3
movss  0x30(%rdi),%xmm5
mulss  %xmm5,%xmm12
mulss  %xmm2,%xmm12
mulss  %xmm1,%xmm2
mulss  %xmm0,%xmm1
movss  0x34(%rdi),%xmm6
mulss  %xmm6,%xmm2
movss  0x3c(%rdi),%xmm7
mulss  %xmm7,%xmm1
subss  %xmm2,%xmm1
movss  0x10(%rdi),%xmm2
mulss  %xmm2,%xmm3
mulss  %xmm7,%xmm3
subss  %xmm3,%xmm1
movss  0xc(%rdi),%xmm3
mulss  %xmm3,%xmm2
mulss  %xmm6,%xmm2
addss  %xmm1,%xmm2
addss  %xmm2,%xmm12
mulss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm12
movss  %xmm12,0x28(%rsi)
movss  0x14(%rdi),%xmm0
movss  0x10(%rdi),%xmm2
movaps %xmm2,%xmm1
movss  0xc(%rdi),%xmm13
mulss  %xmm13,%xmm2
movss  0x20(%rdi),%xmm5
mulss  %xmm5,%xmm13
mulss  %xmm0,%xmm13
movss  (%rdi),%xmm6
mulss  %xmm6,%xmm0
movss  0x1c(%rdi),%xmm7
mulss  %xmm7,%xmm6
movss  0x24(%rdi),%xmm4
mulss  %xmm4,%xmm6
movss  0x2c(%rdi),%xmm3
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm6
movss  0x4(%rdi),%xmm0
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm6,%xmm1
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm1
mulss  %xmm5,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm1
addss  %xmm1,%xmm13
movss  %xmm13,0x2c(%rsi)
movss  0x20(%rdi),%xmm1
movaps %xmm1,%xmm0
movss  0x18(%rdi),%xmm8
mulss  %xmm8,%xmm1
movss  0x30(%rdi),%xmm6
mulss  %xmm6,%xmm8
movss  0x24(%rdi),%xmm3
mulss  %xmm3,%xmm8
movss  0x10(%rdi),%xmm4
mulss  %xmm4,%xmm3
movss  0x28(%rdi),%xmm5
mulss  %xmm5,%xmm4
movss  0x34(%rdi),%xmm7
mulss  %xmm7,%xmm4
movss  0x38(%rdi),%xmm2
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
movss  0x14(%rdi),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm0
mulss  %xmm6,%xmm3
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm0
addss  %xmm0,%xmm8
movss  %xmm8,0x30(%rsi)
movss  0x4(%rdi),%xmm10
movaps %xmm10,%xmm0
movss  0x30(%rdi),%xmm2
mulss  %xmm2,%xmm10
movss  0x28(%rdi),%xmm3
mulss  %xmm3,%xmm10
movss  (%rdi),%xmm4
mulss  %xmm4,%xmm3
movss  0x24(%rdi),%xmm5
mulss  %xmm5,%xmm4
movss  0x34(%rdi),%xmm7
mulss  %xmm7,%xmm3
movss  0x38(%rdi),%xmm1
mulss  %xmm1,%xmm4
subss  %xmm3,%xmm4
movss  0x20(%rdi),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm1,%xmm0
subss  %xmm0,%xmm4
movss  0x8(%rdi),%xmm0
mulss  %xmm0,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm4,%xmm3
addss  %xmm3,%xmm10
mulss  %xmm2,%xmm0
mulss  %xmm5,%xmm0
subss  %xmm0,%xmm10
movss  %xmm10,0x34(%rsi)
movss  0x10(%rdi),%xmm1
movaps %xmm1,%xmm0
movss  0x8(%rdi),%xmm7
mulss  %xmm7,%xmm1
movss  0x30(%rdi),%xmm9
mulss  %xmm9,%xmm7
movss  0x14(%rdi),%xmm3
mulss  %xmm3,%xmm7
movss  (%rdi),%xmm4
mulss  %xmm4,%xmm3
movss  0x18(%rdi),%xmm6
mulss  %xmm6,%xmm4
movss  0x34(%rdi),%xmm5
mulss  %xmm5,%xmm4
movss  0x38(%rdi),%xmm2
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
movss  0x4(%rdi),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm0
mulss  %xmm9,%xmm3
mulss  %xmm6,%xmm3
subss  %xmm3,%xmm0
addss  %xmm0,%xmm7
movss  %xmm7,0x38(%rsi)
movss  0x4(%rdi),%xmm3
movaps %xmm3,%xmm0
movss  0x20(%rdi),%xmm9
mulss  %xmm9,%xmm3
movss  0x18(%rdi),%xmm2
mulss  %xmm2,%xmm3
movss  (%rdi),%xmm4
mulss  %xmm4,%xmm2
movss  0x14(%rdi),%xmm5
mulss  %xmm5,%xmm4
movss  0x24(%rdi),%xmm6
mulss  %xmm6,%xmm2
movss  0x28(%rdi),%xmm1
mulss  %xmm1,%xmm4
subss  %xmm2,%xmm4
movss  0x10(%rdi),%xmm2
mulss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
subss  %xmm0,%xmm4
movss  0x8(%rdi),%xmm0
mulss  %xmm0,%xmm2
mulss  %xmm6,%xmm2
addss  %xmm4,%xmm2
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm0
mulss  %xmm5,%xmm0
subss  %xmm0,%xmm3
movss  %xmm3,0x3c(%rsi)
movss  0x4(%rdi),%xmm0
mulss  %xmm15,%xmm0
movss  (%rdi),%xmm1
movaps -0x18(%rsp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rdi),%xmm0
mulss  %xmm11,%xmm0
addss  %xmm1,%xmm0
movss  0xc(%rdi),%xmm1
mulss  %xmm8,%xmm1
addss  %xmm0,%xmm1
movss  0x6d1(%rip),%xmm0
divss  %xmm1,%xmm0
movaps %xmm2,%xmm1
unpcklps -0x28(%rsp),%xmm1
movaps -0x38(%rsp),%xmm2
unpcklps -0x48(%rsp),%xmm2
movlhps %xmm2,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm1
movups %xmm1,(%rsi)
unpcklps -0x58(%rsp),%xmm15
movaps -0x68(%rsp),%xmm1
unpcklps -0x78(%rsp),%xmm1
movlhps %xmm1,%xmm15
mulps  %xmm0,%xmm15
movups %xmm15,0x10(%rsi)
unpcklps %xmm14,%xmm11
unpcklps %xmm13,%xmm12
movlhps %xmm12,%xmm11
mulps  %xmm0,%xmm11
movups %xmm11,0x20(%rsi)
unpcklps %xmm10,%xmm8
unpcklps %xmm3,%xmm7
movlhps %xmm7,%xmm8
mulps  %xmm0,%xmm8
movups %xmm8,0x30(%rsi)
ret

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

LLVM IR (-O2):
define void @invert4x4(float* %0, float* nocapture %1) {
%3 = getelementptr inbounds float, float* %0, i64 5
%4 = load float, float* %3
%5 = getelementptr inbounds float, float* %0, i64 10
%6 = load float, float* %5
%7 = fmul float %4, %6
%8 = getelementptr inbounds float, float* %0, i64 15
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 11
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 14
%13 = load float, float* %12
%14 = fneg float %4
%15 = fmul float %11, %14
%16 = fmul float %15, %13
%17 = tail call float @llvm.fmuladd.f32(float %7, float %9, float %16)
%18 = getelementptr inbounds float, float* %0, i64 9
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 6
%21 = load float, float* %20
%22 = fneg float %19
%23 = fmul float %21, %22
%24 = tail call float @llvm.fmuladd.f32(float %23, float %9, float %17)
%25 = getelementptr inbounds float, float* %0, i64 7
%26 = load float, float* %25
%27 = fmul float %19, %26
%28 = tail call float @llvm.fmuladd.f32(float %27, float %13, float %24)
%29 = getelementptr inbounds float, float* %0, i64 13
%30 = load float, float* %29
%31 = fmul float %21, %30
%32 = tail call float @llvm.fmuladd.f32(float %31, float %11, float %28)
%33 = fneg float %30
%34 = fmul float %26, %33
%35 = tail call float @llvm.fmuladd.f32(float %34, float %6, float %32)
store float %35, float* %1
%36 = getelementptr inbounds float, float* %0, i64 1
%37 = load float, float* %36
%38 = fneg float %37
%39 = load float, float* %5
%40 = fmul float %39, %38
%41 = load float, float* %8
%42 = load float, float* %10
%43 = fmul float %37, %42
%44 = load float, float* %12
%45 = fmul float %43, %44
%46 = tail call float @llvm.fmuladd.f32(float %40, float %41, float %45)
%47 = load float, float* %18
%48 = getelementptr inbounds float, float* %0, i64 2
%49 = load float, float* %48
%50 = fmul float %47, %49
%51 = tail call float @llvm.fmuladd.f32(float %50, float %41, float %46)
%52 = getelementptr inbounds float, float* %0, i64 3
%53 = load float, float* %52
%54 = fneg float %47
%55 = fmul float %53, %54
%56 = tail call float @llvm.fmuladd.f32(float %55, float %44, float %51)
%57 = load float, float* %29
%58 = fneg float %57
%59 = fmul float %49, %58
%60 = tail call float @llvm.fmuladd.f32(float %59, float %42, float %56)
%61 = fmul float %53, %57
%62 = tail call float @llvm.fmuladd.f32(float %61, float %39, float %60)
%63 = getelementptr inbounds float, float* %1, i64 1
store float %62, float* %63
%64 = load float, float* %36
%65 = load float, float* %20
%66 = fmul float %64, %65
%67 = load float, float* %8
%68 = load float, float* %25
%69 = load float, float* %12
%70 = fneg float %64
%71 = fmul float %68, %70
%72 = fmul float %71, %69
%73 = tail call float @llvm.fmuladd.f32(float %66, float %67, float %72)
%74 = load float, float* %3
%75 = load float, float* %48
%76 = fneg float %74
%77 = fmul float %75, %76
%78 = tail call float @llvm.fmuladd.f32(float %77, float %67, float %73)
%79 = load float, float* %52
%80 = fmul float %74, %79
%81 = tail call float @llvm.fmuladd.f32(float %80, float %69, float %78)
%82 = load float, float* %29
%83 = fmul float %75, %82
%84 = tail call float @llvm.fmuladd.f32(float %83, float %68, float %81)
%85 = fneg float %82
%86 = fmul float %79, %85
%87 = tail call float @llvm.fmuladd.f32(float %86, float %65, float %84)
%88 = getelementptr inbounds float, float* %1, i64 2
store float %87, float* %88
%89 = load float, float* %36
%90 = fneg float %89
%91 = load float, float* %20
%92 = fmul float %91, %90
%93 = load float, float* %10
%94 = load float, float* %25
%95 = fmul float %89, %94
%96 = load float, float* %5
%97 = fmul float %95, %96
%98 = tail call float @llvm.fmuladd.f32(float %92, float %93, float %97)
%99 = load float, float* %3
%100 = load float, float* %48
%101 = fmul float %99, %100
%102 = tail call float @llvm.fmuladd.f32(float %101, float %93, float %98)
%103 = load float, float* %52
%104 = fneg float %99
%105 = fmul float %103, %104
%106 = tail call float @llvm.fmuladd.f32(float %105, float %96, float %102)
%107 = load float, float* %18
%108 = fneg float %107
%109 = fmul float %100, %108
%110 = tail call float @llvm.fmuladd.f32(float %109, float %94, float %106)
%111 = fmul float %103, %107
%112 = tail call float @llvm.fmuladd.f32(float %111, float %91, float %110)
%113 = getelementptr inbounds float, float* %1, i64 3
store float %112, float* %113
%114 = getelementptr inbounds float, float* %0, i64 4
%115 = load float, float* %114
%116 = fneg float %115
%117 = load float, float* %5
%118 = fmul float %117, %116
%119 = load float, float* %8
%120 = load float, float* %10
%121 = fmul float %115, %120
%122 = load float, float* %12
%123 = fmul float %121, %122
%124 = tail call float @llvm.fmuladd.f32(float %118, float %119, float %123)
%125 = getelementptr inbounds float, float* %0, i64 8
%126 = load float, float* %125
%127 = load float, float* %20
%128 = fmul float %126, %127
%129 = tail call float @llvm.fmuladd.f32(float %128, float %119, float %124)
%130 = load float, float* %25
%131 = fneg float %126
%132 = fmul float %130, %131
%133 = tail call float @llvm.fmuladd.f32(float %132, float %122, float %129)
%134 = getelementptr inbounds float, float* %0, i64 12
%135 = load float, float* %134
%136 = fneg float %135
%137 = fmul float %127, %136
%138 = tail call float @llvm.fmuladd.f32(float %137, float %120, float %133)
%139 = fmul float %130, %135
%140 = tail call float @llvm.fmuladd.f32(float %139, float %117, float %138)
%141 = getelementptr inbounds float, float* %1, i64 4
store float %140, float* %141
%142 = load float, float* %0
%143 = load float, float* %5
%144 = fmul float %142, %143
%145 = load float, float* %8
%146 = load float, float* %10
%147 = load float, float* %12
%148 = fneg float %142
%149 = fmul float %146, %148
%150 = fmul float %149, %147
%151 = tail call float @llvm.fmuladd.f32(float %144, float %145, float %150)
%152 = load float, float* %125
%153 = load float, float* %48
%154 = fneg float %152
%155 = fmul float %153, %154
%156 = tail call float @llvm.fmuladd.f32(float %155, float %145, float %151)
%157 = load float, float* %52
%158 = fmul float %152, %157
%159 = tail call float @llvm.fmuladd.f32(float %158, float %147, float %156)
%160 = load float, float* %134
%161 = fmul float %153, %160
%162 = tail call float @llvm.fmuladd.f32(float %161, float %146, float %159)
%163 = fneg float %160
%164 = fmul float %157, %163
%165 = tail call float @llvm.fmuladd.f32(float %164, float %143, float %162)
%166 = getelementptr inbounds float, float* %1, i64 5
store float %165, float* %166
%167 = load float, float* %0
%168 = fneg float %167
%169 = load float, float* %20
%170 = fmul float %169, %168
%171 = load float, float* %8
%172 = load float, float* %25
%173 = fmul float %167, %172
%174 = load float, float* %12
%175 = fmul float %173, %174
%176 = tail call float @llvm.fmuladd.f32(float %170, float %171, float %175)
%177 = load float, float* %114
%178 = load float, float* %48
%179 = fmul float %177, %178
%180 = tail call float @llvm.fmuladd.f32(float %179, float %171, float %176)
%181 = load float, float* %52
%182 = fneg float %177
%183 = fmul float %181, %182
%184 = tail call float @llvm.fmuladd.f32(float %183, float %174, float %180)
%185 = load float, float* %134
%186 = fneg float %185
%187 = fmul float %178, %186
%188 = tail call float @llvm.fmuladd.f32(float %187, float %172, float %184)
%189 = fmul float %181, %185
%190 = tail call float @llvm.fmuladd.f32(float %189, float %169, float %188)
%191 = getelementptr inbounds float, float* %1, i64 6
store float %190, float* %191
%192 = load float, float* %0
%193 = load float, float* %20
%194 = fmul float %192, %193
%195 = load float, float* %10
%196 = load float, float* %25
%197 = load float, float* %5
%198 = fneg float %192
%199 = fmul float %196, %198
%200 = fmul float %199, %197
%201 = tail call float @llvm.fmuladd.f32(float %194, float %195, float %200)
%202 = load float, float* %114
%203 = load float, float* %48
%204 = fneg float %202
%205 = fmul float %203, %204
%206 = tail call float @llvm.fmuladd.f32(float %205, float %195, float %201)
%207 = load float, float* %52
%208 = fmul float %202, %207
%209 = tail call float @llvm.fmuladd.f32(float %208, float %197, float %206)
%210 = load float, float* %125
%211 = fmul float %203, %210
%212 = tail call float @llvm.fmuladd.f32(float %211, float %196, float %209)
%213 = fneg float %210
%214 = fmul float %207, %213
%215 = tail call float @llvm.fmuladd.f32(float %214, float %193, float %212)
%216 = getelementptr inbounds float, float* %1, i64 7
store float %215, float* %216
%217 = load float, float* %114
%218 = load float, float* %18
%219 = fmul float %217, %218
%220 = load float, float* %8
%221 = load float, float* %10
%222 = load float, float* %29
%223 = fneg float %217
%224 = fmul float %221, %223
%225 = fmul float %224, %222
%226 = tail call float @llvm.fmuladd.f32(float %219, float %220, float %225)
%227 = load float, float* %125
%228 = load float, float* %3
%229 = fneg float %227
%230 = fmul float %228, %229
%231 = tail call float @llvm.fmuladd.f32(float %230, float %220, float %226)
%232 = load float, float* %25
%233 = fmul float %227, %232
%234 = tail call float @llvm.fmuladd.f32(float %233, float %222, float %231)
%235 = load float, float* %134
%236 = fmul float %228, %235
%237 = tail call float @llvm.fmuladd.f32(float %236, float %221, float %234)
%238 = fneg float %235
%239 = fmul float %232, %238
%240 = tail call float @llvm.fmuladd.f32(float %239, float %218, float %237)
%241 = getelementptr inbounds float, float* %1, i64 8
store float %240, float* %241
%242 = load float, float* %0
%243 = fneg float %242
%244 = load float, float* %18
%245 = fmul float %244, %243
%246 = load float, float* %8
%247 = load float, float* %10
%248 = fmul float %242, %247
%249 = load float, float* %29
%250 = fmul float %248, %249
%251 = tail call float @llvm.fmuladd.f32(float %245, float %246, float %250)
%252 = load float, float* %125
%253 = load float, float* %36
%254 = fmul float %252, %253
%255 = tail call float @llvm.fmuladd.f32(float %254, float %246, float %251)
%256 = load float, float* %52
%257 = fneg float %252
%258 = fmul float %256, %257
%259 = tail call float @llvm.fmuladd.f32(float %258, float %249, float %255)
%260 = load float, float* %134
%261 = fneg float %260
%262 = fmul float %253, %261
%263 = tail call float @llvm.fmuladd.f32(float %262, float %247, float %259)
%264 = fmul float %256, %260
%265 = tail call float @llvm.fmuladd.f32(float %264, float %244, float %263)
%266 = getelementptr inbounds float, float* %1, i64 9
store float %265, float* %266
%267 = load float, float* %0
%268 = load float, float* %3
%269 = fmul float %267, %268
%270 = load float, float* %8
%271 = load float, float* %25
%272 = load float, float* %29
%273 = fneg float %267
%274 = fmul float %271, %273
%275 = fmul float %274, %272
%276 = tail call float @llvm.fmuladd.f32(float %269, float %270, float %275)
%277 = load float, float* %114
%278 = load float, float* %36
%279 = fneg float %277
%280 = fmul float %278, %279
%281 = tail call float @llvm.fmuladd.f32(float %280, float %270, float %276)
%282 = load float, float* %52
%283 = fmul float %277, %282
%284 = tail call float @llvm.fmuladd.f32(float %283, float %272, float %281)
%285 = load float, float* %134
%286 = fmul float %278, %285
%287 = tail call float @llvm.fmuladd.f32(float %286, float %271, float %284)
%288 = fneg float %285
%289 = fmul float %282, %288
%290 = tail call float @llvm.fmuladd.f32(float %289, float %268, float %287)
%291 = getelementptr inbounds float, float* %1, i64 10
store float %290, float* %291
%292 = load float, float* %0
%293 = fneg float %292
%294 = load float, float* %3
%295 = fmul float %294, %293
%296 = load float, float* %10
%297 = load float, float* %25
%298 = fmul float %292, %297
%299 = load float, float* %18
%300 = fmul float %298, %299
%301 = tail call float @llvm.fmuladd.f32(float %295, float %296, float %300)
%302 = load float, float* %114
%303 = load float, float* %36
%304 = fmul float %302, %303
%305 = tail call float @llvm.fmuladd.f32(float %304, float %296, float %301)
%306 = load float, float* %52
%307 = fneg float %302
%308 = fmul float %306, %307
%309 = tail call float @llvm.fmuladd.f32(float %308, float %299, float %305)
%310 = load float, float* %125
%311 = fneg float %310
%312 = fmul float %303, %311
%313 = tail call float @llvm.fmuladd.f32(float %312, float %297, float %309)
%314 = fmul float %306, %310
%315 = tail call float @llvm.fmuladd.f32(float %314, float %294, float %313)
%316 = getelementptr inbounds float, float* %1, i64 11
store float %315, float* %316
%317 = load float, float* %114
%318 = fneg float %317
%319 = load float, float* %18
%320 = fmul float %319, %318
%321 = load float, float* %12
%322 = load float, float* %5
%323 = fmul float %317, %322
%324 = load float, float* %29
%325 = fmul float %323, %324
%326 = tail call float @llvm.fmuladd.f32(float %320, float %321, float %325)
%327 = load float, float* %125
%328 = load float, float* %3
%329 = fmul float %327, %328
%330 = tail call float @llvm.fmuladd.f32(float %329, float %321, float %326)
%331 = load float, float* %20
%332 = fneg float %327
%333 = fmul float %331, %332
%334 = tail call float @llvm.fmuladd.f32(float %333, float %324, float %330)
%335 = load float, float* %134
%336 = fneg float %335
%337 = fmul float %328, %336
%338 = tail call float @llvm.fmuladd.f32(float %337, float %322, float %334)
%339 = fmul float %331, %335
%340 = tail call float @llvm.fmuladd.f32(float %339, float %319, float %338)
%341 = getelementptr inbounds float, float* %1, i64 12
store float %340, float* %341
%342 = load float, float* %0
%343 = load float, float* %18
%344 = fmul float %342, %343
%345 = load float, float* %12
%346 = load float, float* %5
%347 = load float, float* %29
%348 = fneg float %342
%349 = fmul float %346, %348
%350 = fmul float %349, %347
%351 = tail call float @llvm.fmuladd.f32(float %344, float %345, float %350)
%352 = load float, float* %125
%353 = load float, float* %36
%354 = fneg float %352
%355 = fmul float %353, %354
%356 = tail call float @llvm.fmuladd.f32(float %355, float %345, float %351)
%357 = load float, float* %48
%358 = fmul float %352, %357
%359 = tail call float @llvm.fmuladd.f32(float %358, float %347, float %356)
%360 = load float, float* %134
%361 = fmul float %353, %360
%362 = tail call float @llvm.fmuladd.f32(float %361, float %346, float %359)
%363 = fneg float %360
%364 = fmul float %357, %363
%365 = tail call float @llvm.fmuladd.f32(float %364, float %343, float %362)
%366 = getelementptr inbounds float, float* %1, i64 13
store float %365, float* %366
%367 = load float, float* %0
%368 = fneg float %367
%369 = load float, float* %3
%370 = fmul float %369, %368
%371 = load float, float* %12
%372 = load float, float* %20
%373 = fmul float %367, %372
%374 = load float, float* %29
%375 = fmul float %373, %374
%376 = tail call float @llvm.fmuladd.f32(float %370, float %371, float %375)
%377 = load float, float* %114
%378 = load float, float* %36
%379 = fmul float %377, %378
%380 = tail call float @llvm.fmuladd.f32(float %379, float %371, float %376)
%381 = load float, float* %48
%382 = fneg float %377
%383 = fmul float %381, %382
%384 = tail call float @llvm.fmuladd.f32(float %383, float %374, float %380)
%385 = load float, float* %134
%386 = fneg float %385
%387 = fmul float %378, %386
%388 = tail call float @llvm.fmuladd.f32(float %387, float %372, float %384)
%389 = fmul float %381, %385
%390 = tail call float @llvm.fmuladd.f32(float %389, float %369, float %388)
%391 = getelementptr inbounds float, float* %1, i64 14
store float %390, float* %391
%392 = load float, float* %0
%393 = load float, float* %3
%394 = fmul float %392, %393
%395 = load float, float* %5
%396 = load float, float* %20
%397 = load float, float* %18
%398 = fneg float %392
%399 = fmul float %396, %398
%400 = fmul float %399, %397
%401 = tail call float @llvm.fmuladd.f32(float %394, float %395, float %400)
%402 = load float, float* %114
%403 = load float, float* %36
%404 = fneg float %402
%405 = fmul float %403, %404
%406 = tail call float @llvm.fmuladd.f32(float %405, float %395, float %401)
%407 = load float, float* %48
%408 = fmul float %402, %407
%409 = tail call float @llvm.fmuladd.f32(float %408, float %397, float %406)
%410 = load float, float* %125
%411 = fmul float %403, %410
%412 = tail call float @llvm.fmuladd.f32(float %411, float %396, float %409)
%413 = fneg float %410
%414 = fmul float %407, %413
%415 = tail call float @llvm.fmuladd.f32(float %414, float %393, float %412)
%416 = getelementptr inbounds float, float* %1, i64 15
store float %415, float* %416
%417 = load float, float* %0
%418 = load float, float* %36
%419 = fmul float %140, %418
%420 = tail call float @llvm.fmuladd.f32(float %417, float %35, float %419)
%421 = load float, float* %48
%422 = tail call float @llvm.fmuladd.f32(float %421, float %240, float %420)
%423 = load float, float* %52
%424 = tail call float @llvm.fmuladd.f32(float %423, float %340, float %422)
%425 = fdiv float 1.000000e+00, %424
%426 = insertelement <4 x float> poison, float %35, i64 0
%427 = insertelement <4 x float> %426, float %62, i64 1
%428 = insertelement <4 x float> %427, float %87, i64 2
%429 = insertelement <4 x float> %428, float %112, i64 3
%430 = insertelement <4 x float> poison, float %425, i64 0
%431 = shufflevector <4 x float> %430, <4 x float> poison, <4 x i32> zeroinitializer
%432 = fmul <4 x float> %429, %431
%433 = bitcast float* %1 to <4 x float>*
store <4 x float> %432, <4 x float>* %433
%434 = insertelement <4 x float> poison, float %140, i64 0
%435 = insertelement <4 x float> %434, float %165, i64 1
%436 = insertelement <4 x float> %435, float %190, i64 2
%437 = insertelement <4 x float> %436, float %215, i64 3
%438 = fmul <4 x float> %437, %431
%439 = bitcast float* %141 to <4 x float>*
store <4 x float> %438, <4 x float>* %439
%440 = insertelement <4 x float> poison, float %240, i64 0
%441 = insertelement <4 x float> %440, float %265, i64 1
%442 = insertelement <4 x float> %441, float %290, i64 2
%443 = insertelement <4 x float> %442, float %315, i64 3
%444 = fmul <4 x float> %443, %431
%445 = bitcast float* %241 to <4 x float>*
store <4 x float> %444, <4 x float>* %445
%446 = insertelement <4 x float> poison, float %340, i64 0
%447 = insertelement <4 x float> %446, float %365, i64 1
%448 = insertelement <4 x float> %447, float %390, i64 2
%449 = insertelement <4 x float> %448, float %415, i64 3
%450 = fmul <4 x float> %449, %431
%451 = bitcast float* %341 to <4 x float>*
store <4 x float> %450, <4 x float>* %451
ret void
}