void kernel6(int L, float *ai, float *ef) {
  int i;
  for (i = 0; i < L; i += 4) {
    ai[i + 0] += (double)ef[2 * (i + 0)] * (double)ef[2 * (i + 0)] +
                 (double)ef[2 * (i + 0) + 1] * (double)ef[2 * (i + 0) + 1];
    ai[i + 1] += (double)ef[2 * (i + 1)] * (double)ef[2 * (i + 1)] +
                 (double)ef[2 * (i + 1) + 1] * (double)ef[2 * (i + 1) + 1];
    ai[i + 2] += (double)ef[2 * (i + 2)] * (double)ef[2 * (i + 2)] +
                 (double)ef[2 * (i + 2) + 1] * (double)ef[2 * (i + 2) + 1];
    ai[i + 3] += (double)ef[2 * (i + 3)] * (double)ef[2 * (i + 3)] +
                 (double)ef[2 * (i + 3) + 1] * (double)ef[2 * (i + 3) + 1];
  }
}


x86 assembly (clang, -O0):
<kernel6>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1394 <kernel6+0x294>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1116 <kernel6+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel6>:
test   %edi,%edi
jle    1256 <kernel6+0x156>
mov    %edi,%r10d
lea    -0x1(%r10),%r9
cmp    $0x4,%r9
jb     1143 <kernel6+0x43>
lea    (%r10,%r10,1),%rax
add    $0x6,%rax
and    $0xfffffffffffffff8,%rax
lea    (%rdx,%rax,4),%rax
cmp    %rsi,%rax
jbe    1257 <kernel6+0x157>
lea    0x3(%r10),%rax
and    $0xfffffffffffffffc,%rax
lea    (%rsi,%rax,4),%rax
cmp    %rdx,%rax
jbe    1257 <kernel6+0x157>
xor    %ecx,%ecx
lea    (%rcx,%rcx,1),%rax
add    $0x6,%rax
nopl   (%rax)
movss  (%rdx,%rcx,8),%xmm0
movss  0x4(%rdx,%rcx,8),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  (%rsi,%rcx,4),%xmm1
movss  0x4(%rsi,%rcx,4),%xmm2
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,8),%xmm0
movss  0xc(%rdx,%rcx,8),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
lea    -0x2(%rax),%edi
and    $0xfffffffc,%edi
movss  (%rdx,%rdi,4),%xmm0
movss  0x4(%rdx,%rdi,4),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  0x8(%rsi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
mov    %eax,%edi
and    $0xfffffffe,%edi
movss  (%rdx,%rdi,4),%xmm0
movss  0x4(%rdx,%rdi,4),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  0xc(%rsi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
add    $0x8,%rax
cmp    %r10,%rcx
jb     1150 <kernel6+0x50>
ret
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffe,%r8
lea    0x0(,%r8,4),%rcx
xor    %edi,%edi
mov    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rdx,%rdi,2),%xmm1
movups 0x10(%rdx,%rdi,2),%xmm2
movups 0x20(%rdx,%rdi,2),%xmm6
movups 0x30(%rdx,%rdi,2),%xmm0
movaps %xmm1,%xmm4
unpcklps %xmm6,%xmm4
movaps %xmm6,%xmm3
shufps $0x11,%xmm1,%xmm3
shufps $0xe2,%xmm1,%xmm3
movaps %xmm1,%xmm7
unpckhps %xmm6,%xmm7
shufps $0x33,%xmm1,%xmm6
shufps $0xe2,%xmm1,%xmm6
movaps %xmm2,%xmm9
unpcklps %xmm0,%xmm9
movaps %xmm0,%xmm5
shufps $0x11,%xmm2,%xmm5
shufps $0xe2,%xmm2,%xmm5
movaps %xmm2,%xmm8
unpckhps %xmm0,%xmm8
shufps $0x33,%xmm2,%xmm0
shufps $0xe2,%xmm2,%xmm0
cvtps2pd %xmm4,%xmm2
cvtps2pd %xmm3,%xmm1
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
addpd  %xmm1,%xmm2
movss  0x10(%rsi,%rdi,1),%xmm1
movss  (%rsi,%rdi,1),%xmm3
unpcklps %xmm1,%xmm3
movss  0x4(%rsi,%rdi,1),%xmm4
movss  0x8(%rsi,%rdi,1),%xmm1
movss  0xc(%rsi,%rdi,1),%xmm10
cvtps2pd %xmm3,%xmm3
addpd  %xmm2,%xmm3
cvtpd2ps %xmm3,%xmm2
cvtps2pd %xmm7,%xmm3
cvtps2pd %xmm6,%xmm6
mulpd  %xmm6,%xmm6
mulpd  %xmm3,%xmm3
movss  0x14(%rsi,%rdi,1),%xmm7
unpcklps %xmm7,%xmm4
cvtps2pd %xmm4,%xmm4
addpd  %xmm6,%xmm3
addpd  %xmm3,%xmm4
cvtpd2ps %xmm4,%xmm3
cvtps2pd %xmm9,%xmm4
cvtps2pd %xmm5,%xmm5
mulpd  %xmm5,%xmm5
mulpd  %xmm4,%xmm4
addpd  %xmm5,%xmm4
movss  0x18(%rsi,%rdi,1),%xmm5
unpcklps %xmm5,%xmm1
cvtps2pd %xmm1,%xmm1
addpd  %xmm4,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtps2pd %xmm8,%xmm4
cvtps2pd %xmm0,%xmm0
mulpd  %xmm0,%xmm0
mulpd  %xmm4,%xmm4
movss  0x1c(%rsi,%rdi,1),%xmm5
unpcklps %xmm5,%xmm10
cvtps2pd %xmm10,%xmm5
addpd  %xmm0,%xmm4
addpd  %xmm4,%xmm5
cvtpd2ps %xmm5,%xmm0
unpcklpd %xmm3,%xmm2
unpcklpd %xmm0,%xmm1
movapd %xmm2,%xmm0
shufps $0xdd,%xmm1,%xmm0
shufps $0x88,%xmm1,%xmm2
movups %xmm2,(%rsi,%rdi,1)
movups %xmm0,0x10(%rsi,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rax
jne    1280 <kernel6+0x180>
cmp    %r8,%r9
je     1256 <kernel6+0x156>
jmp    1145 <kernel6+0x45>

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

LLVM IR (-O2):
define void @kernel6(i32 %0, float* nocapture %1, float* nocapture %2) {
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %181
5: ; preds = %3
%6 = zext i32 %0 to i64
%7 = add nsw i64 %6, -1
%8 = lshr i64 %7, 2
%9 = add nuw nsw i64 %8, 1
%10 = icmp ult i64 %7, 4
br i1 %10, label %108, label %11
11: ; preds = %5
%12 = add nuw nsw i64 %6, 3
%13 = and i64 %12, 8589934588
%14 = getelementptr float, float* %1, i64 %13
%15 = shl nuw nsw i64 %6, 1
%16 = add nuw nsw i64 %15, 6
%17 = and i64 %16, 17179869176
%18 = getelementptr float, float* %2, i64 %17
%19 = icmp ugt float* %18, %1
%20 = icmp ugt float* %14, %2
%21 = and i1 %19, %20
br i1 %21, label %108, label %22
22: ; preds = %11
%23 = and i64 %9, 9223372036854775806
%24 = shl i64 %23, 2
br label %25
25: ; preds = %25, %22
%26 = phi i64 [ 0, %22 ], [ %104, %25 ]
%27 = shl i64 %26, 2
%28 = or i64 %27, 4
%29 = shl i64 %26, 3
%30 = getelementptr inbounds float, float* %2, i64 %29
%31 = bitcast float* %30 to <16 x float>*
%32 = load <16 x float>, <16 x float>* %31
%33 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 0, i32 8>
%34 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 1, i32 9>
%35 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 2, i32 10>
%36 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 3, i32 11>
%37 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 4, i32 12>
%38 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 5, i32 13>
%39 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 6, i32 14>
%40 = shufflevector <16 x float> %32, <16 x float> poison, <2 x i32> <i32 7, i32 15>
%41 = fpext <2 x float> %33 to <2 x double>
%42 = fpext <2 x float> %34 to <2 x double>
%43 = fmul <2 x double> %42, %42
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %41, <2 x double> %41, <2 x double> %43)
%45 = getelementptr inbounds float, float* %1, i64 %27
%46 = getelementptr inbounds float, float* %1, i64 %28
%47 = load float, float* %45
%48 = load float, float* %46
%49 = insertelement <2 x float> poison, float %47, i64 0
%50 = insertelement <2 x float> %49, float %48, i64 1
%51 = fpext <2 x float> %50 to <2 x double>
%52 = fadd <2 x double> %44, %51
%53 = fptrunc <2 x double> %52 to <2 x float>
%54 = or i64 %27, 1
%55 = or i64 %27, 5
%56 = fpext <2 x float> %35 to <2 x double>
%57 = fpext <2 x float> %36 to <2 x double>
%58 = fmul <2 x double> %57, %57
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %56, <2 x double> %56, <2 x double> %58)
%60 = getelementptr inbounds float, float* %1, i64 %54
%61 = getelementptr inbounds float, float* %1, i64 %55
%62 = load float, float* %60
%63 = load float, float* %61
%64 = insertelement <2 x float> poison, float %62, i64 0
%65 = insertelement <2 x float> %64, float %63, i64 1
%66 = fpext <2 x float> %65 to <2 x double>
%67 = fadd <2 x double> %59, %66
%68 = fptrunc <2 x double> %67 to <2 x float>
%69 = or i64 %27, 2
%70 = or i64 %27, 6
%71 = fpext <2 x float> %37 to <2 x double>
%72 = fpext <2 x float> %38 to <2 x double>
%73 = fmul <2 x double> %72, %72
%74 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %71, <2 x double> %71, <2 x double> %73)
%75 = getelementptr inbounds float, float* %1, i64 %69
%76 = getelementptr inbounds float, float* %1, i64 %70
%77 = load float, float* %75
%78 = load float, float* %76
%79 = insertelement <2 x float> poison, float %77, i64 0
%80 = insertelement <2 x float> %79, float %78, i64 1
%81 = fpext <2 x float> %80 to <2 x double>
%82 = fadd <2 x double> %74, %81
%83 = fptrunc <2 x double> %82 to <2 x float>
%84 = or i64 %27, 3
%85 = or i64 %27, 7
%86 = fpext <2 x float> %39 to <2 x double>
%87 = fpext <2 x float> %40 to <2 x double>
%88 = fmul <2 x double> %87, %87
%89 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %86, <2 x double> %86, <2 x double> %88)
%90 = getelementptr inbounds float, float* %1, i64 %84
%91 = getelementptr inbounds float, float* %1, i64 %85
%92 = load float, float* %90
%93 = load float, float* %91
%94 = insertelement <2 x float> poison, float %92, i64 0
%95 = insertelement <2 x float> %94, float %93, i64 1
%96 = fpext <2 x float> %95 to <2 x double>
%97 = fadd <2 x double> %89, %96
%98 = fptrunc <2 x double> %97 to <2 x float>
%99 = getelementptr inbounds float, float* %90, i64 -3
%100 = bitcast float* %99 to <8 x float>*
%101 = shufflevector <2 x float> %53, <2 x float> %68, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%102 = shufflevector <2 x float> %83, <2 x float> %98, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%103 = shufflevector <4 x float> %101, <4 x float> %102, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x float> %103, <8 x float>* %100
%104 = add nuw i64 %26, 2
%105 = icmp eq i64 %104, %23
br i1 %105, label %106, label %25
106: ; preds = %25
%107 = icmp eq i64 %9, %23
br i1 %107, label %181, label %108
108: ; preds = %11, %5, %106
%109 = phi i64 [ 0, %11 ], [ 0, %5 ], [ %24, %106 ]
br label %110
110: ; preds = %108, %110
%111 = phi i64 [ %179, %110 ], [ %109, %108 ]
%112 = shl nuw nsw i64 %111, 1
%113 = getelementptr inbounds float, float* %2, i64 %112
%114 = load float, float* %113
%115 = fpext float %114 to double
%116 = or i64 %112, 1
%117 = getelementptr inbounds float, float* %2, i64 %116
%118 = load float, float* %117
%119 = fpext float %118 to double
%120 = fmul double %119, %119
%121 = tail call double @llvm.fmuladd.f64(double %115, double %115, double %120)
%122 = getelementptr inbounds float, float* %1, i64 %111
%123 = load float, float* %122
%124 = fpext float %123 to double
%125 = fadd double %121, %124
%126 = fptrunc double %125 to float
store float %126, float* %122
%127 = or i64 %111, 1
%128 = shl nuw nsw i64 %127, 1
%129 = getelementptr inbounds float, float* %2, i64 %128
%130 = load float, float* %129
%131 = fpext float %130 to double
%132 = or i64 %128, 1
%133 = getelementptr inbounds float, float* %2, i64 %132
%134 = load float, float* %133
%135 = fpext float %134 to double
%136 = fmul double %135, %135
%137 = tail call double @llvm.fmuladd.f64(double %131, double %131, double %136)
%138 = getelementptr inbounds float, float* %1, i64 %127
%139 = load float, float* %138
%140 = fpext float %139 to double
%141 = fadd double %137, %140
%142 = fptrunc double %141 to float
store float %142, float* %138
%143 = or i64 %111, 2
%144 = shl nuw nsw i64 %143, 1
%145 = and i64 %144, 4294967292
%146 = getelementptr inbounds float, float* %2, i64 %145
%147 = load float, float* %146
%148 = fpext float %147 to double
%149 = and i64 %144, 4294967292
%150 = or i64 %149, 1
%151 = getelementptr inbounds float, float* %2, i64 %150
%152 = load float, float* %151
%153 = fpext float %152 to double
%154 = fmul double %153, %153
%155 = tail call double @llvm.fmuladd.f64(double %148, double %148, double %154)
%156 = getelementptr inbounds float, float* %1, i64 %143
%157 = load float, float* %156
%158 = fpext float %157 to double
%159 = fadd double %155, %158
%160 = fptrunc double %159 to float
store float %160, float* %156
%161 = or i64 %111, 3
%162 = shl nuw nsw i64 %161, 1
%163 = and i64 %162, 4294967294
%164 = getelementptr inbounds float, float* %2, i64 %163
%165 = load float, float* %164
%166 = fpext float %165 to double
%167 = and i64 %162, 4294967294
%168 = or i64 %167, 1
%169 = getelementptr inbounds float, float* %2, i64 %168
%170 = load float, float* %169
%171 = fpext float %170 to double
%172 = fmul double %171, %171
%173 = tail call double @llvm.fmuladd.f64(double %166, double %166, double %172)
%174 = getelementptr inbounds float, float* %1, i64 %161
%175 = load float, float* %174
%176 = fpext float %175 to double
%177 = fadd double %173, %176
%178 = fptrunc double %177 to float
store float %178, float* %174
%179 = add nuw nsw i64 %111, 4
%180 = icmp ult i64 %179, %6
br i1 %180, label %110, label %181
181: ; preds = %110, %106, %3
ret void
}