void silk_scale_copy_vector_FLP(float *data_out, const float *data_in,
                                float gain, int dataSize) {
  int i, dataSize4;
  dataSize4 = dataSize & 0xFFFC;
  for (i = 0; i < dataSize4; i += 4) {
    data_out[i + 0] = gain * data_in[i + 0];
    data_out[i + 1] = gain * data_in[i + 1];
    data_out[i + 2] = gain * data_in[i + 2];
    data_out[i + 3] = gain * data_in[i + 3];
  }
  for (; i < dataSize; i++) {
    data_out[i] = gain * data_in[i];
  }
}


x86 assembly (clang, -O0):
<silk_scale_copy_vector_FLP>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xfffc,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11e4 <silk_scale_copy_vector_FLP+0xe4>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1126 <silk_scale_copy_vector_FLP+0x26>
jmp    11e9 <silk_scale_copy_vector_FLP+0xe9>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1222 <silk_scale_copy_vector_FLP+0x122>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e9 <silk_scale_copy_vector_FLP+0xe9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<silk_scale_copy_vector_FLP>:
push   %r14
push   %rbx
mov    %edx,%eax
and    $0xfffc,%eax
je     1190 <silk_scale_copy_vector_FLP+0x90>
mov    %eax,%r10d
lea    -0x1(%r10),%r8
cmp    $0xc,%r8
jb     1137 <silk_scale_copy_vector_FLP+0x37>
lea    (%rsi,%r10,4),%rax
cmp    %rdi,%rax
jbe    130b <silk_scale_copy_vector_FLP+0x20b>
lea    (%rdi,%r10,4),%rax
cmp    %rsi,%rax
jbe    130b <silk_scale_copy_vector_FLP+0x20b>
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi,%rcx,4)
movss  0x8(%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi,%rcx,4)
movss  0xc(%rsi,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %r10,%rcx
jb     1140 <silk_scale_copy_vector_FLP+0x40>
cmp    %edx,%ecx
jl     119a <silk_scale_copy_vector_FLP+0x9a>
jmp    1307 <silk_scale_copy_vector_FLP+0x207>
xor    %ecx,%ecx
cmp    %edx,%ecx
jge    1307 <silk_scale_copy_vector_FLP+0x207>
mov    %ecx,%eax
mov    %edx,%r11d
mov    %r11,%r9
sub    %rax,%r9
cmp    $0x8,%r9
jb     127d <silk_scale_copy_vector_FLP+0x17d>
lea    (%rdi,%rax,4),%rcx
lea    (%rsi,%r11,4),%rdx
cmp    %rdx,%rcx
jae    11cd <silk_scale_copy_vector_FLP+0xcd>
lea    (%rdi,%r11,4),%rcx
lea    (%rsi,%rax,4),%rdx
cmp    %rcx,%rdx
jb     127d <silk_scale_copy_vector_FLP+0x17d>
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     1436 <silk_scale_copy_vector_FLP+0x336>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rdi,%rax,4),%r14
add    $0x30,%r14
lea    (%rsi,%rax,4),%rbx
add    $0x30,%rbx
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x30(%rbx,%rdx,4),%xmm2
movups -0x20(%rbx,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%r14,%rdx,4)
movups %xmm3,-0x20(%r14,%rdx,4)
movups -0x10(%rbx,%rdx,4),%xmm2
movups (%rbx,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x10(%r14,%rdx,4)
movups %xmm3,(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1210 <silk_scale_copy_vector_FLP+0x110>
test   $0x1,%r10b
je     1271 <silk_scale_copy_vector_FLP+0x171>
add    %rax,%rdx
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rdx,4)
movups %xmm3,0x10(%rdi,%rdx,4)
cmp    %r8,%r9
je     1307 <silk_scale_copy_vector_FLP+0x207>
add    %r8,%rax
mov    %r11d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
and    $0x3,%rdx
je     12b8 <silk_scale_copy_vector_FLP+0x1b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12a0 <silk_scale_copy_vector_FLP+0x1a0>
cmp    $0x3,%rcx
jb     1307 <silk_scale_copy_vector_FLP+0x207>
xchg   %ax,%ax
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi,%rax,4)
movss  0xc(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    12c0 <silk_scale_copy_vector_FLP+0x1c0>
pop    %rbx
pop    %r14
ret
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    0x0(,%r9,4),%rcx
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
xor    %eax,%eax
mov    %r9,%r11
movss  0x30(%rsi,%rax,1),%xmm2
movss  0x20(%rsi,%rax,1),%xmm3
unpcklps %xmm2,%xmm3
movss  0x10(%rsi,%rax,1),%xmm4
movss  (%rsi,%rax,1),%xmm9
unpcklps %xmm4,%xmm9
movlhps %xmm3,%xmm9
movss  0x4(%rsi,%rax,1),%xmm3
movss  0x8(%rsi,%rax,1),%xmm4
movss  0xc(%rsi,%rax,1),%xmm5
mulps  %xmm8,%xmm9
movss  0x34(%rsi,%rax,1),%xmm6
movss  0x24(%rsi,%rax,1),%xmm7
unpcklps %xmm6,%xmm7
movss  0x14(%rsi,%rax,1),%xmm6
unpcklps %xmm6,%xmm3
movlhps %xmm7,%xmm3
mulps  %xmm8,%xmm3
movss  0x38(%rsi,%rax,1),%xmm6
movss  0x28(%rsi,%rax,1),%xmm7
unpcklps %xmm6,%xmm7
movss  0x18(%rsi,%rax,1),%xmm6
unpcklps %xmm6,%xmm4
movlhps %xmm7,%xmm4
mulps  %xmm8,%xmm4
movss  0x3c(%rsi,%rax,1),%xmm6
movss  0x2c(%rsi,%rax,1),%xmm7
unpcklps %xmm6,%xmm7
movss  0x1c(%rsi,%rax,1),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm7,%xmm5
mulps  %xmm8,%xmm5
movaps %xmm5,%xmm6
movlhps %xmm4,%xmm6
movaps %xmm9,%xmm7
unpcklps %xmm3,%xmm7
shufps $0x24,%xmm6,%xmm7
movaps %xmm4,%xmm6
unpcklps %xmm5,%xmm6
movaps %xmm3,%xmm1
shufps $0x11,%xmm9,%xmm1
shufps $0xe2,%xmm6,%xmm1
movaps %xmm5,%xmm6
unpckhpd %xmm4,%xmm6
movaps %xmm9,%xmm2
unpckhps %xmm3,%xmm2
shufps $0x24,%xmm6,%xmm2
unpckhps %xmm5,%xmm4
shufps $0x33,%xmm9,%xmm3
shufps $0xe2,%xmm4,%xmm3
movups %xmm3,0x30(%rdi,%rax,1)
movups %xmm2,0x20(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
movups %xmm7,(%rdi,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffc,%r11
jne    1330 <silk_scale_copy_vector_FLP+0x230>
cmp    %r9,%r8
jne    1140 <silk_scale_copy_vector_FLP+0x40>
jmp    1187 <silk_scale_copy_vector_FLP+0x87>
xor    %edx,%edx
test   $0x1,%r10b
jne    1256 <silk_scale_copy_vector_FLP+0x156>
jmp    1271 <silk_scale_copy_vector_FLP+0x171>

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

LLVM IR (-O2):
define void @silk_scale_copy_vector_FLP(float* nocapture writeonly %0, float* nocapture %1, float %2, i32 %3) {
%5 = and i32 %3, 65532
%6 = icmp eq i32 %5, 0
br i1 %6, label %109, label %7
7: ; preds = %4
%8 = zext i32 %5 to i64
%9 = add nsw i64 %8, -1
%10 = lshr i64 %9, 2
%11 = add nuw nsw i64 %10, 1
%12 = icmp ult i64 %9, 12
br i1 %12, label %104, label %13
13: ; preds = %7
%14 = getelementptr float, float* %0, i64 %8
%15 = getelementptr float, float* %1, i64 %8
%16 = icmp ugt float* %15, %0
%17 = icmp ugt float* %14, %1
%18 = and i1 %16, %17
br i1 %18, label %104, label %19
19: ; preds = %13
%20 = and i64 %11, 9223372036854775804
%21 = shl i64 %20, 2
%22 = insertelement <4 x float> poison, float %2, i64 0
%23 = shufflevector <4 x float> %22, <4 x float> poison, <4 x i32> zeroinitializer
%24 = getelementptr inbounds float, float* %0, i64 -3
br label %25
25: ; preds = %25, %19
%26 = phi i64 [ 0, %19 ], [ %100, %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 = fmul <4 x float> %42, %23
%44 = or i64 %27, 1
%45 = or i64 %27, 5
%46 = or i64 %27, 9
%47 = or i64 %27, 13
%48 = getelementptr inbounds float, float* %1, i64 %44
%49 = getelementptr inbounds float, float* %1, i64 %45
%50 = getelementptr inbounds float, float* %1, i64 %46
%51 = getelementptr inbounds float, float* %1, i64 %47
%52 = load float, float* %48
%53 = load float, float* %49
%54 = load float, float* %50
%55 = load float, float* %51
%56 = insertelement <4 x float> poison, float %52, i64 0
%57 = insertelement <4 x float> %56, float %53, i64 1
%58 = insertelement <4 x float> %57, float %54, i64 2
%59 = insertelement <4 x float> %58, float %55, i64 3
%60 = fmul <4 x float> %59, %23
%61 = or i64 %27, 2
%62 = or i64 %27, 6
%63 = or i64 %27, 10
%64 = or i64 %27, 14
%65 = getelementptr inbounds float, float* %1, i64 %61
%66 = getelementptr inbounds float, float* %1, i64 %62
%67 = getelementptr inbounds float, float* %1, i64 %63
%68 = getelementptr inbounds float, float* %1, i64 %64
%69 = load float, float* %65
%70 = load float, float* %66
%71 = load float, float* %67
%72 = load float, float* %68
%73 = insertelement <4 x float> poison, float %69, i64 0
%74 = insertelement <4 x float> %73, float %70, i64 1
%75 = insertelement <4 x float> %74, float %71, i64 2
%76 = insertelement <4 x float> %75, float %72, i64 3
%77 = fmul <4 x float> %76, %23
%78 = or i64 %27, 3
%79 = or i64 %27, 7
%80 = or i64 %27, 11
%81 = or i64 %27, 15
%82 = getelementptr inbounds float, float* %1, i64 %78
%83 = getelementptr inbounds float, float* %1, i64 %79
%84 = getelementptr inbounds float, float* %1, i64 %80
%85 = getelementptr inbounds float, float* %1, i64 %81
%86 = load float, float* %82
%87 = load float, float* %83
%88 = load float, float* %84
%89 = load float, float* %85
%90 = insertelement <4 x float> poison, float %86, i64 0
%91 = insertelement <4 x float> %90, float %87, i64 1
%92 = insertelement <4 x float> %91, float %88, i64 2
%93 = insertelement <4 x float> %92, float %89, i64 3
%94 = fmul <4 x float> %93, %23
%95 = getelementptr inbounds float, float* %24, i64 %78
%96 = bitcast float* %95 to <16 x float>*
%97 = shufflevector <4 x float> %43, <4 x float> %60, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%98 = shufflevector <4 x float> %77, <4 x float> %94, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%99 = shufflevector <8 x float> %97, <8 x float> %98, <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> %99, <16 x float>* %96
%100 = add nuw i64 %26, 4
%101 = icmp eq i64 %100, %20
br i1 %101, label %102, label %25
102: ; preds = %25
%103 = icmp eq i64 %11, %20
br i1 %103, label %106, label %104
104: ; preds = %13, %7, %102
%105 = phi i64 [ 0, %13 ], [ 0, %7 ], [ %21, %102 ]
br label %211
106: ; preds = %211, %102
%107 = phi i64 [ %21, %102 ], [ %232, %211 ]
%108 = trunc i64 %107 to i32
br label %109
109: ; preds = %106, %4
%110 = phi i32 [ 0, %4 ], [ %108, %106 ]
%111 = icmp slt i32 %110, %3
br i1 %111, label %112, label %257
112: ; preds = %109
%113 = zext i32 %110 to i64
%114 = zext i32 %3 to i64
%115 = sub nsw i64 %114, %113
%116 = icmp ult i64 %115, 8
br i1 %116, label %191, label %117
117: ; preds = %112
%118 = getelementptr float, float* %0, i64 %113
%119 = getelementptr float, float* %0, i64 %114
%120 = getelementptr float, float* %1, i64 %113
%121 = getelementptr float, float* %1, i64 %114
%122 = icmp ult float* %118, %121
%123 = icmp ult float* %120, %119
%124 = and i1 %122, %123
br i1 %124, label %191, label %125
125: ; preds = %117
%126 = and i64 %115, -8
%127 = add nsw i64 %126, %113
%128 = insertelement <4 x float> poison, float %2, i64 0
%129 = shufflevector <4 x float> %128, <4 x float> poison, <4 x i32> zeroinitializer
%130 = insertelement <4 x float> poison, float %2, i64 0
%131 = shufflevector <4 x float> %130, <4 x float> poison, <4 x i32> zeroinitializer
%132 = add nsw i64 %126, -8
%133 = lshr exact i64 %132, 3
%134 = add nuw nsw i64 %133, 1
%135 = and i64 %134, 1
%136 = icmp eq i64 %132, 0
br i1 %136, label %172, label %137
137: ; preds = %125
%138 = and i64 %134, 4611686018427387902
br label %139
139: ; preds = %139, %137
%140 = phi i64 [ 0, %137 ], [ %169, %139 ]
%141 = phi i64 [ 0, %137 ], [ %170, %139 ]
%142 = add i64 %140, %113
%143 = getelementptr inbounds float, float* %1, i64 %142
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %143, i64 4
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fmul <4 x float> %145, %129
%150 = fmul <4 x float> %148, %131
%151 = getelementptr inbounds float, float* %0, i64 %142
%152 = bitcast float* %151 to <4 x float>*
store <4 x float> %149, <4 x float>* %152
%153 = getelementptr inbounds float, float* %151, i64 4
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %150, <4 x float>* %154
%155 = or i64 %140, 8
%156 = add i64 %155, %113
%157 = getelementptr inbounds float, float* %1, i64 %156
%158 = bitcast float* %157 to <4 x float>*
%159 = load <4 x float>, <4 x float>* %158
%160 = getelementptr inbounds float, float* %157, i64 4
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = fmul <4 x float> %159, %129
%164 = fmul <4 x float> %162, %131
%165 = getelementptr inbounds float, float* %0, i64 %156
%166 = bitcast float* %165 to <4 x float>*
store <4 x float> %163, <4 x float>* %166
%167 = getelementptr inbounds float, float* %165, i64 4
%168 = bitcast float* %167 to <4 x float>*
store <4 x float> %164, <4 x float>* %168
%169 = add nuw i64 %140, 16
%170 = add i64 %141, 2
%171 = icmp eq i64 %170, %138
br i1 %171, label %172, label %139
172: ; preds = %139, %125
%173 = phi i64 [ 0, %125 ], [ %169, %139 ]
%174 = icmp eq i64 %135, 0
br i1 %174, label %189, label %175
175: ; preds = %172
%176 = add i64 %173, %113
%177 = getelementptr inbounds float, float* %1, i64 %176
%178 = bitcast float* %177 to <4 x float>*
%179 = load <4 x float>, <4 x float>* %178
%180 = getelementptr inbounds float, float* %177, i64 4
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = fmul <4 x float> %179, %129
%184 = fmul <4 x float> %182, %131
%185 = getelementptr inbounds float, float* %0, i64 %176
%186 = bitcast float* %185 to <4 x float>*
store <4 x float> %183, <4 x float>* %186
%187 = getelementptr inbounds float, float* %185, i64 4
%188 = bitcast float* %187 to <4 x float>*
store <4 x float> %184, <4 x float>* %188
br label %189
189: ; preds = %172, %175
%190 = icmp eq i64 %115, %126
br i1 %190, label %257, label %191
191: ; preds = %117, %112, %189
%192 = phi i64 [ %113, %117 ], [ %113, %112 ], [ %127, %189 ]
%193 = sub nsw i64 %114, %192
%194 = xor i64 %192, -1
%195 = add nsw i64 %194, %114
%196 = and i64 %193, 3
%197 = icmp eq i64 %196, 0
br i1 %197, label %208, label %198
198: ; preds = %191, %198
%199 = phi i64 [ %205, %198 ], [ %192, %191 ]
%200 = phi i64 [ %206, %198 ], [ 0, %191 ]
%201 = getelementptr inbounds float, float* %1, i64 %199
%202 = load float, float* %201
%203 = fmul float %202, %2
%204 = getelementptr inbounds float, float* %0, i64 %199
store float %203, float* %204
%205 = add nuw nsw i64 %199, 1
%206 = add i64 %200, 1
%207 = icmp eq i64 %206, %196
br i1 %207, label %208, label %198
208: ; preds = %198, %191
%209 = phi i64 [ %192, %191 ], [ %205, %198 ]
%210 = icmp ult i64 %195, 3
br i1 %210, label %257, label %234
211: ; preds = %104, %211
%212 = phi i64 [ %232, %211 ], [ %105, %104 ]
%213 = getelementptr inbounds float, float* %1, i64 %212
%214 = load float, float* %213
%215 = fmul float %214, %2
%216 = getelementptr inbounds float, float* %0, i64 %212
store float %215, float* %216
%217 = or i64 %212, 1
%218 = getelementptr inbounds float, float* %1, i64 %217
%219 = load float, float* %218
%220 = fmul float %219, %2
%221 = getelementptr inbounds float, float* %0, i64 %217
store float %220, float* %221
%222 = or i64 %212, 2
%223 = getelementptr inbounds float, float* %1, i64 %222
%224 = load float, float* %223
%225 = fmul float %224, %2
%226 = getelementptr inbounds float, float* %0, i64 %222
store float %225, float* %226
%227 = or i64 %212, 3
%228 = getelementptr inbounds float, float* %1, i64 %227
%229 = load float, float* %228
%230 = fmul float %229, %2
%231 = getelementptr inbounds float, float* %0, i64 %227
store float %230, float* %231
%232 = add nuw nsw i64 %212, 4
%233 = icmp ult i64 %232, %8
br i1 %233, label %211, label %106
234: ; preds = %208, %234
%235 = phi i64 [ %255, %234 ], [ %209, %208 ]
%236 = getelementptr inbounds float, float* %1, i64 %235
%237 = load float, float* %236
%238 = fmul float %237, %2
%239 = getelementptr inbounds float, float* %0, i64 %235
store float %238, float* %239
%240 = add nuw nsw i64 %235, 1
%241 = getelementptr inbounds float, float* %1, i64 %240
%242 = load float, float* %241
%243 = fmul float %242, %2
%244 = getelementptr inbounds float, float* %0, i64 %240
store float %243, float* %244
%245 = add nuw nsw i64 %235, 2
%246 = getelementptr inbounds float, float* %1, i64 %245
%247 = load float, float* %246
%248 = fmul float %247, %2
%249 = getelementptr inbounds float, float* %0, i64 %245
store float %248, float* %249
%250 = add nuw nsw i64 %235, 3
%251 = getelementptr inbounds float, float* %1, i64 %250
%252 = load float, float* %251
%253 = fmul float %252, %2
%254 = getelementptr inbounds float, float* %0, i64 %250
store float %253, float* %254
%255 = add nuw nsw i64 %235, 4
%256 = icmp eq i64 %255, %114
br i1 %256, label %257, label %234
257: ; preds = %208, %234, %189, %109
ret void
}