void m4prod(float *restrict A, const float *B, const float *C) {
  register unsigned j;
  for (j = 0; j < 4; ++j) {
    (A)[(0) + (j) * (4)] = ((B)[(0) + (0) * (4)] * (C)[(0) + (j) * (4)] +
                            (B)[(0) + (1) * (4)] * (C)[(1) + (j) * (4)] +
                            (B)[(0) + (2) * (4)] * (C)[(2) + (j) * (4)] +
                            (B)[(0) + (3) * (4)] * (C)[(3) + (j) * (4)]);
    (A)[(1) + (j) * (4)] = ((B)[(1) + (0) * (4)] * (C)[(0) + (j) * (4)] +
                            (B)[(1) + (1) * (4)] * (C)[(1) + (j) * (4)] +
                            (B)[(1) + (2) * (4)] * (C)[(2) + (j) * (4)] +
                            (B)[(1) + (3) * (4)] * (C)[(3) + (j) * (4)]);
    (A)[(2) + (j) * (4)] = ((B)[(2) + (0) * (4)] * (C)[(0) + (j) * (4)] +
                            (B)[(2) + (1) * (4)] * (C)[(1) + (j) * (4)] +
                            (B)[(2) + (2) * (4)] * (C)[(2) + (j) * (4)] +
                            (B)[(2) + (3) * (4)] * (C)[(3) + (j) * (4)]);
    (A)[(3) + (j) * (4)] = ((B)[(3) + (0) * (4)] * (C)[(0) + (j) * (4)] +
                            (B)[(3) + (1) * (4)] * (C)[(1) + (j) * (4)] +
                            (B)[(3) + (2) * (4)] * (C)[(2) + (j) * (4)] +
                            (B)[(3) + (3) * (4)] * (C)[(3) + (j) * (4)]);
  }
}


x86 assembly (clang, -O0):
<m4prod>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jae    13ae <m4prod+0x2ae>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1117 <m4prod+0x17>
pop    %rbp
ret

x86 assembly (clang, -O2):
<m4prod>:
movups (%rsi),%xmm2
movups 0x10(%rsi),%xmm3
movups 0x20(%rsi),%xmm1
movups 0x30(%rsi),%xmm0
movss  (%rdx),%xmm4
movss  0x4(%rdx),%xmm5
movss  0x8(%rdx),%xmm6
movss  0xc(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movups %xmm7,(%rdi)
movss  0x10(%rdx),%xmm4
movss  0x14(%rdx),%xmm5
movss  0x18(%rdx),%xmm6
movss  0x1c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movups %xmm7,0x10(%rdi)
movss  0x20(%rdx),%xmm4
movss  0x24(%rdx),%xmm5
movss  0x28(%rdx),%xmm6
movss  0x2c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movups %xmm7,0x20(%rdi)
movss  0x30(%rdx),%xmm4
movss  0x34(%rdx),%xmm5
movss  0x38(%rdx),%xmm6
movss  0x3c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movups %xmm7,0x30(%rdi)
ret

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

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