void mat3_normalFromMat4(float *dst, float *a) {
  float a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
  float a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
  float a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
  float a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
  float b00 = a00 * a11 - a01 * a10;
  float b01 = a00 * a12 - a02 * a10;
  float b02 = a00 * a13 - a03 * a10;
  float b03 = a01 * a12 - a02 * a11;
  float b04 = a01 * a13 - a03 * a11;
  float b05 = a02 * a13 - a03 * a12;
  float b06 = a20 * a31 - a21 * a30;
  float b07 = a20 * a32 - a22 * a30;
  float b08 = a20 * a33 - a23 * a30;
  float b09 = a21 * a32 - a22 * a31;
  float b10 = a21 * a33 - a23 * a31;
  float b11 = a22 * a33 - a23 * a32;
  float det =
      b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
  if (!det) {
    return;
  }
  det = 1.0 / det;
  dst[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
  dst[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
  dst[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
  dst[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
  dst[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
  dst[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
  dst[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
  dst[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
  dst[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
}


x86 assembly (clang, -O0):
<mat3_normalFromMat4>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x7c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14b9 <mat3_normalFromMat4+0x3b9>
jp     14b9 <mat3_normalFromMat4+0x3b9>
jmp    17bc <mat3_normalFromMat4+0x6bc>
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xb33(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x28(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x24(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movss  -0x28(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x14(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x18(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x14(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x48(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat3_normalFromMat4>:
sub    $0x48,%rsp
movsd  (%rsi),%xmm9
movaps %xmm9,%xmm0
shufps $0x55,%xmm9,%xmm0
movss  0x8(%rsi),%xmm3
movaps %xmm3,0x30(%rsp)
movss  0x10(%rsi),%xmm10
movsd  0x14(%rsi),%xmm11
movss  0x24(%rsi),%xmm14
movss  0x28(%rsi),%xmm2
movss  0x30(%rsi),%xmm4
movaps %xmm4,-0x80(%rsp)
movsd  0x34(%rsi),%xmm15
movaps 0xeb6(%rip),%xmm5
movaps %xmm10,%xmm1
movaps %xmm0,-0x40(%rsp)
mulss  %xmm0,%xmm1
movaps %xmm9,%xmm7
mulss  %xmm11,%xmm7
subss  %xmm1,%xmm7
movaps %xmm14,%xmm6
unpcklps %xmm3,%xmm6
xorps  %xmm5,%xmm6
movaps %xmm2,%xmm3
xorps  %xmm5,%xmm3
movaps %xmm11,%xmm1
unpcklps %xmm10,%xmm1
movaps %xmm4,%xmm5
shufps $0x40,%xmm1,%xmm5
movlhps %xmm6,%xmm3
movaps %xmm6,-0x10(%rsp)
shufps $0x58,%xmm6,%xmm3
mulps  %xmm5,%xmm3
movss  0x20(%rsi),%xmm1
movaps %xmm15,%xmm5
mulss  %xmm2,%xmm5
unpcklps %xmm1,%xmm2
shufps $0x10,%xmm9,%xmm1
movaps %xmm15,%xmm13
shufps $0x51,%xmm11,%xmm13
mulps  %xmm1,%xmm13
movaps %xmm15,%xmm0
shufps $0x55,%xmm15,%xmm0
addps  %xmm3,%xmm13
movaps %xmm9,%xmm6
movss  %xmm14,%xmm6
mulss  %xmm0,%xmm14
subss  %xmm5,%xmm14
movss  0x1c(%rsi),%xmm8
movss  0x3c(%rsi),%xmm3
movaps %xmm3,%xmm12
unpcklps %xmm8,%xmm12
mulps  %xmm6,%xmm12
movss  0xc(%rsi),%xmm4
movss  0x2c(%rsi),%xmm1
movaps %xmm1,%xmm5
unpcklps %xmm4,%xmm5
movaps %xmm15,0x10(%rsp)
unpcklps %xmm11,%xmm15
movaps %xmm5,-0x60(%rsp)
mulps  %xmm5,%xmm15
subps  %xmm15,%xmm12
movaps %xmm11,-0x50(%rsp)
movaps %xmm11,%xmm6
shufps $0x55,%xmm11,%xmm6
movaps %xmm0,-0x20(%rsp)
unpcklps -0x80(%rsp),%xmm0
movaps %xmm10,%xmm15
movlhps %xmm6,%xmm10
shufps $0x24,%xmm10,%xmm0
shufps $0x0,%xmm4,%xmm1
mulps  %xmm1,%xmm0
movaps %xmm9,0x20(%rsp)
movaps %xmm9,%xmm1
movaps 0x30(%rsp),%xmm5
movaps %xmm5,%xmm11
movlhps %xmm5,%xmm1
shufps $0x24,%xmm1,%xmm2
movaps %xmm3,-0x30(%rsp)
movaps %xmm3,%xmm9
shufps $0x0,%xmm8,%xmm9
mulps  %xmm2,%xmm9
subps  %xmm0,%xmm9
movaps %xmm13,%xmm0
shufps $0xff,%xmm13,%xmm0
mulss  %xmm12,%xmm0
movaps %xmm7,(%rsp)
movaps %xmm7,%xmm1
mulss  %xmm9,%xmm1
subss  %xmm0,%xmm1
movaps %xmm9,%xmm7
shufps $0xff,%xmm9,%xmm7
movaps %xmm7,%xmm0
mulss  %xmm14,%xmm0
addss  %xmm1,%xmm0
movaps %xmm13,%xmm1
unpckhpd %xmm13,%xmm1
movaps %xmm9,%xmm5
shufps $0x55,%xmm9,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm0,%xmm5
movaps %xmm12,%xmm3
shufps $0x55,%xmm12,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm13,%xmm0
subss  %xmm0,%xmm5
movaps %xmm13,%xmm2
shufps $0x55,%xmm13,%xmm2
movaps %xmm9,%xmm10
unpckhpd %xmm9,%xmm10
mulss  %xmm2,%xmm10
addss  %xmm5,%xmm10
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm10
jne    12fc <mat3_normalFromMat4+0x1fc>
jnp    144f <mat3_normalFromMat4+0x34f>
movss  0xd0c(%rip),%xmm0
divss  %xmm10,%xmm0
movaps %xmm0,-0x70(%rsp)
movaps %xmm7,%xmm10
movaps 0xce7(%rip),%xmm7
movaps -0x40(%rsp),%xmm0
xorps  %xmm7,%xmm0
xorps  %xmm7,%xmm6
movaps %xmm15,%xmm1
movlhps %xmm15,%xmm11
movaps -0x50(%rsp),%xmm15
unpcklps %xmm15,%xmm1
xorps  %xmm7,%xmm1
movlhps %xmm1,%xmm6
shufps $0xd4,%xmm1,%xmm0
shufps $0x28,%xmm0,%xmm6
movaps %xmm12,%xmm0
movlhps %xmm9,%xmm0
shufps $0x18,%xmm9,%xmm0
mulps  %xmm0,%xmm6
shufps $0x24,%xmm11,%xmm15
movaps %xmm9,%xmm1
shufps $0x4,%xmm12,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm6,%xmm1
movaps %xmm8,%xmm0
xorps  %xmm7,%xmm0
movaps %xmm8,%xmm5
unpcklps %xmm0,%xmm8
movaps -0x60(%rsp),%xmm0
xorps  %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm11
unpcklps %xmm11,%xmm5
movlhps %xmm5,%xmm8
unpcklps %xmm14,%xmm2
unpcklps %xmm13,%xmm14
movlhps %xmm2,%xmm14
mulps  %xmm8,%xmm14
addps  %xmm1,%xmm14
movaps 0x10(%rsp),%xmm8
mulss  %xmm8,%xmm10
movaps -0x80(%rsp),%xmm2
mulss  %xmm2,%xmm3
subss  %xmm10,%xmm3
movaps (%rsp),%xmm6
movaps -0x30(%rsp),%xmm10
mulss  %xmm10,%xmm6
addss  %xmm3,%xmm6
movaps -0x70(%rsp),%xmm1
mulss  %xmm1,%xmm6
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm14
movups %xmm14,(%rdi)
movaps -0x20(%rsp),%xmm0
unpcklps %xmm2,%xmm0
movaps %xmm9,%xmm2
shufps $0xc5,%xmm12,%xmm2
movaps %xmm4,%xmm5
movaps %xmm9,%xmm4
shufps $0xd6,%xmm12,%xmm4
shufps $0x28,%xmm4,%xmm2
movaps 0x20(%rsp),%xmm4
movaps %xmm4,%xmm3
xorps  %xmm7,%xmm3
shufps $0xd4,-0x10(%rsp),%xmm3
xorps  %xmm7,%xmm0
shufps $0x42,%xmm0,%xmm3
mulps  %xmm2,%xmm3
movlhps %xmm8,%xmm4
mulps  %xmm9,%xmm4
addps  %xmm3,%xmm4
unpcklps %xmm11,%xmm5
xorps  %xmm10,%xmm7
movaps %xmm10,%xmm0
unpcklps %xmm7,%xmm0
movlhps %xmm0,%xmm5
mulps  %xmm13,%xmm5
addps  %xmm4,%xmm5
mulps  %xmm1,%xmm5
movups %xmm5,0x10(%rdi)
movss  %xmm6,0x20(%rdi)
add    $0x48,%rsp
ret

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

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