int main() {
  int i = 0, j = 0, N = 100, alpha, beta;
  float A[100][100], u1[100], u2[100], v1[100], v2[100], w[100], x[100], y[100],
      z[100];
#pragma scop
  for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
      A[i][j] = A[i][j] + u1[i] * v1[j] + u2[i] * v2[j];
  for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
      x[i] = x[i] + beta * A[i][j] * y[j];
  for (i = 0; i < N; i++)
    x[i] = x[i] + z[i];
  for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
      w[i] = w[i] + alpha * A[i][j] * x[j];
#pragma endscop
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa860,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x64,-0x10(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11ee <main+0xee>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11db <main+0xdb>
movslq -0x8(%rbp),%rcx
lea    -0x9c60(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x8(%rbp),%rax
movss  -0x9df0(%rbp,%rax,4),%xmm1
ff ff
movslq -0xc(%rbp),%rax
movss  -0xa110(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq -0x8(%rbp),%rax
movss  -0x9f80(%rbp,%rax,4),%xmm0
ff ff
movslq -0xc(%rbp),%rax
movss  -0xa2a0(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x9c60(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1141 <main+0x41>
jmp    11e0 <main+0xe0>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    112e <main+0x2e>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1287 <main+0x187>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1274 <main+0x174>
movslq -0x8(%rbp),%rax
movss  -0xa5c0(%rbp,%rax,4),%xmm1
ff ff
cvtsi2ssl -0x18(%rbp),%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x9c60(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq -0xc(%rbp),%rax
movss  -0xa750(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xa5c0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1208 <main+0x108>
jmp    1279 <main+0x179>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11f5 <main+0xf5>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12cf <main+0x1cf>
movslq -0x8(%rbp),%rax
movss  -0xa5c0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
addss  -0xa8e0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xa5c0(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    128e <main+0x18e>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1368 <main+0x268>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1355 <main+0x255>
movslq -0x8(%rbp),%rax
movss  -0xa430(%rbp,%rax,4),%xmm1
cvtsi2ssl -0x14(%rbp),%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x9c60(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq -0xc(%rbp),%rax
movss  -0xa5c0(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xa430(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12e9 <main+0x1e9>
jmp    135a <main+0x25a>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12d6 <main+0x1d6>
xor    %eax,%eax
add    $0xa860,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0xa848,%rsp
lea    0xc00(%rsp),%rax
xor    %ecx,%ecx
jmp    1130 <main+0x30>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
add    $0x190,%rax
cmp    $0x64,%rcx
je     11a0 <main+0xa0>
movss  0xa70(%rsp,%rcx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  0x8e0(%rsp,%rcx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mov    $0x4,%edx
nop
movaps 0x740(%rsp,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
addps  -0x10(%rax,%rdx,4),%xmm2
movaps 0x5b0(%rsp,%rdx,4),%xmm3
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movaps %xmm3,-0x10(%rax,%rdx,4)
cmp    $0x64,%rdx
je     1120 <main+0x20>
movaps 0x750(%rsp,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
addps  (%rax,%rdx,4),%xmm2
movaps 0x5c0(%rsp,%rdx,4),%xmm3
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movaps %xmm3,(%rax,%rdx,4)
add    $0x8,%rdx
jmp    1150 <main+0x50>
lea    0xc00(%rsp),%rax
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
nopl   (%rax)
movss  -0x80(%rsp,%rcx,4),%xmm1
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rax,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
mulss  0x29c(%rsp,%rdx,4),%xmm2
addss  %xmm1,%xmm2
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
mulss  0x2a0(%rsp,%rdx,4),%xmm1
addss  %xmm2,%xmm1
add    $0x2,%rdx
cmp    $0x65,%rdx
jne    11c0 <main+0xc0>
movss  %xmm1,-0x80(%rsp,%rcx,4)
add    $0x1,%rcx
add    $0x190,%rax
cmp    $0x64,%rcx
jne    11b0 <main+0xb0>
movaps -0x80(%rsp),%xmm0
movaps -0x70(%rsp),%xmm1
movaps -0x60(%rsp),%xmm2
movaps -0x50(%rsp),%xmm3
addps  0x110(%rsp),%xmm0
movaps %xmm0,-0x80(%rsp)
addps  0x120(%rsp),%xmm1
addps  0x130(%rsp),%xmm2
movaps %xmm1,-0x70(%rsp)
movaps %xmm2,-0x60(%rsp)
addps  0x140(%rsp),%xmm3
movaps %xmm3,-0x50(%rsp)
movaps -0x40(%rsp),%xmm0
addps  0x150(%rsp),%xmm0
movaps %xmm0,-0x40(%rsp)
movaps -0x30(%rsp),%xmm0
addps  0x160(%rsp),%xmm0
movaps %xmm0,-0x30(%rsp)
movaps -0x20(%rsp),%xmm0
addps  0x170(%rsp),%xmm0
movaps %xmm0,-0x20(%rsp)
movaps -0x10(%rsp),%xmm0
addps  0x180(%rsp),%xmm0
movaps %xmm0,-0x10(%rsp)
movaps (%rsp),%xmm0
addps  0x190(%rsp),%xmm0
movaps %xmm0,(%rsp)
movaps 0x10(%rsp),%xmm0
addps  0x1a0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0x20(%rsp),%xmm0
addps  0x1b0(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0x30(%rsp),%xmm0
addps  0x1c0(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x40(%rsp),%xmm0
addps  0x1d0(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0x50(%rsp),%xmm0
addps  0x1e0(%rsp),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x60(%rsp),%xmm0
addps  0x1f0(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x70(%rsp),%xmm0
addps  0x200(%rsp),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x80(%rsp),%xmm0
addps  0x210(%rsp),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0x90(%rsp),%xmm0
addps  0x220(%rsp),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xa0(%rsp),%xmm0
addps  0x230(%rsp),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xb0(%rsp),%xmm0
addps  0x240(%rsp),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xc0(%rsp),%xmm0
addps  0x250(%rsp),%xmm0
movaps %xmm0,0xc0(%rsp)
movaps 0xd0(%rsp),%xmm0
addps  0x260(%rsp),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xe0(%rsp),%xmm0
addps  0x270(%rsp),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xf0(%rsp),%xmm0
addps  0x280(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
movaps 0x100(%rsp),%xmm0
addps  0x290(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
lea    0xc00(%rsp),%rax
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
movss  0x430(%rsp,%rcx,4),%xmm1
mov    $0x1,%edx
xchg   %ax,%ax
movss  -0x4(%rax,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
mulss  -0x84(%rsp,%rdx,4),%xmm2
ff ff
addss  %xmm1,%xmm2
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
mulss  -0x80(%rsp,%rdx,4),%xmm1
addss  %xmm2,%xmm1
add    $0x2,%rdx
cmp    $0x65,%rdx
jne    1420 <main+0x320>
movss  %xmm1,0x430(%rsp,%rcx,4)
add    $0x1,%rcx
add    $0x190,%rax
cmp    $0x64,%rcx
jne    1410 <main+0x310>
xor    %eax,%eax
add    $0xa848,%rsp
ret

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

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