void babl_matrix_mul_vectorff_buf4(const float *mat, const float *v_in,
                                   float *v_out, int samples) {
  const float m_0_0 = mat[0 * 3 + 0];
  const float m_0_1 = mat[0 * 3 + 1];
  const float m_0_2 = mat[0 * 3 + 2];
  const float m_1_0 = mat[1 * 3 + 0];
  const float m_1_1 = mat[1 * 3 + 1];
  const float m_1_2 = mat[1 * 3 + 2];
  const float m_2_0 = mat[2 * 3 + 0];
  const float m_2_1 = mat[2 * 3 + 1];
  const float m_2_2 = mat[2 * 3 + 2];
  int i;
  for (i = 0; i < samples; i++) {
    float a = v_in[0], b = v_in[1], c = v_in[2];
    v_out[0] = m_0_0 * a + m_0_1 * b + m_0_2 * c;
    v_out[1] = m_1_0 * a + m_1_1 * b + m_1_2 * c;
    v_out[2] = m_2_0 * a + m_2_1 * b + m_2_2 * c;
    v_out[3] = v_in[3];
    v_in += 4;
    v_out += 4;
  }
}


x86 assembly (clang, -O0):
<babl_matrix_mul_vectorff_buf4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a8 <babl_matrix_mul_vectorff_buf4+0x1a8>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x20(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x38(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1197 <babl_matrix_mul_vectorff_buf4+0x97>
pop    %rbp
ret

x86 assembly (clang, -O2):
<babl_matrix_mul_vectorff_buf4>:
sub    $0x68,%rsp
test   %ecx,%ecx
jle    1213 <babl_matrix_mul_vectorff_buf4+0x113>
movss  (%rdi),%xmm9
movss  0x4(%rdi),%xmm7
movss  0x8(%rdi),%xmm0
movss  0xc(%rdi),%xmm8
movss  0x10(%rdi),%xmm6
movss  0x14(%rdi),%xmm10
movss  0x18(%rdi),%xmm11
movss  0x1c(%rdi),%xmm12
movss  0x20(%rdi),%xmm13
lea    -0x1(%rcx),%r9d
xor    %r8d,%r8d
cmp    $0x3,%r9d
jb     1173 <babl_matrix_mul_vectorff_buf4+0x73>
mov    %r9,%rax
shl    $0x4,%rax
lea    (%rsi,%rax,1),%rdi
add    $0x10,%rdi
cmp    %rdx,%rdi
jbe    1218 <babl_matrix_mul_vectorff_buf4+0x118>
add    %rdx,%rax
add    $0x10,%rax
cmp    %rsi,%rax
jbe    1218 <babl_matrix_mul_vectorff_buf4+0x118>
mov    %rsi,%r10
mov    %rdx,%rdi
sub    %r8d,%ecx
xor    %eax,%eax
xchg   %ax,%ax
movss  (%r10,%rax,1),%xmm1
movss  0x4(%r10,%rax,1),%xmm3
movss  0x8(%r10,%rax,1),%xmm2
movaps %xmm7,%xmm4
mulss  %xmm3,%xmm4
movaps %xmm9,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movaps %xmm0,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,(%rdi,%rax,1)
movaps %xmm6,%xmm4
mulss  %xmm3,%xmm4
movaps %xmm8,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movaps %xmm10,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,0x4(%rdi,%rax,1)
mulss  %xmm12,%xmm3
mulss  %xmm11,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm13,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x8(%rdi,%rax,1)
movss  0xc(%r10,%rax,1),%xmm1
movss  %xmm1,0xc(%rdi,%rax,1)
add    $0x10,%rax
add    $0xffffffff,%ecx
jne    1180 <babl_matrix_mul_vectorff_buf4+0x80>
add    $0x68,%rsp
ret
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
mov    %r8,%rdi
shl    $0x4,%rdi
lea    (%rsi,%rdi,1),%r10
add    %rdx,%rdi
movaps %xmm7,(%rsp)
shufps $0x0,%xmm7,%xmm7
movaps %xmm7,0x40(%rsp)
movaps %xmm9,-0x60(%rsp)
shufps $0x0,%xmm9,%xmm9
movaps %xmm9,0x50(%rsp)
movaps %xmm0,-0x10(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm6,-0x20(%rsp)
shufps $0x0,%xmm6,%xmm6
movaps %xmm6,0x20(%rsp)
movaps %xmm8,-0x80(%rsp)
shufps $0x0,%xmm8,%xmm8
movaps %xmm8,0x10(%rsp)
movaps %xmm10,-0x30(%rsp)
movaps %xmm10,%xmm0
shufps $0x0,%xmm10,%xmm0
movaps %xmm12,-0x40(%rsp)
movaps %xmm12,%xmm5
shufps $0x0,%xmm12,%xmm5
movaps %xmm11,-0x50(%rsp)
movaps %xmm11,%xmm6
shufps $0x0,%xmm11,%xmm6
movaps %xmm13,-0x70(%rsp)
movaps %xmm13,%xmm7
shufps $0x0,%xmm13,%xmm7
xor    %eax,%eax
mov    %r8,%r11
nopl   (%rax)
movups (%rsi,%rax,1),%xmm10
movups 0x10(%rsi,%rax,1),%xmm8
movups 0x20(%rsi,%rax,1),%xmm11
movups 0x30(%rsi,%rax,1),%xmm12
movaps %xmm12,%xmm1
movlhps %xmm11,%xmm1
movaps %xmm10,%xmm15
unpcklps %xmm8,%xmm15
shufps $0x24,%xmm1,%xmm15
movaps %xmm11,%xmm1
unpcklps %xmm12,%xmm1
movaps %xmm8,%xmm14
shufps $0x11,%xmm10,%xmm14
shufps $0xe2,%xmm1,%xmm14
movaps %xmm12,%xmm1
unpckhpd %xmm11,%xmm1
movaps %xmm10,%xmm13
unpckhps %xmm8,%xmm13
shufps $0x24,%xmm1,%xmm13
movaps 0x40(%rsp),%xmm1
mulps  %xmm14,%xmm1
movaps 0x50(%rsp),%xmm2
mulps  %xmm15,%xmm2
addps  %xmm1,%xmm2
movaps 0x30(%rsp),%xmm9
mulps  %xmm13,%xmm9
addps  %xmm2,%xmm9
movaps 0x20(%rsp),%xmm1
mulps  %xmm14,%xmm1
movaps 0x10(%rsp),%xmm2
mulps  %xmm15,%xmm2
addps  %xmm1,%xmm2
movaps %xmm0,%xmm1
mulps  %xmm13,%xmm1
addps  %xmm2,%xmm1
mulps  %xmm5,%xmm14
mulps  %xmm6,%xmm15
addps  %xmm14,%xmm15
mulps  %xmm7,%xmm13
addps  %xmm15,%xmm13
movaps %xmm1,%xmm2
shufps $0x11,%xmm9,%xmm2
shufps $0x13,%xmm13,%xmm8
shufps $0x22,%xmm8,%xmm2
movaps %xmm9,%xmm3
unpcklps %xmm1,%xmm3
shufps $0x3,%xmm13,%xmm10
shufps $0x24,%xmm10,%xmm3
shufps $0x23,%xmm13,%xmm11
unpckhps %xmm12,%xmm13
movaps %xmm1,%xmm4
shufps $0x33,%xmm9,%xmm4
shufps $0xe2,%xmm13,%xmm4
unpckhps %xmm1,%xmm9
shufps $0x24,%xmm11,%xmm9
movups %xmm9,0x20(%rdx,%rax,1)
movups %xmm4,0x30(%rdx,%rax,1)
movups %xmm3,(%rdx,%rax,1)
movups %xmm2,0x10(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffc,%r11
jne    12c0 <babl_matrix_mul_vectorff_buf4+0x1c0>
cmp    %r8,%r9
movaps -0x60(%rsp),%xmm9
movaps (%rsp),%xmm7
movaps -0x10(%rsp),%xmm0
movaps -0x80(%rsp),%xmm8
movaps -0x20(%rsp),%xmm6
movaps -0x30(%rsp),%xmm10
movaps -0x50(%rsp),%xmm11
movaps -0x40(%rsp),%xmm12
movaps -0x70(%rsp),%xmm13
jne    1179 <babl_matrix_mul_vectorff_buf4+0x79>
jmp    1213 <babl_matrix_mul_vectorff_buf4+0x113>

LLVM IR (-O0):
define void @babl_matrix_mul_vectorff_buf4(float* %0, float* %1, float* %2, i32 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%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 i32
%19 = alloca float
%20 = alloca float
%21 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store float* %2, float** %7
store i32 %3, i32* %8
%22 = load float*, float** %5
%23 = getelementptr inbounds float, float* %22, i64 0
%24 = load float, float* %23
store float %24, float* %9
%25 = load float*, float** %5
%26 = getelementptr inbounds float, float* %25, i64 1
%27 = load float, float* %26
store float %27, float* %10
%28 = load float*, float** %5
%29 = getelementptr inbounds float, float* %28, i64 2
%30 = load float, float* %29
store float %30, float* %11
%31 = load float*, float** %5
%32 = getelementptr inbounds float, float* %31, i64 3
%33 = load float, float* %32
store float %33, float* %12
%34 = load float*, float** %5
%35 = getelementptr inbounds float, float* %34, i64 4
%36 = load float, float* %35
store float %36, float* %13
%37 = load float*, float** %5
%38 = getelementptr inbounds float, float* %37, i64 5
%39 = load float, float* %38
store float %39, float* %14
%40 = load float*, float** %5
%41 = getelementptr inbounds float, float* %40, i64 6
%42 = load float, float* %41
store float %42, float* %15
%43 = load float*, float** %5
%44 = getelementptr inbounds float, float* %43, i64 7
%45 = load float, float* %44
store float %45, float* %16
%46 = load float*, float** %5
%47 = getelementptr inbounds float, float* %46, i64 8
%48 = load float, float* %47
store float %48, float* %17
store i32 0, i32* %18
br label %49
49: ; preds = %105, %4
%50 = load i32, i32* %18
%51 = load i32, i32* %8
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %108
53: ; preds = %49
%54 = load float*, float** %6
%55 = getelementptr inbounds float, float* %54, i64 0
%56 = load float, float* %55
store float %56, float* %19
%57 = load float*, float** %6
%58 = getelementptr inbounds float, float* %57, i64 1
%59 = load float, float* %58
store float %59, float* %20
%60 = load float*, float** %6
%61 = getelementptr inbounds float, float* %60, i64 2
%62 = load float, float* %61
store float %62, float* %21
%63 = load float, float* %9
%64 = load float, float* %19
%65 = load float, float* %10
%66 = load float, float* %20
%67 = fmul float %65, %66
%68 = call float @llvm.fmuladd.f32(float %63, float %64, float %67)
%69 = load float, float* %11
%70 = load float, float* %21
%71 = call float @llvm.fmuladd.f32(float %69, float %70, float %68)
%72 = load float*, float** %7
%73 = getelementptr inbounds float, float* %72, i64 0
store float %71, float* %73
%74 = load float, float* %12
%75 = load float, float* %19
%76 = load float, float* %13
%77 = load float, float* %20
%78 = fmul float %76, %77
%79 = call float @llvm.fmuladd.f32(float %74, float %75, float %78)
%80 = load float, float* %14
%81 = load float, float* %21
%82 = call float @llvm.fmuladd.f32(float %80, float %81, float %79)
%83 = load float*, float** %7
%84 = getelementptr inbounds float, float* %83, i64 1
store float %82, float* %84
%85 = load float, float* %15
%86 = load float, float* %19
%87 = load float, float* %16
%88 = load float, float* %20
%89 = fmul float %87, %88
%90 = call float @llvm.fmuladd.f32(float %85, float %86, float %89)
%91 = load float, float* %17
%92 = load float, float* %21
%93 = call float @llvm.fmuladd.f32(float %91, float %92, float %90)
%94 = load float*, float** %7
%95 = getelementptr inbounds float, float* %94, i64 2
store float %93, float* %95
%96 = load float*, float** %6
%97 = getelementptr inbounds float, float* %96, i64 3
%98 = load float, float* %97
%99 = load float*, float** %7
%100 = getelementptr inbounds float, float* %99, i64 3
store float %98, float* %100
%101 = load float*, float** %6
%102 = getelementptr inbounds float, float* %101, i64 4
store float* %102, float** %6
%103 = load float*, float** %7
%104 = getelementptr inbounds float, float* %103, i64 4
store float* %104, float** %7
br label %105
105: ; preds = %53
%106 = load i32, i32* %18
%107 = add nsw i32 %106, 1
store i32 %107, i32* %18
br label %49
108: ; preds = %49
ret void
}

LLVM IR (-O2):
define void @babl_matrix_mul_vectorff_buf4(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2, i32 %3) {
%5 = load float, float* %0
%6 = getelementptr inbounds float, float* %0, i64 1
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %0, i64 2
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 3
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 4
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %0, i64 5
%15 = load float, float* %14
%16 = getelementptr inbounds float, float* %0, i64 6
%17 = load float, float* %16
%18 = getelementptr inbounds float, float* %0, i64 7
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 8
%21 = load float, float* %20
%22 = icmp sgt i32 %3, 0
br i1 %22, label %23, label %123
23: ; preds = %4
%24 = add i32 %3, -1
%25 = zext i32 %24 to i64
%26 = add nuw nsw i64 %25, 1
%27 = icmp ult i32 %24, 3
br i1 %27, label %92, label %28
28: ; preds = %23
%29 = add i32 %3, -1
%30 = zext i32 %29 to i64
%31 = shl nuw nsw i64 %30, 2
%32 = add nuw nsw i64 %31, 4
%33 = getelementptr float, float* %2, i64 %32
%34 = getelementptr float, float* %1, i64 %32
%35 = icmp ugt float* %34, %2
%36 = icmp ugt float* %33, %1
%37 = and i1 %35, %36
br i1 %37, label %92, label %38
38: ; preds = %28
%39 = and i64 %26, 8589934588
%40 = shl nuw nsw i64 %39, 2
%41 = getelementptr float, float* %1, i64 %40
%42 = shl nuw nsw i64 %39, 2
%43 = getelementptr float, float* %2, i64 %42
%44 = trunc i64 %39 to i32
%45 = insertelement <4 x float> poison, float %7, i64 0
%46 = shufflevector <4 x float> %45, <4 x float> poison, <4 x i32> zeroinitializer
%47 = insertelement <4 x float> poison, float %5, i64 0
%48 = shufflevector <4 x float> %47, <4 x float> poison, <4 x i32> zeroinitializer
%49 = insertelement <4 x float> poison, float %9, i64 0
%50 = shufflevector <4 x float> %49, <4 x float> poison, <4 x i32> zeroinitializer
%51 = insertelement <4 x float> poison, float %13, i64 0
%52 = shufflevector <4 x float> %51, <4 x float> poison, <4 x i32> zeroinitializer
%53 = insertelement <4 x float> poison, float %11, i64 0
%54 = shufflevector <4 x float> %53, <4 x float> poison, <4 x i32> zeroinitializer
%55 = insertelement <4 x float> poison, float %15, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = insertelement <4 x float> poison, float %19, i64 0
%58 = shufflevector <4 x float> %57, <4 x float> poison, <4 x i32> zeroinitializer
%59 = insertelement <4 x float> poison, float %17, i64 0
%60 = shufflevector <4 x float> %59, <4 x float> poison, <4 x i32> zeroinitializer
%61 = insertelement <4 x float> poison, float %21, i64 0
%62 = shufflevector <4 x float> %61, <4 x float> poison, <4 x i32> zeroinitializer
br label %63
63: ; preds = %63, %38
%64 = phi i64 [ 0, %38 ], [ %88, %63 ]
%65 = shl i64 %64, 2
%66 = getelementptr float, float* %1, i64 %65
%67 = shl i64 %64, 2
%68 = bitcast float* %66 to <16 x float>*
%69 = load <16 x float>, <16 x float>* %68
%70 = shufflevector <16 x float> %69, <16 x float> poison, <4 x i32> <i32 0, i32 4, i32 8, i32 12>
%71 = shufflevector <16 x float> %69, <16 x float> poison, <4 x i32> <i32 1, i32 5, i32 9, i32 13>
%72 = shufflevector <16 x float> %69, <16 x float> poison, <4 x i32> <i32 2, i32 6, i32 10, i32 14>
%73 = shufflevector <16 x float> %69, <16 x float> poison, <4 x i32> <i32 3, i32 7, i32 11, i32 15>
%74 = fmul <4 x float> %46, %71
%75 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %48, <4 x float> %70, <4 x float> %74)
%76 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %50, <4 x float> %72, <4 x float> %75)
%77 = fmul <4 x float> %52, %71
%78 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %54, <4 x float> %70, <4 x float> %77)
%79 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %56, <4 x float> %72, <4 x float> %78)
%80 = fmul <4 x float> %58, %71
%81 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %60, <4 x float> %70, <4 x float> %80)
%82 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %62, <4 x float> %72, <4 x float> %81)
%83 = getelementptr inbounds float, float* %2, i64 %67
%84 = bitcast float* %83 to <16 x float>*
%85 = shufflevector <4 x float> %76, <4 x float> %79, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%86 = shufflevector <4 x float> %82, <4 x float> %73, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%87 = shufflevector <8 x float> %85, <8 x float> %86, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
store <16 x float> %87, <16 x float>* %84
%88 = add nuw i64 %64, 4
%89 = icmp eq i64 %88, %39
br i1 %89, label %90, label %63
90: ; preds = %63
%91 = icmp eq i64 %26, %39
br i1 %91, label %123, label %92
92: ; preds = %28, %23, %90
%93 = phi float* [ %1, %28 ], [ %1, %23 ], [ %41, %90 ]
%94 = phi float* [ %2, %28 ], [ %2, %23 ], [ %43, %90 ]
%95 = phi i32 [ 0, %28 ], [ 0, %23 ], [ %44, %90 ]
br label %96
96: ; preds = %92, %96
%97 = phi float* [ %119, %96 ], [ %93, %92 ]
%98 = phi float* [ %120, %96 ], [ %94, %92 ]
%99 = phi i32 [ %121, %96 ], [ %95, %92 ]
%100 = load float, float* %97
%101 = getelementptr inbounds float, float* %97, i64 1
%102 = load float, float* %101
%103 = getelementptr inbounds float, float* %97, i64 2
%104 = load float, float* %103
%105 = fmul float %7, %102
%106 = tail call float @llvm.fmuladd.f32(float %5, float %100, float %105)
%107 = tail call float @llvm.fmuladd.f32(float %9, float %104, float %106)
store float %107, float* %98
%108 = fmul float %13, %102
%109 = tail call float @llvm.fmuladd.f32(float %11, float %100, float %108)
%110 = tail call float @llvm.fmuladd.f32(float %15, float %104, float %109)
%111 = getelementptr inbounds float, float* %98, i64 1
store float %110, float* %111
%112 = fmul float %19, %102
%113 = tail call float @llvm.fmuladd.f32(float %17, float %100, float %112)
%114 = tail call float @llvm.fmuladd.f32(float %21, float %104, float %113)
%115 = getelementptr inbounds float, float* %98, i64 2
store float %114, float* %115
%116 = getelementptr inbounds float, float* %97, i64 3
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %98, i64 3
store float %117, float* %118
%119 = getelementptr inbounds float, float* %97, i64 4
%120 = getelementptr inbounds float, float* %98, i64 4
%121 = add nuw nsw i32 %99, 1
%122 = icmp eq i32 %121, %3
br i1 %122, label %123, label %96
123: ; preds = %96, %90, %4
ret void
}