#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float mean(float *, int);
float std(float *, int);
void mapstd(float *x, int N, float ymean, float ystd, float *y) {
  float xmean, xstd, t;
  int i;
  xmean = mean(x, N);
  xstd = std(x, N);
  if (xstd != 0) {
    t = ystd / xstd;
    for (i = 0; i < N; ++i) {
      y[i] = (x[i] - xmean) * t + ymean;
    }
  } else {
    for (i = 0; i < N; ++i) {
      y[i] = x[i];
    }
  }
}


x86 assembly (clang, -O0):
<mapstd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
movss  %xmm1,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1040 <mean@plt>
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <std@plt>
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    117b <mapstd+0x5b>
jp     117b <mapstd+0x5b>
jmp    11e1 <mapstd+0xc1>
movss  -0x14(%rbp),%xmm0
divss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11dc <mapstd+0xbc>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x24(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1191 <mapstd+0x71>
jmp    1221 <mapstd+0x101>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    121c <mapstd+0xfc>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e8 <mapstd+0xc8>
jmp    1221 <mapstd+0x101>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mapstd>:
push   %rbp
push   %r14
push   %rbx
sub    $0x30,%rsp
mov    %rdx,%r14
movaps %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %esi,%ebp
mov    %rdi,%rbx
call   1040 <mean@plt>
movaps %xmm0,(%rsp)
mov    %rbx,%rdi
mov    %ebp,%esi
call   1030 <std@plt>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    115b <mapstd+0x3b>
jnp    120e <mapstd+0xee>
test   %ebp,%ebp
movaps 0x20(%rsp),%xmm5
movaps 0x10(%rsp),%xmm6
movaps (%rsp),%xmm7
jle    1474 <mapstd+0x354>
divss  %xmm0,%xmm5
mov    %ebp,%eax
cmp    $0x8,%ebp
jb     1196 <mapstd+0x76>
lea    (%rbx,%rax,4),%rcx
cmp    %r14,%rcx
jbe    12b0 <mapstd+0x190>
lea    (%r14,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    12b0 <mapstd+0x190>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     11bd <mapstd+0x9d>
movss  (%rbx,%rcx,4),%xmm0
subss  %xmm7,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%r14,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     1474 <mapstd+0x354>
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
subss  %xmm7,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
subss  %xmm7,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,0x4(%r14,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    11d0 <mapstd+0xb0>
jmp    1474 <mapstd+0x354>
test   %ebp,%ebp
jle    1474 <mapstd+0x354>
mov    %ebp,%eax
cmp    $0x8,%ebp
jb     1237 <mapstd+0x117>
lea    (%rbx,%rax,4),%rcx
cmp    %r14,%rcx
jbe    1392 <mapstd+0x272>
lea    (%r14,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    1392 <mapstd+0x272>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1265 <mapstd+0x145>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1250 <mapstd+0x130>
cmp    $0x3,%rdx
jb     1474 <mapstd+0x354>
nop
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r14,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%r14,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1270 <mapstd+0x150>
jmp    1474 <mapstd+0x354>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm7,%xmm2
shufps $0x0,%xmm7,%xmm2
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
movaps %xmm6,%xmm1
shufps $0x0,%xmm6,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     13b5 <mapstd+0x295>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rsi,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm4
subps  %xmm2,%xmm3
subps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm0,%xmm4
addps  %xmm1,%xmm4
movups %xmm3,(%r14,%rdx,4)
movups %xmm4,0x10(%r14,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm3
movups 0x30(%rbx,%rdx,4),%xmm4
subps  %xmm2,%xmm3
subps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm0,%xmm4
addps  %xmm1,%xmm4
movups %xmm3,0x20(%r14,%rdx,4)
movups %xmm4,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1300 <mapstd+0x1e0>
test   $0x1,%sil
je     1384 <mapstd+0x264>
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm4
subps  %xmm2,%xmm3
subps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm0,%xmm4
addps  %xmm1,%xmm4
movups %xmm3,(%r14,%rdx,4)
movups %xmm4,0x10(%r14,%rdx,4)
cmp    %rax,%rcx
je     1474 <mapstd+0x354>
jmp    1198 <mapstd+0x78>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    13bf <mapstd+0x29f>
xor    %edi,%edi
jmp    1430 <mapstd+0x310>
xor    %edx,%edx
test   $0x1,%sil
jne    135e <mapstd+0x23e>
jmp    1384 <mapstd+0x264>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%r14,%rdi,4)
movups %xmm1,0x50(%r14,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%r14,%rdi,4)
movups %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13d0 <mapstd+0x2b0>
test   %rdx,%rdx
je     146b <mapstd+0x34b>
lea    (%r14,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1450 <mapstd+0x330>
cmp    %rax,%rcx
jne    1239 <mapstd+0x119>
add    $0x30,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @mapstd(float* %0, i32 %1, float %2, float %3, float* %4) {
%6 = alloca float*
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float*
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca i32
store float* %0, float** %6
store i32 %1, i32* %7
store float %2, float* %8
store float %3, float* %9
store float* %4, float** %10
%15 = load float*, float** %6
%16 = load i32, i32* %7
%17 = call float @mean(float* %15, i32 %16)
store float %17, float* %11
%18 = load float*, float** %6
%19 = load i32, i32* %7
%20 = call float @std(float* %18, i32 %19)
store float %20, float* %12
%21 = load float, float* %12
%22 = fcmp une float %21, 0.000000e+00
br i1 %22, label %23, label %50
23: ; preds = %5
%24 = load float, float* %9
%25 = load float, float* %12
%26 = fdiv float %24, %25
store float %26, float* %13
store i32 0, i32* %14
br label %27
27: ; preds = %46, %23
%28 = load i32, i32* %14
%29 = load i32, i32* %7
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %49
31: ; preds = %27
%32 = load float*, float** %6
%33 = load i32, i32* %14
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %32, i64 %34
%36 = load float, float* %35
%37 = load float, float* %11
%38 = fsub float %36, %37
%39 = load float, float* %13
%40 = load float, float* %8
%41 = call float @llvm.fmuladd.f32(float %38, float %39, float %40)
%42 = load float*, float** %10
%43 = load i32, i32* %14
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
store float %41, float* %45
br label %46
46: ; preds = %31
%47 = load i32, i32* %14
%48 = add nsw i32 %47, 1
store i32 %48, i32* %14
br label %27
49: ; preds = %27
br label %69
50: ; preds = %5
store i32 0, i32* %14
br label %51
51: ; preds = %65, %50
%52 = load i32, i32* %14
%53 = load i32, i32* %7
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %68
55: ; preds = %51
%56 = load float*, float** %6
%57 = load i32, i32* %14
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = load float*, float** %10
%62 = load i32, i32* %14
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %61, i64 %63
store float %60, float* %64
br label %65
65: ; preds = %55
%66 = load i32, i32* %14
%67 = add nsw i32 %66, 1
store i32 %67, i32* %14
br label %51
68: ; preds = %51
br label %69
69: ; preds = %68, %49
ret void
}

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