float sdot(long n, float *sx, long incx, float *sy, long incy) {
  static long i, ix, iy, m, mp1;
  static float sdot, stemp;
  stemp = sdot = 0.0;
  if (n <= 0)
    return sdot;
  if (incx == 1 && incy == 1)
    goto S20;
  ix = iy = 1;
  if (incx < 0)
    ix = (-n + 1) * incx + 1;
  if (incy < 0)
    iy = (-n + 1) * incy + 1;
  for (i = 1; i <= n; i++) {
    stemp += (*(sx + ix - 1) * *(sy + iy - 1));
    ix += incx;
    iy += incy;
  }
  sdot = stemp;
  return sdot;
S20:
  m = n % 5L;
  if (m == 0)
    goto S40;
  for (i = 0; i < m; i++)
    stemp += (*(sx + i) * *(sy + i));
  if (n < 5)
    goto S60;
S40:
  mp1 = m + 1;
  for (i = mp1; i <= n; i += 5)
    stemp += (*(sx + i - 1) * *(sy + i - 1) + *(sx + i) * *(sy + i) +
              *(sx + i + 1) * *(sy + i + 1) + *(sx + i + 2) * *(sy + i + 2) +
              *(sx + i + 3) * *(sy + i + 3));
S60:
  sdot = stemp;
  return sdot;
}


x86 assembly (clang, -O0):
<sdot>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x2f2d(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x2f26(%rip)
cmpq   $0x0,-0x10(%rbp)
jg     114b <sdot+0x4b>
movss  0x2f0f(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1466 <sdot+0x366>
cmpq   $0x1,-0x20(%rbp)
jne    1166 <sdot+0x66>
cmpq   $0x1,-0x30(%rbp)
jne    1166 <sdot+0x66>
jmp    1279 <sdot+0x179>
movq   $0x1,0x2ec7(%rip)
movq   $0x1,0x2eb4(%rip)
cmpq   $0x0,-0x20(%rbp)
jge    11a1 <sdot+0xa1>
xor    %eax,%eax
sub    -0x10(%rbp),%rax
add    $0x1,%rax
imul   -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x2e8f(%rip)
cmpq   $0x0,-0x30(%rbp)
jge    11c6 <sdot+0xc6>
xor    %eax,%eax
sub    -0x10(%rbp),%rax
add    $0x1,%rax
imul   -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x2e72(%rip)
movq   $0x1,0x2e57(%rip)
mov    0x2e50(%rip),%rax
cmp    -0x10(%rbp),%rax
jg     1257 <sdot+0x157>
mov    -0x18(%rbp),%rax
mov    0x2e43(%rip),%rcx
movss  -0x4(%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2e3a(%rip),%rcx
movss  -0x4(%rax,%rcx,4),%xmm2
movss  0x2e48(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x2e38(%rip)
mov    -0x20(%rbp),%rax
add    0x2e09(%rip),%rax
mov    %rax,0x2e02(%rip)
mov    -0x30(%rbp),%rax
add    0x2dff(%rip),%rax
mov    %rax,0x2df8(%rip)
mov    0x2de1(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2dd6(%rip)
jmp    11d1 <sdot+0xd1>
movss  0x2df5(%rip),%xmm0
movss  %xmm0,0x2de9(%rip)
movss  0x2de1(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1466 <sdot+0x366>
mov    -0x10(%rbp),%rax
mov    $0x5,%ecx
cqto
idiv   %rcx
mov    %rdx,0x2db2(%rip)
cmpq   $0x0,0x2daa(%rip)
jne    12a1 <sdot+0x1a1>
jmp    1324 <sdot+0x224>
movq   $0x0,0x2d7c(%rip)
mov    0x2d75(%rip),%rax
cmp    0x2d86(%rip),%rax
jge    130f <sdot+0x20f>
mov    -0x18(%rbp),%rax
mov    0x2d5d(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2d4d(%rip),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0x2d6c(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x2d5c(%rip)
mov    0x2d29(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2d1e(%rip)
jmp    12ac <sdot+0x1ac>
cmpq   $0x5,-0x10(%rbp)
jge    131f <sdot+0x21f>
jmp    1449 <sdot+0x349>
jmp    1324 <sdot+0x224>
mov    0x2d15(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2d12(%rip)
mov    0x2d0b(%rip),%rax
mov    %rax,0x2ce4(%rip)
mov    0x2cdd(%rip),%rax
cmp    -0x10(%rbp),%rax
jg     1444 <sdot+0x344>
mov    -0x18(%rbp),%rax
mov    0x2cc8(%rip),%rcx
movss  -0x4(%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
mov    0x2cb7(%rip),%rcx
movss  -0x4(%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    0x2ca6(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2c96(%rip),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    0x2c7e(%rip),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2c6d(%rip),%rcx
movss  0x4(%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x2c54(%rip),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
mov    0x2c43(%rip),%rcx
movss  0x8(%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    0x2c2a(%rip),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2c19(%rip),%rcx
movss  0xc(%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  0x2c2f(%rip),%xmm0
movss  %xmm0,0x2c27(%rip)
mov    0x2bf4(%rip),%rax
add    $0x5,%rax
mov    %rax,0x2be9(%rip)
jmp    1344 <sdot+0x244>
jmp    1449 <sdot+0x349>
movss  0x2c03(%rip),%xmm0
movss  %xmm0,0x2bf7(%rip)
movss  0x2bef(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<sdot>:
push   %r15
push   %r14
push   %rbx
test   %rdi,%rdi
jle    1169 <sdot+0x69>
cmp    $0x1,%rdx
jne    1171 <sdot+0x71>
cmp    $0x1,%r8
jne    1171 <sdot+0x71>
movabs $0xcccccccccccccccd,%r8
cc cc cc
mov    %rdi,%rax
mul    %r8
shr    $0x2,%rdx
lea    (%rdx,%rdx,4),%rax
mov    %rdi,%r9
sub    %rax,%r9
je     1236 <sdot+0x136>
mov    %rdi,%rax
mul    %r8
shr    $0x2,%rdx
lea    (%rdx,%rdx,4),%rax
not    %rax
add    %rdi,%rax
mov    %r9d,%r10d
and    $0x3,%r10d
cmp    $0x3,%rax
jae    123e <sdot+0x13e>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1297 <sdot+0x197>
xorps  %xmm0,%xmm0
jmp    134e <sdot+0x24e>
lea    -0x1(%rdi),%r9
neg    %r9
mov    %r9,%rax
imul   %rdx,%rax
add    $0x1,%rax
test   %rdx,%rdx
mov    $0x1,%ebx
cmovns %rbx,%rax
imul   %r8,%r9
add    $0x1,%r9
test   %r8,%r8
cmovns %rbx,%r9
mov    %rdi,%rbx
dec    %rbx
jne    11ab <sdot+0xab>
xorps  %xmm0,%xmm0
jmp    1213 <sdot+0x113>
mov    %rdi,%r10
and    $0xfffffffffffffffe,%r10
lea    (%rsi,%rdx,4),%r11
add    $0xfffffffffffffffc,%r11
lea    (%rcx,%r9,4),%rbx
add    $0xfffffffffffffffc,%rbx
lea    0x0(,%r8,8),%r14
lea    (%rcx,%r8,4),%r15
add    $0xfffffffffffffffc,%r15
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rsi,%rax,4),%xmm1
mulss  (%rbx),%xmm1
addss  %xmm0,%xmm1
movss  (%r11,%rax,4),%xmm0
add    %rdx,%rax
mulss  (%r15,%r9,4),%xmm0
add    %r8,%r9
addss  %xmm1,%xmm0
add    %rdx,%rax
add    %r8,%r9
add    %r14,%rbx
add    $0xfffffffffffffffe,%r10
jne    11e0 <sdot+0xe0>
test   $0x1,%dil
je     134e <sdot+0x24e>
movss  -0x4(%rsi,%rax,4),%xmm1
mulss  -0x4(%rcx,%r9,4),%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
jmp    134e <sdot+0x24e>
xorps  %xmm0,%xmm0
jmp    12d1 <sdot+0x1d1>
mov    %r9d,%ebx
and    $0x4,%ebx
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  (%rsi,%rdx,4),%xmm1
movss  0x4(%rsi,%rdx,4),%xmm2
mulss  (%rcx,%rdx,4),%xmm1
mulss  0x4(%rcx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rsi,%rdx,4),%xmm3
mulss  0x8(%rcx,%rdx,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rsi,%rdx,4),%xmm0
mulss  0xc(%rcx,%rdx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1250 <sdot+0x150>
test   %r10,%r10
je     12c7 <sdot+0x1c7>
lea    (%rcx,%rdx,4),%rbx
lea    (%rsi,%rdx,4),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm1
mulss  (%rbx,%rax,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rax
cmp    %rax,%r10
jne    12b0 <sdot+0x1b0>
cmp    $0x5,%rdi
jl     134e <sdot+0x24e>
cmp    %rdi,%r9
jge    134e <sdot+0x24e>
mov    %rdi,%rax
mul    %r8
shr    $0x2,%rdx
lea    (%rdx,%rdx,4),%rax
neg    %rax
add    %rdi,%rax
add    $0x4,%rax
xchg   %ax,%ax
movss  -0xc(%rsi,%rax,4),%xmm1
mulss  -0xc(%rcx,%rax,4),%xmm1
movss  -0x10(%rsi,%rax,4),%xmm2
mulss  -0x10(%rcx,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x8(%rsi,%rax,4),%xmm1
mulss  -0x8(%rcx,%rax,4),%xmm1
addss  %xmm2,%xmm1
movss  -0x4(%rsi,%rax,4),%xmm2
mulss  -0x4(%rcx,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  (%rsi,%rax,4),%xmm1
mulss  (%rcx,%rax,4),%xmm1
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
lea    0x5(%rax),%rdx
add    $0x2,%rax
cmp    %rdi,%rax
mov    %rdx,%rax
jle    12f0 <sdot+0x1f0>
pop    %rbx
pop    %r14
pop    %r15
ret

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

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