void unblocked(float *restrict a, float *restrict b, float *restrict c,
               float *restrict d, float *restrict e, float *restrict f,
               float *restrict g, float *restrict h, float *restrict k,
               float *restrict l, float *restrict m, float *restrict n,
               float *restrict o, float *restrict p, float *restrict q,
               float *restrict r) {
  int i, j;
  for (i = 0; i < 4096; i++) {
    for (j = 0; j < 4096; j++) {
      a[j] = (a[j] + b[j] + c[j] + d[j] + e[j] + f[j] + g[j] + h[j] + k[j] +
              l[j] + m[j] + n[j] + o[j] + p[j] + q[j] + r[j]);
    }
    a += 4096;
    b += 4096;
    c += 4096;
    d += 4096;
    e += 4096;
    f += 4096;
    g += 4096;
    h += 4096;
    k += 4096;
    l += 4096;
    m += 4096;
    n += 4096;
    o += 4096;
    p += 4096;
    q += 4096;
    r += 4096;
  }
}


x86 assembly (clang, -O0):
<unblocked>:
push   %rbp
mov    %rsp,%rbp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x1000,-0x34(%rbp)
jge    1345 <unblocked+0x245>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    1257 <unblocked+0x157>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    115f <unblocked+0x5f>
mov    -0x8(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x30(%rbp)
mov    0x10(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x10(%rbp)
mov    0x18(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x18(%rbp)
mov    0x20(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x20(%rbp)
mov    0x28(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x28(%rbp)
mov    0x30(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x30(%rbp)
mov    0x38(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x48(%rbp)
mov    0x50(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x50(%rbp)
mov    0x58(%rbp),%rax
add    $0x4000,%rax
mov    %rax,0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114b <unblocked+0x4b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<unblocked>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x30(%rsp)
mov    %rcx,-0x38(%rsp)
mov    %rdx,-0x40(%rsp)
mov    %rsi,-0x48(%rsp)
xor    %ecx,%ecx
mov    0x80(%rsp),%rbp
mov    0x78(%rsp),%r12
mov    0x70(%rsp),%rax
mov    0x68(%rsp),%r15
mov    0x60(%rsp),%r8
mov    0x58(%rsp),%r13
mov    0x50(%rsp),%r14
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,-0x28(%rsp)
mov    %rax,-0x20(%rsp)
mov    %r12,-0x18(%rsp)
mov    %rbp,-0x10(%rsp)
mov    %rcx,-0x8(%rsp)
mov    %r9,%r15
xor    %r9d,%r9d
mov    -0x30(%rsp),%rcx
mov    %r14,%r12
mov    %rbx,%rbp
mov    %rdx,%rbx
mov    -0x38(%rsp),%rdx
mov    -0x40(%rsp),%rsi
mov    -0x48(%rsp),%r14
nopl   0x0(%rax)
movups (%rdi,%r9,1),%xmm0
movups (%r14,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups (%rsi,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups (%rcx,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups (%r15,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups (%rbx,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups 0x0(%rbp,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups (%r11,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups (%r12,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups 0x0(%r13,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups (%r8,%r9,1),%xmm1
addps  %xmm0,%xmm1
mov    -0x28(%rsp),%rax
movups (%rax,%r9,1),%xmm0
addps  %xmm1,%xmm0
mov    -0x20(%rsp),%rax
movups (%rax,%r9,1),%xmm1
addps  %xmm0,%xmm1
mov    -0x18(%rsp),%rax
movups (%rax,%r9,1),%xmm0
addps  %xmm1,%xmm0
mov    -0x10(%rsp),%r10
movups (%r10,%r9,1),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi,%r9,1)
add    $0x10,%r9
cmp    $0x4000,%r9
jne    11a0 <unblocked+0xa0>
add    $0x4000,%rdi
add    $0x4000,%r14
mov    %r14,-0x48(%rsp)
add    $0x4000,%rsi
mov    %rsi,-0x40(%rsp)
add    $0x4000,%rdx
mov    %rdx,-0x38(%rsp)
add    $0x4000,%rcx
mov    %rcx,-0x30(%rsp)
add    $0x4000,%r15
mov    %rbx,%rdx
add    $0x4000,%rdx
mov    %rbp,%rbx
add    $0x4000,%rbx
add    $0x4000,%r11
mov    %r12,%r10
add    $0x4000,%r10
mov    %r13,%r14
add    $0x4000,%r14
add    $0x4000,%r8
mov    -0x28(%rsp),%rsi
add    $0x4000,%rsi
mov    -0x20(%rsp),%r13
add    $0x4000,%r13
mov    -0x18(%rsp),%r12
add    $0x4000,%r12
mov    -0x10(%rsp),%rbp
add    $0x4000,%rbp
mov    -0x8(%rsp),%rcx
add    $0x1,%ecx
cmp    $0x1000,%ecx
mov    %r15,%r9
mov    %rsi,%r15
mov    %r13,%rax
mov    %r14,%r13
mov    %r10,%r14
jne    1160 <unblocked+0x60>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @unblocked(float* noalias nocapture %0, float* noalias nocapture %1, float* noalias nocapture %2, float* noalias nocapture %3, float* noalias nocapture %4, float* noalias nocapture %5, float* noalias nocapture %6, float* noalias nocapture %7, float* noalias nocapture %8, float* noalias nocapture %9, float* noalias nocapture %10, float* noalias nocapture %11, float* noalias nocapture %12, float* noalias nocapture %13, float* noalias nocapture %14, float* noalias nocapture %15) {
br label %17
17: ; preds = %103, %16
%18 = phi i32 [ 0, %16 ], [ %120, %103 ]
%19 = phi float* [ %15, %16 ], [ %119, %103 ]
%20 = phi float* [ %14, %16 ], [ %118, %103 ]
%21 = phi float* [ %13, %16 ], [ %117, %103 ]
%22 = phi float* [ %12, %16 ], [ %116, %103 ]
%23 = phi float* [ %11, %16 ], [ %115, %103 ]
%24 = phi float* [ %10, %16 ], [ %114, %103 ]
%25 = phi float* [ %9, %16 ], [ %113, %103 ]
%26 = phi float* [ %8, %16 ], [ %112, %103 ]
%27 = phi float* [ %7, %16 ], [ %111, %103 ]
%28 = phi float* [ %6, %16 ], [ %110, %103 ]
%29 = phi float* [ %5, %16 ], [ %109, %103 ]
%30 = phi float* [ %4, %16 ], [ %108, %103 ]
%31 = phi float* [ %3, %16 ], [ %107, %103 ]
%32 = phi float* [ %2, %16 ], [ %106, %103 ]
%33 = phi float* [ %1, %16 ], [ %105, %103 ]
%34 = phi float* [ %0, %16 ], [ %104, %103 ]
br label %35
35: ; preds = %35, %17
%36 = phi i64 [ 0, %17 ], [ %101, %35 ]
%37 = getelementptr inbounds float, float* %34, i64 %36
%38 = bitcast float* %37 to <4 x float>*
%39 = load <4 x float>, <4 x float>* %38
%40 = getelementptr inbounds float, float* %33, i64 %36
%41 = bitcast float* %40 to <4 x float>*
%42 = load <4 x float>, <4 x float>* %41
%43 = fadd <4 x float> %39, %42
%44 = getelementptr inbounds float, float* %32, i64 %36
%45 = bitcast float* %44 to <4 x float>*
%46 = load <4 x float>, <4 x float>* %45
%47 = fadd <4 x float> %43, %46
%48 = getelementptr inbounds float, float* %31, i64 %36
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = fadd <4 x float> %47, %50
%52 = getelementptr inbounds float, float* %30, i64 %36
%53 = bitcast float* %52 to <4 x float>*
%54 = load <4 x float>, <4 x float>* %53
%55 = fadd <4 x float> %51, %54
%56 = getelementptr inbounds float, float* %29, i64 %36
%57 = bitcast float* %56 to <4 x float>*
%58 = load <4 x float>, <4 x float>* %57
%59 = fadd <4 x float> %55, %58
%60 = getelementptr inbounds float, float* %28, i64 %36
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = fadd <4 x float> %59, %62
%64 = getelementptr inbounds float, float* %27, i64 %36
%65 = bitcast float* %64 to <4 x float>*
%66 = load <4 x float>, <4 x float>* %65
%67 = fadd <4 x float> %63, %66
%68 = getelementptr inbounds float, float* %26, i64 %36
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = fadd <4 x float> %67, %70
%72 = getelementptr inbounds float, float* %25, i64 %36
%73 = bitcast float* %72 to <4 x float>*
%74 = load <4 x float>, <4 x float>* %73
%75 = fadd <4 x float> %71, %74
%76 = getelementptr inbounds float, float* %24, i64 %36
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = fadd <4 x float> %75, %78
%80 = getelementptr inbounds float, float* %23, i64 %36
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = fadd <4 x float> %79, %82
%84 = getelementptr inbounds float, float* %22, i64 %36
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = fadd <4 x float> %83, %86
%88 = getelementptr inbounds float, float* %21, i64 %36
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = fadd <4 x float> %87, %90
%92 = getelementptr inbounds float, float* %20, i64 %36
%93 = bitcast float* %92 to <4 x float>*
%94 = load <4 x float>, <4 x float>* %93
%95 = fadd <4 x float> %91, %94
%96 = getelementptr inbounds float, float* %19, i64 %36
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = fadd <4 x float> %95, %98
%100 = bitcast float* %37 to <4 x float>*
store <4 x float> %99, <4 x float>* %100
%101 = add nuw i64 %36, 4
%102 = icmp eq i64 %101, 4096
br i1 %102, label %103, label %35
103: ; preds = %35
%104 = getelementptr inbounds float, float* %34, i64 4096
%105 = getelementptr inbounds float, float* %33, i64 4096
%106 = getelementptr inbounds float, float* %32, i64 4096
%107 = getelementptr inbounds float, float* %31, i64 4096
%108 = getelementptr inbounds float, float* %30, i64 4096
%109 = getelementptr inbounds float, float* %29, i64 4096
%110 = getelementptr inbounds float, float* %28, i64 4096
%111 = getelementptr inbounds float, float* %27, i64 4096
%112 = getelementptr inbounds float, float* %26, i64 4096
%113 = getelementptr inbounds float, float* %25, i64 4096
%114 = getelementptr inbounds float, float* %24, i64 4096
%115 = getelementptr inbounds float, float* %23, i64 4096
%116 = getelementptr inbounds float, float* %22, i64 4096
%117 = getelementptr inbounds float, float* %21, i64 4096
%118 = getelementptr inbounds float, float* %20, i64 4096
%119 = getelementptr inbounds float, float* %19, i64 4096
%120 = add nuw nsw i32 %18, 1
%121 = icmp eq i32 %120, 4096
br i1 %121, label %122, label %17
122: ; preds = %103
ret void
}