char matrixInverse4x4(float **output, char outRows, char outCols, float **input,
                      char inRows, char inCols) {
  if (!(inRows == inCols && inRows == outRows &&
        inRows == outCols & inRows == 4)) {
    return 0;
  }
  char arr_length = 16;
  char matrix_rows = 4;
  char matrix_cols = 4;
  float m[arr_length];
  float invOut[arr_length];
  matrixToArray_CMO(m, arr_length, input, matrix_rows, matrix_cols);
  double inv[16], det;
  int i;
  inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] +
           m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
  inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] -
           m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
  inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] +
           m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
  inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] -
            m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
  inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] -
           m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
  inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] +
           m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
  inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] -
           m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
  inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] +
            m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
  inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] +
           m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
  inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] -
           m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
  inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] +
            m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
  inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] -
            m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
  inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] -
           m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
  inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] +
           m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
  inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] -
            m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
  inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] +
            m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
  det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
  if (det == 0)
    return 0;
  det = 1.0 / det;
  for (i = 0; i < 16; i++)
    invOut[i] = inv[i] * det;
  arrayToMatrix_CMO(output, matrix_rows, matrix_cols, invOut, arr_length);
  return 1;
}


x86 assembly (clang, -O0):
<matrixInverse4x4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %r8d,-0xe4(%rbp)
mov    %rcx,%rax
mov    -0xe4(%rbp),%ecx
mov    %rax,-0xe0(%rbp)
mov    %edx,%eax
mov    -0xe0(%rbp),%rdx
mov    %eax,-0xd8(%rbp)
mov    %esi,%eax
mov    -0xd8(%rbp),%esi
mov    %eax,-0xd4(%rbp)
mov    %rdi,%r8
mov    -0xd4(%rbp),%edi
mov    %r9b,%al
mov    %r8,-0x10(%rbp)
mov    %dil,-0x11(%rbp)
mov    %sil,-0x12(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %cl,-0x21(%rbp)
mov    %al,-0x22(%rbp)
movsbl -0x21(%rbp),%eax
movsbl -0x22(%rbp),%ecx
cmp    %ecx,%eax
jne    11ce <matrixInverse4x4+0xae>
movsbl -0x21(%rbp),%eax
movsbl -0x11(%rbp),%ecx
cmp    %ecx,%eax
jne    11ce <matrixInverse4x4+0xae>
movsbl -0x21(%rbp),%eax
movsbl -0x12(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x21(%rbp),%ecx
cmp    $0x4,%ecx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
jne    11d7 <matrixInverse4x4+0xb7>
movb   $0x0,-0x1(%rbp)
jmp    1ee2 <matrixInverse4x4+0xdc2>
movb   $0x10,-0x23(%rbp)
movb   $0x4,-0x24(%rbp)
movb   $0x4,-0x25(%rbp)
movzbl -0x23(%rbp),%edx
mov    %edx,%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0xf0(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x38(%rbp)
movzbl -0x23(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(,%rcx,4),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movsbl -0x23(%rbp),%esi
mov    -0x20(%rbp),%rdx
movsbl -0x24(%rbp),%ecx
movsbl -0x25(%rbp),%r8d
mov    $0x0,%al
call   1030 <matrixToArray_CMO@plt>
mov    -0xf0(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  0x28(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  0x14(%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x24(%rax),%xmm1
mulss  0x18(%rax),%xmm1
movss  0x3c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x24(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x34(%rax),%xmm1
mulss  0x18(%rax),%xmm1
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x34(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x28(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movss  0x10(%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x28(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  0x10(%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x18(%rax),%xmm1
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x38(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x18(%rax),%xmm1
movss  0x2c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movss  0x10(%rax),%xmm0
mulss  0x24(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  0x10(%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x34(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x14(%rax),%xmm1
movss  0x3c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x14(%rax),%xmm1
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0x1c(%rax),%xmm0
movss  0x24(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  0x10(%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x24(%rax),%xmm0
movss  0x38(%rax),%xmm2
movss  0x10(%rax),%xmm1
mulss  0x28(%rax),%xmm1
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x14(%rax),%xmm1
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0x18(%rax),%xmm0
movss  0x34(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x14(%rax),%xmm1
movss  0x28(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0x18(%rax),%xmm0
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  0x4(%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x28(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  0x4(%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x24(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x24(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x38(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x34(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x2c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x34(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movss  (%rax),%xmm0
mulss  0x28(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x3c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x28(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  (%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x24(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x2c(%rax),%xmm1
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x34(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x2c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  (%rax),%xmm0
mulss  0x24(%rax),%xmm0
movss  0x38(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x28(%rax),%xmm1
mulss  0x34(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x38(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x24(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  0x4(%rax),%xmm0
mulss  0x18(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  0x4(%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x14(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x3c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x14(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x34(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x34(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x18(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  (%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x18(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x38(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x1c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movss  (%rax),%xmm0
mulss  0x14(%rax),%xmm0
movss  0x3c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x34(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x3c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x14(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  (%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x14(%rax),%xmm0
movss  0x38(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x18(%rax),%xmm1
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x34(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x18(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  0x4(%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x18(%rax),%xmm0
movss  0x2c(%rax),%xmm2
movss  0x4(%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x28(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x14(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x14(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x28(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x24(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x1c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x24(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movss  (%rax),%xmm0
mulss  0x18(%rax),%xmm0
movss  0x2c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x28(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x2c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x8(%rax),%xmm1
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x18(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movss  (%rax),%xmm0
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  0x14(%rax),%xmm0
movss  0x2c(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x1c(%rax),%xmm1
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x24(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x1c(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0xc(%rax),%xmm0
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  (%rax),%xmm0
mulss  0x14(%rax),%xmm0
movss  0x28(%rax),%xmm2
movss  (%rax),%xmm1
mulss  0x18(%rax),%xmm1
mulss  0x24(%rax),%xmm1
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x28(%rax),%xmm2
movd   %xmm1,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x20(%rax),%xmm1
mulss  0x4(%rax),%xmm1
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rax),%xmm0
mulss  0x8(%rax),%xmm0
movss  0x14(%rax),%xmm2
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e3c <matrixInverse4x4+0xd1c>
jp     1e3c <matrixInverse4x4+0xd1c>
movb   $0x0,-0x1(%rbp)
movl   $0x1,-0xd0(%rbp)
jmp    1edb <matrixInverse4x4+0xdbb>
movsd  0x1bc(%rip),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xcc(%rbp)
cmpl   $0x10,-0xcc(%rbp)
jge    1eae <matrixInverse4x4+0xd8e>
mov    -0xf8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  -0xc0(%rbp,%rcx,8),%xmm0
ff ff
mulsd  -0xc8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movslq -0xcc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1e5e <matrixInverse4x4+0xd3e>
mov    -0xf8(%rbp),%rcx
mov    -0x10(%rbp),%rdi
movsbl -0x24(%rbp),%esi
movsbl -0x25(%rbp),%edx
movsbl -0x23(%rbp),%r8d
mov    $0x0,%al
call   1040 <arrayToMatrix_CMO@plt>
movb   $0x1,-0x1(%rbp)
movl   $0x1,-0xd0(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
movsbl -0x1(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrixInverse4x4>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
xor    %r13d,%r13d
cmp    %sil,%r8b
jne    1ac9 <matrixInverse4x4+0x9a9>
cmp    %r9b,%r8b
jne    1ac9 <matrixInverse4x4+0x9a9>
xor    %r13d,%r13d
cmp    $0x4,%dl
jne    1ac9 <matrixInverse4x4+0x9a9>
cmp    $0x4,%r8b
jne    1ac9 <matrixInverse4x4+0x9a9>
mov    %rdi,%r14
mov    %rsp,%r12
mov    %rsp,%rbx
lea    -0x40(%rbx),%rdi
mov    %rdi,%rsp
mov    %rsp,%r15
add    $0xffffffffffffffc0,%r15
mov    %r15,%rsp
xor    %r13d,%r13d
mov    $0x10,%esi
mov    %rcx,%rdx
mov    $0x4,%ecx
mov    $0x4,%r8d
xor    %eax,%eax
call   1030 <matrixToArray_CMO@plt>
movss  -0x2c(%rbx),%xmm4
movaps %xmm4,-0x70(%rbp)
movss  -0x18(%rbx),%xmm1
movaps %xmm4,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm1,%xmm8
movss  -0x4(%rbx),%xmm13
movss  -0x14(%rbx),%xmm9
movss  -0x8(%rbx),%xmm6
movaps %xmm9,%xmm1
mulss  %xmm4,%xmm1
mulss  %xmm6,%xmm1
mulss  %xmm13,%xmm0
subss  %xmm1,%xmm0
movss  -0x1c(%rbx),%xmm2
movaps %xmm2,-0xb0(%rbp)
movss  -0x28(%rbx),%xmm4
movaps %xmm4,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm13,%xmm1
subss  %xmm1,%xmm0
movss  -0x24(%rbx),%xmm11
movaps %xmm2,%xmm1
mulss  %xmm11,%xmm1
mulss  %xmm6,%xmm1
movaps %xmm6,%xmm2
addss  %xmm0,%xmm1
movss  -0xc(%rbx),%xmm14
movaps %xmm4,%xmm10
mulss  %xmm14,%xmm10
mulss  %xmm9,%xmm10
addss  %xmm1,%xmm10
movaps %xmm11,%xmm0
mulss  %xmm14,%xmm0
mulss  %xmm8,%xmm0
subss  %xmm0,%xmm10
movsd  -0x34(%rbx),%xmm7
movaps %xmm7,-0xa0(%rbp)
shufps $0x55,%xmm7,%xmm7
movaps %xmm9,%xmm5
movaps %xmm9,-0x140(%rbp)
ff
mulss  %xmm7,%xmm5
movaps %xmm6,%xmm1
movaps %xmm6,-0x60(%rbp)
mulss  %xmm5,%xmm1
movaps %xmm8,%xmm0
movaps %xmm8,%xmm12
movaps %xmm8,-0x130(%rbp)
ff
mulss  %xmm7,%xmm0
movaps %xmm0,%xmm3
mulss  %xmm13,%xmm3
subss  %xmm3,%xmm1
movss  -0x20(%rbx),%xmm8
movaps %xmm4,%xmm15
mulss  %xmm8,%xmm15
movaps %xmm15,%xmm3
mulss  %xmm13,%xmm3
addss  %xmm1,%xmm3
movaps %xmm11,%xmm6
mulss  %xmm8,%xmm6
movaps %xmm6,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm3
movss  -0x10(%rbx),%xmm2
movaps %xmm4,-0x90(%rbp)
mulss  %xmm2,%xmm4
movaps %xmm4,%xmm1
mulss  %xmm9,%xmm1
subss  %xmm1,%xmm3
movaps %xmm11,-0x250(%rbp)
ff
movaps %xmm11,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm1,%xmm11
mulss  %xmm12,%xmm11
addss  %xmm3,%xmm11
movaps -0xb0(%rbp),%xmm12
ff
movaps %xmm7,-0x40(%rbp)
mulss  %xmm7,%xmm12
mulss  %xmm14,%xmm5
movaps %xmm12,%xmm7
mulss  %xmm13,%xmm7
subss  %xmm5,%xmm7
movaps -0x70(%rbp),%xmm9
movaps %xmm9,%xmm3
movaps %xmm8,-0x50(%rbp)
mulss  %xmm8,%xmm3
movaps %xmm3,%xmm5
movaps %xmm13,-0x260(%rbp)
ff
mulss  %xmm13,%xmm5
subss  %xmm5,%xmm7
mulss  %xmm14,%xmm6
addss  %xmm7,%xmm6
movaps %xmm9,%xmm7
movaps %xmm2,%xmm9
mulss  %xmm2,%xmm7
movaps %xmm7,%xmm5
mulss  -0x140(%rbp),%xmm5
ff
addss  %xmm6,%xmm5
movaps -0xb0(%rbp),%xmm2
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm14,%xmm0
movaps -0x60(%rbp),%xmm1
mulss  %xmm1,%xmm12
subss  %xmm12,%xmm0
mulss  %xmm1,%xmm3
addss  %xmm0,%xmm3
movaps %xmm14,-0x80(%rbp)
mulss  %xmm14,%xmm15
subss  %xmm15,%xmm3
mulss  -0x130(%rbp),%xmm7
ff
subss  %xmm7,%xmm3
movaps %xmm2,%xmm0
movaps %xmm2,%xmm14
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
xorps  %xmm6,%xmm6
cvtss2sd %xmm10,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm11,%xmm1
movss  -0x3c(%rbx),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movaps %xmm1,-0x240(%rbp)
mulsd  %xmm1,%xmm0
movss  -0x40(%rbx),%xmm15
xorps  %xmm1,%xmm1
cvtss2sd %xmm15,%xmm1
movaps %xmm6,-0x230(%rbp)
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
movss  -0x38(%rbx),%xmm12
xorps  %xmm0,%xmm0
cvtss2sd %xmm12,%xmm0
movaps %xmm3,-0x220(%rbp)
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
movaps -0xa0(%rbp),%xmm3
cvtss2sd %xmm3,%xmm8
mulsd  %xmm1,%xmm8
addsd  %xmm0,%xmm8
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm8
jne    1448 <matrixInverse4x4+0x328>
jnp    1ac6 <matrixInverse4x4+0x9a6>
movaps %xmm3,%xmm10
movaps 0xbad(%rip),%xmm4
movaps %xmm9,%xmm7
xorps  %xmm4,%xmm7
movaps %xmm9,%xmm0
movlhps %xmm3,%xmm0
shufps $0xe2,%xmm3,%xmm0
movaps %xmm7,%xmm6
unpcklps %xmm3,%xmm6
mulps  %xmm0,%xmm6
movaps %xmm6,-0x200(%rbp)
movaps %xmm2,%xmm0
unpcklps %xmm9,%xmm0
movaps %xmm1,-0x210(%rbp)
movaps %xmm12,%xmm1
unpcklps %xmm7,%xmm1
unpcklps %xmm2,%xmm7
mulps  %xmm0,%xmm7
movaps %xmm7,-0x1f0(%rbp)
unpcklps %xmm12,%xmm9
mulps  %xmm1,%xmm9
movaps %xmm9,-0x1e0(%rbp)
ff
movaps -0x50(%rbp),%xmm6
movaps %xmm6,%xmm3
xorps  %xmm4,%xmm3
movaps %xmm10,%xmm0
movss  %xmm12,%xmm0
movaps %xmm3,%xmm1
movaps %xmm3,-0x1b0(%rbp)
unpcklps %xmm12,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,-0xe0(%rbp)
movaps -0x40(%rbp),%xmm7
xorps  %xmm4,%xmm7
movaps %xmm6,%xmm0
unpcklps %xmm10,%xmm0
movaps %xmm7,%xmm1
movaps %xmm7,%xmm5
movlhps %xmm10,%xmm1
shufps $0xe2,%xmm10,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,-0xf0(%rbp)
movaps %xmm12,%xmm0
unpcklps %xmm6,%xmm0
unpcklps %xmm2,%xmm6
movaps %xmm2,%xmm1
unpcklps %xmm7,%xmm1
mulps  %xmm6,%xmm1
movaps %xmm1,%xmm6
movaps %xmm2,%xmm1
unpcklps %xmm3,%xmm1
movaps %xmm2,%xmm7
movaps %xmm2,-0x120(%rbp)
shufps $0xd4,%xmm10,%xmm7
shufps $0x52,%xmm10,%xmm7
mulps  %xmm1,%xmm7
unpcklps %xmm12,%xmm5
mulps  %xmm0,%xmm5
movaps %xmm5,-0x40(%rbp)
movaps -0x70(%rbp),%xmm11
movaps %xmm11,%xmm0
xorps  %xmm4,%xmm0
movaps %xmm0,-0x50(%rbp)
movaps %xmm14,%xmm5
movaps %xmm14,%xmm0
xorps  %xmm4,%xmm0
movaps %xmm0,-0x100(%rbp)
movaps -0x80(%rbp),%xmm0
xorps  %xmm4,%xmm0
movaps %xmm0,-0x1d0(%rbp)
xorps  %xmm4,%xmm2
movaps %xmm2,-0x110(%rbp)
xorps  %xmm15,%xmm4
movaps -0x90(%rbp),%xmm10
ff
movaps %xmm10,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm0,-0x1c0(%rbp)
movaps %xmm4,%xmm3
movaps %xmm11,%xmm1
mulss  %xmm15,%xmm1
movaps %xmm14,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm15,%xmm4
mulss  %xmm3,%xmm14
unpcklps %xmm1,%xmm14
movaps %xmm1,%xmm0
movsd  %xmm8,-0xb8(%rbp)
ff ff
movaps -0x130(%rbp),%xmm9
ff
mulss  %xmm9,%xmm0
addss  %xmm2,%xmm0
movaps %xmm6,%xmm2
movaps %xmm6,-0x170(%rbp)
movaps %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm1
mulss  %xmm9,%xmm1
addss  %xmm0,%xmm1
movaps -0xe0(%rbp),%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm10,%xmm1
addss  %xmm0,%xmm1
movaps %xmm6,%xmm0
mulss  %xmm11,%xmm0
addss  %xmm1,%xmm0
movaps %xmm0,-0x1a0(%rbp)
movaps -0x250(%rbp),%xmm13
ff
movaps %xmm13,%xmm6
mulss  %xmm15,%xmm6
movaps %xmm6,-0x180(%rbp)
movaps %xmm3,%xmm15
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
movaps %xmm5,%xmm8
movaps %xmm5,%xmm2
mulss  %xmm6,%xmm2
movaps %xmm12,-0xd0(%rbp)
ff
movaps %xmm1,%xmm5
movaps -0x140(%rbp),%xmm3
mulss  %xmm3,%xmm5
addss  %xmm2,%xmm5
movaps %xmm7,%xmm0
movaps %xmm7,-0x150(%rbp)
movaps %xmm7,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm5,%xmm2
movaps -0xf0(%rbp),%xmm7
movaps %xmm7,%xmm5
shufps $0x55,%xmm7,%xmm5
mulss  %xmm8,%xmm5
addss  %xmm2,%xmm5
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
mulss  %xmm13,%xmm2
addss  %xmm5,%xmm2
movaps %xmm7,%xmm5
mulss  %xmm11,%xmm5
addss  %xmm2,%xmm5
movaps %xmm5,-0x190(%rbp)
movaps %xmm13,%xmm8
mulss  %xmm15,%xmm8
movaps %xmm15,%xmm11
movaps %xmm15,-0x160(%rbp)
ff
movaps %xmm10,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm9,%xmm6
mulss  %xmm8,%xmm6
movaps %xmm5,%xmm7
mulss  %xmm3,%xmm7
addss  %xmm6,%xmm7
movaps -0x40(%rbp),%xmm15
movaps %xmm15,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movaps -0x1b0(%rbp),%xmm2
movaps -0xa0(%rbp),%xmm0
unpcklps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm2,%xmm7
shufps $0x55,%xmm2,%xmm7
mulss  %xmm9,%xmm7
addss  %xmm6,%xmm7
movaps %xmm15,%xmm6
shufps $0x55,%xmm15,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm7,%xmm6
movaps %xmm9,%xmm7
mulss  %xmm11,%xmm7
unpcklps %xmm7,%xmm5
movaps %xmm3,%xmm12
mulss  %xmm4,%xmm12
unpcklps %xmm8,%xmm12
movaps -0x80(%rbp),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm5
mulps  %xmm7,%xmm15
movaps %xmm15,%xmm11
mulps  %xmm7,%xmm12
mulps  %xmm2,%xmm7
mulss  %xmm10,%xmm2
addss  %xmm6,%xmm2
movaps %xmm2,-0x40(%rbp)
movaps -0x110(%rbp),%xmm6
mulss  %xmm10,%xmm6
movaps %xmm13,%xmm8
mulss  -0x120(%rbp),%xmm8
ff ff
mulss  %xmm9,%xmm8
mulss  %xmm3,%xmm6
addss  %xmm8,%xmm6
movaps -0x70(%rbp),%xmm8
movaps -0xd0(%rbp),%xmm2
mulss  %xmm2,%xmm8
mulss  %xmm3,%xmm8
addss  %xmm6,%xmm8
movaps -0x50(%rbp),%xmm6
mulss  %xmm0,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm8,%xmm6
movaps -0x100(%rbp),%xmm15
ff
mulss  %xmm2,%xmm15
mulss  %xmm13,%xmm15
addss  %xmm6,%xmm15
movaps -0xb0(%rbp),%xmm10
ff
movaps %xmm10,%xmm8
mulss  %xmm0,%xmm8
movaps -0x90(%rbp),%xmm0
mulss  %xmm0,%xmm8
addss  %xmm15,%xmm8
movaps %xmm10,%xmm6
mulss  %xmm4,%xmm6
unpcklps %xmm6,%xmm1
movaps -0x60(%rbp),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm1
addps  %xmm5,%xmm1
movaps -0x150(%rbp),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm1,%xmm5
addps  %xmm5,%xmm11
unpcklps %xmm9,%xmm0
movaps -0x1f0(%rbp),%xmm5
mulps  %xmm5,%xmm0
addps  %xmm11,%xmm0
movaps -0x70(%rbp),%xmm11
movaps %xmm11,%xmm6
unpcklps %xmm10,%xmm6
movaps -0x1e0(%rbp),%xmm15
ff
mulps  %xmm15,%xmm6
addps  %xmm0,%xmm6
movaps %xmm6,-0x60(%rbp)
movaps -0x260(%rbp),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm14
addps  %xmm12,%xmm14
movaps -0x170(%rbp),%xmm1
mulps  %xmm6,%xmm1
addps  %xmm14,%xmm1
addps  %xmm1,%xmm7
movaps %xmm3,%xmm1
unpcklps %xmm13,%xmm1
movaps %xmm5,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm7,%xmm0
movaps -0x200(%rbp),%xmm12
ff
movaps %xmm12,%xmm5
shufps $0xe1,%xmm12,%xmm5
movaps %xmm10,%xmm14
unpcklps %xmm11,%xmm14
movaps %xmm11,%xmm13
mulps  %xmm5,%xmm14
addps  %xmm0,%xmm14
mulss  -0x160(%rbp),%xmm3
ff
unpcklps -0x180(%rbp),%xmm3
mulss  %xmm9,%xmm4
unpcklps -0x1c0(%rbp),%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm6,%xmm4
addps  %xmm3,%xmm4
movaps -0xe0(%rbp),%xmm0
mulps  %xmm6,%xmm0
addps  %xmm4,%xmm0
movaps -0xf0(%rbp),%xmm3
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movaps %xmm15,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
unpcklps -0x90(%rbp),%xmm9
ff
mulps  %xmm9,%xmm12
addps  %xmm0,%xmm12
movaps -0x80(%rbp),%xmm4
movaps %xmm4,%xmm0
movaps -0xa0(%rbp),%xmm7
unpcklps %xmm7,%xmm0
movaps -0x1d0(%rbp),%xmm3
movaps %xmm3,%xmm5
movlhps %xmm7,%xmm5
shufps $0xe2,%xmm7,%xmm5
mulps  %xmm0,%xmm5
movaps -0xd0(%rbp),%xmm11
ff
movlhps %xmm11,%xmm4
shufps $0xe2,%xmm11,%xmm4
unpcklps %xmm11,%xmm3
mulps  %xmm4,%xmm3
movaps %xmm3,%xmm15
movaps %xmm13,%xmm0
movlhps %xmm7,%xmm0
shufps $0xe2,%xmm7,%xmm0
movaps %xmm0,%xmm3
movaps -0x100(%rbp),%xmm0
unpcklps %xmm7,%xmm0
mulps  %xmm3,%xmm0
movaps %xmm0,%xmm13
unpcklps %xmm11,%xmm10
movaps -0x50(%rbp),%xmm4
movlhps %xmm11,%xmm4
shufps $0xe2,%xmm11,%xmm4
mulps  %xmm10,%xmm4
movaps -0x110(%rbp),%xmm0
movaps %xmm0,%xmm7
movaps -0x120(%rbp),%xmm3
unpcklps %xmm3,%xmm7
movlhps %xmm3,%xmm0
shufps $0xe2,%xmm3,%xmm0
mulps  %xmm9,%xmm7
mulps  %xmm1,%xmm0
mulps  %xmm2,%xmm0
mulps  %xmm6,%xmm7
addps  %xmm0,%xmm7
mulps  %xmm6,%xmm4
addps  %xmm7,%xmm4
mulps  %xmm2,%xmm13
addps  %xmm4,%xmm13
mulps  %xmm1,%xmm15
addps  %xmm13,%xmm15
mulps  %xmm9,%xmm5
addps  %xmm15,%xmm5
movsd  0x647(%rip),%xmm0
divsd  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm8,%xmm1
cvtps2pd %xmm5,%xmm3
movaps -0x230(%rbp),%xmm2
movlhps %xmm3,%xmm2
shufps $0x4e,%xmm1,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm3,%xmm1
mulpd  %xmm0,%xmm2
cvtpd2ps %xmm2,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm3,(%r15)
movaps -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtps2pd %xmm12,%xmm2
movaps -0x240(%rbp),%xmm3
movlhps %xmm2,%xmm3
shufps $0x4e,%xmm1,%xmm2
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm2,%xmm1
cvtpd2ps %xmm3,%xmm2
unpcklpd %xmm1,%xmm2
movaps -0x190(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtps2pd %xmm14,%xmm3
movaps -0x220(%rbp),%xmm4
movlhps %xmm3,%xmm4
shufps $0x4e,%xmm1,%xmm3
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm3,%xmm1
cvtpd2ps %xmm4,%xmm3
movapd %xmm2,0x10(%r15)
unpcklpd %xmm1,%xmm3
movapd %xmm3,0x20(%r15)
movaps -0x1a0(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtps2pd -0x60(%rbp),%xmm2
movaps -0x210(%rbp),%xmm3
shufps $0xe4,%xmm2,%xmm3
movlhps %xmm1,%xmm2
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm2,%xmm0
cvtpd2ps %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm1,0x30(%r15)
mov    %r14,%rdi
mov    $0x4,%esi
mov    $0x4,%edx
mov    %r15,%rcx
mov    $0x10,%r8d
xor    %eax,%eax
call   1040 <arrayToMatrix_CMO@plt>
mov    $0x1,%r13b
mov    %r12,%rsp
mov    %r13d,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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