void h1(float *c, float *a, double b[], int size) {
  int t = 0;
#pragma omp simd safelen(16) linear(t) aligned(c : 32) aligned(a, b)
  for (int i = 0; i < size; ++i) {
    c[i] = a[i] * a[i] + b[i] * b[t];
    ++t;
  }
#pragma omp simd safelen(16) linear(t) aligned(c : 32) aligned(a, b) simdlen(8)
  for (int i = 0; i < size; ++i) {
    c[i] = a[i] * a[i] + b[i] * b[t];
    ++t;
  }
#pragma omp simd linear(t) aligned(c : 32) aligned(a, b) simdlen(8)
  for (int i = 0; i < size; ++i) {
    c[i] = a[i] * a[i] + b[i] * b[t];
    ++t;
  }
}


x86 assembly (clang, -O0):
<h1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1195 <h1+0x95>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1121 <h1+0x21>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1210 <h1+0x110>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    119c <h1+0x9c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128b <h1+0x18b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1217 <h1+0x117>
pop    %rbp
ret

x86 assembly (clang, -O2):
<h1>:
push   %r15
push   %r14
push   %r12
push   %rbx
test   %ecx,%ecx
jle    1576 <h1+0x476>
mov    %ecx,%r9d
cmp    $0x4,%ecx
jb     1131 <h1+0x31>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    11da <h1+0xda>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    11da <h1+0xda>
xor    %eax,%eax
mov    %rax,%rbx
not    %rbx
test   $0x1,%r9b
je     1169 <h1+0x69>
movss  (%rsi,%rax,4),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rdi,%rax,4)
or     $0x1,%rax
add    %r9,%rbx
je     1245 <h1+0x145>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8(%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    1180 <h1+0x80>
jmp    1245 <h1+0x145>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    0x0(,%r9,4),%r8
and    $0xfffffffffffffff0,%r8
xor    %ebx,%ebx
xchg   %ax,%ax
movsd  (%rsi,%rbx,1),%xmm0
movsd  0x8(%rsi,%rbx,1),%xmm1
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
cvtps2pd %xmm0,%xmm0
cvtps2pd %xmm1,%xmm1
movupd (%rdx,%rbx,2),%xmm2
movupd 0x10(%rdx,%rbx,2),%xmm3
mulpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
cvtpd2ps %xmm2,%xmm0
cvtpd2ps %xmm3,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdi,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%r8
jne    11f0 <h1+0xf0>
cmp    %r9,%rax
jne    1133 <h1+0x33>
test   %ecx,%ecx
jle    1576 <h1+0x476>
cmp    $0x4,%ecx
jb     126c <h1+0x16c>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    1359 <h1+0x259>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    1359 <h1+0x259>
xor    %r10d,%r10d
mov    %r9,%r8
mov    %r10,%rax
not    %rax
test   $0x1,%r9b
je     12b1 <h1+0x1b1>
movss  (%rsi,%r10,4),%xmm0
mulss  %xmm0,%xmm0
movsd  (%rdx,%r10,8),%xmm1
mulsd  (%rdx,%r8,8),%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rdi,%r10,4)
add    $0x1,%r8
or     $0x1,%r10
add    %r9,%rax
je     13e9 <h1+0x2e9>
lea    (%rdx,%r8,8),%r14
add    $0x8,%r14
mov    %r9,%r11
sub    %r10,%r11
lea    (%rdi,%r10,4),%r15
add    $0x4,%r15
lea    (%rdx,%r10,8),%r12
add    $0x8,%r12
lea    (%rsi,%r10,4),%rbx
add    $0x4,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rbx,%rax,4),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x8(%r12,%rax,8),%xmm1
mulsd  -0x8(%r14,%rax,8),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,-0x4(%r15,%rax,4)
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm0,%xmm0
movsd  (%r12,%rax,8),%xmm1
mulsd  (%r14,%rax,8),%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    12f0 <h1+0x1f0>
add    %rax,%r8
jmp    13e9 <h1+0x2e9>
mov    %r9d,%r10d
and    $0xfffffffc,%r10d
lea    (%r10,%r9,1),%r8
lea    0x10(%rdx),%rax
mov    $0x1,%r11d
mov    %r10,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%r11,8),%xmm0
movsd  (%rsi,%r11,8),%xmm1
mulps  %xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
mulps  %xmm1,%xmm1
cvtps2pd %xmm1,%xmm1
movupd -0x10(%rax),%xmm2
movupd (%rax),%xmm3
movupd -0x10(%rax,%r9,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd (%rax,%r9,8),%xmm0
mulpd  %xmm3,%xmm0
cvtpd2ps %xmm4,%xmm2
addpd  %xmm1,%xmm0
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm0,%xmm2
movupd %xmm2,-0x8(%rdi,%r11,8)
add    $0x2,%r11
add    $0x20,%rax
add    $0xfffffffffffffffc,%rbx
jne    1380 <h1+0x280>
cmp    %r9,%r10
jne    1272 <h1+0x172>
test   %ecx,%ecx
jle    1576 <h1+0x476>
mov    %r8d,%r11d
cmp    $0x4,%ecx
jb     1413 <h1+0x313>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    14f0 <h1+0x3f0>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    14f0 <h1+0x3f0>
xor    %r10d,%r10d
mov    %r11,%r8
mov    %r10,%rax
not    %rax
test   $0x1,%r9b
je     1458 <h1+0x358>
movss  (%rsi,%r10,4),%xmm0
mulss  %xmm0,%xmm0
movsd  (%rdx,%r10,8),%xmm1
mulsd  (%rdx,%r8,8),%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rdi,%r10,4)
add    $0x1,%r8
or     $0x1,%r10
add    %r9,%rax
je     1576 <h1+0x476>
lea    (%rdx,%r8,8),%rax
add    $0x8,%rax
sub    %r10,%r9
lea    (%rdi,%r10,4),%rcx
add    $0x4,%rcx
lea    (%rdx,%r10,8),%rdx
add    $0x8,%rdx
lea    (%rsi,%r10,4),%rsi
add    $0x4,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rdi,4),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x8(%rdx,%rdi,8),%xmm1
mulsd  -0x8(%rax,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,-0x4(%rcx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm0
mulss  %xmm0,%xmm0
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rax,%rdi,8),%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rcx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1490 <h1+0x390>
jmp    1576 <h1+0x476>
mov    %r9d,%r10d
and    $0xfffffffc,%r10d
lea    (%r11,%r10,1),%r8
lea    0x10(%rdx),%rcx
mov    $0x1,%eax
mov    %r10,%rbx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
mulps  %xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
mulps  %xmm1,%xmm1
cvtps2pd %xmm1,%xmm1
movupd -0x10(%rcx),%xmm2
movupd (%rcx),%xmm3
movupd -0x10(%rcx,%r11,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd (%rcx,%r11,8),%xmm0
mulpd  %xmm3,%xmm0
cvtpd2ps %xmm4,%xmm2
addpd  %xmm1,%xmm0
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm0,%xmm2
movupd %xmm2,-0x8(%rdi,%rax,8)
add    $0x2,%rax
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1510 <h1+0x410>
cmp    %r9,%r10
jne    1419 <h1+0x319>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @h1(float* nocapture writeonly %0, float* nocapture %1, double* nocapture %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %274
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = icmp ult i32 %3, 4
br i1 %8, label %47, label %9
9: ; preds = %6
%10 = getelementptr float, float* %0, i64 %7
%11 = getelementptr float, float* %1, i64 %7
%12 = icmp ugt float* %11, %0
%13 = icmp ugt float* %10, %1
%14 = and i1 %12, %13
br i1 %14, label %47, label %15
15: ; preds = %9
%16 = and i64 %7, 4294967292
br label %17
17: ; preds = %17, %15
%18 = phi i64 [ 0, %15 ], [ %43, %17 ]
%19 = getelementptr inbounds float, float* %1, i64 %18
%20 = bitcast float* %19 to <2 x float>*
%21 = load <2 x float>, <2 x float>* %20
%22 = getelementptr inbounds float, float* %19, i64 2
%23 = bitcast float* %22 to <2 x float>*
%24 = load <2 x float>, <2 x float>* %23
%25 = fmul <2 x float> %21, %21
%26 = fmul <2 x float> %24, %24
%27 = fpext <2 x float> %25 to <2 x double>
%28 = fpext <2 x float> %26 to <2 x double>
%29 = getelementptr inbounds double, double* %2, i64 %18
%30 = bitcast double* %29 to <2 x double>*
%31 = load <2 x double>, <2 x double>* %30
%32 = getelementptr inbounds double, double* %29, i64 2
%33 = bitcast double* %32 to <2 x double>*
%34 = load <2 x double>, <2 x double>* %33
%35 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %31, <2 x double> %31, <2 x double> %27)
%36 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %34, <2 x double> %34, <2 x double> %28)
%37 = fptrunc <2 x double> %35 to <2 x float>
%38 = fptrunc <2 x double> %36 to <2 x float>
%39 = getelementptr inbounds float, float* %0, i64 %18
%40 = bitcast float* %39 to <2 x float>*
store <2 x float> %37, <2 x float>* %40
%41 = getelementptr inbounds float, float* %39, i64 2
%42 = bitcast float* %41 to <2 x float>*
store <2 x float> %38, <2 x float>* %42
%43 = add nuw i64 %18, 4
%44 = icmp eq i64 %43, %16
br i1 %44, label %45, label %17
45: ; preds = %17
%46 = icmp eq i64 %16, %7
br i1 %46, label %67, label %47
47: ; preds = %9, %6, %45
%48 = phi i64 [ 0, %9 ], [ 0, %6 ], [ %16, %45 ]
%49 = xor i64 %48, -1
%50 = and i64 %7, 1
%51 = icmp eq i64 %50, 0
br i1 %51, label %63, label %52
52: ; preds = %47
%53 = getelementptr inbounds float, float* %1, i64 %48
%54 = load float, float* %53
%55 = fmul float %54, %54
%56 = fpext float %55 to double
%57 = getelementptr inbounds double, double* %2, i64 %48
%58 = load double, double* %57
%59 = tail call double @llvm.fmuladd.f64(double %58, double %58, double %56)
%60 = fptrunc double %59 to float
%61 = getelementptr inbounds float, float* %0, i64 %48
store float %60, float* %61
%62 = or i64 %48, 1
br label %63
63: ; preds = %52, %47
%64 = phi i64 [ %48, %47 ], [ %62, %52 ]
%65 = sub nsw i64 0, %7
%66 = icmp eq i64 %49, %65
br i1 %66, label %67, label %144
67: ; preds = %63, %144, %45
br i1 %5, label %68, label %274
68: ; preds = %67
%69 = zext i32 %3 to i64
%70 = zext i32 %3 to i64
%71 = icmp ult i32 %3, 4
br i1 %71, label %118, label %72
72: ; preds = %68
%73 = getelementptr float, float* %0, i64 %7
%74 = getelementptr float, float* %1, i64 %7
%75 = icmp ugt float* %74, %0
%76 = icmp ugt float* %73, %1
%77 = and i1 %75, %76
br i1 %77, label %118, label %78
78: ; preds = %72
%79 = and i64 %7, 4294967292
%80 = add nuw nsw i64 %79, %69
br label %81
81: ; preds = %81, %78
%82 = phi i64 [ 0, %78 ], [ %114, %81 ]
%83 = add i64 %82, %69
%84 = getelementptr inbounds float, float* %1, i64 %82
%85 = bitcast float* %84 to <2 x float>*
%86 = load <2 x float>, <2 x float>* %85
%87 = getelementptr inbounds float, float* %84, i64 2
%88 = bitcast float* %87 to <2 x float>*
%89 = load <2 x float>, <2 x float>* %88
%90 = fmul <2 x float> %86, %86
%91 = fmul <2 x float> %89, %89
%92 = fpext <2 x float> %90 to <2 x double>
%93 = fpext <2 x float> %91 to <2 x double>
%94 = getelementptr inbounds double, double* %2, i64 %82
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %94, i64 2
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = getelementptr inbounds double, double* %2, i64 %83
%101 = bitcast double* %100 to <2 x double>*
%102 = load <2 x double>, <2 x double>* %101
%103 = getelementptr inbounds double, double* %100, i64 2
%104 = bitcast double* %103 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %102, <2 x double> %92)
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %105, <2 x double> %93)
%108 = fptrunc <2 x double> %106 to <2 x float>
%109 = fptrunc <2 x double> %107 to <2 x float>
%110 = getelementptr inbounds float, float* %0, i64 %82
%111 = bitcast float* %110 to <2 x float>*
store <2 x float> %108, <2 x float>* %111
%112 = getelementptr inbounds float, float* %110, i64 2
%113 = bitcast float* %112 to <2 x float>*
store <2 x float> %109, <2 x float>* %113
%114 = add nuw i64 %82, 4
%115 = icmp eq i64 %114, %79
br i1 %115, label %116, label %81
116: ; preds = %81
%117 = icmp eq i64 %79, %7
br i1 %117, label %167, label %118
118: ; preds = %72, %68, %116
%119 = phi i64 [ %69, %72 ], [ %69, %68 ], [ %80, %116 ]
%120 = phi i64 [ 0, %72 ], [ 0, %68 ], [ %79, %116 ]
%121 = xor i64 %120, -1
%122 = and i64 %7, 1
%123 = icmp eq i64 %122, 0
br i1 %123, label %138, label %124
124: ; preds = %118
%125 = getelementptr inbounds float, float* %1, i64 %120
%126 = load float, float* %125
%127 = fmul float %126, %126
%128 = fpext float %127 to double
%129 = getelementptr inbounds double, double* %2, i64 %120
%130 = load double, double* %129
%131 = getelementptr inbounds double, double* %2, i64 %119
%132 = load double, double* %131
%133 = tail call double @llvm.fmuladd.f64(double %130, double %132, double %128)
%134 = fptrunc double %133 to float
%135 = getelementptr inbounds float, float* %0, i64 %120
store float %134, float* %135
%136 = add nuw nsw i64 %119, 1
%137 = or i64 %120, 1
br label %138
138: ; preds = %124, %118
%139 = phi i64 [ undef, %118 ], [ %136, %124 ]
%140 = phi i64 [ %119, %118 ], [ %136, %124 ]
%141 = phi i64 [ %120, %118 ], [ %137, %124 ]
%142 = sub nsw i64 0, %7
%143 = icmp eq i64 %121, %142
br i1 %143, label %167, label %244
144: ; preds = %63, %144
%145 = phi i64 [ %165, %144 ], [ %64, %63 ]
%146 = getelementptr inbounds float, float* %1, i64 %145
%147 = load float, float* %146
%148 = fmul float %147, %147
%149 = fpext float %148 to double
%150 = getelementptr inbounds double, double* %2, i64 %145
%151 = load double, double* %150
%152 = tail call double @llvm.fmuladd.f64(double %151, double %151, double %149)
%153 = fptrunc double %152 to float
%154 = getelementptr inbounds float, float* %0, i64 %145
store float %153, float* %154
%155 = add nuw nsw i64 %145, 1
%156 = getelementptr inbounds float, float* %1, i64 %155
%157 = load float, float* %156
%158 = fmul float %157, %157
%159 = fpext float %158 to double
%160 = getelementptr inbounds double, double* %2, i64 %155
%161 = load double, double* %160
%162 = tail call double @llvm.fmuladd.f64(double %161, double %161, double %159)
%163 = fptrunc double %162 to float
%164 = getelementptr inbounds float, float* %0, i64 %155
store float %163, float* %164
%165 = add nuw nsw i64 %145, 2
%166 = icmp eq i64 %165, %7
br i1 %166, label %67, label %144
167: ; preds = %138, %244, %116
%168 = phi i64 [ %80, %116 ], [ %139, %138 ], [ %271, %244 ]
br i1 %5, label %169, label %274
169: ; preds = %167
%170 = and i64 %168, 4294967295
%171 = zext i32 %3 to i64
%172 = icmp ult i32 %3, 4
br i1 %172, label %219, label %173
173: ; preds = %169
%174 = getelementptr float, float* %0, i64 %7
%175 = getelementptr float, float* %1, i64 %7
%176 = icmp ugt float* %175, %0
%177 = icmp ugt float* %174, %1
%178 = and i1 %176, %177
br i1 %178, label %219, label %179
179: ; preds = %173
%180 = and i64 %7, 4294967292
%181 = add nuw nsw i64 %170, %180
br label %182
182: ; preds = %182, %179
%183 = phi i64 [ 0, %179 ], [ %215, %182 ]
%184 = add i64 %170, %183
%185 = getelementptr inbounds float, float* %1, i64 %183
%186 = bitcast float* %185 to <2 x float>*
%187 = load <2 x float>, <2 x float>* %186
%188 = getelementptr inbounds float, float* %185, i64 2
%189 = bitcast float* %188 to <2 x float>*
%190 = load <2 x float>, <2 x float>* %189
%191 = fmul <2 x float> %187, %187
%192 = fmul <2 x float> %190, %190
%193 = fpext <2 x float> %191 to <2 x double>
%194 = fpext <2 x float> %192 to <2 x double>
%195 = getelementptr inbounds double, double* %2, i64 %183
%196 = bitcast double* %195 to <2 x double>*
%197 = load <2 x double>, <2 x double>* %196
%198 = getelementptr inbounds double, double* %195, i64 2
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = getelementptr inbounds double, double* %2, i64 %184
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = getelementptr inbounds double, double* %201, i64 2
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %197, <2 x double> %203, <2 x double> %193)
%208 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %200, <2 x double> %206, <2 x double> %194)
%209 = fptrunc <2 x double> %207 to <2 x float>
%210 = fptrunc <2 x double> %208 to <2 x float>
%211 = getelementptr inbounds float, float* %0, i64 %183
%212 = bitcast float* %211 to <2 x float>*
store <2 x float> %209, <2 x float>* %212
%213 = getelementptr inbounds float, float* %211, i64 2
%214 = bitcast float* %213 to <2 x float>*
store <2 x float> %210, <2 x float>* %214
%215 = add nuw i64 %183, 4
%216 = icmp eq i64 %215, %180
br i1 %216, label %217, label %182
217: ; preds = %182
%218 = icmp eq i64 %180, %7
br i1 %218, label %274, label %219
219: ; preds = %173, %169, %217
%220 = phi i64 [ %170, %173 ], [ %170, %169 ], [ %181, %217 ]
%221 = phi i64 [ 0, %173 ], [ 0, %169 ], [ %180, %217 ]
%222 = xor i64 %221, -1
%223 = and i64 %7, 1
%224 = icmp eq i64 %223, 0
br i1 %224, label %239, label %225
225: ; preds = %219
%226 = getelementptr inbounds float, float* %1, i64 %221
%227 = load float, float* %226
%228 = fmul float %227, %227
%229 = fpext float %228 to double
%230 = getelementptr inbounds double, double* %2, i64 %221
%231 = load double, double* %230
%232 = getelementptr inbounds double, double* %2, i64 %220
%233 = load double, double* %232
%234 = tail call double @llvm.fmuladd.f64(double %231, double %233, double %229)
%235 = fptrunc double %234 to float
%236 = getelementptr inbounds float, float* %0, i64 %221
store float %235, float* %236
%237 = add nuw nsw i64 %220, 1
%238 = or i64 %221, 1
br label %239
239: ; preds = %225, %219
%240 = phi i64 [ %220, %219 ], [ %237, %225 ]
%241 = phi i64 [ %221, %219 ], [ %238, %225 ]
%242 = sub nsw i64 0, %7
%243 = icmp eq i64 %222, %242
br i1 %243, label %274, label %275
244: ; preds = %138, %244
%245 = phi i64 [ %271, %244 ], [ %140, %138 ]
%246 = phi i64 [ %272, %244 ], [ %141, %138 ]
%247 = getelementptr inbounds float, float* %1, i64 %246
%248 = load float, float* %247
%249 = fmul float %248, %248
%250 = fpext float %249 to double
%251 = getelementptr inbounds double, double* %2, i64 %246
%252 = load double, double* %251
%253 = getelementptr inbounds double, double* %2, i64 %245
%254 = load double, double* %253
%255 = tail call double @llvm.fmuladd.f64(double %252, double %254, double %250)
%256 = fptrunc double %255 to float
%257 = getelementptr inbounds float, float* %0, i64 %246
store float %256, float* %257
%258 = add nuw nsw i64 %245, 1
%259 = add nuw nsw i64 %246, 1
%260 = getelementptr inbounds float, float* %1, i64 %259
%261 = load float, float* %260
%262 = fmul float %261, %261
%263 = fpext float %262 to double
%264 = getelementptr inbounds double, double* %2, i64 %259
%265 = load double, double* %264
%266 = getelementptr inbounds double, double* %2, i64 %258
%267 = load double, double* %266
%268 = tail call double @llvm.fmuladd.f64(double %265, double %267, double %263)
%269 = fptrunc double %268 to float
%270 = getelementptr inbounds float, float* %0, i64 %259
store float %269, float* %270
%271 = add nuw nsw i64 %245, 2
%272 = add nuw nsw i64 %246, 2
%273 = icmp eq i64 %272, %70
br i1 %273, label %167, label %244
274: ; preds = %239, %275, %217, %4, %67, %167
ret void
275: ; preds = %239, %275
%276 = phi i64 [ %302, %275 ], [ %240, %239 ]
%277 = phi i64 [ %303, %275 ], [ %241, %239 ]
%278 = getelementptr inbounds float, float* %1, i64 %277
%279 = load float, float* %278
%280 = fmul float %279, %279
%281 = fpext float %280 to double
%282 = getelementptr inbounds double, double* %2, i64 %277
%283 = load double, double* %282
%284 = getelementptr inbounds double, double* %2, i64 %276
%285 = load double, double* %284
%286 = tail call double @llvm.fmuladd.f64(double %283, double %285, double %281)
%287 = fptrunc double %286 to float
%288 = getelementptr inbounds float, float* %0, i64 %277
store float %287, float* %288
%289 = add nuw nsw i64 %276, 1
%290 = add nuw nsw i64 %277, 1
%291 = getelementptr inbounds float, float* %1, i64 %290
%292 = load float, float* %291
%293 = fmul float %292, %292
%294 = fpext float %293 to double
%295 = getelementptr inbounds double, double* %2, i64 %290
%296 = load double, double* %295
%297 = getelementptr inbounds double, double* %2, i64 %289
%298 = load double, double* %297
%299 = tail call double @llvm.fmuladd.f64(double %296, double %298, double %294)
%300 = fptrunc double %299 to float
%301 = getelementptr inbounds float, float* %0, i64 %290
store float %300, float* %301
%302 = add nuw nsw i64 %276, 2
%303 = add nuw nsw i64 %277, 2
%304 = icmp eq i64 %303, %171
br i1 %304, label %274, label %275
}