#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int fabs(double);
int m_inv(float *I, const float *N) {
  double T[16], M[16];
  double d;
  int i;
  for (i = 0; i < 16; i++)
    M[i] = N[i];
  T[0] = +(M[5] * (M[10] * M[15] - M[11] * M[14]) -
           M[9] * (M[6] * M[15] - M[7] * M[14]) +
           M[13] * (M[6] * M[11] - M[7] * M[10]));
  T[1] = -(M[4] * (M[10] * M[15] - M[11] * M[14]) -
           M[8] * (M[6] * M[15] - M[7] * M[14]) +
           M[12] * (M[6] * M[11] - M[7] * M[10]));
  T[2] = +(M[4] * (M[9] * M[15] - M[11] * M[13]) -
           M[8] * (M[5] * M[15] - M[7] * M[13]) +
           M[12] * (M[5] * M[11] - M[7] * M[9]));
  T[3] = -(M[4] * (M[9] * M[14] - M[10] * M[13]) -
           M[8] * (M[5] * M[14] - M[6] * M[13]) +
           M[12] * (M[5] * M[10] - M[6] * M[9]));
  T[4] = -(M[1] * (M[10] * M[15] - M[11] * M[14]) -
           M[9] * (M[2] * M[15] - M[3] * M[14]) +
           M[13] * (M[2] * M[11] - M[3] * M[10]));
  T[5] = +(M[0] * (M[10] * M[15] - M[11] * M[14]) -
           M[8] * (M[2] * M[15] - M[3] * M[14]) +
           M[12] * (M[2] * M[11] - M[3] * M[10]));
  T[6] = -(M[0] * (M[9] * M[15] - M[11] * M[13]) -
           M[8] * (M[1] * M[15] - M[3] * M[13]) +
           M[12] * (M[1] * M[11] - M[3] * M[9]));
  T[7] = +(M[0] * (M[9] * M[14] - M[10] * M[13]) -
           M[8] * (M[1] * M[14] - M[2] * M[13]) +
           M[12] * (M[1] * M[10] - M[2] * M[9]));
  T[8] = +(M[1] * (M[6] * M[15] - M[7] * M[14]) -
           M[5] * (M[2] * M[15] - M[3] * M[14]) +
           M[13] * (M[2] * M[7] - M[3] * M[6]));
  T[9] = -(M[0] * (M[6] * M[15] - M[7] * M[14]) -
           M[4] * (M[2] * M[15] - M[3] * M[14]) +
           M[12] * (M[2] * M[7] - M[3] * M[6]));
  T[10] = +(M[0] * (M[5] * M[15] - M[7] * M[13]) -
            M[4] * (M[1] * M[15] - M[3] * M[13]) +
            M[12] * (M[1] * M[7] - M[3] * M[5]));
  T[11] = -(M[0] * (M[5] * M[14] - M[6] * M[13]) -
            M[4] * (M[1] * M[14] - M[2] * M[13]) +
            M[12] * (M[1] * M[6] - M[2] * M[5]));
  T[12] = -(M[1] * (M[6] * M[11] - M[7] * M[10]) -
            M[5] * (M[2] * M[11] - M[3] * M[10]) +
            M[9] * (M[2] * M[7] - M[3] * M[6]));
  T[13] = +(M[0] * (M[6] * M[11] - M[7] * M[10]) -
            M[4] * (M[2] * M[11] - M[3] * M[10]) +
            M[8] * (M[2] * M[7] - M[3] * M[6]));
  T[14] = -(M[0] * (M[5] * M[11] - M[7] * M[9]) -
            M[4] * (M[1] * M[11] - M[3] * M[9]) +
            M[8] * (M[1] * M[7] - M[3] * M[5]));
  T[15] = +(M[0] * (M[5] * M[10] - M[6] * M[9]) -
            M[4] * (M[1] * M[10] - M[2] * M[9]) +
            M[8] * (M[1] * M[6] - M[2] * M[5]));
  d = M[0] * T[0] + M[4] * T[4] + M[8] * T[8] + M[12] * T[12];
  if (fabs(d) > 1e-5) {
    I[0] = T[0] / d;
    I[1] = T[4] / d;
    I[2] = T[8] / d;
    I[3] = T[12] / d;
    I[4] = T[1] / d;
    I[5] = T[5] / d;
    I[6] = T[9] / d;
    I[7] = T[13] / d;
    I[8] = T[2] / d;
    I[9] = T[6] / d;
    I[10] = T[10] / d;
    I[11] = T[14] / d;
    I[12] = T[3] / d;
    I[13] = T[7] / d;
    I[14] = T[11] / d;
    I[15] = T[15] / d;
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<m_inv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x12c(%rbp)
cmpl   $0x10,-0x12c(%rbp)
jge    1172 <m_inv+0x62>
mov    -0x18(%rbp),%rax
movslq -0x12c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x12c(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    112d <m_inv+0x1d>
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xd0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xd0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0xe8(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0xe8(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm5
ff
movsd  -0xf0(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm4
ff
movsd  -0xf0(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xd0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xd0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm5
ff
movsd  -0x110(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm4
ff
movsd  -0x110(%rbp),%xmm3
ff
mulsd  -0xd8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm5
ff
movsd  -0x110(%rbp),%xmm4
ff
mulsd  -0xb8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0x110(%rbp),%xmm3
ff
mulsd  -0xf8(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xd0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xd0(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf0(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xc8(%rbp),%xmm5
ff
movsd  -0x108(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm4
ff
movsd  -0x108(%rbp),%xmm3
ff
mulsd  -0xf8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm3
ff
movsd  -0xd0(%rbp),%xmm5
ff
movsd  -0x110(%rbp),%xmm4
ff
mulsd  -0xd8(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm4
ff
movsd  -0x110(%rbp),%xmm3
ff
mulsd  -0xf8(%rbp),%xmm3
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
call   1030 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0xd0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    24b7 <m_inv+0x13a7>
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movsd  -0x60(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movsd  -0x40(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movsd  -0x78(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movsd  -0x58(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
movsd  -0x38(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movsd  -0x70(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
movsd  -0x50(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
movsd  -0x30(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
movsd  -0x68(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
movsd  -0x48(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
movsd  -0x28(%rbp),%xmm0
divsd  -0x128(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x3c(%rax)
movl   $0x1,-0x4(%rbp)
jmp    24be <m_inv+0x13ae>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_inv>:
push   %rbx
sub    $0x170,%rsp
mov    %rdi,%rbx
movss  0x8(%rsi),%xmm0
cvtss2sd %xmm0,%xmm10
movss  0xc(%rsi),%xmm0
cvtss2sd %xmm0,%xmm6
movss  0x14(%rsi),%xmm0
cvtss2sd %xmm0,%xmm4
movsd  %xmm4,0x28(%rsp)
movss  0x18(%rsi),%xmm0
cvtss2sd %xmm0,%xmm15
movss  0x1c(%rsi),%xmm0
cvtss2sd %xmm0,%xmm3
movaps %xmm3,0xb0(%rsp)
movss  0x24(%rsi),%xmm0
cvtss2sd %xmm0,%xmm13
movss  0x28(%rsi),%xmm0
cvtss2sd %xmm0,%xmm11
movss  0x2c(%rsi),%xmm0
cvtss2sd %xmm0,%xmm9
movss  0x34(%rsi),%xmm0
cvtss2sd %xmm0,%xmm14
movss  0x38(%rsi),%xmm0
cvtss2sd %xmm0,%xmm7
movss  0x3c(%rsi),%xmm0
cvtss2sd %xmm0,%xmm8
movaps %xmm7,%xmm0
mulsd  %xmm9,%xmm0
movaps %xmm11,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm0,%xmm5
movaps %xmm7,%xmm0
mulsd  %xmm3,%xmm0
movaps %xmm15,%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm13,%xmm0
movaps %xmm4,%xmm1
mulsd  %xmm5,%xmm1
subsd  %xmm0,%xmm1
movaps %xmm11,%xmm0
mulsd  %xmm3,%xmm0
movaps %xmm15,%xmm4
mulsd  %xmm9,%xmm4
subsd  %xmm0,%xmm4
movaps %xmm14,%xmm12
mulsd  %xmm4,%xmm12
addsd  %xmm1,%xmm12
movsd  %xmm7,0x88(%rsp)
movaps %xmm7,%xmm0
movaps %xmm6,%xmm3
mulsd  %xmm6,%xmm0
movaps %xmm10,%xmm7
movaps %xmm10,%xmm6
movsd  %xmm8,0x8(%rsp)
mulsd  %xmm8,%xmm6
subsd  %xmm0,%xmm6
movss  0x4(%rsi),%xmm0
xorps  %xmm10,%xmm10
cvtss2sd %xmm0,%xmm10
movapd %xmm6,%xmm0
mulsd  %xmm13,%xmm0
movaps %xmm10,%xmm1
movsd  %xmm5,0x98(%rsp)
mulsd  %xmm5,%xmm1
subsd  %xmm0,%xmm1
movaps %xmm11,0x130(%rsp)
movaps %xmm11,%xmm0
mulsd  %xmm3,%xmm0
movaps %xmm7,%xmm5
movaps %xmm7,%xmm8
movaps %xmm9,0x150(%rsp)
mulsd  %xmm9,%xmm5
subsd  %xmm0,%xmm5
movaps %xmm14,%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm1,%xmm7
movsd  %xmm6,0x80(%rsp)
movapd %xmm6,%xmm0
movsd  0x28(%rsp),%xmm6
mulsd  %xmm6,%xmm0
movaps %xmm10,%xmm1
movsd  %xmm2,0x90(%rsp)
mulsd  %xmm2,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm15,0x50(%rsp)
movsd  %xmm3,0x58(%rsp)
mulsd  %xmm3,%xmm15
movaps %xmm8,%xmm2
movsd  %xmm8,0x60(%rsp)
mulsd  0xb0(%rsp),%xmm2
subsd  %xmm15,%xmm2
movsd  %xmm14,0x40(%rsp)
mulsd  %xmm2,%xmm14
addsd  %xmm1,%xmm14
movapd %xmm5,0xa0(%rsp)
movapd %xmm5,%xmm0
mulsd  %xmm6,%xmm0
movaps %xmm10,0x160(%rsp)
movaps %xmm10,%xmm1
movsd  %xmm4,0x20(%rsp)
mulsd  %xmm4,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm13,0x48(%rsp)
movapd %xmm2,0x120(%rsp)
mulsd  %xmm2,%xmm13
addsd  %xmm1,%xmm13
movss  (%rsi),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movss  0x10(%rsi),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
movapd %xmm7,0x110(%rsp)
mulsd  %xmm7,%xmm0
movsd  %xmm1,0x68(%rsp)
movapd %xmm12,0x140(%rsp)
mulsd  %xmm12,%xmm1
subsd  %xmm0,%xmm1
movss  0x20(%rsi),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x70(%rsp)
movapd %xmm14,0xf0(%rsp)
mulsd  %xmm14,%xmm0
addsd  %xmm1,%xmm0
movss  0x30(%rsi),%xmm1
cvtss2sd %xmm1,%xmm1
movaps %xmm1,0xe0(%rsp)
movapd %xmm13,0xd0(%rsp)
mulsd  %xmm13,%xmm1
subsd  %xmm1,%xmm0
movapd %xmm0,0x100(%rsp)
call   1030 <fabs@plt>
test   %eax,%eax
jle    1817 <m_inv+0x707>
movsd  0x40(%rsp),%xmm5
movapd %xmm5,%xmm0
movapd 0x150(%rsp),%xmm12
mulsd  %xmm12,%xmm0
movsd  0x48(%rsp),%xmm6
movapd %xmm6,%xmm1
movsd  0x8(%rsp),%xmm7
mulsd  %xmm7,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
movapd %xmm5,%xmm0
movapd 0xb0(%rsp),%xmm15
mulsd  %xmm15,%xmm0
movsd  0x28(%rsp),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm7,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movapd %xmm6,%xmm1
mulsd  %xmm15,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm12,%xmm0
subsd  %xmm1,%xmm0
movapd %xmm0,%xmm9
movapd %xmm0,0xc0(%rsp)
movapd %xmm5,%xmm1
movapd 0x130(%rsp),%xmm14
mulsd  %xmm14,%xmm1
movapd %xmm6,%xmm0
movsd  0x88(%rsp),%xmm10
mulsd  %xmm10,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rsp)
movapd %xmm5,%xmm1
movsd  0x50(%rsp),%xmm4
mulsd  %xmm4,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm10,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rsp)
movapd %xmm6,%xmm3
mulsd  %xmm4,%xmm3
movapd %xmm2,%xmm13
mulsd  %xmm14,%xmm13
subsd  %xmm3,%xmm13
movapd %xmm5,%xmm3
movsd  0x58(%rsp),%xmm1
mulsd  %xmm1,%xmm3
movapd 0x160(%rsp),%xmm8
mulsd  %xmm8,%xmm7
subsd  %xmm3,%xmm7
movsd  %xmm7,0x8(%rsp)
movapd %xmm6,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm8,%xmm12
subsd  %xmm3,%xmm12
movsd  0x60(%rsp),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm8,%xmm10
subsd  %xmm5,%xmm10
mulsd  %xmm0,%xmm6
mulsd  %xmm8,%xmm14
subsd  %xmm6,%xmm14
mulsd  %xmm2,%xmm1
mulsd  %xmm8,%xmm15
subsd  %xmm1,%xmm15
mulsd  %xmm0,%xmm2
mulsd  %xmm4,%xmm8
subsd  %xmm2,%xmm8
movapd %xmm14,%xmm3
movsd  0x78(%rsp),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x68(%rsp),%xmm1
movapd %xmm1,%xmm6
mulsd  %xmm13,%xmm6
subsd  %xmm3,%xmm6
movsd  0x70(%rsp),%xmm11
movapd %xmm11,%xmm3
mulsd  %xmm8,%xmm3
addsd  %xmm6,%xmm3
movapd %xmm12,%xmm6
mulsd  %xmm4,%xmm6
movapd %xmm1,%xmm7
mulsd  %xmm9,%xmm7
subsd  %xmm6,%xmm7
movapd %xmm11,%xmm6
mulsd  %xmm15,%xmm6
addsd  %xmm7,%xmm6
movapd 0xa0(%rsp),%xmm7
mulsd  %xmm4,%xmm7
movapd %xmm1,%xmm2
mulsd  0x20(%rsp),%xmm2
subsd  %xmm7,%xmm2
movapd %xmm11,%xmm7
movapd 0x120(%rsp),%xmm9
mulsd  %xmm9,%xmm7
addsd  %xmm2,%xmm7
movapd %xmm10,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm1,%xmm5
mulsd  0x10(%rsp),%xmm5
subsd  %xmm2,%xmm5
movapd 0xe0(%rsp),%xmm0
mulsd  %xmm0,%xmm8
addsd  %xmm5,%xmm8
movapd 0xa11(%rip),%xmm2
xorpd  %xmm2,%xmm8
movapd %xmm2,%xmm5
unpcklpd %xmm3,%xmm8
movsd  0x8(%rsp),%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm1,%xmm3
mulsd  0x18(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm15
addsd  %xmm3,%xmm15
xorpd  %xmm5,%xmm6
unpcklpd %xmm6,%xmm15
movsd  0x80(%rsp),%xmm6
movapd %xmm6,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm1,%xmm3
movsd  0x90(%rsp),%xmm5
mulsd  %xmm5,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm9
addsd  %xmm3,%xmm9
xorpd  0x99f(%rip),%xmm9
unpcklpd %xmm7,%xmm9
mulsd  %xmm11,%xmm10
movapd %xmm1,%xmm2
movsd  0x30(%rsp),%xmm7
mulsd  %xmm7,%xmm2
subsd  %xmm10,%xmm2
mulsd  %xmm0,%xmm14
addsd  %xmm2,%xmm14
movsd  0x8(%rsp),%xmm10
mulsd  %xmm11,%xmm10
movapd %xmm1,%xmm2
movsd  0x38(%rsp),%xmm3
mulsd  %xmm3,%xmm2
subsd  %xmm10,%xmm2
mulsd  %xmm0,%xmm12
addsd  %xmm2,%xmm12
mulsd  %xmm11,%xmm6
movsd  0x98(%rsp),%xmm2
mulsd  %xmm2,%xmm1
subsd  %xmm6,%xmm1
movapd 0xa0(%rsp),%xmm10
mulsd  %xmm0,%xmm10
addsd  %xmm1,%xmm10
movsd  0x10(%rsp),%xmm6
mulsd  %xmm11,%xmm6
movapd %xmm7,%xmm1
mulsd  %xmm4,%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm0,%xmm13
addsd  %xmm1,%xmm13
movapd 0x8fc(%rip),%xmm7
xorpd  %xmm7,%xmm13
unpcklpd %xmm14,%xmm13
movsd  0x18(%rsp),%xmm6
mulsd  %xmm11,%xmm6
movapd %xmm3,%xmm1
mulsd  %xmm4,%xmm1
subsd  %xmm6,%xmm1
movapd 0xc0(%rsp),%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm7,%xmm1
xorpd  %xmm7,%xmm12
unpcklpd %xmm12,%xmm6
mulsd  %xmm11,%xmm5
mulsd  %xmm2,%xmm4
subsd  %xmm5,%xmm4
mulsd  0x20(%rsp),%xmm0
addsd  %xmm4,%xmm0
movapd 0x110(%rsp),%xmm2
xorpd  %xmm7,%xmm2
movapd 0xd0(%rsp),%xmm3
xorpd  %xmm1,%xmm3
xorpd  %xmm1,%xmm0
movapd 0xf0(%rsp),%xmm4
unpcklpd %xmm3,%xmm4
movapd 0x140(%rsp),%xmm3
unpcklpd %xmm2,%xmm3
movapd 0x100(%rsp),%xmm5
unpcklpd %xmm5,%xmm5
divpd  %xmm5,%xmm3
divpd  %xmm5,%xmm4
cvtpd2ps %xmm4,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm10,%xmm0
unpcklpd %xmm2,%xmm3
divpd  %xmm5,%xmm0
divpd  %xmm5,%xmm9
cvtpd2ps %xmm9,%xmm2
cvtpd2ps %xmm0,%xmm4
movupd %xmm3,(%rbx)
unpcklpd %xmm2,%xmm4
divpd  %xmm5,%xmm6
divpd  %xmm5,%xmm15
cvtpd2ps %xmm15,%xmm2
cvtpd2ps %xmm6,%xmm0
movupd %xmm4,0x10(%rbx)
unpcklpd %xmm2,%xmm0
divpd  %xmm5,%xmm13
divpd  %xmm5,%xmm8
cvtpd2ps %xmm8,%xmm2
cvtpd2ps %xmm13,%xmm1
movupd %xmm0,0x20(%rbx)
unpcklpd %xmm2,%xmm1
movupd %xmm1,0x30(%rbx)
mov    $0x1,%eax
jmp    1819 <m_inv+0x709>
xor    %eax,%eax
add    $0x170,%rsp
pop    %rbx
ret

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

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