void mat3_multiply(float *dst, float *b) {
  float a00 = dst[0], a01 = dst[1], a02 = dst[2];
  float a10 = dst[3], a11 = dst[4], a12 = dst[5];
  float a20 = dst[6], a21 = dst[7], a22 = dst[8];
  float b00 = b[0], b01 = b[1], b02 = b[2];
  float b10 = b[3], b11 = b[4], b12 = b[5];
  float b20 = b[6], b21 = b[7], b22 = b[8];
  dst[0] = b00 * a00 + b01 * a10 + b02 * a20;
  dst[1] = b00 * a01 + b01 * a11 + b02 * a21;
  dst[2] = b00 * a02 + b01 * a12 + b02 * a22;
  dst[3] = b10 * a00 + b11 * a10 + b12 * a20;
  dst[4] = b10 * a01 + b11 * a11 + b12 * a21;
  dst[5] = b10 * a02 + b11 * a12 + b12 * a22;
  dst[6] = b20 * a00 + b21 * a10 + b22 * a20;
  dst[7] = b20 * a01 + b21 * a11 + b22 * a21;
  dst[8] = b20 * a02 + b21 * a12 + b22 * a22;
}


x86 assembly (clang, -O0):
<mat3_multiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x38(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x38(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x50(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x50(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x50(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat3_multiply>:
movsd  0x4(%rdi),%xmm15
movsd  0x10(%rdi),%xmm11
movsd  0x1c(%rdi),%xmm0
movss  0x18(%rsi),%xmm8
movss  0x1c(%rsi),%xmm10
movss  0x20(%rsi),%xmm9
movss  0xc(%rdi),%xmm6
movaps %xmm6,%xmm7
movaps %xmm11,%xmm12
movlhps %xmm6,%xmm12
movlhps %xmm11,%xmm6
shufps $0xd4,%xmm11,%xmm7
shufps $0x28,%xmm7,%xmm6
movss  0x10(%rsi),%xmm7
movss  (%rsi),%xmm2
movss  0x4(%rsi),%xmm4
movss  0x8(%rsi),%xmm1
movss  0xc(%rsi),%xmm13
unpcklps %xmm7,%xmm4
shufps $0x40,%xmm4,%xmm4
mulps  %xmm6,%xmm4
unpcklps %xmm13,%xmm2
shufps $0x40,%xmm2,%xmm2
movss  (%rdi),%xmm6
movaps %xmm6,%xmm5
movaps %xmm15,%xmm14
movlhps %xmm6,%xmm14
movlhps %xmm15,%xmm6
shufps $0xd4,%xmm15,%xmm5
shufps $0x28,%xmm5,%xmm6
mulps  %xmm2,%xmm6
addps  %xmm4,%xmm6
movss  0x14(%rsi),%xmm2
unpcklps %xmm2,%xmm1
shufps $0x40,%xmm1,%xmm1
movss  0x18(%rdi),%xmm4
movaps %xmm4,%xmm5
movaps %xmm0,%xmm3
movlhps %xmm4,%xmm3
movlhps %xmm0,%xmm4
shufps $0xd4,%xmm0,%xmm5
shufps $0x28,%xmm5,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm6,%xmm4
movups %xmm4,(%rdi)
movaps %xmm11,%xmm1
shufps $0x55,%xmm11,%xmm1
shufps $0x24,%xmm12,%xmm11
shufps $0x0,%xmm10,%xmm7
mulps  %xmm11,%xmm7
shufps $0x0,%xmm8,%xmm13
movaps %xmm15,%xmm4
shufps $0x55,%xmm15,%xmm4
shufps $0x24,%xmm14,%xmm15
mulps  %xmm13,%xmm15
addps  %xmm7,%xmm15
shufps $0x0,%xmm9,%xmm2
movaps %xmm0,%xmm5
shufps $0x55,%xmm0,%xmm5
shufps $0x24,%xmm3,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm15,%xmm0
movups %xmm0,0x10(%rdi)
mulss  %xmm10,%xmm1
mulss  %xmm8,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm9,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,0x20(%rdi)
ret

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

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