void kernel_sgemv_n_2_lib8(int kmax, float *A, float *x, float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0;
  k = 0;
  for (; k < kmax - 3; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[1 + lda * 0] * x_0;
    y_0 += A[0 + lda * 1] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[0 + lda * 2] * x_2;
    y_1 += A[1 + lda * 2] * x_2;
    y_0 += A[0 + lda * 3] * x_3;
    y_1 += A[1 + lda * 3] * x_3;
    A += 4 * lda;
    x += 4;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[1 + lda * 0] * x_0;
    A += 1 * lda;
    x += 1;
  }
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
  }
}


x86 assembly (clang, -O0):
<kernel_sgemv_n_2_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1126 <kernel_sgemv_n_2_lib8+0x26>
jmp    13c4 <kernel_sgemv_n_2_lib8+0x2c4>
movl   $0x8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    12b3 <kernel_sgemv_n_2_lib8+0x1b3>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1144 <kernel_sgemv_n_2_lib8+0x44>
jmp    12b8 <kernel_sgemv_n_2_lib8+0x1b8>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1336 <kernel_sgemv_n_2_lib8+0x236>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b8 <kernel_sgemv_n_2_lib8+0x1b8>
cmpl   $0x0,-0x24(%rbp)
jne    1360 <kernel_sgemv_n_2_lib8+0x260>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    13c4 <kernel_sgemv_n_2_lib8+0x2c4>
cmpl   $0x1,-0x24(%rbp)
jne    1393 <kernel_sgemv_n_2_lib8+0x293>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
jmp    13bf <kernel_sgemv_n_2_lib8+0x2bf>
movss  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
jmp    13c4 <kernel_sgemv_n_2_lib8+0x2c4>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_n_2_lib8>:
test   %edi,%edi
jle    11f2 <kernel_sgemv_n_2_lib8+0xf2>
cmp    $0x4,%edi
jb     119d <kernel_sgemv_n_2_lib8+0x9d>
lea    -0x3(%rdi),%r9d
xorps  %xmm2,%xmm2
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm3
movsd  0x20(%rsi),%xmm4
movsd  0x40(%rsi),%xmm5
movsd  0x60(%rsi),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm6
movss  0x8(%rdx),%xmm1
movss  0xc(%rdx),%xmm0
shufps $0x0,%xmm7,%xmm7
mulps  %xmm3,%xmm7
addps  %xmm2,%xmm7
shufps $0x0,%xmm6,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
shufps $0x0,%xmm1,%xmm1
mulps  %xmm5,%xmm1
addps  %xmm6,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
sub    $0xffffffffffffff80,%rsi
add    $0x10,%rdx
add    $0x4,%eax
cmp    %r9d,%eax
jl     1120 <kernel_sgemv_n_2_lib8+0x20>
addps  %xmm1,%xmm0
mov    %edi,%eax
and    $0xfffffffc,%eax
cmp    %edi,%eax
jl     11a6 <kernel_sgemv_n_2_lib8+0xa6>
movaps %xmm0,%xmm1
cmp    $0x1,%r8d
jne    11c1 <kernel_sgemv_n_2_lib8+0xc1>
jmp    1264 <kernel_sgemv_n_2_lib8+0x164>
xorps  %xmm0,%xmm0
xor    %eax,%eax
cmp    %edi,%eax
jge    118f <kernel_sgemv_n_2_lib8+0x8f>
mov    %eax,%r9d
not    %r9d
test   $0x1,%dil
jne    11f3 <kernel_sgemv_n_2_lib8+0xf3>
add    %edi,%r9d
jne    1218 <kernel_sgemv_n_2_lib8+0x118>
cmp    $0x1,%r8d
je     1264 <kernel_sgemv_n_2_lib8+0x164>
test   %r8d,%r8d
jne    11d4 <kernel_sgemv_n_2_lib8+0xd4>
movss  %xmm1,(%rcx)
shufps $0x55,%xmm1,%xmm1
movss  %xmm1,0x4(%rcx)
ret
movss  (%rcx),%xmm0
movss  0x4(%rcx),%xmm2
subss  %xmm1,%xmm0
movss  %xmm0,(%rcx)
shufps $0x55,%xmm1,%xmm1
subss  %xmm1,%xmm2
movss  %xmm2,0x4(%rcx)
ret
movsd  (%rsi),%xmm2
movss  (%rdx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
add    $0x20,%rsi
add    $0x4,%rdx
or     $0x1,%eax
movaps %xmm1,%xmm0
add    %edi,%r9d
je     11b7 <kernel_sgemv_n_2_lib8+0xb7>
sub    %eax,%edi
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm1
shufps $0x0,%xmm3,%xmm3
movsd  (%rsi),%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movsd  0x20(%rsi),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x2,%rax
add    $0x40,%rsi
cmp    %eax,%edi
jne    1220 <kernel_sgemv_n_2_lib8+0x120>
addps  %xmm2,%xmm1
cmp    $0x1,%r8d
jne    11c1 <kernel_sgemv_n_2_lib8+0xc1>
movss  (%rcx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rcx)
shufps $0x55,%xmm1,%xmm1
addss  0x4(%rcx),%xmm1
movss  %xmm1,0x4(%rcx)
ret

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

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