void invertMatrix(float *out, const float *m) {
  double wtmp[4][8];
  double m0, m1, m2, m3, s;
  double *r0, *r1, *r2, *r3;
  r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
  r0[0] = (m)[(0) * 4 + (0)], r0[1] = (m)[(0) * 4 + (1)],
  r0[2] = (m)[(0) * 4 + (2)], r0[3] = (m)[(0) * 4 + (3)], r0[4] = 1.0,
  r0[5] = r0[6] = r0[7] = 0.0, r1[0] = (m)[(1) * 4 + (0)],
  r1[1] = (m)[(1) * 4 + (1)], r1[2] = (m)[(1) * 4 + (2)],
  r1[3] = (m)[(1) * 4 + (3)], r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
  r2[0] = (m)[(2) * 4 + (0)], r2[1] = (m)[(2) * 4 + (1)],
  r2[2] = (m)[(2) * 4 + (2)], r2[3] = (m)[(2) * 4 + (3)], r2[6] = 1.0,
  r2[4] = r2[5] = r2[7] = 0.0, r3[0] = (m)[(3) * 4 + (0)],
  r3[1] = (m)[(3) * 4 + (1)], r3[2] = (m)[(3) * 4 + (2)],
  r3[3] = (m)[(3) * 4 + (3)], r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
  if (fabs(r3[0]) > fabs(r2[0])) {
    double *_tmp = r3;
    (r3) = (r2);
    (r2) = _tmp;
  };
  if (fabs(r2[0]) > fabs(r1[0])) {
    double *_tmp = r2;
    (r2) = (r1);
    (r1) = _tmp;
  };
  if (fabs(r1[0]) > fabs(r0[0])) {
    double *_tmp = r1;
    (r1) = (r0);
    (r0) = _tmp;
  };
  if (0.0 == r0[0]) {
    assert(!"could not invert matrix");
  }
  m1 = r1[0] / r0[0];
  m2 = r2[0] / r0[0];
  m3 = r3[0] / r0[0];
  s = r0[1];
  r1[1] -= m1 * s;
  r2[1] -= m2 * s;
  r3[1] -= m3 * s;
  s = r0[2];
  r1[2] -= m1 * s;
  r2[2] -= m2 * s;
  r3[2] -= m3 * s;
  s = r0[3];
  r1[3] -= m1 * s;
  r2[3] -= m2 * s;
  r3[3] -= m3 * s;
  s = r0[4];
  if (s != 0.0) {
    r1[4] -= m1 * s;
    r2[4] -= m2 * s;
    r3[4] -= m3 * s;
  }
  s = r0[5];
  if (s != 0.0) {
    r1[5] -= m1 * s;
    r2[5] -= m2 * s;
    r3[5] -= m3 * s;
  }
  s = r0[6];
  if (s != 0.0) {
    r1[6] -= m1 * s;
    r2[6] -= m2 * s;
    r3[6] -= m3 * s;
  }
  s = r0[7];
  if (s != 0.0) {
    r1[7] -= m1 * s;
    r2[7] -= m2 * s;
    r3[7] -= m3 * s;
  }
  if (fabs(r3[1]) > fabs(r2[1])) {
    double *_tmp = r3;
    (r3) = (r2);
    (r2) = _tmp;
  };
  if (fabs(r2[1]) > fabs(r1[1])) {
    double *_tmp = r2;
    (r2) = (r1);
    (r1) = _tmp;
  };
  if (0.0 == r1[1]) {
    assert(!"could not invert matrix");
  }
  m2 = r2[1] / r1[1];
  m3 = r3[1] / r1[1];
  r2[2] -= m2 * r1[2];
  r3[2] -= m3 * r1[2];
  r2[3] -= m2 * r1[3];
  r3[3] -= m3 * r1[3];
  s = r1[4];
  if (0.0 != s) {
    r2[4] -= m2 * s;
    r3[4] -= m3 * s;
  }
  s = r1[5];
  if (0.0 != s) {
    r2[5] -= m2 * s;
    r3[5] -= m3 * s;
  }
  s = r1[6];
  if (0.0 != s) {
    r2[6] -= m2 * s;
    r3[6] -= m3 * s;
  }
  s = r1[7];
  if (0.0 != s) {
    r2[7] -= m2 * s;
    r3[7] -= m3 * s;
  }
  if (fabs(r3[2]) > fabs(r2[2])) {
    double *_tmp = r3;
    (r3) = (r2);
    (r2) = _tmp;
  };
  if (0.0 == r2[2]) {
    assert(!"could not invert matrix");
  }
  m3 = r3[2] / r2[2];
  r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4], r3[5] -= m3 * r2[5],
      r3[6] -= m3 * r2[6], r3[7] -= m3 * r2[7];
  if (0.0 == r3[3]) {
    assert(!"could not invert matrix");
  }
  s = 1.0 / r3[3];
  r3[4] *= s;
  r3[5] *= s;
  r3[6] *= s;
  r3[7] *= s;
  m2 = r2[3];
  s = 1.0 / r2[2];
  r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
  r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
  m1 = r1[3];
  r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1, r1[6] -= r3[6] * m1,
      r1[7] -= r3[7] * m1;
  m0 = r0[3];
  r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0, r0[6] -= r3[6] * m0,
      r0[7] -= r3[7] * m0;
  m1 = r1[2];
  s = 1.0 / r1[1];
  r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
  r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
  m0 = r0[2];
  r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0, r0[6] -= r2[6] * m0,
      r0[7] -= r2[7] * m0;
  m0 = r0[1];
  s = 1.0 / r0[0];
  r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
  r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
  (out)[(0) * 4 + (0)] = (float)r0[4];
  (out)[(0) * 4 + (1)] = (float)r0[5], (out)[(0) * 4 + (2)] = (float)r0[6];
  (out)[(0) * 4 + (3)] = (float)r0[7], (out)[(1) * 4 + (0)] = (float)r1[4];
  (out)[(1) * 4 + (1)] = (float)r1[5], (out)[(1) * 4 + (2)] = (float)r1[6];
  (out)[(1) * 4 + (3)] = (float)r1[7], (out)[(2) * 4 + (0)] = (float)r2[4];
  (out)[(2) * 4 + (1)] = (float)r2[5], (out)[(2) * 4 + (2)] = (float)r2[6];
  (out)[(2) * 4 + (3)] = (float)r2[7], (out)[(3) * 4 + (0)] = (float)r3[4];
  (out)[(3) * 4 + (1)] = (float)r3[5], (out)[(3) * 4 + (2)] = (float)r3[6];
  (out)[(3) * 4 + (3)] = (float)r3[7];
}


x86 assembly (clang, -O0):
<invertMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x110(%rbp),%rax
mov    %rax,-0x140(%rbp)
lea    -0x110(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x148(%rbp)
lea    -0x110(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x150(%rbp)
lea    -0x110(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0x158(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x140(%rbp),%rax
movsd  0x1e34(%rip),%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x140(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x140(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x140(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x148(%rbp),%rax
movsd  0x1d90(%rip),%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x148(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x148(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x148(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x150(%rbp),%rax
movsd  0x1cec(%rip),%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x150(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x150(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x150(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x158(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x158(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x158(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x158(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x158(%rbp),%rax
movsd  0x1c48(%rip),%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x158(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x158(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x158(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x158(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0x1bf4(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  (%rax),%xmm1
movaps 0x1bde(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    145a <invertMatrix+0x34a>
mov    -0x158(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x150(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0x1b94(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  (%rax),%xmm1
movaps 0x1b7e(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    14ba <invertMatrix+0x3aa>
mov    -0x150(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x168(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0x1b34(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm1
movaps 0x1b1e(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    151a <invertMatrix+0x40a>
mov    -0x148(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x170(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jne    153d <invertMatrix+0x42d>
jp     153d <invertMatrix+0x42d>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <assert@plt>
mov    -0x148(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x140(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x150(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x140(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x158(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x140(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x140(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x8(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x8(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x8(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x140(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x140(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x140(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1847 <invertMatrix+0x737>
jp     1847 <invertMatrix+0x737>
jmp    1907 <invertMatrix+0x7f7>
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x140(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    193b <invertMatrix+0x82b>
jp     193b <invertMatrix+0x82b>
jmp    19fb <invertMatrix+0x8eb>
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x140(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a2f <invertMatrix+0x91f>
jp     1a2f <invertMatrix+0x91f>
jmp    1aef <invertMatrix+0x9df>
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x140(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b23 <invertMatrix+0xa13>
jp     1b23 <invertMatrix+0xa13>
jmp    1be3 <invertMatrix+0xad3>
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x158(%rbp),%rax
movsd  0x8(%rax),%xmm0
movaps 0x140a(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  0x8(%rax),%xmm1
movaps 0x13f3(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c45 <invertMatrix+0xb35>
mov    -0x158(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x150(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x178(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
movsd  0x8(%rax),%xmm0
movaps 0x13a8(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  0x8(%rax),%xmm1
movaps 0x1391(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ca7 <invertMatrix+0xb97>
mov    -0x150(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x180(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd 0x8(%rax),%xmm0
jne    1ccb <invertMatrix+0xbbb>
jp     1ccb <invertMatrix+0xbbb>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <assert@plt>
mov    -0x150(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x148(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x158(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x148(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x10(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jne    1e4b <invertMatrix+0xd3b>
jp     1e4b <invertMatrix+0xd3b>
jmp    1ecb <invertMatrix+0xdbb>
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jne    1efb <invertMatrix+0xdeb>
jp     1efb <invertMatrix+0xdeb>
jmp    1f7b <invertMatrix+0xe6b>
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jne    1fab <invertMatrix+0xe9b>
jp     1fab <invertMatrix+0xe9b>
jmp    202b <invertMatrix+0xf1b>
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jne    205b <invertMatrix+0xf4b>
jp     205b <invertMatrix+0xf4b>
jmp    20db <invertMatrix+0xfcb>
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x158(%rbp),%rax
movsd  0x10(%rax),%xmm0
movaps 0xf12(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  0x10(%rax),%xmm1
movaps 0xefb(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    213d <invertMatrix+0x102d>
mov    -0x158(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x150(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x188(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd 0x10(%rax),%xmm0
jne    2161 <invertMatrix+0x1051>
jp     2161 <invertMatrix+0x1051>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <assert@plt>
mov    -0x158(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x150(%rbp),%rax
divsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x18(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x158(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd 0x18(%rax),%xmm0
jne    22f9 <invertMatrix+0x11e9>
jp     22f9 <invertMatrix+0x11e9>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <assert@plt>
mov    -0x158(%rbp),%rax
movsd  0xd08(%rip),%xmm0
divsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x158(%rbp),%rax
mulsd  0x38(%rax),%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x150(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x150(%rbp),%rax
movsd  0xc74(%rip),%xmm0
divsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x128(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm1
movsd  -0x128(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x128(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm1
movsd  -0x128(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x148(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x140(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x148(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x148(%rbp),%rax
movsd  0x8a0(%rip),%xmm0
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x120(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm1
movsd  -0x120(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x120(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm1
movsd  -0x120(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x140(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
mov    -0x140(%rbp),%rax
movsd  0x20(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x28(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x30(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rax)
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
mov    -0x140(%rbp),%rax
movsd  0x38(%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x140(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x140(%rbp),%rax
movsd  0x5f0(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x118(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm1
movsd  -0x118(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x118(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm1
movsd  -0x118(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x140(%rbp),%rax
movsd  0x20(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x140(%rbp),%rax
movsd  0x28(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x140(%rbp),%rax
movsd  0x30(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x140(%rbp),%rax
movsd  0x38(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x148(%rbp),%rax
movsd  0x20(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x148(%rbp),%rax
movsd  0x28(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x148(%rbp),%rax
movsd  0x30(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x148(%rbp),%rax
movsd  0x38(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x150(%rbp),%rax
movsd  0x20(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x150(%rbp),%rax
movsd  0x28(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x150(%rbp),%rax
movsd  0x30(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x150(%rbp),%rax
movsd  0x38(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x158(%rbp),%rax
movsd  0x20(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x158(%rbp),%rax
movsd  0x28(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x158(%rbp),%rax
movsd  0x30(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x158(%rbp),%rax
movsd  0x38(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invertMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x298,%rsp
mov    %rdi,0x238(%rsp)
lea    0xb0(%rsp),%rdi
lea    0xf0(%rsp),%r12
cvtps2pd (%rsi),%xmm9
movapd %xmm9,0x30(%rsp)
cvtps2pd 0x8(%rsi),%xmm0
movaps %xmm0,0x40(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x50(%rsp)
xorps  %xmm0,%xmm0
movups %xmm0,0x58(%rsp)
movq   $0x0,0x68(%rsp)
cvtps2pd 0x10(%rsi),%xmm10
movapd %xmm10,0x70(%rsp)
cvtps2pd 0x18(%rsi),%xmm1
movaps %xmm1,0x80(%rsp)
xorps  %xmm1,%xmm1
movhps 0x1e71(%rip),%xmm1
movaps %xmm1,0x90(%rsp)
movsd  0x1e61(%rip),%xmm1
movaps %xmm0,0xa0(%rsp)
cvtps2pd 0x20(%rsi),%xmm13
movapd %xmm13,0xb0(%rsp)
cvtps2pd 0x28(%rsi),%xmm2
movaps %xmm2,0xc0(%rsp)
movaps %xmm1,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
cvtps2pd 0x30(%rsi),%xmm14
movapd %xmm14,0xf0(%rsp)
cvtps2pd 0x38(%rsi),%xmm1
movaps %xmm1,0x100(%rsp)
mov    %rax,0x128(%rsp)
movapd 0x1e13(%rip),%xmm1
andpd  %xmm1,%xmm14
andpd  %xmm1,%xmm13
xor    %ebp,%ebp
ucomisd %xmm13,%xmm14
seta   %bpl
mov    %rdi,%rsi
cmova  %r12,%rsi
shl    $0x6,%rbp
movaps %xmm0,0x110(%rsp)
movq   $0x0,0x120(%rsp)
movsd  0xb0(%rsp,%rbp,1),%xmm11
or     $0x80,%rbp
andpd  %xmm1,%xmm11
andpd  %xmm1,%xmm10
ucomisd %xmm10,%xmm11
mov    $0x40,%eax
mov    %rbp,%r13
cmova  %rax,%r13
lea    0x70(%rsp),%rcx
mov    %rsi,%rdx
cmova  %rcx,%rdx
mov    %rdx,0x1b8(%rsp)
cmovbe %rax,%rbp
cmovbe %rcx,%rsi
movsd  0x30(%rsp,%rbp,1),%xmm12
andpd  %xmm1,%xmm12
andpd  %xmm1,%xmm9
xor    %eax,%eax
ucomisd %xmm9,%xmm12
mov    %rbp,%r14
cmova  %rax,%r14
lea    0x108(%rsp),%rcx
cmovbe %rax,%rbp
lea    0x30(%rsp),%rax
cmova  %rax,%rsi
mov    %rsi,0x138(%rsp)
movsd  0x30(%rsp,%rbp,1),%xmm3
xorpd  %xmm7,%xmm7
ucomisd %xmm7,%xmm3
movapd %xmm13,0x140(%rsp)
movapd %xmm14,0x150(%rsp)
movapd %xmm9,0x1d0(%rsp)
movapd %xmm10,0x1c0(%rsp)
movapd %xmm11,0x1a0(%rsp)
movapd %xmm12,0x280(%rsp)
jne    135e <invertMatrix+0x24e>
jp     135e <invertMatrix+0x24e>
mov    %rdi,%r15
xor    %edi,%edi
xor    %eax,%eax
mov    %rcx,%rbx
call   1030 <assert@plt>
mov    %r15,%rdi
xorpd  %xmm7,%xmm7
movapd 0x280(%rsp),%xmm12
movapd 0x1a0(%rsp),%xmm11
movapd 0x1c0(%rsp),%xmm10
movapd 0x1d0(%rsp),%xmm9
movapd 0x150(%rsp),%xmm14
movapd 0x140(%rsp),%xmm13
mov    %rbx,%rcx
movsd  0x30(%rsp,%rbp,1),%xmm3
mov    %rbp,0x230(%rsp)
xor    %r9d,%r9d
xor    %r15d,%r15d
ucomisd %xmm13,%xmm14
seta   %r9b
setbe  %r15b
cmova  %rdi,%r12
lea    0xf8(%rsp),%rdx
lea    0xb8(%rsp),%rax
cmova  %rax,%rdx
mov    %rdx,0x130(%rsp)
lea    0x100(%rsp),%rdx
lea    0xc0(%rsp),%rax
cmova  %rax,%rdx
mov    %rdx,0x8(%rsp)
lea    0xc8(%rsp),%rax
cmova  %rax,%rcx
mov    %rcx,0x28(%rsp)
shl    $0x6,%r9
lea    0x88(%r9),%rsi
shl    $0x6,%r15
lea    0x90(%r9),%rdx
lea    0x98(%r9),%r11
or     $0xa0,%r9
ucomisd %xmm10,%xmm11
mov    $0x48,%r10d
cmova  %rsi,%r10
mov    $0x48,%eax
cmova  %rax,%rsi
mov    $0x50,%ebx
cmova  %rdx,%rbx
mov    $0x50,%eax
cmova  %rax,%rdx
mov    $0x58,%ecx
cmova  %r11,%rcx
mov    $0x58,%eax
cmova  %rax,%r11
mov    $0x60,%r8d
cmova  %r9,%r8
ucomisd %xmm9,%xmm12
mov    $0x8,%edi
cmova  %r10,%rdi
mov    $0x8,%ebp
cmova  %rbp,%r10
movsd  0x30(%rsp,%r14,1),%xmm1
mov    %rsi,%r14
movsd  0x30(%rsp,%r13,1),%xmm2
movsd  (%r12),%xmm0
mov    $0x10,%ebp
mov    $0x10,%eax
cmova  %rbx,%rax
cmova  %rbp,%rbx
mov    $0x18,%esi
cmova  %rcx,%rsi
mov    $0x18,%ebp
cmova  %rbp,%rcx
mov    %rdi,0x228(%rsp)
movsd  0x30(%rsp,%rdi,1),%xmm6
movapd 0x1b8b(%rip),%xmm5
xorpd  %xmm5,%xmm1
divsd  %xmm3,%xmm1
movapd %xmm1,%xmm4
mulsd  %xmm6,%xmm4
addsd  0x30(%rsp,%r10,1),%xmm4
movsd  %xmm4,0x30(%rsp,%r10,1)
xorpd  %xmm5,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm6,%xmm4
addsd  0x30(%rsp,%r14,1),%xmm4
movsd  %xmm4,0x30(%rsp,%r14,1)
xorpd  %xmm5,%xmm0
divsd  %xmm3,%xmm0
mulsd  %xmm0,%xmm6
addsd  0xb8(%rsp,%r15,1),%xmm6
movsd  %xmm6,0xb8(%rsp,%r15,1)
mov    %rax,0x218(%rsp)
movsd  0x30(%rsp,%rax,1),%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%rbx,1),%xmm4
movsd  %xmm4,0x30(%rsp,%rbx,1)
movapd %xmm2,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%rdx,1),%xmm4
movsd  %xmm4,0x30(%rsp,%rdx,1)
mov    $0x60,%edx
mulsd  %xmm0,%xmm3
addsd  0xc0(%rsp,%r15,1),%xmm3
movsd  %xmm3,0xc0(%rsp,%r15,1)
mov    %rsi,0x208(%rsp)
movsd  0x30(%rsp,%rsi,1),%xmm3
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%rcx,1),%xmm4
movsd  %xmm4,0x30(%rsp,%rcx,1)
movapd %xmm2,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%r11,1),%xmm4
movsd  %xmm4,0x30(%rsp,%r11,1)
mulsd  %xmm0,%xmm3
addsd  0xc8(%rsp,%r15,1),%xmm3
movsd  %xmm3,0xc8(%rsp,%r15,1)
mov    $0x20,%edi
cmova  %r8,%rdi
mov    $0x20,%ecx
mov    %rdi,0x220(%rsp)
movsd  0x30(%rsp,%rdi,1),%xmm3
ucomisd %xmm7,%xmm3
lea    0x30(%rsp),%rbp
jne    15bd <invertMatrix+0x4ad>
jnp    1620 <invertMatrix+0x510>
xor    %edi,%edi
ucomisd %xmm13,%xmm14
setbe  %dil
ucomisd %xmm9,%xmm12
cmova  %rcx,%r8
ucomisd %xmm10,%xmm11
movapd %xmm1,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%r8,1),%xmm4
movsd  %xmm4,0x30(%rsp,%r8,1)
cmova  %rdx,%r9
movapd %xmm2,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%r9,1),%xmm4
movsd  %xmm4,0x30(%rsp,%r9,1)
shl    $0x6,%rdi
mulsd  %xmm0,%xmm3
addsd  0xa0(%rdi,%rbp,1),%xmm3
movsd  %xmm3,0xa0(%rdi,%rbp,1)
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %al
shl    $0x6,%rax
or     $0xa8,%rax
ucomisd %xmm10,%xmm11
mov    $0x68,%edx
cmova  %rax,%rdx
mov    $0x68,%ecx
ucomisd %xmm9,%xmm12
mov    $0x28,%esi
mov    $0x28,%edi
cmova  %rdx,%rdi
mov    %rdi,0x210(%rsp)
movsd  0x30(%rsp,%rdi,1),%xmm4
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm4
jne    1674 <invertMatrix+0x564>
jnp    16d3 <invertMatrix+0x5c3>
xor    %edi,%edi
ucomisd %xmm13,%xmm14
setbe  %dil
ucomisd %xmm9,%xmm12
cmova  %rsi,%rdx
ucomisd %xmm10,%xmm11
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
addsd  0x30(%rsp,%rdx,1),%xmm5
movsd  %xmm5,0x30(%rsp,%rdx,1)
cmova  %rcx,%rax
movapd %xmm2,%xmm5
mulsd  %xmm4,%xmm5
addsd  0x30(%rsp,%rax,1),%xmm5
movsd  %xmm5,0x30(%rsp,%rax,1)
shl    $0x6,%rdi
mulsd  %xmm0,%xmm4
addsd  0xa8(%rdi,%rbp,1),%xmm4
movsd  %xmm4,0xa8(%rdi,%rbp,1)
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %al
shl    $0x6,%rax
or     $0xb0,%rax
ucomisd %xmm10,%xmm11
mov    $0x70,%edx
cmova  %rax,%rdx
mov    $0x70,%ecx
ucomisd %xmm9,%xmm12
mov    $0x30,%edi
cmova  %rdx,%rdi
mov    $0x30,%esi
mov    %rdi,0x200(%rsp)
movsd  0x30(%rsp,%rdi,1),%xmm4
ucomisd %xmm3,%xmm4
jne    1723 <invertMatrix+0x613>
jnp    1782 <invertMatrix+0x672>
xor    %edi,%edi
ucomisd %xmm13,%xmm14
setbe  %dil
ucomisd %xmm9,%xmm12
cmova  %rsi,%rdx
ucomisd %xmm10,%xmm11
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm3
addsd  0x30(%rsp,%rdx,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rdx,1)
cmova  %rcx,%rax
movapd %xmm2,%xmm3
mulsd  %xmm4,%xmm3
addsd  0x30(%rsp,%rax,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rax,1)
shl    $0x6,%rdi
mulsd  %xmm0,%xmm4
addsd  0xb0(%rdi,%rbp,1),%xmm4
movsd  %xmm4,0xb0(%rdi,%rbp,1)
lea    0x88(%r15),%rbx
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %al
shl    $0x6,%rax
or     $0xb8,%rax
ucomisd %xmm10,%xmm11
mov    $0x78,%edx
cmova  %rax,%rdx
mov    $0x78,%ecx
ucomisd %xmm9,%xmm12
mov    $0x38,%esi
mov    $0x38,%edi
cmova  %rdx,%rdi
mov    %rdi,0x1f8(%rsp)
movsd  0x30(%rsp,%rdi,1),%xmm4
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm4
jne    17dd <invertMatrix+0x6cd>
jnp    1834 <invertMatrix+0x724>
xor    %edi,%edi
ucomisd %xmm13,%xmm14
setbe  %dil
ucomisd %xmm9,%xmm12
cmova  %rsi,%rdx
ucomisd %xmm10,%xmm11
mulsd  %xmm4,%xmm1
addsd  0x30(%rsp,%rdx,1),%xmm1
movsd  %xmm1,0x30(%rsp,%rdx,1)
cmova  %rcx,%rax
mulsd  %xmm4,%xmm2
addsd  0x30(%rsp,%rax,1),%xmm2
movsd  %xmm2,0x30(%rsp,%rax,1)
shl    $0x6,%rdi
mulsd  %xmm4,%xmm0
addsd  0xb8(%rdi,%rbp,1),%xmm0
movsd  %xmm0,0xb8(%rdi,%rbp,1)
lea    0x90(%r15),%rax
mov    %rax,0x20(%rsp)
or     $0x98,%r15
mov    %r15,0x198(%rsp)
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %al
lea    0xb8(%rsp),%rdi
lea    0xf8(%rsp),%rcx
cmova  %rcx,%rdi
shl    $0x6,%rax
or     $0x88,%rax
ucomisd %xmm10,%xmm11
mov    $0x48,%ebp
mov    %rax,%rcx
cmova  %rbp,%rcx
lea    0x78(%rsp),%rdx
mov    %rdi,%rsi
cmova  %rdx,%rsi
cmovbe %rbp,%rax
movapd 0x1770(%rip),%xmm0
andpd  %xmm0,%xmm6
cmovbe %rdx,%rdi
movsd  0x30(%rsp,%r14,1),%xmm7
andpd  %xmm0,%xmm7
ucomisd %xmm7,%xmm6
mov    %rcx,0x180(%rsp)
mov    %rbx,0x10(%rsp)
cmova  %rbx,%rcx
mov    %rcx,0x190(%rsp)
cmova  0x130(%rsp),%rsi
ucomisd %xmm9,%xmm12
movsd  (%rsi),%xmm15
andpd  %xmm0,%xmm15
mov    $0x8,%ecx
cmovbe %rax,%rcx
mov    %rcx,0x188(%rsp)
lea    0x38(%rsp),%rbx
cmovbe %rdi,%rbx
movsd  0x30(%rsp,%r10,1),%xmm5
andpd  %xmm0,%xmm5
ucomisd %xmm5,%xmm15
lea    0xd0(%rsp),%r12
cmova  %rsi,%rbx
lea    0x110(%rsp),%r15
movsd  (%rbx),%xmm2
ucomisd %xmm3,%xmm2
movapd %xmm6,0x270(%rsp)
movapd %xmm15,0x260(%rsp)
movapd %xmm7,0x250(%rsp)
movapd %xmm5,0x240(%rsp)
jne    19c5 <invertMatrix+0x8b5>
jp     19c5 <invertMatrix+0x8b5>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <assert@plt>
movapd 0x240(%rsp),%xmm5
movapd 0x250(%rsp),%xmm7
movapd 0x260(%rsp),%xmm15
movapd 0x270(%rsp),%xmm6
movapd 0x280(%rsp),%xmm12
movapd 0x1a0(%rsp),%xmm11
movapd 0x1c0(%rsp),%xmm10
movapd 0x1d0(%rsp),%xmm9
movapd 0x150(%rsp),%xmm14
movapd 0x140(%rsp),%xmm13
movsd  (%rbx),%xmm2
mov    %rbx,0x1f0(%rsp)
xor    %edx,%edx
xor    %esi,%esi
ucomisd %xmm13,%xmm14
seta   %dl
setbe  %sil
lea    0xc0(%rsp),%rax
lea    0x100(%rsp),%rcx
cmova  %rcx,%rax
lea    0xc8(%rsp),%r14
lea    0x108(%rsp),%rcx
cmova  %rcx,%r14
mov    %r15,%rcx
cmova  %r12,%rcx
mov    %rcx,0x130(%rsp)
mov    %r12,%r11
cmova  %r15,%r11
shl    $0x6,%rdx
lea    0x90(%rdx),%rdi
shl    $0x6,%rsi
or     $0xa0,%rsi
lea    0x98(%rdx),%r9
or     $0xa0,%rdx
ucomisd %xmm10,%xmm11
mov    $0x50,%r8d
mov    %rdi,%r13
cmova  %r8,%r13
cmova  %rdi,%r8
lea    0x80(%rsp),%rdi
mov    %rax,%rcx
cmova  %rdi,%rcx
cmovbe %rdi,%rax
mov    $0x58,%r12d
mov    %r9,%rdi
cmova  %r12,%rdi
cmova  %r9,%r12
lea    0x88(%rsp),%r9
mov    %r14,%r15
cmova  %r9,%r15
cmovbe %r9,%r14
mov    $0x60,%r9d
mov    %rdx,%r10
cmova  %r9,%r10
cmovbe %r9,%rdx
lea    0x90(%rsp),%r9
mov    %r11,%rbx
cmova  %r9,%rbx
cmovbe %r9,%r11
ucomisd %xmm7,%xmm6
mov    0x10(%rsp),%rbp
cmova  0x180(%rsp),%rbp
mov    %rbp,0x10(%rsp)
mov    %r13,%rbp
mov    0x20(%rsp),%r9
cmova  %r9,%rbp
mov    %rbp,0x170(%rsp)
cmovbe %r9,%r13
mov    %r13,0x20(%rsp)
mov    %rcx,%r9
mov    0x8(%rsp),%r13
cmova  %r13,%r9
cmovbe %r13,%rcx
mov    %rcx,0x8(%rsp)
mov    %rdi,%rbp
mov    0x198(%rsp),%rcx
cmova  %rcx,%rbp
mov    %rbp,0x178(%rsp)
cmovbe %rcx,%rdi
mov    %r15,%r13
mov    0x28(%rsp),%rcx
cmova  %rcx,%r13
cmovbe %rcx,%r15
mov    %r15,0x180(%rsp)
mov    %r10,0x168(%rsp)
mov    %r10,%rcx
mov    %rsi,%r10
cmova  %rsi,%rcx
mov    %rbx,0x1e8(%rsp)
cmova  0x130(%rsp),%rbx
mov    %rbx,0x28(%rsp)
ucomisd %xmm9,%xmm12
mov    $0x10,%ebx
cmovbe %r8,%rbx
lea    0x40(%rsp),%r8
cmovbe %rax,%r8
mov    $0x18,%eax
cmovbe %r12,%rax
lea    0x48(%rsp),%r12
cmovbe %r14,%r12
mov    $0x20,%r15d
cmovbe %rdx,%r15
lea    0x50(%rsp),%rdx
cmovbe %r11,%rdx
ucomisd %xmm5,%xmm15
mov    0x190(%rsp),%rbp
cmova  0x188(%rsp),%rbp
cmova  %r9,%r8
cmovbe 0x170(%rsp),%rbx
movsd  0x30(%rsp,%rbp,1),%xmm0
cmova  %r13,%r12
mov    0x10(%rsp),%rsi
movsd  0x30(%rsp,%rsi,1),%xmm1
cmovbe 0x178(%rsp),%rax
mov    %r8,0x198(%rsp)
movsd  (%r8),%xmm8
mov    %rbx,%r11
movapd 0x1437(%rip),%xmm4
xorpd  %xmm4,%xmm0
divsd  %xmm2,%xmm0
movapd %xmm0,%xmm3
mulsd  %xmm8,%xmm3
addsd  0x30(%rsp,%rbx,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rbx,1)
xorpd  %xmm4,%xmm1
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm8
mov    0x20(%rsp),%rsi
addsd  0x30(%rsp,%rsi,1),%xmm8
movapd %xmm8,0x10(%rsp)
movsd  %xmm8,0x30(%rsp,%rsi,1)
mov    %r12,0x20(%rsp)
movsd  (%r12),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
addsd  0x30(%rsp,%rax,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rax,1)
mulsd  %xmm1,%xmm2
addsd  0x30(%rsp,%rdi,1),%xmm2
movsd  %xmm2,0x30(%rsp,%rdi,1)
lea    0xd8(%rsp),%rsi
cmova  0x28(%rsp),%rdx
lea    0x118(%rsp),%rdi
mov    %rdx,0x28(%rsp)
movsd  (%rdx),%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm3
jne    1c87 <invertMatrix+0xb77>
jnp    1cc3 <invertMatrix+0xbb3>
ucomisd %xmm5,%xmm15
cmova  %r15,%rcx
ucomisd %xmm7,%xmm6
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%rcx,1),%xmm4
movsd  %xmm4,0x30(%rsp,%rcx,1)
cmova  0x168(%rsp),%r10
mulsd  %xmm1,%xmm3
addsd  0x30(%rsp,%r10,1),%xmm3
movsd  %xmm3,0x30(%rsp,%r10,1)
xor    %ecx,%ecx
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %cl
mov    %rdi,%rbp
cmova  %rsi,%rbp
cmova  %rdi,%rsi
setbe  %al
shl    $0x6,%rax
or     $0xa8,%rax
shl    $0x6,%rcx
or     $0xa8,%rcx
ucomisd %xmm10,%xmm11
mov    $0x68,%edi
mov    %rcx,%rdx
cmova  %rdi,%rdx
lea    0x98(%rsp),%rbx
mov    %rsi,%r10
cmova  %rbx,%r10
cmovbe %rdi,%rcx
cmovbe %rbx,%rsi
ucomisd %xmm7,%xmm6
mov    %rdx,%rdi
cmova  %rax,%rdi
mov    %r10,%rbx
mov    %rbp,0x178(%rsp)
cmova  %rbp,%rbx
ucomisd %xmm9,%xmm12
mov    $0x28,%ebp
cmovbe %rcx,%rbp
lea    0x58(%rsp),%rcx
cmovbe %rsi,%rcx
ucomisd %xmm5,%xmm15
lea    0xe0(%rsp),%rsi
cmova  %rbx,%rcx
lea    0x120(%rsp),%rbx
mov    %rcx,0x190(%rsp)
movsd  (%rcx),%xmm3
ucomisd %xmm2,%xmm3
jne    1d78 <invertMatrix+0xc68>
jnp    1dad <invertMatrix+0xc9d>
ucomisd %xmm5,%xmm15
cmova  %rbp,%rdi
ucomisd %xmm7,%xmm6
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
addsd  0x30(%rsp,%rdi,1),%xmm2
movsd  %xmm2,0x30(%rsp,%rdi,1)
cmova  %rdx,%rax
mulsd  %xmm1,%xmm3
addsd  0x30(%rsp,%rax,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rax,1)
xor    %ecx,%ecx
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %cl
mov    %rbx,%rbp
cmova  %rsi,%rbp
cmova  %rbx,%rsi
setbe  %al
shl    $0x6,%rax
or     $0xb0,%rax
shl    $0x6,%rcx
or     $0xb0,%rcx
ucomisd %xmm10,%xmm11
mov    $0x70,%edi
mov    %rcx,%rdx
cmova  %rdi,%rdx
lea    0xa0(%rsp),%rbx
mov    %rsi,%r8
cmova  %rbx,%r8
cmovbe %rdi,%rcx
cmovbe %rbx,%rsi
ucomisd %xmm7,%xmm6
mov    %rdx,%rdi
cmova  %rax,%rdi
mov    %r8,%rbx
mov    %rbp,0x170(%rsp)
cmova  %rbp,%rbx
ucomisd %xmm9,%xmm12
mov    $0x30,%ebp
cmovbe %rcx,%rbp
lea    0x60(%rsp),%rcx
cmovbe %rsi,%rcx
lea    0xe8(%rsp),%rsi
ucomisd %xmm5,%xmm15
lea    0x128(%rsp),%r14
cmova  %rbx,%rcx
mov    %rcx,0x188(%rsp)
movsd  (%rcx),%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm3
mov    0x1b8(%rsp),%r9
lea    0xd0(%rsp),%r15
jne    1e76 <invertMatrix+0xd66>
jnp    1eab <invertMatrix+0xd9b>
ucomisd %xmm5,%xmm15
cmova  %rbp,%rdi
ucomisd %xmm7,%xmm6
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30(%rsp,%rdi,1),%xmm4
movsd  %xmm4,0x30(%rsp,%rdi,1)
cmova  %rdx,%rax
mulsd  %xmm1,%xmm3
addsd  0x30(%rsp,%rax,1),%xmm3
movsd  %xmm3,0x30(%rsp,%rax,1)
xor    %ecx,%ecx
xor    %eax,%eax
ucomisd %xmm13,%xmm14
seta   %cl
mov    %r14,%rbp
cmova  %rsi,%rbp
mov    %rsi,%rdx
cmova  %r14,%rdx
setbe  %al
shl    $0x6,%rax
or     $0xb8,%rax
shl    $0x6,%rcx
or     $0xb8,%rcx
ucomisd %xmm10,%xmm11
mov    $0x78,%edi
mov    %rcx,%r14
cmova  %rdi,%r14
lea    0xa8(%rsp),%rbx
mov    %rdx,%rsi
cmova  %rbx,%rsi
cmovbe %rdi,%rcx
cmovbe %rbx,%rdx
ucomisd %xmm7,%xmm6
mov    %r14,%rdi
cmova  %rax,%rdi
mov    %rsi,0x168(%rsp)
mov    %rsi,%rbx
mov    %rbp,0x1c0(%rsp)
cmova  %rbp,%rbx
ucomisd %xmm9,%xmm12
mov    $0x38,%ebp
cmovbe %rcx,%rbp
lea    0x68(%rsp),%rcx
cmovbe %rdx,%rcx
ucomisd %xmm5,%xmm15
cmova  %rbx,%rcx
mov    %rcx,0x1d0(%rsp)
movsd  (%rcx),%xmm3
ucomisd %xmm2,%xmm3
jne    1f5b <invertMatrix+0xe4b>
jnp    1f8c <invertMatrix+0xe7c>
ucomisd %xmm5,%xmm15
cmova  %rbp,%rdi
ucomisd %xmm7,%xmm6
mulsd  %xmm3,%xmm0
addsd  0x30(%rsp,%rdi,1),%xmm0
movsd  %xmm0,0x30(%rsp,%rdi,1)
cmova  %r14,%rax
mulsd  %xmm3,%xmm1
addsd  0x30(%rsp,%rax,1),%xmm1
movsd  %xmm1,0x30(%rsp,%rax,1)
ucomisd %xmm13,%xmm14
lea    0xc0(%rsp),%rax
lea    0x100(%rsp),%rcx
cmova  %rax,%rcx
ucomisd %xmm7,%xmm6
lea    0x10(%r9),%r13
cmova  %rcx,%r13
mov    0x138(%rsp),%rax
add    $0x10,%rax
ucomisd %xmm5,%xmm15
movapd 0x10(%rsp),%xmm1
movapd 0x1040(%rip),%xmm0
andpd  %xmm0,%xmm1
cmova  %rax,%r13
movsd  0x30(%rsp,%r11,1),%xmm2
andpd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
mov    %r13,%rbx
cmova  0x8(%rsp),%rbx
movsd  (%rbx),%xmm0
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jne    207f <invertMatrix+0xf6f>
jp     207f <invertMatrix+0xf6f>
xor    %edi,%edi
xor    %eax,%eax
movapd %xmm1,0x10(%rsp)
mov    %r10,%r14
mov    %r8,%rbp
movapd %xmm2,0x1a0(%rsp)
call   1030 <assert@plt>
movapd 0x1a0(%rsp),%xmm2
xorpd  %xmm8,%xmm8
mov    %rbp,%r8
mov    %r14,%r10
movapd 0x10(%rsp),%xmm1
movapd 0x240(%rsp),%xmm5
movapd 0x250(%rsp),%xmm7
movapd 0x260(%rsp),%xmm15
movapd 0x270(%rsp),%xmm6
movapd 0x150(%rsp),%xmm14
movapd 0x140(%rsp),%xmm13
mov    0x1b8(%rsp),%r9
movsd  (%rbx),%xmm0
mov    %rbx,0x1a0(%rsp)
mov    0x138(%rsp),%rdx
lea    0x18(%rdx),%rax
mov    %rax,0x140(%rsp)
lea    0x20(%rdx),%rax
mov    %rax,0x150(%rsp)
lea    0x28(%rdx),%rax
mov    %rax,0x10(%rsp)
lea    0x30(%rdx),%rsi
add    $0x38,%rdx
ucomisd %xmm13,%xmm14
lea    0x108(%rsp),%rbp
lea    0xc8(%rsp),%rax
cmova  %rax,%rbp
lea    0x110(%rsp),%r14
cmova  %r15,%r14
lea    0x118(%rsp),%r12
lea    0xd8(%rsp),%rax
cmova  %rax,%r12
lea    0x120(%rsp),%r15
lea    0xe0(%rsp),%rax
cmova  %rax,%r15
lea    0x128(%rsp),%r11
lea    0xe8(%rsp),%rax
cmova  %rax,%r11
lea    0x18(%r9),%rdi
lea    0x20(%r9),%rbx
lea    0x28(%r9),%rax
lea    0x30(%r9),%rcx
add    $0x38,%r9
ucomisd %xmm7,%xmm6
cmovbe %rdi,%rbp
mov    0x130(%rsp),%rdi
cmova  0x1e8(%rsp),%rdi
cmovbe %rbx,%r14
mov    0x178(%rsp),%rbx
cmova  %r10,%rbx
cmovbe %rax,%r12
mov    0x170(%rsp),%r10
cmova  %r8,%r10
cmovbe %rcx,%r15
mov    0x1c0(%rsp),%r8
cmova  0x168(%rsp),%r8
cmova  %r11,%r9
ucomisd %xmm5,%xmm15
cmova  0x140(%rsp),%rbp
cmova  0x150(%rsp),%r14
cmova  0x10(%rsp),%r12
cmova  %rsi,%r15
cmova  %rdx,%r9
ucomisd %xmm2,%xmm1
mov    0x8(%rsp),%rax
cmova  %r13,%rax
mov    %rbp,%r11
mov    0x180(%rsp),%rcx
cmova  %rcx,%r11
cmovbe %rcx,%rbp
mov    %r14,%rsi
cmova  %rdi,%rsi
cmovbe %rdi,%r14
mov    %r12,%rdi
cmova  %rbx,%rdi
cmovbe %rbx,%r12
mov    %r15,%rcx
cmova  %r10,%rcx
cmovbe %r10,%r15
mov    %r9,%rdx
cmova  %r8,%rdx
movsd  (%rax),%xmm2
cmovbe %r8,%r9
xorpd  0xe24(%rip),%xmm2
divsd  %xmm0,%xmm2
movsd  (%r11),%xmm5
mulsd  %xmm2,%xmm5
addsd  0x0(%rbp),%xmm5
movsd  %xmm5,0x0(%rbp)
mov    %rsi,%r13
movsd  (%rsi),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%r14),%xmm1
movsd  %xmm1,(%r14)
mov    %rdi,%rsi
movsd  (%rdi),%xmm4
mulsd  %xmm2,%xmm4
addsd  (%r12),%xmm4
movsd  %xmm4,(%r12)
mov    %rcx,0x10(%rsp)
movsd  (%rcx),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r15),%xmm3
mov    %r15,%rcx
movsd  %xmm3,(%r15)
mov    %rdx,0x150(%rsp)
mulsd  (%rdx),%xmm2
addsd  (%r9),%xmm2
movsd  %xmm2,(%r9)
ucomisd %xmm8,%xmm5
mov    %r15,0x140(%rsp)
jne    22ce <invertMatrix+0x11be>
jp     22ce <invertMatrix+0x11be>
xor    %edi,%edi
xor    %eax,%eax
mov    %r9,%rbx
mov    %r12,0x8(%rsp)
mov    %r14,%r15
mov    %rsi,%r14
mov    %r11,%r12
call   1030 <assert@plt>
mov    %r12,%r11
mov    %r14,%rsi
mov    %r15,%r14
mov    0x140(%rsp),%rax
mov    0x8(%rsp),%r12
mov    %rbx,%r9
movsd  0x0(%rbp),%xmm5
movsd  (%r15),%xmm1
movsd  (%r12),%xmm4
mov    %rax,%rcx
movsd  (%rax),%xmm3
movsd  (%rbx),%xmm2
movsd  0xd29(%rip),%xmm8
movapd %xmm8,%xmm6
divsd  %xmm5,%xmm6
mulsd  %xmm6,%xmm1
movsd  %xmm1,(%r14)
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%r12)
mulsd  %xmm6,%xmm3
movsd  %xmm3,(%rcx)
mov    %rcx,%rdx
mulsd  %xmm2,%xmm6
movsd  %xmm6,(%r9)
movsd  (%r11),%xmm3
movapd %xmm8,%xmm2
mov    0x1a0(%rsp),%rax
divsd  (%rax),%xmm2
mov    %r13,%r10
movsd  0x0(%r13),%xmm4
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm4
movsd  %xmm4,0x0(%r13)
mov    %rsi,%r15
movsd  (%rsi),%xmm1
movsd  (%r12),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi)
mov    %r14,%rcx
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm1
movsd  (%rdx),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rax)
mov    0x150(%rsp),%r14
movsd  (%r14),%xmm1
mulsd  (%r9),%xmm3
subsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%r14)
mov    0x20(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x28(%rsp),%rbp
movsd  0x0(%rbp),%xmm2
movsd  (%rcx),%xmm3
mov    %rcx,%rsi
mov    %rcx,0x138(%rsp)
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp)
mov    0x190(%rsp),%rbx
movsd  (%rbx),%xmm2
movsd  (%r12),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx)
mov    0x188(%rsp),%rdi
movsd  (%rdi),%xmm2
movsd  (%rdx),%xmm3
mov    %rdx,%r8
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi)
mulsd  (%r9),%xmm1
mov    0x1d0(%rsp),%rcx
movsd  (%rcx),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx)
mov    0x208(%rsp),%rax
movsd  0x30(%rsp,%rax,1),%xmm5
mov    0x220(%rsp),%r11
movsd  0x30(%rsp,%r11,1),%xmm1
movsd  (%rsi),%xmm2
mulsd  %xmm5,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x30(%rsp,%r11,1)
mov    0x210(%rsp),%rdx
movsd  0x30(%rsp,%rdx,1),%xmm3
movsd  (%r12),%xmm2
mulsd  %xmm5,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,0x30(%rsp,%rdx,1)
mov    0x200(%rsp),%rsi
movsd  0x30(%rsp,%rsi,1),%xmm2
movsd  (%r8),%xmm4
mulsd  %xmm5,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,0x30(%rsp,%rsi,1)
mov    0x1f8(%rsp),%r8
movsd  0x30(%rsp,%r8,1),%xmm4
mulsd  (%r9),%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,0x30(%rsp,%r8,1)
mov    0x198(%rsp),%rax
movsd  (%rax),%xmm6
movapd %xmm8,%xmm5
mov    0x1f0(%rsp),%rax
divsd  (%rax),%xmm5
movsd  0x0(%rbp),%xmm7
movsd  0x0(%r13),%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm0,%xmm7
mulsd  %xmm5,%xmm7
movsd  %xmm7,0x0(%rbp)
movsd  (%rbx),%xmm0
movsd  (%r15),%xmm7
mulsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rbx)
movsd  (%rdi),%xmm0
mov    0x10(%rsp),%r13
movsd  0x0(%r13),%xmm7
mulsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rdi)
movsd  (%rcx),%xmm0
mulsd  (%r14),%xmm6
subsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx)
mov    0x218(%rsp),%rax
movsd  0x30(%rsp,%rax,1),%xmm0
movsd  (%r10),%xmm5
mulsd  %xmm0,%xmm5
subsd  %xmm5,%xmm1
movsd  %xmm1,0x30(%rsp,%r11,1)
movsd  (%r15),%xmm5
mulsd  %xmm0,%xmm5
subsd  %xmm5,%xmm3
movsd  %xmm3,0x30(%rsp,%rdx,1)
movsd  0x0(%r13),%xmm5
mulsd  %xmm0,%xmm5
subsd  %xmm5,%xmm2
movsd  %xmm2,0x30(%rsp,%rsi,1)
mov    0x230(%rsp),%rax
divsd  0x30(%rsp,%rax,1),%xmm8
mulsd  (%r14),%xmm0
mov    0x228(%rsp),%rax
movsd  0x30(%rsp,%rax,1),%xmm5
movsd  (%rdi),%xmm6
movhpd (%rcx),%xmm6
subsd  %xmm0,%xmm4
movsd  0x0(%rbp),%xmm0
movhpd (%rbx),%xmm0
unpcklpd %xmm5,%xmm5
unpcklpd %xmm4,%xmm2
unpcklpd %xmm3,%xmm1
mulpd  %xmm5,%xmm0
subpd  %xmm0,%xmm1
mulpd  %xmm6,%xmm5
subpd  %xmm5,%xmm2
unpcklpd %xmm8,%xmm8
mulpd  %xmm8,%xmm2
mulpd  %xmm1,%xmm8
movlpd %xmm8,0x30(%rsp,%r11,1)
movhpd %xmm8,0x30(%rsp,%rdx,1)
movlpd %xmm2,0x30(%rsp,%rsi,1)
movhpd %xmm2,0x30(%rsp,%r8,1)
cvtpd2ps %xmm8,%xmm0
cvtpd2ps %xmm2,%xmm1
unpcklpd %xmm1,%xmm0
mov    0x238(%rsp),%rax
movupd %xmm0,(%rax)
movsd  0x0(%rbp),%xmm0
movhpd (%rbx),%xmm0
movsd  (%rdi),%xmm1
movhpd (%rcx),%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%rax)
movsd  (%r10),%xmm0
movhpd (%r15),%xmm0
movsd  0x0(%r13),%xmm1
movhpd (%r14),%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x20(%rax)
mov    0x138(%rsp),%rcx
movsd  (%rcx),%xmm0
movhpd (%r12),%xmm0
mov    0x140(%rsp),%rcx
movsd  (%rcx),%xmm1
movhpd (%r9),%xmm1
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x30(%rax)
add    $0x298,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @invertMatrix(float* nocapture writeonly %0, float* nocapture %1) {
%3 = alloca [4 x [8 x double]]
%4 = bitcast [4 x [8 x double]]* %3 to i8*
%5 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 0
%6 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 0
%7 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 0
%8 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 0
%9 = bitcast float* %1 to <2 x float>*
%10 = load <2 x float>, <2 x float>* %9
%11 = fpext <2 x float> %10 to <2 x double>
%12 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 1
%13 = bitcast [4 x [8 x double]]* %3 to <2 x double>*
store <2 x double> %11, <2 x double>* %13
%14 = getelementptr inbounds float, float* %1, i64 2
%15 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 2
%16 = bitcast float* %14 to <2 x float>*
%17 = load <2 x float>, <2 x float>* %16
%18 = fpext <2 x float> %17 to <2 x double>
%19 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 3
%20 = bitcast double* %15 to <2 x double>*
store <2 x double> %18, <2 x double>* %20
%21 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 4
store double 1.000000e+00, double* %21
%22 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 7
%23 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 6
%24 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 5
%25 = getelementptr inbounds float, float* %1, i64 4
%26 = bitcast double* %24 to i8*
%27 = bitcast float* %25 to <2 x float>*
%28 = load <2 x float>, <2 x float>* %27
%29 = fpext <2 x float> %28 to <2 x double>
%30 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 1
%31 = bitcast double* %6 to <2 x double>*
store <2 x double> %29, <2 x double>* %31
%32 = getelementptr inbounds float, float* %1, i64 6
%33 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 2
%34 = bitcast float* %32 to <2 x float>*
%35 = load <2 x float>, <2 x float>* %34
%36 = fpext <2 x float> %35 to <2 x double>
%37 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 3
%38 = bitcast double* %33 to <2 x double>*
store <2 x double> %36, <2 x double>* %38
%39 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 5
%40 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 7
%41 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 6
%42 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 4
%43 = bitcast double* %42 to <2 x double>*
store <2 x double> <double 0.000000e+00, double 1.000000e+00>, <2 x double>* %43
%44 = getelementptr inbounds float, float* %1, i64 8
%45 = bitcast double* %41 to i8*
%46 = bitcast float* %44 to <2 x float>*
%47 = load <2 x float>, <2 x float>* %46
%48 = fpext <2 x float> %47 to <2 x double>
%49 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 1
%50 = bitcast double* %7 to <2 x double>*
store <2 x double> %48, <2 x double>* %50
%51 = getelementptr inbounds float, float* %1, i64 10
%52 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 2
%53 = bitcast float* %51 to <2 x float>*
%54 = load <2 x float>, <2 x float>* %53
%55 = fpext <2 x float> %54 to <2 x double>
%56 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 3
%57 = bitcast double* %52 to <2 x double>*
store <2 x double> %55, <2 x double>* %57
%58 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 6
%59 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 7
%60 = bitcast double* %58 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 0.000000e+00>, <2 x double>* %60
%61 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 5
%62 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 4
%63 = getelementptr inbounds float, float* %1, i64 12
%64 = bitcast double* %62 to i8*
%65 = bitcast float* %63 to <2 x float>*
%66 = load <2 x float>, <2 x float>* %65
%67 = fpext <2 x float> %66 to <2 x double>
%68 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 1
%69 = bitcast double* %8 to <2 x double>*
store <2 x double> %67, <2 x double>* %69
%70 = getelementptr inbounds float, float* %1, i64 14
%71 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 2
%72 = bitcast float* %70 to <2 x float>*
%73 = load <2 x float>, <2 x float>* %72
%74 = fpext <2 x float> %73 to <2 x double>
%75 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 3
%76 = bitcast double* %71 to <2 x double>*
store <2 x double> %74, <2 x double>* %76
%77 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 7
store double 1.000000e+00, double* %77
%78 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 6
%79 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 5
%80 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 4
%81 = extractelement <2 x double> %67, i64 0
%82 = tail call double @llvm.fabs.f64(double %81)
%83 = extractelement <2 x double> %48, i64 0
%84 = tail call double @llvm.fabs.f64(double %83)
%85 = fcmp ogt double %82, %84
%86 = select i1 %85, double* %8, double* %7
%87 = bitcast double* %80 to i8*
%88 = load double, double* %86
%89 = tail call double @llvm.fabs.f64(double %88)
%90 = extractelement <2 x double> %29, i64 0
%91 = tail call double @llvm.fabs.f64(double %90)
%92 = fcmp ogt double %89, %91
%93 = select i1 %92, double* %6, double* %86
%94 = select i1 %92, double* %86, double* %6
%95 = load double, double* %94
%96 = tail call double @llvm.fabs.f64(double %95)
%97 = extractelement <2 x double> %11, i64 0
%98 = tail call double @llvm.fabs.f64(double %97)
%99 = fcmp ogt double %96, %98
%100 = select i1 %99, double* %5, double* %94
%101 = select i1 %99, double* %94, double* %5
%102 = load double, double* %101
%103 = fcmp oeq double %102, 0.000000e+00
br i1 %103, label %104, label %107
104: ; preds = %2
%105 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 0)
%106 = load double, double* %101
br label %107
107: ; preds = %104, %2
%108 = phi double [ %106, %104 ], [ %102, %2 ]
%109 = load double, double* %100
%110 = load double, double* %93
%111 = load double, double* %7
%112 = load double, double* %8
%113 = select i1 %85, double %111, double %112
%114 = select i1 %85, double* %68, double* %49
%115 = select i1 %92, double* %114, double* %30
%116 = select i1 %99, double* %115, double* %12
%117 = load double, double* %116
%118 = select i1 %99, double* %12, double* %115
%119 = load double, double* %118
%120 = fneg double %109
%121 = fdiv double %120, %108
%122 = tail call double @llvm.fmuladd.f64(double %121, double %117, double %119)
store double %122, double* %118
%123 = select i1 %92, double* %30, double* %114
%124 = load double, double* %123
%125 = fneg double %110
%126 = fdiv double %125, %108
%127 = tail call double @llvm.fmuladd.f64(double %126, double %117, double %124)
store double %127, double* %123
%128 = select i1 %85, double* %49, double* %68
%129 = load double, double* %128
%130 = fneg double %113
%131 = fdiv double %130, %108
%132 = tail call double @llvm.fmuladd.f64(double %131, double %117, double %129)
store double %132, double* %128
%133 = select i1 %85, double* %71, double* %52
%134 = select i1 %92, double* %133, double* %33
%135 = select i1 %99, double* %134, double* %15
%136 = load double, double* %135
%137 = select i1 %99, double* %15, double* %134
%138 = load double, double* %137
%139 = tail call double @llvm.fmuladd.f64(double %121, double %136, double %138)
store double %139, double* %137
%140 = select i1 %92, double* %33, double* %133
%141 = load double, double* %140
%142 = tail call double @llvm.fmuladd.f64(double %126, double %136, double %141)
store double %142, double* %140
%143 = select i1 %85, double* %52, double* %71
%144 = load double, double* %143
%145 = tail call double @llvm.fmuladd.f64(double %131, double %136, double %144)
store double %145, double* %143
%146 = select i1 %85, double* %75, double* %56
%147 = select i1 %92, double* %146, double* %37
%148 = select i1 %99, double* %147, double* %19
%149 = load double, double* %148
%150 = select i1 %99, double* %19, double* %147
%151 = load double, double* %150
%152 = tail call double @llvm.fmuladd.f64(double %121, double %149, double %151)
store double %152, double* %150
%153 = select i1 %92, double* %37, double* %146
%154 = load double, double* %153
%155 = tail call double @llvm.fmuladd.f64(double %126, double %149, double %154)
store double %155, double* %153
%156 = select i1 %85, double* %56, double* %75
%157 = load double, double* %156
%158 = tail call double @llvm.fmuladd.f64(double %131, double %149, double %157)
store double %158, double* %156
%159 = select i1 %85, double* %80, double* %62
%160 = select i1 %92, double* %159, double* %42
%161 = select i1 %99, double* %160, double* %21
%162 = load double, double* %161
%163 = fcmp une double %162, 0.000000e+00
br i1 %163, label %164, label %174
164: ; preds = %107
%165 = select i1 %99, double* %21, double* %160
%166 = load double, double* %165
%167 = tail call double @llvm.fmuladd.f64(double %121, double %162, double %166)
store double %167, double* %165
%168 = select i1 %92, double* %42, double* %159
%169 = load double, double* %168
%170 = tail call double @llvm.fmuladd.f64(double %126, double %162, double %169)
store double %170, double* %168
%171 = select i1 %85, double* %62, double* %80
%172 = load double, double* %171
%173 = tail call double @llvm.fmuladd.f64(double %131, double %162, double %172)
store double %173, double* %171
br label %174
174: ; preds = %164, %107
%175 = select i1 %85, double* %79, double* %61
%176 = select i1 %92, double* %175, double* %39
%177 = select i1 %99, double* %176, double* %24
%178 = load double, double* %177
%179 = fcmp une double %178, 0.000000e+00
br i1 %179, label %180, label %190
180: ; preds = %174
%181 = select i1 %99, double* %24, double* %176
%182 = load double, double* %181
%183 = tail call double @llvm.fmuladd.f64(double %121, double %178, double %182)
store double %183, double* %181
%184 = select i1 %92, double* %39, double* %175
%185 = load double, double* %184
%186 = tail call double @llvm.fmuladd.f64(double %126, double %178, double %185)
store double %186, double* %184
%187 = select i1 %85, double* %61, double* %79
%188 = load double, double* %187
%189 = tail call double @llvm.fmuladd.f64(double %131, double %178, double %188)
store double %189, double* %187
br label %190
190: ; preds = %180, %174
%191 = select i1 %85, double* %78, double* %58
%192 = select i1 %92, double* %191, double* %41
%193 = select i1 %99, double* %192, double* %23
%194 = load double, double* %193
%195 = fcmp une double %194, 0.000000e+00
br i1 %195, label %196, label %206
196: ; preds = %190
%197 = select i1 %99, double* %23, double* %192
%198 = load double, double* %197
%199 = tail call double @llvm.fmuladd.f64(double %121, double %194, double %198)
store double %199, double* %197
%200 = select i1 %92, double* %41, double* %191
%201 = load double, double* %200
%202 = tail call double @llvm.fmuladd.f64(double %126, double %194, double %201)
store double %202, double* %200
%203 = select i1 %85, double* %58, double* %78
%204 = load double, double* %203
%205 = tail call double @llvm.fmuladd.f64(double %131, double %194, double %204)
store double %205, double* %203
br label %206
206: ; preds = %196, %190
%207 = select i1 %85, double* %77, double* %59
%208 = select i1 %92, double* %207, double* %40
%209 = select i1 %99, double* %208, double* %22
%210 = load double, double* %209
%211 = fcmp une double %210, 0.000000e+00
br i1 %211, label %212, label %222
212: ; preds = %206
%213 = select i1 %99, double* %22, double* %208
%214 = load double, double* %213
%215 = tail call double @llvm.fmuladd.f64(double %121, double %210, double %214)
store double %215, double* %213
%216 = select i1 %92, double* %40, double* %207
%217 = load double, double* %216
%218 = tail call double @llvm.fmuladd.f64(double %126, double %210, double %217)
store double %218, double* %216
%219 = select i1 %85, double* %59, double* %77
%220 = load double, double* %219
%221 = tail call double @llvm.fmuladd.f64(double %131, double %210, double %220)
store double %221, double* %219
br label %222
222: ; preds = %212, %206
%223 = tail call double @llvm.fabs.f64(double %132)
%224 = load double, double* %123
%225 = tail call double @llvm.fabs.f64(double %224)
%226 = fcmp ogt double %223, %225
%227 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 1
%228 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 1
%229 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 1
%230 = select i1 %85, double* %228, double* %229
%231 = select i1 %92, double* %227, double* %230
%232 = select i1 %226, double* %128, double* %231
%233 = load double, double* %232
%234 = tail call double @llvm.fabs.f64(double %233)
%235 = load double, double* %118
%236 = tail call double @llvm.fabs.f64(double %235)
%237 = fcmp ogt double %234, %236
%238 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 1
%239 = select i1 %92, double* %230, double* %227
%240 = select i1 %99, double* %238, double* %239
%241 = select i1 %237, double* %232, double* %240
%242 = load double, double* %241
%243 = fcmp oeq double %242, 0.000000e+00
br i1 %243, label %244, label %247
244: ; preds = %222
%245 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 0)
%246 = load double, double* %241
br label %247
247: ; preds = %244, %222
%248 = phi double [ %246, %244 ], [ %242, %222 ]
%249 = select i1 %237, double* %240, double* %232
%250 = load double, double* %249
%251 = select i1 %226, double* %231, double* %128
%252 = load double, double* %251
%253 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 2
%254 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 2
%255 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 2
%256 = select i1 %85, double* %254, double* %255
%257 = select i1 %92, double* %253, double* %256
%258 = select i1 %226, double* %143, double* %257
%259 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 2
%260 = select i1 %92, double* %256, double* %253
%261 = select i1 %99, double* %259, double* %260
%262 = select i1 %237, double* %258, double* %261
%263 = load double, double* %262
%264 = select i1 %237, double* %261, double* %258
%265 = load double, double* %264
%266 = fneg double %250
%267 = fdiv double %266, %248
%268 = tail call double @llvm.fmuladd.f64(double %267, double %263, double %265)
store double %268, double* %264
%269 = select i1 %226, double* %257, double* %143
%270 = load double, double* %269
%271 = fneg double %252
%272 = fdiv double %271, %248
%273 = tail call double @llvm.fmuladd.f64(double %272, double %263, double %270)
store double %273, double* %269
%274 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 3
%275 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 3
%276 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 3
%277 = select i1 %85, double* %275, double* %276
%278 = select i1 %92, double* %274, double* %277
%279 = select i1 %226, double* %156, double* %278
%280 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 3
%281 = select i1 %92, double* %277, double* %274
%282 = select i1 %99, double* %280, double* %281
%283 = select i1 %237, double* %279, double* %282
%284 = load double, double* %283
%285 = select i1 %237, double* %282, double* %279
%286 = load double, double* %285
%287 = tail call double @llvm.fmuladd.f64(double %267, double %284, double %286)
store double %287, double* %285
%288 = select i1 %226, double* %278, double* %156
%289 = load double, double* %288
%290 = tail call double @llvm.fmuladd.f64(double %272, double %284, double %289)
store double %290, double* %288
%291 = select i1 %85, double* %62, double* %80
%292 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 4
%293 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 4
%294 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 4
%295 = select i1 %85, double* %293, double* %294
%296 = select i1 %92, double* %292, double* %295
%297 = select i1 %226, double* %291, double* %296
%298 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 4
%299 = select i1 %92, double* %295, double* %292
%300 = select i1 %99, double* %298, double* %299
%301 = select i1 %237, double* %297, double* %300
%302 = load double, double* %301
%303 = fcmp une double %302, 0.000000e+00
br i1 %303, label %304, label %311
304: ; preds = %247
%305 = select i1 %237, double* %300, double* %297
%306 = load double, double* %305
%307 = tail call double @llvm.fmuladd.f64(double %267, double %302, double %306)
store double %307, double* %305
%308 = select i1 %226, double* %296, double* %291
%309 = load double, double* %308
%310 = tail call double @llvm.fmuladd.f64(double %272, double %302, double %309)
store double %310, double* %308
br label %311
311: ; preds = %304, %247
%312 = select i1 %85, double* %61, double* %79
%313 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 5
%314 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 5
%315 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 5
%316 = select i1 %85, double* %314, double* %315
%317 = select i1 %92, double* %313, double* %316
%318 = select i1 %226, double* %312, double* %317
%319 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 5
%320 = select i1 %92, double* %316, double* %313
%321 = select i1 %99, double* %319, double* %320
%322 = select i1 %237, double* %318, double* %321
%323 = load double, double* %322
%324 = fcmp une double %323, 0.000000e+00
br i1 %324, label %325, label %332
325: ; preds = %311
%326 = select i1 %237, double* %321, double* %318
%327 = load double, double* %326
%328 = tail call double @llvm.fmuladd.f64(double %267, double %323, double %327)
store double %328, double* %326
%329 = select i1 %226, double* %317, double* %312
%330 = load double, double* %329
%331 = tail call double @llvm.fmuladd.f64(double %272, double %323, double %330)
store double %331, double* %329
br label %332
332: ; preds = %325, %311
%333 = select i1 %85, double* %58, double* %78
%334 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 6
%335 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 6
%336 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 6
%337 = select i1 %85, double* %335, double* %336
%338 = select i1 %92, double* %334, double* %337
%339 = select i1 %226, double* %333, double* %338
%340 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 6
%341 = select i1 %92, double* %337, double* %334
%342 = select i1 %99, double* %340, double* %341
%343 = select i1 %237, double* %339, double* %342
%344 = load double, double* %343
%345 = fcmp une double %344, 0.000000e+00
br i1 %345, label %346, label %353
346: ; preds = %332
%347 = select i1 %237, double* %342, double* %339
%348 = load double, double* %347
%349 = tail call double @llvm.fmuladd.f64(double %267, double %344, double %348)
store double %349, double* %347
%350 = select i1 %226, double* %338, double* %333
%351 = load double, double* %350
%352 = tail call double @llvm.fmuladd.f64(double %272, double %344, double %351)
store double %352, double* %350
br label %353
353: ; preds = %346, %332
%354 = select i1 %85, double* %59, double* %77
%355 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 1, i64 7
%356 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 3, i64 7
%357 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 2, i64 7
%358 = select i1 %85, double* %356, double* %357
%359 = select i1 %92, double* %355, double* %358
%360 = select i1 %226, double* %354, double* %359
%361 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %3, i64 0, i64 0, i64 7
%362 = select i1 %92, double* %358, double* %355
%363 = select i1 %99, double* %361, double* %362
%364 = select i1 %237, double* %360, double* %363
%365 = load double, double* %364
%366 = fcmp une double %365, 0.000000e+00
br i1 %366, label %367, label %374
367: ; preds = %353
%368 = select i1 %237, double* %363, double* %360
%369 = load double, double* %368
%370 = tail call double @llvm.fmuladd.f64(double %267, double %365, double %369)
store double %370, double* %368
%371 = select i1 %226, double* %359, double* %354
%372 = load double, double* %371
%373 = tail call double @llvm.fmuladd.f64(double %272, double %365, double %372)
store double %373, double* %371
br label %374
374: ; preds = %367, %353
%375 = tail call double @llvm.fabs.f64(double %273)
%376 = load double, double* %264
%377 = tail call double @llvm.fabs.f64(double %376)
%378 = fcmp ogt double %375, %377
%379 = getelementptr inbounds double, double* %100, i64 2
%380 = select i1 %85, double* %255, double* %254
%381 = getelementptr inbounds double, double* %93, i64 2
%382 = select i1 %226, double* %380, double* %381
%383 = select i1 %237, double* %379, double* %382
%384 = select i1 %378, double* %269, double* %383
%385 = load double, double* %384
%386 = fcmp oeq double %385, 0.000000e+00
br i1 %386, label %387, label %390
387: ; preds = %374
%388 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 0)
%389 = load double, double* %384
br label %390
390: ; preds = %387, %374
%391 = phi double [ %389, %387 ], [ %385, %374 ]
%392 = select i1 %378, double* %383, double* %269
%393 = load double, double* %392
%394 = getelementptr inbounds double, double* %100, i64 3
%395 = select i1 %85, double* %276, double* %275
%396 = getelementptr inbounds double, double* %93, i64 3
%397 = select i1 %226, double* %395, double* %396
%398 = select i1 %237, double* %394, double* %397
%399 = select i1 %378, double* %288, double* %398
%400 = load double, double* %399
%401 = select i1 %378, double* %398, double* %288
%402 = load double, double* %401
%403 = fneg double %393
%404 = fdiv double %403, %391
%405 = tail call double @llvm.fmuladd.f64(double %404, double %400, double %402)
store double %405, double* %401
%406 = select i1 %226, double* %296, double* %291
%407 = getelementptr inbounds double, double* %100, i64 4
%408 = select i1 %85, double* %294, double* %293
%409 = getelementptr inbounds double, double* %93, i64 4
%410 = select i1 %226, double* %408, double* %409
%411 = select i1 %237, double* %407, double* %410
%412 = select i1 %378, double* %406, double* %411
%413 = load double, double* %412
%414 = select i1 %378, double* %411, double* %406
%415 = load double, double* %414
%416 = tail call double @llvm.fmuladd.f64(double %404, double %413, double %415)
store double %416, double* %414
%417 = select i1 %226, double* %317, double* %312
%418 = getelementptr inbounds double, double* %100, i64 5
%419 = select i1 %85, double* %315, double* %314
%420 = getelementptr inbounds double, double* %93, i64 5
%421 = select i1 %226, double* %419, double* %420
%422 = select i1 %237, double* %418, double* %421
%423 = select i1 %378, double* %417, double* %422
%424 = load double, double* %423
%425 = select i1 %378, double* %422, double* %417
%426 = load double, double* %425
%427 = tail call double @llvm.fmuladd.f64(double %404, double %424, double %426)
store double %427, double* %425
%428 = select i1 %226, double* %338, double* %333
%429 = getelementptr inbounds double, double* %100, i64 6
%430 = select i1 %85, double* %336, double* %335
%431 = getelementptr inbounds double, double* %93, i64 6
%432 = select i1 %226, double* %430, double* %431
%433 = select i1 %237, double* %429, double* %432
%434 = select i1 %378, double* %428, double* %433
%435 = load double, double* %434
%436 = select i1 %378, double* %433, double* %428
%437 = load double, double* %436
%438 = tail call double @llvm.fmuladd.f64(double %404, double %435, double %437)
store double %438, double* %436
%439 = select i1 %226, double* %359, double* %354
%440 = getelementptr inbounds double, double* %100, i64 7
%441 = select i1 %85, double* %357, double* %356
%442 = getelementptr inbounds double, double* %93, i64 7
%443 = select i1 %226, double* %441, double* %442
%444 = select i1 %237, double* %440, double* %443
%445 = select i1 %378, double* %439, double* %444
%446 = load double, double* %445
%447 = select i1 %378, double* %444, double* %439
%448 = load double, double* %447
%449 = tail call double @llvm.fmuladd.f64(double %404, double %446, double %448)
store double %449, double* %447
%450 = fcmp oeq double %405, 0.000000e+00
br i1 %450, label %451, label %458
451: ; preds = %390
%452 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 0)
%453 = load double, double* %401
%454 = load double, double* %414
%455 = load double, double* %425
%456 = load double, double* %436
%457 = load double, double* %447
br label %458
458: ; preds = %451, %390
%459 = phi double [ %457, %451 ], [ %449, %390 ]
%460 = phi double [ %456, %451 ], [ %438, %390 ]
%461 = phi double [ %455, %451 ], [ %427, %390 ]
%462 = phi double [ %454, %451 ], [ %416, %390 ]
%463 = phi double [ %453, %451 ], [ %405, %390 ]
%464 = fdiv double 1.000000e+00, %463
%465 = fmul double %462, %464
store double %465, double* %414
%466 = fmul double %464, %461
store double %466, double* %425
%467 = fmul double %464, %460
store double %467, double* %436
%468 = fmul double %464, %459
store double %468, double* %447
%469 = load double, double* %399
%470 = load double, double* %384
%471 = fdiv double 1.000000e+00, %470
%472 = load double, double* %412
%473 = fneg double %465
%474 = tail call double @llvm.fmuladd.f64(double %473, double %469, double %472)
%475 = fmul double %471, %474
store double %475, double* %412
%476 = load double, double* %423
%477 = load double, double* %425
%478 = fneg double %477
%479 = tail call double @llvm.fmuladd.f64(double %478, double %469, double %476)
%480 = fmul double %471, %479
store double %480, double* %423
%481 = load double, double* %434
%482 = load double, double* %436
%483 = fneg double %482
%484 = tail call double @llvm.fmuladd.f64(double %483, double %469, double %481)
%485 = fmul double %471, %484
store double %485, double* %434
%486 = load double, double* %445
%487 = load double, double* %447
%488 = fneg double %487
%489 = tail call double @llvm.fmuladd.f64(double %488, double %469, double %486)
%490 = fmul double %471, %489
store double %490, double* %445
%491 = load double, double* %283
%492 = load double, double* %414
%493 = load double, double* %301
%494 = fneg double %492
%495 = tail call double @llvm.fmuladd.f64(double %494, double %491, double %493)
store double %495, double* %301
%496 = load double, double* %425
%497 = load double, double* %322
%498 = fneg double %496
%499 = tail call double @llvm.fmuladd.f64(double %498, double %491, double %497)
store double %499, double* %322
%500 = load double, double* %436
%501 = load double, double* %343
%502 = fneg double %500
%503 = tail call double @llvm.fmuladd.f64(double %502, double %491, double %501)
store double %503, double* %343
%504 = load double, double* %447
%505 = load double, double* %364
%506 = fneg double %504
%507 = tail call double @llvm.fmuladd.f64(double %506, double %491, double %505)
store double %507, double* %364
%508 = load double, double* %148
%509 = load double, double* %414
%510 = load double, double* %161
%511 = fneg double %509
%512 = tail call double @llvm.fmuladd.f64(double %511, double %508, double %510)
store double %512, double* %161
%513 = load double, double* %425
%514 = load double, double* %177
%515 = fneg double %513
%516 = tail call double @llvm.fmuladd.f64(double %515, double %508, double %514)
store double %516, double* %177
%517 = load double, double* %436
%518 = load double, double* %193
%519 = fneg double %517
%520 = tail call double @llvm.fmuladd.f64(double %519, double %508, double %518)
store double %520, double* %193
%521 = load double, double* %447
%522 = load double, double* %209
%523 = fneg double %521
%524 = tail call double @llvm.fmuladd.f64(double %523, double %508, double %522)
store double %524, double* %209
%525 = load double, double* %262
%526 = load double, double* %241
%527 = fdiv double 1.000000e+00, %526
%528 = load double, double* %301
%529 = load double, double* %412
%530 = fneg double %529
%531 = tail call double @llvm.fmuladd.f64(double %530, double %525, double %528)
%532 = fmul double %527, %531
store double %532, double* %301
%533 = load double, double* %322
%534 = load double, double* %423
%535 = fneg double %534
%536 = tail call double @llvm.fmuladd.f64(double %535, double %525, double %533)
%537 = fmul double %527, %536
store double %537, double* %322
%538 = load double, double* %343
%539 = load double, double* %434
%540 = fneg double %539
%541 = tail call double @llvm.fmuladd.f64(double %540, double %525, double %538)
%542 = fmul double %527, %541
store double %542, double* %343
%543 = load double, double* %364
%544 = load double, double* %445
%545 = fneg double %544
%546 = tail call double @llvm.fmuladd.f64(double %545, double %525, double %543)
%547 = fmul double %527, %546
store double %547, double* %364
%548 = load double, double* %135
%549 = load double, double* %412
%550 = fneg double %549
%551 = tail call double @llvm.fmuladd.f64(double %550, double %548, double %512)
store double %551, double* %161
%552 = load double, double* %423
%553 = fneg double %552
%554 = tail call double @llvm.fmuladd.f64(double %553, double %548, double %516)
store double %554, double* %177
%555 = load double, double* %434
%556 = fneg double %555
%557 = tail call double @llvm.fmuladd.f64(double %556, double %548, double %520)
store double %557, double* %193
%558 = load double, double* %445
%559 = fneg double %558
%560 = tail call double @llvm.fmuladd.f64(double %559, double %548, double %524)
%561 = load double, double* %116
%562 = load double, double* %101
%563 = fdiv double 1.000000e+00, %562
%564 = load double, double* %301
%565 = load double, double* %322
%566 = load double, double* %343
%567 = load double, double* %364
%568 = insertelement <4 x double> poison, double %564, i64 0
%569 = insertelement <4 x double> %568, double %565, i64 1
%570 = insertelement <4 x double> %569, double %566, i64 2
%571 = insertelement <4 x double> %570, double %567, i64 3
%572 = fneg <4 x double> %571
%573 = insertelement <4 x double> poison, double %561, i64 0
%574 = shufflevector <4 x double> %573, <4 x double> poison, <4 x i32> zeroinitializer
%575 = insertelement <4 x double> poison, double %551, i64 0
%576 = insertelement <4 x double> %575, double %554, i64 1
%577 = insertelement <4 x double> %576, double %557, i64 2
%578 = insertelement <4 x double> %577, double %560, i64 3
%579 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %572, <4 x double> %574, <4 x double> %578)
%580 = insertelement <4 x double> poison, double %563, i64 0
%581 = shufflevector <4 x double> %580, <4 x double> poison, <4 x i32> zeroinitializer
%582 = fmul <4 x double> %581, %579
%583 = extractelement <4 x double> %582, i64 0
store double %583, double* %161
%584 = extractelement <4 x double> %582, i64 1
store double %584, double* %177
%585 = extractelement <4 x double> %582, i64 2
store double %585, double* %193
%586 = extractelement <4 x double> %582, i64 3
store double %586, double* %209
%587 = fptrunc <4 x double> %582 to <4 x float>
%588 = bitcast float* %0 to <4 x float>*
store <4 x float> %587, <4 x float>* %588
%589 = load double, double* %301
%590 = getelementptr inbounds float, float* %0, i64 4
%591 = load double, double* %322
%592 = load double, double* %343
%593 = load double, double* %364
%594 = insertelement <4 x double> poison, double %589, i64 0
%595 = insertelement <4 x double> %594, double %591, i64 1
%596 = insertelement <4 x double> %595, double %592, i64 2
%597 = insertelement <4 x double> %596, double %593, i64 3
%598 = fptrunc <4 x double> %597 to <4 x float>
%599 = bitcast float* %590 to <4 x float>*
store <4 x float> %598, <4 x float>* %599
%600 = load double, double* %412
%601 = getelementptr inbounds float, float* %0, i64 8
%602 = load double, double* %423
%603 = load double, double* %434
%604 = load double, double* %445
%605 = insertelement <4 x double> poison, double %600, i64 0
%606 = insertelement <4 x double> %605, double %602, i64 1
%607 = insertelement <4 x double> %606, double %603, i64 2
%608 = insertelement <4 x double> %607, double %604, i64 3
%609 = fptrunc <4 x double> %608 to <4 x float>
%610 = bitcast float* %601 to <4 x float>*
store <4 x float> %609, <4 x float>* %610
%611 = load double, double* %414
%612 = getelementptr inbounds float, float* %0, i64 12
%613 = load double, double* %425
%614 = load double, double* %436
%615 = load double, double* %447
%616 = insertelement <4 x double> poison, double %611, i64 0
%617 = insertelement <4 x double> %616, double %613, i64 1
%618 = insertelement <4 x double> %617, double %614, i64 2
%619 = insertelement <4 x double> %618, double %615, i64 3
%620 = fptrunc <4 x double> %619 to <4 x float>
%621 = bitcast float* %612 to <4 x float>*
store <4 x float> %620, <4 x float>* %621
ret void
}