void invert4d(float from[4][4], float to[4][4]) {
  float wtemp[4][8];
  register float m0, m1, m2, m3, s;
  register float *r0, *r1, *r2, *r3, *rtemp;
  r0 = wtemp[0];
  r1 = wtemp[1];
  r2 = wtemp[2];
  r3 = wtemp[3];
  r0[0] = from[0][0];
  r0[1] = from[0][1];
  r0[2] = from[0][2];
  r0[3] = from[0][3];
  r0[4] = 1.0;
  r0[5] = 0.0;
  r0[6] = 0.0;
  r0[7] = 0.0;
  r1[0] = from[1][0];
  r1[1] = from[1][1];
  r1[2] = from[1][2];
  r1[3] = from[1][3];
  r1[4] = 0.0;
  r1[5] = 1.0;
  r1[6] = 0.0;
  r1[7] = 0.0;
  r2[0] = from[2][0];
  r2[1] = from[2][1];
  r2[2] = from[2][2];
  r2[3] = from[2][3];
  r2[4] = 0.0;
  r2[5] = 0.0;
  r2[6] = 1.0;
  r2[7] = 0.0;
  r3[0] = from[3][0];
  r3[1] = from[3][1];
  r3[2] = from[3][2];
  r3[3] = from[3][3];
  r3[4] = 0.0;
  r3[5] = 0.0;
  r3[6] = 0.0;
  r3[7] = 1.0;
  if (r0[0] == 0.0) {
    if (r1[0] == 0.0) {
      if (r2[0] == 0.0) {
        if (r3[0] == 0.0)
          goto singular;
        rtemp = r0;
        r0 = r3;
        r3 = rtemp;
      } else {
        rtemp = r0;
        r0 = r2;
        r2 = rtemp;
      }
    } else {
      rtemp = r0;
      r0 = r1;
      r1 = rtemp;
    }
  }
  m1 = r1[0] / r0[0];
  m2 = r2[0] / r0[0];
  m3 = r3[0] / r0[0];
  s = r0[1];
  r1[1] = r1[1] - m1 * s;
  r2[1] = r2[1] - m2 * s;
  r3[1] = r3[1] - m3 * s;
  s = r0[2];
  r1[2] = r1[2] - m1 * s;
  r2[2] = r2[2] - m2 * s;
  r3[2] = r3[2] - m3 * s;
  s = r0[3];
  r1[3] = r1[3] - m1 * s;
  r2[3] = r2[3] - m2 * s;
  r3[3] = r3[3] - m3 * s;
  s = r0[4];
  if (s != 0.0) {
    r1[4] = r1[4] - m1 * s;
    r2[4] = r2[4] - m2 * s;
    r3[4] = r3[4] - m3 * s;
  }
  s = r0[5];
  if (s != 0.0) {
    r1[5] = r1[5] - m1 * s;
    r2[5] = r2[5] - m2 * s;
    r3[5] = r3[5] - m3 * s;
  }
  s = r0[6];
  if (s != 0.0) {
    r1[6] = r1[6] - m1 * s;
    r2[6] = r2[6] - m2 * s;
    r3[6] = r3[6] - m3 * s;
  }
  s = r0[7];
  if (s != 0.0) {
    r1[7] = r1[7] - m1 * s;
    r2[7] = r2[7] - m2 * s;
    r3[7] = r3[7] - m3 * s;
  }
  if (r1[1] == 0.0) {
    if (r2[1] == 0.0) {
      if (r3[1] == 0.0)
        goto singular;
      rtemp = r1;
      r1 = r3;
      r3 = rtemp;
    } else {
      rtemp = r1;
      r1 = r2;
      r2 = rtemp;
    }
  }
  m2 = r2[1] / r1[1];
  m3 = r3[1] / r1[1];
  r2[2] = r2[2] - m2 * r1[2];
  r3[2] = r3[2] - m3 * r1[2];
  r3[3] = r3[3] - m3 * r1[3];
  r2[3] = r2[3] - m2 * r1[3];
  s = r1[4];
  if (s != 0.0) {
    r2[4] = r2[4] - m2 * s;
    r3[4] = r3[4] - m3 * s;
  }
  s = r1[5];
  if (s != 0.0) {
    r2[5] = r2[5] - m2 * s;
    r3[5] = r3[5] - m3 * s;
  }
  s = r1[6];
  if (s != 0.0) {
    r2[6] = r2[6] - m2 * s;
    r3[6] = r3[6] - m3 * s;
  }
  s = r1[7];
  if (s != 0.0) {
    r2[7] = r2[7] - m2 * s;
    r3[7] = r3[7] - m3 * s;
  }
  if (r2[2] == 0.0) {
    if (r3[2] == 0.0)
      goto singular;
    rtemp = r2;
    r2 = r3;
    r3 = rtemp;
  }
  m3 = r3[2] / r2[2];
  r3[3] = r3[3] - m3 * r2[3];
  r3[4] = r3[4] - m3 * r2[4];
  r3[5] = r3[5] - m3 * r2[5];
  r3[6] = r3[6] - m3 * r2[6];
  r3[7] = r3[7] - m3 * r2[7];
  if (r3[3] == 0.0)
    goto singular;
  s = 1.0 / r3[3];
  r3[4] = r3[4] * s;
  r3[5] = r3[5] * s;
  r3[6] = r3[6] * s;
  r3[7] = 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] = (r1[4] - r3[4] * m1);
  r1[5] = (r1[5] - r3[5] * m1);
  r1[6] = (r1[6] - r3[6] * m1);
  r1[7] = (r1[7] - r3[7] * m1);
  m0 = r0[3];
  r0[4] = (r0[4] - r3[4] * m0);
  r0[5] = (r0[5] - r3[5] * m0);
  r0[6] = (r0[6] - r3[6] * m0);
  r0[7] = (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] = (r0[4] - r2[4] * m0);
  r0[5] = (r0[5] - r2[5] * m0);
  r0[6] = (r0[6] - r2[6] * m0);
  r0[7] = (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);
  to[0][0] = r0[4];
  to[0][1] = r0[5];
  to[0][2] = r0[6];
  to[0][3] = r0[7];
  to[1][0] = r1[4];
  to[1][1] = r1[5];
  to[1][2] = r1[6];
  to[1][3] = r1[7];
  to[2][0] = r2[4];
  to[2][1] = r2[5];
  to[2][2] = r2[6];
  to[2][3] = r2[7];
  to[3][0] = r3[4];
  to[3][1] = r3[5];
  to[3][2] = r3[6];
  to[3][3] = r3[7];
  return;
singular:
  printf("ERROR : non_invertable transform\n");
  return;
}


x86 assembly (clang, -O0):
<invert4d>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x90(%rbp),%rax
mov    %rax,-0xb0(%rbp)
lea    -0x90(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0xb8(%rbp)
lea    -0x90(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xc0(%rbp)
lea    -0x90(%rbp),%rax
add    $0x60,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xb0(%rbp),%rax
movss  0x1e38(%rip),%xmm0
movss  %xmm0,0x10(%rax)
mov    -0xb0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x14(%rax)
mov    -0xb0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x18(%rax)
mov    -0xb0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xb8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rax)
mov    -0xb8(%rbp),%rax
movss  0x1d95(%rip),%xmm0
movss  %xmm0,0x14(%rax)
mov    -0xb8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x18(%rax)
mov    -0xb8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rax)
mov    -0xc0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x14(%rax)
mov    -0xc0(%rbp),%rax
movss  0x1cf2(%rip),%xmm0
movss  %xmm0,0x18(%rax)
mov    -0xc0(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rax)
mov    -0xc8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x14(%rax)
mov    -0xc8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x18(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c4f(%rip),%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0xb0(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14d0 <invert4d+0x3c0>
jp     14d0 <invert4d+0x3c0>
mov    -0xb8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14a1 <invert4d+0x391>
jp     14a1 <invert4d+0x391>
mov    -0xc0(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1472 <invert4d+0x362>
jp     1472 <invert4d+0x362>
mov    -0xc8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1443 <invert4d+0x333>
jp     1443 <invert4d+0x333>
jmp    2bb4 <invert4d+0x1aa4>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    149c <invert4d+0x38c>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
jmp    14cb <invert4d+0x3bb>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    14d0 <invert4d+0x3c0>
mov    -0xb8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xc0(%rbp),%rax
movss  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xc8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xb0(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xb8(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xc0(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xc8(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xb0(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xb8(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xc0(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xc8(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xb0(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xb8(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc0(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc8(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xb0(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17c3 <invert4d+0x6b3>
jp     17c3 <invert4d+0x6b3>
jmp    187a <invert4d+0x76a>
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb0(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18b2 <invert4d+0x7a2>
jp     18b2 <invert4d+0x7a2>
jmp    1969 <invert4d+0x859>
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb0(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19a1 <invert4d+0x891>
jp     19a1 <invert4d+0x891>
jmp    1a58 <invert4d+0x948>
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb0(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a90 <invert4d+0x980>
jp     1a90 <invert4d+0x980>
jmp    1b47 <invert4d+0xa37>
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c13 <invert4d+0xb03>
jp     1c13 <invert4d+0xb03>
mov    -0xc0(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1be4 <invert4d+0xad4>
jp     1be4 <invert4d+0xad4>
mov    -0xc8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bb5 <invert4d+0xaa5>
jp     1bb5 <invert4d+0xaa5>
jmp    2bb4 <invert4d+0x1aa4>
mov    -0xb8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    1c0e <invert4d+0xafe>
mov    -0xb8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
jmp    1c13 <invert4d+0xb03>
mov    -0xc0(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0xb8(%rbp),%rax
divss  0x4(%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xc8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0xb8(%rbp),%rax
divss  0x4(%rax),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xc0(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xc8(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xc8(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0xc(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc0(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0xc(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d8f <invert4d+0xc7f>
jp     1d8f <invert4d+0xc7f>
jmp    1e09 <invert4d+0xcf9>
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e41 <invert4d+0xd31>
jp     1e41 <invert4d+0xd31>
jmp    1ebb <invert4d+0xdab>
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ef3 <invert4d+0xde3>
jp     1ef3 <invert4d+0xde3>
jmp    1f6d <invert4d+0xe5d>
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1fa5 <invert4d+0xe95>
jp     1fa5 <invert4d+0xe95>
jmp    201f <invert4d+0xf0f>
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc0(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2094 <invert4d+0xf84>
jp     2094 <invert4d+0xf84>
mov    -0xc8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    206a <invert4d+0xf5a>
jp     206a <invert4d+0xf5a>
jmp    2bb4 <invert4d+0x1aa4>
mov    -0xc0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0xc0(%rbp),%rax
divss  0x8(%rax),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xc8(%rbp),%rax
movss  0xc(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0xc(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc8(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2221 <invert4d+0x1111>
jp     2221 <invert4d+0x1111>
jmp    2bb4 <invert4d+0x1aa4>
mov    -0xc8(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdcf(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mulss  -0xa4(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc0(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xc0(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd13(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x9c(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x9c(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x9c(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x9c(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb0(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0xb0(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb0(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb0(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb0(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xb8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x973(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x98(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x98(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x98(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x98(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb0(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0xb0(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb0(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb0(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb0(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb0(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0xb0(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x6ec(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm1
movss  -0x94(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm1
movss  -0x94(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm1
movss  -0x94(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movss  -0x94(%rbp),%xmm3
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xb0(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0xb0(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0xb0(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0xb0(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0xb8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0xb8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0xb8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0xb8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0xc0(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0xc0(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0xc0(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0xc0(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0xc8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0xc8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0xc8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0xc8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x3c(%rax)
jmp    2bc2 <invert4d+0x1ab2>
lea    0x455(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert4d>:
push   %rax
lea    -0x60(%rsp),%rax
lea    -0x40(%rsp),%rdx
lea    -0x20(%rsp),%rcx
movups (%rdi),%xmm1
movaps %xmm1,-0x80(%rsp)
movss  0xed0(%rip),%xmm0
movaps %xmm0,-0x70(%rsp)
movups 0x10(%rdi),%xmm3
movaps %xmm3,-0x60(%rsp)
movaps 0xecb(%rip),%xmm0
movaps %xmm0,-0x50(%rsp)
movups 0x20(%rdi),%xmm2
movaps %xmm2,-0x40(%rsp)
movaps 0xec6(%rip),%xmm0
movaps %xmm0,-0x30(%rsp)
movups 0x30(%rdi),%xmm0
movaps %xmm0,-0x20(%rsp)
movaps 0xec1(%rip),%xmm4
movaps %xmm4,-0x10(%rsp)
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm1
jne    11a7 <invert4d+0x97>
jp     11a7 <invert4d+0x97>
ucomiss %xmm4,%xmm3
jne    11ae <invert4d+0x9e>
jp     11ae <invert4d+0x9e>
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm2
jne    11b8 <invert4d+0xa8>
jp     11b8 <invert4d+0xa8>
ucomiss %xmm3,%xmm0
jne    119a <invert4d+0x8a>
jnp    1564 <invert4d+0x454>
mov    %rcx,%r8
lea    -0x80(%rsp),%rcx
movaps %xmm1,%xmm0
jmp    11c0 <invert4d+0xb0>
lea    -0x80(%rsp),%r8
jmp    11c0 <invert4d+0xb0>
mov    %rax,%r8
lea    -0x80(%rsp),%rax
jmp    11c0 <invert4d+0xb0>
mov    %rdx,%r8
lea    -0x80(%rsp),%rdx
movss  (%r8),%xmm5
movss  0x4(%r8),%xmm6
movss  (%rax),%xmm2
movaps 0xe6a(%rip),%xmm1
xorps  %xmm1,%xmm2
divss  %xmm5,%xmm2
movaps %xmm2,%xmm7
mulss  %xmm6,%xmm7
addss  0x4(%rax),%xmm7
movss  (%rdx),%xmm3
movss  %xmm7,0x4(%rax)
xorps  %xmm1,%xmm3
divss  %xmm5,%xmm3
movaps %xmm3,%xmm7
mulss  %xmm6,%xmm7
addss  0x4(%rdx),%xmm7
movss  %xmm7,0x4(%rdx)
xorps  %xmm1,%xmm0
divss  %xmm5,%xmm0
mulss  %xmm0,%xmm6
addss  0x4(%rcx),%xmm6
movss  %xmm6,0x4(%rcx)
movss  0x8(%r8),%xmm5
movaps %xmm2,%xmm6
mulss  %xmm5,%xmm6
addss  0x8(%rax),%xmm6
movss  %xmm6,0x8(%rax)
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  0x8(%rdx),%xmm6
movss  %xmm6,0x8(%rdx)
mulss  %xmm0,%xmm5
addss  0x8(%rcx),%xmm5
movss  %xmm5,0x8(%rcx)
movss  0xc(%r8),%xmm5
movaps %xmm2,%xmm6
mulss  %xmm5,%xmm6
addss  0xc(%rax),%xmm6
movss  %xmm6,0xc(%rax)
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  0xc(%rdx),%xmm6
movss  %xmm6,0xc(%rdx)
mulss  %xmm0,%xmm5
addss  0xc(%rcx),%xmm5
movss  %xmm5,0xc(%rcx)
movss  0x10(%r8),%xmm5
ucomiss %xmm4,%xmm5
jne    1298 <invert4d+0x188>
jnp    12c8 <invert4d+0x1b8>
movaps %xmm2,%xmm4
mulss  %xmm5,%xmm4
addss  0x10(%rax),%xmm4
movss  %xmm4,0x10(%rax)
movaps %xmm3,%xmm4
mulss  %xmm5,%xmm4
addss  0x10(%rdx),%xmm4
movss  %xmm4,0x10(%rdx)
mulss  %xmm0,%xmm5
addss  0x10(%rcx),%xmm5
movss  %xmm5,0x10(%rcx)
movss  0x14(%r8),%xmm5
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm5
jne    12d8 <invert4d+0x1c8>
jnp    1308 <invert4d+0x1f8>
movaps %xmm2,%xmm6
mulss  %xmm5,%xmm6
addss  0x14(%rax),%xmm6
movss  %xmm6,0x14(%rax)
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  0x14(%rdx),%xmm6
movss  %xmm6,0x14(%rdx)
mulss  %xmm0,%xmm5
addss  0x14(%rcx),%xmm5
movss  %xmm5,0x14(%rcx)
movss  0x18(%r8),%xmm5
ucomiss %xmm4,%xmm5
jne    1315 <invert4d+0x205>
jnp    1345 <invert4d+0x235>
movaps %xmm2,%xmm4
mulss  %xmm5,%xmm4
addss  0x18(%rax),%xmm4
movss  %xmm4,0x18(%rax)
movaps %xmm3,%xmm4
mulss  %xmm5,%xmm4
addss  0x18(%rdx),%xmm4
movss  %xmm4,0x18(%rdx)
mulss  %xmm0,%xmm5
addss  0x18(%rcx),%xmm5
movss  %xmm5,0x18(%rcx)
movss  0x1c(%r8),%xmm5
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm5
jne    1355 <invert4d+0x245>
jnp    137f <invert4d+0x26f>
mulss  %xmm5,%xmm2
addss  0x1c(%rax),%xmm2
movss  %xmm2,0x1c(%rax)
mulss  %xmm5,%xmm3
addss  0x1c(%rdx),%xmm3
movss  %xmm3,0x1c(%rdx)
mulss  %xmm5,%xmm0
addss  0x1c(%rcx),%xmm0
movss  %xmm0,0x1c(%rcx)
movss  0x4(%rax),%xmm3
ucomiss %xmm4,%xmm3
jne    13af <invert4d+0x29f>
jp     13af <invert4d+0x29f>
movss  0x4(%rdx),%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jne    13b4 <invert4d+0x2a4>
jp     13b4 <invert4d+0x2a4>
movss  0x4(%rcx),%xmm3
ucomiss %xmm0,%xmm3
mov    %rcx,%rdi
jne    13bd <invert4d+0x2ad>
jnp    1564 <invert4d+0x454>
jmp    13bd <invert4d+0x2ad>
mov    %rax,%rdi
jmp    13ba <invert4d+0x2aa>
mov    %rdx,%rdi
mov    %rax,%rdx
mov    %rcx,%rax
movss  0x8(%rdi),%xmm4
movss  0x4(%rdx),%xmm0
xorps  %xmm1,%xmm0
divss  %xmm3,%xmm0
movaps %xmm0,%xmm5
mulss  %xmm4,%xmm5
addss  0x8(%rdx),%xmm5
movss  0x4(%rax),%xmm2
movss  %xmm5,0x8(%rdx)
xorps  %xmm1,%xmm2
divss  %xmm3,%xmm2
mulss  %xmm2,%xmm4
addss  0x8(%rax),%xmm4
movss  %xmm4,0x8(%rax)
movss  0xc(%rdi),%xmm1
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  0xc(%rax),%xmm3
movss  %xmm3,0xc(%rax)
mulss  %xmm0,%xmm1
addss  0xc(%rdx),%xmm1
movss  %xmm1,0xc(%rdx)
movss  0x10(%rdi),%xmm3
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm3
jne    142c <invert4d+0x31c>
jnp    144b <invert4d+0x33b>
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm4
addss  0x10(%rdx),%xmm4
movss  %xmm4,0x10(%rdx)
mulss  %xmm2,%xmm3
addss  0x10(%rax),%xmm3
movss  %xmm3,0x10(%rax)
movss  0x14(%rdi),%xmm3
ucomiss %xmm1,%xmm3
jne    1457 <invert4d+0x347>
jnp    1476 <invert4d+0x366>
movaps %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  0x14(%rdx),%xmm1
movss  %xmm1,0x14(%rdx)
mulss  %xmm2,%xmm3
addss  0x14(%rax),%xmm3
movss  %xmm3,0x14(%rax)
movss  0x18(%rdi),%xmm3
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm3
jne    1485 <invert4d+0x375>
jnp    14a4 <invert4d+0x394>
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm4
addss  0x18(%rdx),%xmm4
movss  %xmm4,0x18(%rdx)
mulss  %xmm2,%xmm3
addss  0x18(%rax),%xmm3
movss  %xmm3,0x18(%rax)
movss  0x1c(%rdi),%xmm3
ucomiss %xmm1,%xmm3
jne    14b0 <invert4d+0x3a0>
jnp    14cc <invert4d+0x3bc>
mulss  %xmm3,%xmm0
addss  0x1c(%rdx),%xmm0
movss  %xmm0,0x1c(%rdx)
mulss  %xmm3,%xmm2
addss  0x1c(%rax),%xmm2
movss  %xmm2,0x1c(%rax)
movss  0x8(%rdx),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    14ec <invert4d+0x3dc>
jp     14ec <invert4d+0x3dc>
movss  0x8(%rax),%xmm1
ucomiss %xmm0,%xmm1
mov    %rax,%rcx
jne    14f2 <invert4d+0x3e2>
jnp    1564 <invert4d+0x454>
jmp    14f2 <invert4d+0x3e2>
mov    %rdx,%rcx
mov    %rax,%rdx
movss  0x8(%rdx),%xmm2
xorps  0xb42(%rip),%xmm2
divss  %xmm1,%xmm2
movss  0xc(%rcx),%xmm3
mulss  %xmm2,%xmm3
addss  0xc(%rdx),%xmm3
movss  %xmm3,0xc(%rdx)
movss  0x10(%rcx),%xmm1
mulss  %xmm2,%xmm1
addss  0x10(%rdx),%xmm1
movss  %xmm1,0x10(%rdx)
movss  0x14(%rcx),%xmm4
mulss  %xmm2,%xmm4
addss  0x14(%rdx),%xmm4
movss  %xmm4,0x14(%rdx)
movss  0x18(%rcx),%xmm5
mulss  %xmm2,%xmm5
addss  0x18(%rdx),%xmm5
movss  %xmm5,0x18(%rdx)
mulss  0x1c(%rcx),%xmm2
addss  0x1c(%rdx),%xmm2
movss  %xmm2,0x1c(%rdx)
ucomiss %xmm0,%xmm3
jne    1571 <invert4d+0x461>
jp     1571 <invert4d+0x461>
lea    0xae5(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>
movss  0xa87(%rip),%xmm0
movaps %xmm0,%xmm6
divss  %xmm3,%xmm6
shufps $0x0,%xmm6,%xmm6
unpcklps %xmm2,%xmm5
unpcklps %xmm4,%xmm1
movlhps %xmm5,%xmm1
mulps  %xmm6,%xmm1
movups %xmm1,0x10(%rdx)
movaps %xmm0,%xmm2
divss  0x8(%rcx),%xmm2
movss  0xc(%rcx),%xmm3
movss  0x10(%rcx),%xmm4
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm4
mulss  %xmm2,%xmm4
movss  %xmm4,0x10(%rcx)
movss  0x14(%rcx),%xmm1
movss  0x14(%rdx),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,0x14(%rcx)
movss  0x18(%rcx),%xmm1
movss  0x18(%rdx),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,0x18(%rcx)
movss  0x1c(%rcx),%xmm1
mulss  0x1c(%rdx),%xmm3
subss  %xmm3,%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,0x1c(%rcx)
movss  0xc(%rdi),%xmm1
movss  0x10(%rdi),%xmm2
movss  0x10(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x10(%rdi)
movss  0x14(%rdi),%xmm2
movss  0x14(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x14(%rdi)
movss  0x18(%rdi),%xmm2
movss  0x18(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x18(%rdi)
mulss  0x1c(%rdx),%xmm1
movss  0x1c(%rdi),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rdi)
movss  0xc(%r8),%xmm1
movss  0x10(%r8),%xmm2
movss  0x10(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x10(%r8)
movss  0x14(%r8),%xmm2
movss  0x14(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x14(%r8)
movss  0x18(%r8),%xmm2
movss  0x18(%rdx),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,0x18(%r8)
movss  0x1c(%r8),%xmm2
mulss  0x1c(%rdx),%xmm1
subss  %xmm1,%xmm2
movss  %xmm2,0x1c(%r8)
movaps %xmm0,%xmm1
divss  0x4(%rdi),%xmm1
movss  0x8(%rdi),%xmm2
movss  0x10(%rdi),%xmm3
movss  0x10(%rcx),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
mulss  %xmm1,%xmm3
movss  %xmm3,0x10(%rdi)
movss  0x14(%rdi),%xmm3
movss  0x14(%rcx),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
mulss  %xmm1,%xmm3
movss  %xmm3,0x14(%rdi)
movss  0x18(%rdi),%xmm3
movss  0x18(%rcx),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
mulss  %xmm1,%xmm3
movss  %xmm3,0x18(%rdi)
movss  0x1c(%rdi),%xmm3
mulss  0x1c(%rcx),%xmm2
subss  %xmm2,%xmm3
mulss  %xmm1,%xmm3
movss  %xmm3,0x1c(%rdi)
movss  0x4(%r8),%xmm1
movss  0x8(%r8),%xmm6
movss  0x10(%rcx),%xmm3
mulss  %xmm6,%xmm3
movss  0x10(%r8),%xmm2
subss  %xmm3,%xmm2
movss  0x14(%r8),%xmm3
movss  %xmm2,0x10(%r8)
movss  0x14(%rcx),%xmm4
mulss  %xmm6,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x14(%r8)
movss  0x18(%r8),%xmm4
movss  0x18(%rcx),%xmm5
mulss  %xmm6,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,0x18(%r8)
movss  0x1c(%r8),%xmm5
mulss  0x1c(%rcx),%xmm6
subss  %xmm6,%xmm5
movss  %xmm5,0x1c(%r8)
divss  (%r8),%xmm0
movss  0x10(%rdi),%xmm6
mulss  %xmm1,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%r8)
movss  0x14(%rdi),%xmm6
mulss  %xmm1,%xmm6
subss  %xmm6,%xmm3
mulss  %xmm0,%xmm3
movss  %xmm3,0x14(%r8)
movss  0x18(%rdi),%xmm6
mulss  %xmm1,%xmm6
subss  %xmm6,%xmm4
mulss  %xmm0,%xmm4
movss  %xmm4,0x18(%r8)
mulss  0x1c(%rdi),%xmm1
subss  %xmm1,%xmm5
mulss  %xmm0,%xmm5
movss  %xmm5,0x1c(%r8)
movss  %xmm2,(%rsi)
movss  %xmm3,0x4(%rsi)
movss  %xmm4,0x8(%rsi)
movss  %xmm5,0xc(%rsi)
movss  0x10(%rdi),%xmm0
movss  %xmm0,0x10(%rsi)
movss  0x14(%rdi),%xmm0
movss  %xmm0,0x14(%rsi)
movss  0x18(%rdi),%xmm0
movss  %xmm0,0x18(%rsi)
movss  0x1c(%rdi),%xmm0
movss  %xmm0,0x1c(%rsi)
movss  0x10(%rcx),%xmm0
movss  %xmm0,0x20(%rsi)
movss  0x14(%rcx),%xmm0
movss  %xmm0,0x24(%rsi)
movss  0x18(%rcx),%xmm0
movss  %xmm0,0x28(%rsi)
movss  0x1c(%rcx),%xmm0
movss  %xmm0,0x2c(%rsi)
movss  0x10(%rdx),%xmm0
movss  %xmm0,0x30(%rsi)
movss  0x14(%rdx),%xmm0
movss  %xmm0,0x34(%rsi)
movss  0x18(%rdx),%xmm0
movss  %xmm0,0x38(%rsi)
movss  0x1c(%rdx),%xmm0
movss  %xmm0,0x3c(%rsi)
pop    %rax
ret

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

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