int MATRIXMATH_inverse4x4(float *matrix_out, float *matrix_in) {
  float det_A;
  float inv_det_A;
  det_A = matrix_in[0] * matrix_in[5] * matrix_in[10] * matrix_in[15] +
          matrix_in[0] * matrix_in[6] * matrix_in[11] * matrix_in[13] +
          matrix_in[0] * matrix_in[7] * matrix_in[9] * matrix_in[14] +
          matrix_in[1] * matrix_in[4] * matrix_in[11] * matrix_in[14] +
          matrix_in[1] * matrix_in[6] * matrix_in[8] * matrix_in[15] +
          matrix_in[1] * matrix_in[7] * matrix_in[10] * matrix_in[12] +
          matrix_in[2] * matrix_in[4] * matrix_in[9] * matrix_in[15] +
          matrix_in[2] * matrix_in[5] * matrix_in[11] * matrix_in[12] +
          matrix_in[2] * matrix_in[7] * matrix_in[8] * matrix_in[13] +
          matrix_in[3] * matrix_in[4] * matrix_in[10] * matrix_in[13] +
          matrix_in[3] * matrix_in[5] * matrix_in[8] * matrix_in[14] +
          matrix_in[3] * matrix_in[6] * matrix_in[9] * matrix_in[12] -
          matrix_in[0] * matrix_in[5] * matrix_in[11] * matrix_in[14] -
          matrix_in[0] * matrix_in[6] * matrix_in[9] * matrix_in[15] -
          matrix_in[0] * matrix_in[7] * matrix_in[10] * matrix_in[13] -
          matrix_in[1] * matrix_in[4] * matrix_in[10] * matrix_in[15] -
          matrix_in[1] * matrix_in[6] * matrix_in[11] * matrix_in[12] -
          matrix_in[1] * matrix_in[7] * matrix_in[8] * matrix_in[14] -
          matrix_in[2] * matrix_in[4] * matrix_in[11] * matrix_in[13] -
          matrix_in[2] * matrix_in[5] * matrix_in[8] * matrix_in[15] -
          matrix_in[2] * matrix_in[7] * matrix_in[9] * matrix_in[12] -
          matrix_in[3] * matrix_in[4] * matrix_in[9] * matrix_in[14] -
          matrix_in[3] * matrix_in[5] * matrix_in[10] * matrix_in[12] -
          matrix_in[3] * matrix_in[6] * matrix_in[8] * matrix_in[13];
  inv_det_A = 1 / det_A;
  matrix_out[0] = (inv_det_A) * (matrix_in[5] * matrix_in[10] * matrix_in[15] +
                                 matrix_in[6] * matrix_in[11] * matrix_in[13] +
                                 matrix_in[7] * matrix_in[9] * matrix_in[14] -
                                 matrix_in[5] * matrix_in[11] * matrix_in[14] -
                                 matrix_in[6] * matrix_in[9] * matrix_in[15] -
                                 matrix_in[7] * matrix_in[10] * matrix_in[13]);
  matrix_out[1] = (inv_det_A) * (matrix_in[1] * matrix_in[11] * matrix_in[14] +
                                 matrix_in[2] * matrix_in[9] * matrix_in[15] +
                                 matrix_in[3] * matrix_in[10] * matrix_in[13] -
                                 matrix_in[1] * matrix_in[10] * matrix_in[15] -
                                 matrix_in[2] * matrix_in[11] * matrix_in[13] -
                                 matrix_in[3] * matrix_in[9] * matrix_in[14]);
  matrix_out[2] = (inv_det_A) * (matrix_in[1] * matrix_in[6] * matrix_in[15] +
                                 matrix_in[2] * matrix_in[7] * matrix_in[13] +
                                 matrix_in[3] * matrix_in[5] * matrix_in[14] -
                                 matrix_in[1] * matrix_in[7] * matrix_in[14] -
                                 matrix_in[2] * matrix_in[5] * matrix_in[15] -
                                 matrix_in[3] * matrix_in[6] * matrix_in[13]);
  matrix_out[3] = (inv_det_A) * (matrix_in[1] * matrix_in[7] * matrix_in[10] +
                                 matrix_in[2] * matrix_in[5] * matrix_in[11] +
                                 matrix_in[3] * matrix_in[6] * matrix_in[9] -
                                 matrix_in[1] * matrix_in[6] * matrix_in[11] -
                                 matrix_in[2] * matrix_in[7] * matrix_in[9] -
                                 matrix_in[3] * matrix_in[5] * matrix_in[10]);
  matrix_out[4] = (inv_det_A) * (matrix_in[4] * matrix_in[11] * matrix_in[14] +
                                 matrix_in[6] * matrix_in[8] * matrix_in[15] +
                                 matrix_in[7] * matrix_in[10] * matrix_in[12] -
                                 matrix_in[4] * matrix_in[10] * matrix_in[15] -
                                 matrix_in[6] * matrix_in[11] * matrix_in[12] -
                                 matrix_in[7] * matrix_in[8] * matrix_in[14]);
  matrix_out[5] = (inv_det_A) * (matrix_in[0] * matrix_in[10] * matrix_in[15] +
                                 matrix_in[2] * matrix_in[11] * matrix_in[12] +
                                 matrix_in[3] * matrix_in[8] * matrix_in[14] -
                                 matrix_in[0] * matrix_in[11] * matrix_in[14] -
                                 matrix_in[2] * matrix_in[8] * matrix_in[15] -
                                 matrix_in[3] * matrix_in[10] * matrix_in[12]);
  matrix_out[6] = (inv_det_A) * (matrix_in[0] * matrix_in[7] * matrix_in[14] +
                                 matrix_in[2] * matrix_in[4] * matrix_in[15] +
                                 matrix_in[3] * matrix_in[6] * matrix_in[12] -
                                 matrix_in[0] * matrix_in[6] * matrix_in[15] -
                                 matrix_in[2] * matrix_in[7] * matrix_in[12] -
                                 matrix_in[3] * matrix_in[4] * matrix_in[14]);
  matrix_out[7] = (inv_det_A) * (matrix_in[0] * matrix_in[6] * matrix_in[11] +
                                 matrix_in[2] * matrix_in[7] * matrix_in[8] +
                                 matrix_in[3] * matrix_in[4] * matrix_in[10] -
                                 matrix_in[0] * matrix_in[7] * matrix_in[10] -
                                 matrix_in[2] * matrix_in[4] * matrix_in[11] -
                                 matrix_in[3] * matrix_in[6] * matrix_in[8]);
  matrix_out[8] = (inv_det_A) * (matrix_in[4] * matrix_in[9] * matrix_in[15] +
                                 matrix_in[5] * matrix_in[11] * matrix_in[12] +
                                 matrix_in[7] * matrix_in[8] * matrix_in[13] -
                                 matrix_in[4] * matrix_in[11] * matrix_in[13] -
                                 matrix_in[5] * matrix_in[8] * matrix_in[15] -
                                 matrix_in[7] * matrix_in[9] * matrix_in[12]);
  matrix_out[9] = (inv_det_A) * (matrix_in[0] * matrix_in[11] * matrix_in[13] +
                                 matrix_in[1] * matrix_in[8] * matrix_in[15] +
                                 matrix_in[3] * matrix_in[9] * matrix_in[12] -
                                 matrix_in[0] * matrix_in[9] * matrix_in[15] -
                                 matrix_in[1] * matrix_in[11] * matrix_in[12] -
                                 matrix_in[3] * matrix_in[8] * matrix_in[13]);
  matrix_out[10] = (inv_det_A) * (matrix_in[0] * matrix_in[5] * matrix_in[15] +
                                  matrix_in[1] * matrix_in[7] * matrix_in[12] +
                                  matrix_in[3] * matrix_in[4] * matrix_in[13] -
                                  matrix_in[0] * matrix_in[7] * matrix_in[13] -
                                  matrix_in[1] * matrix_in[4] * matrix_in[15] -
                                  matrix_in[3] * matrix_in[5] * matrix_in[12]);
  matrix_out[11] = (inv_det_A) * (matrix_in[0] * matrix_in[7] * matrix_in[9] +
                                  matrix_in[1] * matrix_in[4] * matrix_in[11] +
                                  matrix_in[3] * matrix_in[5] * matrix_in[8] -
                                  matrix_in[0] * matrix_in[5] * matrix_in[11] -
                                  matrix_in[1] * matrix_in[7] * matrix_in[8] -
                                  matrix_in[3] * matrix_in[4] * matrix_in[9]);
  matrix_out[12] = (inv_det_A) * (matrix_in[4] * matrix_in[10] * matrix_in[13] +
                                  matrix_in[5] * matrix_in[8] * matrix_in[14] +
                                  matrix_in[6] * matrix_in[9] * matrix_in[12] -
                                  matrix_in[4] * matrix_in[9] * matrix_in[14] -
                                  matrix_in[5] * matrix_in[10] * matrix_in[12] -
                                  matrix_in[6] * matrix_in[8] * matrix_in[13]);
  matrix_out[13] = (inv_det_A) * (matrix_in[0] * matrix_in[9] * matrix_in[14] +
                                  matrix_in[1] * matrix_in[10] * matrix_in[12] +
                                  matrix_in[2] * matrix_in[8] * matrix_in[13] -
                                  matrix_in[0] * matrix_in[10] * matrix_in[13] -
                                  matrix_in[1] * matrix_in[8] * matrix_in[14] -
                                  matrix_in[2] * matrix_in[9] * matrix_in[12]);
  matrix_out[14] = (inv_det_A) * (matrix_in[0] * matrix_in[6] * matrix_in[13] +
                                  matrix_in[1] * matrix_in[4] * matrix_in[14] +
                                  matrix_in[2] * matrix_in[5] * matrix_in[12] -
                                  matrix_in[0] * matrix_in[5] * matrix_in[14] -
                                  matrix_in[1] * matrix_in[6] * matrix_in[12] -
                                  matrix_in[2] * matrix_in[4] * matrix_in[13]);
  matrix_out[15] = (inv_det_A) * (matrix_in[0] * matrix_in[5] * matrix_in[10] +
                                  matrix_in[1] * matrix_in[6] * matrix_in[8] +
                                  matrix_in[2] * matrix_in[4] * matrix_in[9] -
                                  matrix_in[0] * matrix_in[6] * matrix_in[9] -
                                  matrix_in[1] * matrix_in[4] * matrix_in[10] -
                                  matrix_in[2] * matrix_in[5] * matrix_in[8]);
  return 1;
}


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

x86 assembly (clang, -O2):
<MATRIXMATH_inverse4x4>:
movss  0x14(%rsi),%xmm9
movss  (%rsi),%xmm3
movss  0x4(%rsi),%xmm5
movaps %xmm3,%xmm1
mulss  %xmm9,%xmm1
movss  %xmm1,-0x4(%rsp)
movss  0x28(%rsi),%xmm4
movaps %xmm1,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm4,%xmm10
movss  0x3c(%rsi),%xmm4
movss  0x18(%rsi),%xmm1
movaps %xmm3,%xmm6
mulss  %xmm1,%xmm6
movss  %xmm6,-0x8(%rsp)
movaps %xmm1,%xmm15
movss  %xmm1,-0x28(%rsp)
movss  0x2c(%rsi),%xmm14
movaps %xmm6,%xmm1
mulss  %xmm14,%xmm1
movss  0x34(%rsi),%xmm8
mulss  %xmm8,%xmm1
mulss  %xmm4,%xmm0
movaps %xmm4,%xmm6
addss  %xmm1,%xmm0
movss  0x1c(%rsi),%xmm7
mulss  %xmm7,%xmm3
movss  %xmm3,-0xc(%rsp)
movss  0x24(%rsi),%xmm11
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
movss  0x38(%rsi),%xmm4
movss  %xmm4,-0x14(%rsp)
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rsi),%xmm12
movaps %xmm5,%xmm3
mulss  %xmm12,%xmm3
movss  %xmm3,-0x10(%rsp)
movaps %xmm14,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movaps %xmm15,%xmm1
mulss  %xmm5,%xmm1
movss  %xmm1,-0x18(%rsp)
movss  0x20(%rsi),%xmm2
mulss  %xmm2,%xmm1
movss  %xmm6,-0x1c(%rsp)
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm7,%xmm5
movss  %xmm5,-0x30(%rsp)
movaps %xmm10,%xmm4
movss  %xmm10,-0x2c(%rsp)
movaps %xmm10,%xmm0
mulss  %xmm5,%xmm0
movss  0x30(%rsi),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm15
movaps %xmm12,%xmm13
mulss  %xmm15,%xmm13
movaps %xmm11,%xmm1
mulss  %xmm13,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
movaps %xmm9,%xmm10
movaps %xmm9,%xmm5
movss  %xmm9,-0x24(%rsp)
mulss  %xmm15,%xmm10
movaps %xmm14,%xmm0
mulss  %xmm10,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm3,%xmm6
addss  %xmm1,%xmm0
mulss  %xmm7,%xmm15
movaps %xmm2,%xmm3
mulss  %xmm15,%xmm3
movaps %xmm8,%xmm1
movss  %xmm8,-0x20(%rsp)
mulss  %xmm8,%xmm3
addss  %xmm0,%xmm3
movss  0xc(%rsi),%xmm9
mulss  %xmm9,%xmm12
movaps %xmm4,%xmm8
mulss  %xmm12,%xmm8
mulss  %xmm1,%xmm8
addss  %xmm3,%xmm8
movss  -0x30(%rsp),%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,-0x30(%rsp)
mulss  %xmm2,%xmm10
movaps %xmm2,%xmm0
movaps %xmm5,%xmm2
mulss  %xmm9,%xmm2
mulss  -0x28(%rsp),%xmm9
movaps %xmm11,%xmm3
mulss  %xmm9,%xmm3
mulss  %xmm0,%xmm9
mulss  %xmm2,%xmm0
movss  -0x14(%rsp),%xmm5
mulss  %xmm5,%xmm0
addss  %xmm8,%xmm0
movaps %xmm6,%xmm4
mulss  %xmm6,%xmm3
addss  %xmm0,%xmm3
movss  -0x4(%rsp),%xmm0
mulss  %xmm14,%xmm0
mulss  %xmm5,%xmm0
subss  %xmm0,%xmm3
movss  -0x8(%rsp),%xmm8
mulss  %xmm11,%xmm8
movss  -0x1c(%rsp),%xmm0
mulss  %xmm0,%xmm8
subss  %xmm8,%xmm3
movss  -0xc(%rsp),%xmm6
movss  -0x2c(%rsp),%xmm1
mulss  %xmm1,%xmm6
movss  -0x20(%rsp),%xmm8
mulss  %xmm8,%xmm6
subss  %xmm6,%xmm3
movss  -0x10(%rsp),%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm0,%xmm6
subss  %xmm6,%xmm3
movss  -0x18(%rsp),%xmm1
mulss  %xmm14,%xmm1
movaps %xmm4,%xmm6
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm3
movss  -0x30(%rsp),%xmm4
mulss  %xmm5,%xmm4
subss  %xmm4,%xmm3
mulss  %xmm14,%xmm13
mulss  %xmm8,%xmm13
subss  %xmm13,%xmm3
mulss  %xmm0,%xmm10
subss  %xmm10,%xmm3
mulss  %xmm11,%xmm15
mulss  %xmm6,%xmm15
subss  %xmm15,%xmm3
mulss  %xmm11,%xmm12
mulss  %xmm5,%xmm12
movaps %xmm5,%xmm10
subss  %xmm12,%xmm3
movss  -0x2c(%rsp),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm2
subss  %xmm2,%xmm3
mulss  %xmm8,%xmm9
movaps %xmm8,%xmm4
subss  %xmm9,%xmm3
movss  0xc28(%rip),%xmm8
divss  %xmm3,%xmm8
movss  -0x28(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm14,%xmm1
movss  -0x24(%rsp),%xmm2
mulss  %xmm2,%xmm14
movaps %xmm5,%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm7,%xmm6
mulss  %xmm11,%xmm7
mulss  %xmm10,%xmm7
addss  %xmm2,%xmm7
mulss  %xmm10,%xmm14
subss  %xmm14,%xmm7
mulss  %xmm3,%xmm11
mulss  %xmm0,%xmm11
subss  %xmm11,%xmm7
movaps %xmm6,%xmm0
mulss  %xmm4,%xmm0
subss  %xmm0,%xmm7
mulss  %xmm8,%xmm7
movss  %xmm7,(%rdi)
movss  0x2c(%rsi),%xmm1
movss  0x4(%rsi),%xmm4
movss  0x8(%rsi),%xmm9
movss  0x24(%rsi),%xmm2
movaps %xmm9,%xmm5
mulss  %xmm2,%xmm5
movss  0xc(%rsi),%xmm6
movss  0x28(%rsi),%xmm7
mulss  %xmm6,%xmm2
mulss  %xmm7,%xmm6
mulss  %xmm4,%xmm7
mulss  %xmm1,%xmm4
movss  0x38(%rsi),%xmm0
movss  0x3c(%rsi),%xmm3
mulss  %xmm3,%xmm5
mulss  %xmm0,%xmm4
addss  %xmm5,%xmm4
movss  0x34(%rsi),%xmm5
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm3,%xmm7
subss  %xmm7,%xmm6
mulss  %xmm9,%xmm1
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm6
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm6
mulss  %xmm8,%xmm6
movss  %xmm6,0x4(%rdi)
movss  0x18(%rsi),%xmm1
movss  0x4(%rsi),%xmm0
movss  0x8(%rsi),%xmm9
movss  0x1c(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x3c(%rsi),%xmm5
movss  0x34(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0xc(%rsi),%xmm4
movss  0x14(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x38(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x8(%rdi)
movss  0x1c(%rsi),%xmm1
movss  0x4(%rsi),%xmm0
movss  0x8(%rsi),%xmm9
movss  0x14(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0xc(%rsi),%xmm5
movss  0x18(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm7
movss  0x2c(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x24(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0xc(%rdi)
movss  0x2c(%rsi),%xmm1
movss  0x10(%rsi),%xmm0
movss  0x18(%rsi),%xmm9
movss  0x20(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0x1c(%rsi),%xmm5
movss  0x28(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm7
movss  0x3c(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x30(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x10(%rdi)
movss  0x28(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x8(%rsi),%xmm9
movss  0x2c(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x3c(%rsi),%xmm5
movss  0x30(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0xc(%rsi),%xmm4
movss  0x20(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x38(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x14(%rdi)
movss  0x1c(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x8(%rsi),%xmm9
movss  0x10(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0xc(%rsi),%xmm5
movss  0x18(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm7
movss  0x3c(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x30(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x18(%rdi)
movss  0x18(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x8(%rsi),%xmm9
movss  0x1c(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x2c(%rsi),%xmm5
movss  0x20(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0xc(%rsi),%xmm4
movss  0x10(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x28(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x1c(%rdi)
movss  0x24(%rsi),%xmm1
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm9
movss  0x2c(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x3c(%rsi),%xmm5
movss  0x30(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0x1c(%rsi),%xmm4
movss  0x20(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x34(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x20(%rdi)
movss  0x2c(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x20(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0xc(%rsi),%xmm5
movss  0x24(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x34(%rsi),%xmm7
movss  0x3c(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x30(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x24(%rdi)
movss  0x14(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x1c(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x3c(%rsi),%xmm5
movss  0x30(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0xc(%rsi),%xmm4
movss  0x10(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x34(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x28(%rdi)
movss  0x1c(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x10(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0xc(%rsi),%xmm5
movss  0x14(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x24(%rsi),%xmm7
movss  0x2c(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x20(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x2c(%rdi)
movss  0x28(%rsi),%xmm1
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm9
movss  0x20(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0x18(%rsi),%xmm5
movss  0x24(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x34(%rsi),%xmm7
movss  0x38(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x30(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x30(%rdi)
movss  0x24(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x28(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm5
movss  0x30(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0x8(%rsi),%xmm4
movss  0x20(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x34(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x34(%rdi)
movss  0x18(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x10(%rsi),%xmm2
movaps %xmm9,%xmm4
mulss  %xmm2,%xmm4
movss  0x8(%rsi),%xmm5
movss  0x14(%rsi),%xmm6
mulss  %xmm5,%xmm2
mulss  %xmm6,%xmm5
mulss  %xmm0,%xmm6
mulss  %xmm1,%xmm0
movss  0x34(%rsi),%xmm7
movss  0x38(%rsi),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm7,%xmm0
addss  %xmm4,%xmm0
movss  0x30(%rsi),%xmm4
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm5
mulss  %xmm9,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm7,%xmm2
subss  %xmm2,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,0x38(%rdi)
movss  0x14(%rsi),%xmm1
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm9
movss  0x18(%rsi),%xmm3
movaps %xmm9,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm5
movss  0x20(%rsi),%xmm6
mulss  %xmm6,%xmm4
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  0x8(%rsi),%xmm4
movss  0x10(%rsi),%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm7,%xmm4
movss  0x24(%rsi),%xmm2
mulss  %xmm2,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm7,%xmm4
mulss  %xmm6,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,0x3c(%rdi)
mov    $0x1,%eax
ret

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

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