void THFloatVector_add(float *y, const float *x, const float c, const long n) {
  long i = 0;
  for (; i < n - 4; i += 4) {
    y[i] += c * x[i];
    y[i + 1] += c * x[i + 1];
    y[i + 2] += c * x[i + 2];
    y[i + 3] += c * x[i + 3];
  }
  for (; i < n; i++)
    y[i] += c * x[i];
}


x86 assembly (clang, -O0):
<THFloatVector_add>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x4,%rcx
cmp    %rcx,%rax
jge    11fc <THFloatVector_add+0xfc>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    111d <THFloatVector_add+0x1d>
jmp    1201 <THFloatVector_add+0x101>
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    124c <THFloatVector_add+0x14c>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1201 <THFloatVector_add+0x101>
pop    %rbp
ret

x86 assembly (clang, -O2):
<THFloatVector_add>:
push   %r14
push   %rbx
cmp    $0x5,%rdx
jl     11b0 <THFloatVector_add+0xb0>
lea    -0x5(%rdx),%r9
cmp    $0xc,%r9
jb     1142 <THFloatVector_add+0x42>
lea    -0x1(%rdx),%rcx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rcx,%rax
lea    (%rsi,%rax,4),%rcx
cmp    %rdi,%rcx
jbe    1336 <THFloatVector_add+0x236>
lea    (%rdi,%rax,4),%rax
cmp    %rsi,%rax
jbe    1336 <THFloatVector_add+0x236>
xor    %eax,%eax
lea    -0x4(%rdx),%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rdi,%rax,4),%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x8(%rdi,%rax,4),%xmm1
movss  %xmm1,0x8(%rdi,%rax,4)
movss  0xc(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0xc(%rdi,%rax,4),%xmm1
movss  %xmm1,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rcx,%rax
jl     1150 <THFloatVector_add+0x50>
jmp    11b2 <THFloatVector_add+0xb2>
xor    %eax,%eax
cmp    %rdx,%rax
jge    1332 <THFloatVector_add+0x232>
mov    %rdx,%r9
sub    %rax,%r9
cmp    $0x8,%r9
jb     12c7 <THFloatVector_add+0x1c7>
lea    (%rdi,%rax,4),%rcx
lea    (%rsi,%rdx,4),%rbx
cmp    %rbx,%rcx
jae    11e9 <THFloatVector_add+0xe9>
lea    (%rdi,%rdx,4),%rcx
lea    (%rsi,%rax,4),%rbx
cmp    %rcx,%rbx
jb     12c7 <THFloatVector_add+0x1c7>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r8),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1500 <THFloatVector_add+0x400>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
lea    (%rdi,%rax,4),%rbx
add    $0x30,%rbx
lea    (%rsi,%rax,4),%r14
add    $0x30,%r14
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x30(%r14,%rcx,4),%xmm2
movups -0x20(%r14,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
movups -0x30(%rbx,%rcx,4),%xmm4
addps  %xmm2,%xmm4
movups -0x20(%rbx,%rcx,4),%xmm2
movups -0x10(%rbx,%rcx,4),%xmm5
movups (%rbx,%rcx,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,-0x30(%rbx,%rcx,4)
movups %xmm3,-0x20(%rbx,%rcx,4)
movups -0x10(%r14,%rcx,4),%xmm2
movups (%r14,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,-0x10(%rbx,%rcx,4)
movups %xmm3,(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%r11
jne    1230 <THFloatVector_add+0x130>
test   $0x1,%r10b
je     12bf <THFloatVector_add+0x1bf>
add    %rax,%rcx
movups (%rsi,%rcx,4),%xmm2
movups 0x10(%rsi,%rcx,4),%xmm3
movups (%rdi,%rcx,4),%xmm4
movups 0x10(%rdi,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rdi,%rcx,4)
movups %xmm3,0x10(%rdi,%rcx,4)
cmp    %r8,%r9
je     1332 <THFloatVector_add+0x232>
add    %r8,%rax
mov    %edx,%ebx
sub    %eax,%ebx
mov    %rax,%rcx
not    %rcx
test   $0x1,%bl
je     12ed <THFloatVector_add+0x1ed>
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    $0x1,%rax
add    %rdx,%rcx
je     1332 <THFloatVector_add+0x232>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rdi,%rax,4),%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1300 <THFloatVector_add+0x200>
pop    %rbx
pop    %r14
ret
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    0x0(,%r8,4),%rax
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
xor    %ecx,%ecx
mov    %r8,%r10
nopl   0x0(%rax,%rax,1)
movss  0x30(%rsi,%rcx,1),%xmm2
movss  0x20(%rsi,%rcx,1),%xmm3
unpcklps %xmm2,%xmm3
movss  0x10(%rsi,%rcx,1),%xmm4
movss  (%rsi,%rcx,1),%xmm12
unpcklps %xmm4,%xmm12
movlhps %xmm3,%xmm12
movss  0x4(%rsi,%rcx,1),%xmm3
movss  0x8(%rsi,%rcx,1),%xmm4
movss  0xc(%rsi,%rcx,1),%xmm5
movss  0x30(%rdi,%rcx,1),%xmm6
movss  0x20(%rdi,%rcx,1),%xmm7
unpcklps %xmm6,%xmm7
movss  0x10(%rdi,%rcx,1),%xmm6
movss  (%rdi,%rcx,1),%xmm1
unpcklps %xmm6,%xmm1
movlhps %xmm7,%xmm1
movss  0x4(%rdi,%rcx,1),%xmm6
movss  0x8(%rdi,%rcx,1),%xmm11
movss  0xc(%rdi,%rcx,1),%xmm9
mulps  %xmm8,%xmm12
addps  %xmm1,%xmm12
movss  0x34(%rsi,%rcx,1),%xmm10
movss  0x24(%rsi,%rcx,1),%xmm1
unpcklps %xmm10,%xmm1
movss  0x14(%rsi,%rcx,1),%xmm7
unpcklps %xmm7,%xmm3
movlhps %xmm1,%xmm3
movss  0x34(%rdi,%rcx,1),%xmm1
movss  0x24(%rdi,%rcx,1),%xmm7
unpcklps %xmm1,%xmm7
movss  0x14(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm6
movlhps %xmm7,%xmm6
mulps  %xmm8,%xmm3
addps  %xmm6,%xmm3
movss  0x38(%rsi,%rcx,1),%xmm1
movss  0x28(%rsi,%rcx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x18(%rsi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm4
movlhps %xmm6,%xmm4
movss  0x38(%rdi,%rcx,1),%xmm1
movss  0x28(%rdi,%rcx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x18(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm11
movlhps %xmm6,%xmm11
mulps  %xmm8,%xmm4
addps  %xmm11,%xmm4
movss  0x3c(%rsi,%rcx,1),%xmm1
movss  0x2c(%rsi,%rcx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x1c(%rsi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm5
movlhps %xmm6,%xmm5
movss  0x3c(%rdi,%rcx,1),%xmm1
movss  0x2c(%rdi,%rcx,1),%xmm6
unpcklps %xmm1,%xmm6
movss  0x1c(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm9
movlhps %xmm6,%xmm9
mulps  %xmm8,%xmm5
addps  %xmm9,%xmm5
movaps %xmm5,%xmm1
movlhps %xmm4,%xmm1
movaps %xmm12,%xmm6
unpcklps %xmm3,%xmm6
shufps $0x24,%xmm1,%xmm6
movaps %xmm4,%xmm1
unpcklps %xmm5,%xmm1
movaps %xmm3,%xmm7
shufps $0x11,%xmm12,%xmm7
shufps $0xe2,%xmm1,%xmm7
movaps %xmm5,%xmm1
unpckhpd %xmm4,%xmm1
movaps %xmm12,%xmm2
unpckhps %xmm3,%xmm2
shufps $0x24,%xmm1,%xmm2
unpckhps %xmm5,%xmm4
shufps $0x33,%xmm12,%xmm3
shufps $0xe2,%xmm4,%xmm3
movups %xmm3,0x30(%rdi,%rcx,1)
movups %xmm2,0x20(%rdi,%rcx,1)
movups %xmm7,0x10(%rdi,%rcx,1)
movups %xmm6,(%rdi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffc,%r10
jne    1360 <THFloatVector_add+0x260>
cmp    %r8,%r9
je     11b2 <THFloatVector_add+0xb2>
jmp    1144 <THFloatVector_add+0x44>
xor    %ecx,%ecx
test   $0x1,%r10b
jne    1295 <THFloatVector_add+0x195>
jmp    12bf <THFloatVector_add+0x1bf>

LLVM IR (-O0):
define void @THFloatVector_add(float* %0, float* %1, float %2, i64 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float
%8 = alloca i64
%9 = alloca i64
store float* %0, float** %5
store float* %1, float** %6
store float %2, float* %7
store i64 %3, i64* %8
store i64 0, i64* %9
br label %10
10: ; preds = %62, %4
%11 = load i64, i64* %9
%12 = load i64, i64* %8
%13 = sub nsw i64 %12, 4
%14 = icmp slt i64 %11, %13
br i1 %14, label %15, label %65
15: ; preds = %10
%16 = load float, float* %7
%17 = load float*, float** %6
%18 = load i64, i64* %9
%19 = getelementptr inbounds float, float* %17, i64 %18
%20 = load float, float* %19
%21 = load float*, float** %5
%22 = load i64, i64* %9
%23 = getelementptr inbounds float, float* %21, i64 %22
%24 = load float, float* %23
%25 = call float @llvm.fmuladd.f32(float %16, float %20, float %24)
store float %25, float* %23
%26 = load float, float* %7
%27 = load float*, float** %6
%28 = load i64, i64* %9
%29 = add nsw i64 %28, 1
%30 = getelementptr inbounds float, float* %27, i64 %29
%31 = load float, float* %30
%32 = load float*, float** %5
%33 = load i64, i64* %9
%34 = add nsw i64 %33, 1
%35 = getelementptr inbounds float, float* %32, i64 %34
%36 = load float, float* %35
%37 = call float @llvm.fmuladd.f32(float %26, float %31, float %36)
store float %37, float* %35
%38 = load float, float* %7
%39 = load float*, float** %6
%40 = load i64, i64* %9
%41 = add nsw i64 %40, 2
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
%44 = load float*, float** %5
%45 = load i64, i64* %9
%46 = add nsw i64 %45, 2
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = call float @llvm.fmuladd.f32(float %38, float %43, float %48)
store float %49, float* %47
%50 = load float, float* %7
%51 = load float*, float** %6
%52 = load i64, i64* %9
%53 = add nsw i64 %52, 3
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = load float*, float** %5
%57 = load i64, i64* %9
%58 = add nsw i64 %57, 3
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = call float @llvm.fmuladd.f32(float %50, float %55, float %60)
store float %61, float* %59
br label %62
62: ; preds = %15
%63 = load i64, i64* %9
%64 = add nsw i64 %63, 4
store i64 %64, i64* %9
br label %10
65: ; preds = %10
br label %66
66: ; preds = %81, %65
%67 = load i64, i64* %9
%68 = load i64, i64* %8
%69 = icmp slt i64 %67, %68
br i1 %69, label %70, label %84
70: ; preds = %66
%71 = load float, float* %7
%72 = load float*, float** %6
%73 = load i64, i64* %9
%74 = getelementptr inbounds float, float* %72, i64 %73
%75 = load float, float* %74
%76 = load float*, float** %5
%77 = load i64, i64* %9
%78 = getelementptr inbounds float, float* %76, i64 %77
%79 = load float, float* %78
%80 = call float @llvm.fmuladd.f32(float %71, float %75, float %79)
store float %80, float* %78
br label %81
81: ; preds = %70
%82 = load i64, i64* %9
%83 = add nsw i64 %82, 1
store i64 %83, i64* %9
br label %66
84: ; preds = %66
ret void
}

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