void invert3x3(const float *src, float *dst) {
  float det;
  dst[0] = +src[4] * src[8] - src[5] * src[7];
  dst[1] = -src[1] * src[8] + src[2] * src[7];
  dst[2] = +src[1] * src[5] - src[2] * src[4];
  dst[3] = -src[3] * src[8] + src[5] * src[6];
  dst[4] = +src[0] * src[8] - src[2] * src[6];
  dst[5] = -src[0] * src[5] + src[2] * src[3];
  dst[6] = +src[3] * src[7] - src[4] * src[6];
  dst[7] = -src[0] * src[7] + src[1] * src[6];
  dst[8] = +src[0] * src[4] - src[1] * src[3];
  det = src[0] * dst[0] + src[1] * dst[3] + src[2] * dst[6];
  det = 1.0f / det;
  dst[0] *= det;
  dst[1] *= det;
  dst[2] *= det;
  dst[3] *= det;
  dst[4] *= det;
  dst[5] *= det;
  dst[6] *= det;
  dst[7] *= det;
  dst[8] *= det;
}


x86 assembly (clang, -O0):
<invert3x3>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xc56(%rip),%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x20(%rax),%xmm0
movss  %xmm0,0x20(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert3x3>:
movss  0x1c(%rdi),%xmm1
mulss  0x14(%rdi),%xmm1
movss  0x10(%rdi),%xmm0
mulss  0x20(%rdi),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rsi)
movss  0x8(%rdi),%xmm8
mulss  0x1c(%rdi),%xmm8
movss  0x4(%rdi),%xmm1
mulss  0x20(%rdi),%xmm1
subss  %xmm1,%xmm8
movss  %xmm8,0x4(%rsi)
movss  0x10(%rdi),%xmm1
mulss  0x8(%rdi),%xmm1
movss  0x4(%rdi),%xmm2
mulss  0x14(%rdi),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x8(%rsi)
movss  0x14(%rdi),%xmm5
mulss  0x18(%rdi),%xmm5
movss  0xc(%rdi),%xmm1
mulss  0x20(%rdi),%xmm1
subss  %xmm1,%xmm5
movss  %xmm5,0xc(%rsi)
movss  0x18(%rdi),%xmm1
mulss  0x8(%rdi),%xmm1
movss  (%rdi),%xmm3
mulss  0x20(%rdi),%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,0x10(%rsi)
movss  0x8(%rdi),%xmm9
mulss  0xc(%rdi),%xmm9
movss  (%rdi),%xmm1
mulss  0x14(%rdi),%xmm1
subss  %xmm1,%xmm9
movss  %xmm9,0x14(%rsi)
movss  0x18(%rdi),%xmm1
mulss  0x10(%rdi),%xmm1
movss  0xc(%rdi),%xmm6
mulss  0x1c(%rdi),%xmm6
subss  %xmm1,%xmm6
movss  %xmm6,0x18(%rsi)
movss  0x4(%rdi),%xmm7
mulss  0x18(%rdi),%xmm7
movss  (%rdi),%xmm1
mulss  0x1c(%rdi),%xmm1
subss  %xmm1,%xmm7
movss  %xmm7,0x1c(%rsi)
movss  0xc(%rdi),%xmm4
mulss  0x4(%rdi),%xmm4
movss  (%rdi),%xmm1
mulss  0x10(%rdi),%xmm1
subss  %xmm4,%xmm1
movss  %xmm1,0x20(%rsi)
unpcklps %xmm5,%xmm2
mulss  0x4(%rdi),%xmm5
movss  (%rdi),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm5,%xmm4
movss  0x8(%rdi),%xmm5
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movss  0xdcf(%rip),%xmm4
divss  %xmm5,%xmm4
unpcklps %xmm8,%xmm0
movlhps %xmm2,%xmm0
mulss  %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm0
movups %xmm0,(%rsi)
unpcklps %xmm9,%xmm3
unpcklps %xmm7,%xmm6
movlhps %xmm6,%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,0x10(%rsi)
movss  %xmm1,0x20(%rsi)
ret

LLVM IR (-O0):
define void @invert3x3(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca float
store float* %0, float** %3
store float* %1, float** %4
%6 = load float*, float** %3
%7 = getelementptr inbounds float, float* %6, i64 4
%8 = load float, float* %7
%9 = load float*, float** %3
%10 = getelementptr inbounds float, float* %9, i64 8
%11 = load float, float* %10
%12 = load float*, float** %3
%13 = getelementptr inbounds float, float* %12, i64 5
%14 = load float, float* %13
%15 = load float*, float** %3
%16 = getelementptr inbounds float, float* %15, i64 7
%17 = load float, float* %16
%18 = fmul float %14, %17
%19 = fneg float %18
%20 = call float @llvm.fmuladd.f32(float %8, float %11, float %19)
%21 = load float*, float** %4
%22 = getelementptr inbounds float, float* %21, i64 0
store float %20, float* %22
%23 = load float*, float** %3
%24 = getelementptr inbounds float, float* %23, i64 1
%25 = load float, float* %24
%26 = fneg float %25
%27 = load float*, float** %3
%28 = getelementptr inbounds float, float* %27, i64 8
%29 = load float, float* %28
%30 = load float*, float** %3
%31 = getelementptr inbounds float, float* %30, i64 2
%32 = load float, float* %31
%33 = load float*, float** %3
%34 = getelementptr inbounds float, float* %33, i64 7
%35 = load float, float* %34
%36 = fmul float %32, %35
%37 = call float @llvm.fmuladd.f32(float %26, float %29, float %36)
%38 = load float*, float** %4
%39 = getelementptr inbounds float, float* %38, i64 1
store float %37, float* %39
%40 = load float*, float** %3
%41 = getelementptr inbounds float, float* %40, i64 1
%42 = load float, float* %41
%43 = load float*, float** %3
%44 = getelementptr inbounds float, float* %43, i64 5
%45 = load float, float* %44
%46 = load float*, float** %3
%47 = getelementptr inbounds float, float* %46, i64 2
%48 = load float, float* %47
%49 = load float*, float** %3
%50 = getelementptr inbounds float, float* %49, i64 4
%51 = load float, float* %50
%52 = fmul float %48, %51
%53 = fneg float %52
%54 = call float @llvm.fmuladd.f32(float %42, float %45, float %53)
%55 = load float*, float** %4
%56 = getelementptr inbounds float, float* %55, i64 2
store float %54, float* %56
%57 = load float*, float** %3
%58 = getelementptr inbounds float, float* %57, i64 3
%59 = load float, float* %58
%60 = fneg float %59
%61 = load float*, float** %3
%62 = getelementptr inbounds float, float* %61, i64 8
%63 = load float, float* %62
%64 = load float*, float** %3
%65 = getelementptr inbounds float, float* %64, i64 5
%66 = load float, float* %65
%67 = load float*, float** %3
%68 = getelementptr inbounds float, float* %67, i64 6
%69 = load float, float* %68
%70 = fmul float %66, %69
%71 = call float @llvm.fmuladd.f32(float %60, float %63, float %70)
%72 = load float*, float** %4
%73 = getelementptr inbounds float, float* %72, i64 3
store float %71, float* %73
%74 = load float*, float** %3
%75 = getelementptr inbounds float, float* %74, i64 0
%76 = load float, float* %75
%77 = load float*, float** %3
%78 = getelementptr inbounds float, float* %77, i64 8
%79 = load float, float* %78
%80 = load float*, float** %3
%81 = getelementptr inbounds float, float* %80, i64 2
%82 = load float, float* %81
%83 = load float*, float** %3
%84 = getelementptr inbounds float, float* %83, i64 6
%85 = load float, float* %84
%86 = fmul float %82, %85
%87 = fneg float %86
%88 = call float @llvm.fmuladd.f32(float %76, float %79, float %87)
%89 = load float*, float** %4
%90 = getelementptr inbounds float, float* %89, i64 4
store float %88, float* %90
%91 = load float*, float** %3
%92 = getelementptr inbounds float, float* %91, i64 0
%93 = load float, float* %92
%94 = fneg float %93
%95 = load float*, float** %3
%96 = getelementptr inbounds float, float* %95, i64 5
%97 = load float, float* %96
%98 = load float*, float** %3
%99 = getelementptr inbounds float, float* %98, i64 2
%100 = load float, float* %99
%101 = load float*, float** %3
%102 = getelementptr inbounds float, float* %101, i64 3
%103 = load float, float* %102
%104 = fmul float %100, %103
%105 = call float @llvm.fmuladd.f32(float %94, float %97, float %104)
%106 = load float*, float** %4
%107 = getelementptr inbounds float, float* %106, i64 5
store float %105, float* %107
%108 = load float*, float** %3
%109 = getelementptr inbounds float, float* %108, i64 3
%110 = load float, float* %109
%111 = load float*, float** %3
%112 = getelementptr inbounds float, float* %111, i64 7
%113 = load float, float* %112
%114 = load float*, float** %3
%115 = getelementptr inbounds float, float* %114, i64 4
%116 = load float, float* %115
%117 = load float*, float** %3
%118 = getelementptr inbounds float, float* %117, i64 6
%119 = load float, float* %118
%120 = fmul float %116, %119
%121 = fneg float %120
%122 = call float @llvm.fmuladd.f32(float %110, float %113, float %121)
%123 = load float*, float** %4
%124 = getelementptr inbounds float, float* %123, i64 6
store float %122, float* %124
%125 = load float*, float** %3
%126 = getelementptr inbounds float, float* %125, i64 0
%127 = load float, float* %126
%128 = fneg float %127
%129 = load float*, float** %3
%130 = getelementptr inbounds float, float* %129, i64 7
%131 = load float, float* %130
%132 = load float*, float** %3
%133 = getelementptr inbounds float, float* %132, i64 1
%134 = load float, float* %133
%135 = load float*, float** %3
%136 = getelementptr inbounds float, float* %135, i64 6
%137 = load float, float* %136
%138 = fmul float %134, %137
%139 = call float @llvm.fmuladd.f32(float %128, float %131, float %138)
%140 = load float*, float** %4
%141 = getelementptr inbounds float, float* %140, i64 7
store float %139, float* %141
%142 = load float*, float** %3
%143 = getelementptr inbounds float, float* %142, i64 0
%144 = load float, float* %143
%145 = load float*, float** %3
%146 = getelementptr inbounds float, float* %145, i64 4
%147 = load float, float* %146
%148 = load float*, float** %3
%149 = getelementptr inbounds float, float* %148, i64 1
%150 = load float, float* %149
%151 = load float*, float** %3
%152 = getelementptr inbounds float, float* %151, i64 3
%153 = load float, float* %152
%154 = fmul float %150, %153
%155 = fneg float %154
%156 = call float @llvm.fmuladd.f32(float %144, float %147, float %155)
%157 = load float*, float** %4
%158 = getelementptr inbounds float, float* %157, i64 8
store float %156, float* %158
%159 = load float*, float** %3
%160 = getelementptr inbounds float, float* %159, i64 0
%161 = load float, float* %160
%162 = load float*, float** %4
%163 = getelementptr inbounds float, float* %162, i64 0
%164 = load float, float* %163
%165 = load float*, float** %3
%166 = getelementptr inbounds float, float* %165, i64 1
%167 = load float, float* %166
%168 = load float*, float** %4
%169 = getelementptr inbounds float, float* %168, i64 3
%170 = load float, float* %169
%171 = fmul float %167, %170
%172 = call float @llvm.fmuladd.f32(float %161, float %164, float %171)
%173 = load float*, float** %3
%174 = getelementptr inbounds float, float* %173, i64 2
%175 = load float, float* %174
%176 = load float*, float** %4
%177 = getelementptr inbounds float, float* %176, i64 6
%178 = load float, float* %177
%179 = call float @llvm.fmuladd.f32(float %175, float %178, float %172)
store float %179, float* %5
%180 = load float, float* %5
%181 = fdiv float 1.000000e+00, %180
store float %181, float* %5
%182 = load float, float* %5
%183 = load float*, float** %4
%184 = getelementptr inbounds float, float* %183, i64 0
%185 = load float, float* %184
%186 = fmul float %185, %182
store float %186, float* %184
%187 = load float, float* %5
%188 = load float*, float** %4
%189 = getelementptr inbounds float, float* %188, i64 1
%190 = load float, float* %189
%191 = fmul float %190, %187
store float %191, float* %189
%192 = load float, float* %5
%193 = load float*, float** %4
%194 = getelementptr inbounds float, float* %193, i64 2
%195 = load float, float* %194
%196 = fmul float %195, %192
store float %196, float* %194
%197 = load float, float* %5
%198 = load float*, float** %4
%199 = getelementptr inbounds float, float* %198, i64 3
%200 = load float, float* %199
%201 = fmul float %200, %197
store float %201, float* %199
%202 = load float, float* %5
%203 = load float*, float** %4
%204 = getelementptr inbounds float, float* %203, i64 4
%205 = load float, float* %204
%206 = fmul float %205, %202
store float %206, float* %204
%207 = load float, float* %5
%208 = load float*, float** %4
%209 = getelementptr inbounds float, float* %208, i64 5
%210 = load float, float* %209
%211 = fmul float %210, %207
store float %211, float* %209
%212 = load float, float* %5
%213 = load float*, float** %4
%214 = getelementptr inbounds float, float* %213, i64 6
%215 = load float, float* %214
%216 = fmul float %215, %212
store float %216, float* %214
%217 = load float, float* %5
%218 = load float*, float** %4
%219 = getelementptr inbounds float, float* %218, i64 7
%220 = load float, float* %219
%221 = fmul float %220, %217
store float %221, float* %219
%222 = load float, float* %5
%223 = load float*, float** %4
%224 = getelementptr inbounds float, float* %223, i64 8
%225 = load float, float* %224
%226 = fmul float %225, %222
store float %226, float* %224
ret void
}

LLVM IR (-O2):
define void @invert3x3(float* nocapture %0, float* nocapture %1) {
%3 = getelementptr inbounds float, float* %0, i64 4
%4 = load float, float* %3
%5 = getelementptr inbounds float, float* %0, i64 8
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %0, i64 5
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %0, i64 7
%10 = load float, float* %9
%11 = fneg float %8
%12 = fmul float %10, %11
%13 = tail call float @llvm.fmuladd.f32(float %4, float %6, float %12)
store float %13, float* %1
%14 = getelementptr inbounds float, float* %0, i64 1
%15 = load float, float* %14
%16 = fneg float %15
%17 = load float, float* %5
%18 = getelementptr inbounds float, float* %0, i64 2
%19 = load float, float* %18
%20 = load float, float* %9
%21 = fmul float %19, %20
%22 = tail call float @llvm.fmuladd.f32(float %16, float %17, float %21)
%23 = getelementptr inbounds float, float* %1, i64 1
store float %22, float* %23
%24 = load float, float* %14
%25 = load float, float* %7
%26 = load float, float* %18
%27 = load float, float* %3
%28 = fneg float %26
%29 = fmul float %27, %28
%30 = tail call float @llvm.fmuladd.f32(float %24, float %25, float %29)
%31 = getelementptr inbounds float, float* %1, i64 2
store float %30, float* %31
%32 = getelementptr inbounds float, float* %0, i64 3
%33 = load float, float* %32
%34 = fneg float %33
%35 = load float, float* %5
%36 = load float, float* %7
%37 = getelementptr inbounds float, float* %0, i64 6
%38 = load float, float* %37
%39 = fmul float %36, %38
%40 = tail call float @llvm.fmuladd.f32(float %34, float %35, float %39)
%41 = getelementptr inbounds float, float* %1, i64 3
store float %40, float* %41
%42 = load float, float* %0
%43 = load float, float* %5
%44 = load float, float* %18
%45 = load float, float* %37
%46 = fneg float %44
%47 = fmul float %45, %46
%48 = tail call float @llvm.fmuladd.f32(float %42, float %43, float %47)
%49 = getelementptr inbounds float, float* %1, i64 4
store float %48, float* %49
%50 = load float, float* %0
%51 = fneg float %50
%52 = load float, float* %7
%53 = load float, float* %18
%54 = load float, float* %32
%55 = fmul float %53, %54
%56 = tail call float @llvm.fmuladd.f32(float %51, float %52, float %55)
%57 = getelementptr inbounds float, float* %1, i64 5
store float %56, float* %57
%58 = load float, float* %32
%59 = load float, float* %9
%60 = load float, float* %3
%61 = load float, float* %37
%62 = fneg float %60
%63 = fmul float %61, %62
%64 = tail call float @llvm.fmuladd.f32(float %58, float %59, float %63)
%65 = getelementptr inbounds float, float* %1, i64 6
store float %64, float* %65
%66 = load float, float* %0
%67 = fneg float %66
%68 = load float, float* %9
%69 = load float, float* %14
%70 = load float, float* %37
%71 = fmul float %69, %70
%72 = tail call float @llvm.fmuladd.f32(float %67, float %68, float %71)
%73 = getelementptr inbounds float, float* %1, i64 7
store float %72, float* %73
%74 = load float, float* %0
%75 = load float, float* %3
%76 = load float, float* %14
%77 = load float, float* %32
%78 = fneg float %76
%79 = fmul float %77, %78
%80 = tail call float @llvm.fmuladd.f32(float %74, float %75, float %79)
%81 = getelementptr inbounds float, float* %1, i64 8
store float %80, float* %81
%82 = load float, float* %0
%83 = load float, float* %14
%84 = fmul float %40, %83
%85 = tail call float @llvm.fmuladd.f32(float %82, float %13, float %84)
%86 = load float, float* %18
%87 = tail call float @llvm.fmuladd.f32(float %86, float %64, float %85)
%88 = fdiv float 1.000000e+00, %87
%89 = insertelement <4 x float> poison, float %13, i64 0
%90 = insertelement <4 x float> %89, float %22, i64 1
%91 = insertelement <4 x float> %90, float %30, i64 2
%92 = insertelement <4 x float> %91, float %40, i64 3
%93 = insertelement <4 x float> poison, float %88, i64 0
%94 = shufflevector <4 x float> %93, <4 x float> poison, <4 x i32> zeroinitializer
%95 = fmul <4 x float> %92, %94
%96 = bitcast float* %1 to <4 x float>*
store <4 x float> %95, <4 x float>* %96
%97 = insertelement <4 x float> poison, float %48, i64 0
%98 = insertelement <4 x float> %97, float %56, i64 1
%99 = insertelement <4 x float> %98, float %64, i64 2
%100 = insertelement <4 x float> %99, float %72, i64 3
%101 = fmul <4 x float> %100, %94
%102 = bitcast float* %49 to <4 x float>*
store <4 x float> %101, <4 x float>* %102
%103 = fmul float %80, %88
store float %103, float* %81
ret void
}