void blocked(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];
    }
    for (j = 0; j < 4096; j++) {
      a[j] = a[j] + e[j] + f[j] + g[j];
    }
    for (j = 0; j < 4096; j++) {
      a[j] = a[j] + h[j] + k[j] + l[j];
    }
    for (j = 0; j < 4096; j++) {
      a[j] = a[j] + m[j] + n[j] + o[j];
    }
    for (j = 0; j < 4096; j++) {
      a[j] = a[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):
<blocked>:
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    1435 <blocked+0x335>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    11bb <blocked+0xbb>
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    -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 <blocked+0x5f>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    121e <blocked+0x11e>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%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    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c2 <blocked+0xc2>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    1281 <blocked+0x181>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%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    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1225 <blocked+0x125>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    12e4 <blocked+0x1e4>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%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    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1288 <blocked+0x188>
movl   $0x0,-0x38(%rbp)
cmpl   $0x1000,-0x38(%rbp)
jge    1347 <blocked+0x247>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%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    12eb <blocked+0x1eb>
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 <blocked+0x4b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<blocked>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
xor    %eax,%eax
mov    0x80(%rsp),%rbp
mov    %rbp,-0x38(%rsp)
mov    0x78(%rsp),%rbp
mov    %rbp,-0x40(%rsp)
mov    0x70(%rsp),%rbp
mov    %rbp,-0x48(%rsp)
mov    0x68(%rsp),%rbp
mov    %rbp,-0x50(%rsp)
mov    0x60(%rsp),%r13
mov    0x58(%rsp),%r14
mov    0x50(%rsp),%rbx
mov    0x48(%rsp),%r12
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,-0x10(%rsp)
mov    %r8,-0x20(%rsp)
mov    %r9,-0x8(%rsp)
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%r9,1),%xmm0
movups 0x10(%rdi,%r9,1),%xmm1
movups (%rsi,%r9,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%r9,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%rdx,%r9,1),%xmm2
addps  %xmm0,%xmm2
movups (%rcx,%r9,1),%xmm0
addps  %xmm1,%xmm0
movups 0x10(%rcx,%r9,1),%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdi,%r9,1)
movups %xmm1,0x10(%rdi,%r9,1)
add    $0x20,%r9
cmp    $0x4000,%r9
jne    1180 <blocked+0x80>
xor    %eax,%eax
mov    -0x8(%rsp),%r9
mov    -0x20(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups (%r8,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r8,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups (%r9,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%r9,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups (%r11,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups 0x10(%r11,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    $0x4000,%rax
jne    11f0 <blocked+0xf0>
mov    %r14,-0x30(%rsp)
mov    %r13,-0x28(%rsp)
xor    %eax,%eax
nopl   (%rax)
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups (%r10,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r10,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups (%r12,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%r12,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups (%rbx,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    $0x4000,%rax
jne    1250 <blocked+0x150>
mov    %rbx,-0x18(%rsp)
xor    %eax,%eax
mov    -0x38(%rsp),%rbx
mov    -0x40(%rsp),%r8
mov    -0x48(%rsp),%rbp
mov    -0x50(%rsp),%r13
mov    -0x28(%rsp),%r14
mov    -0x30(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups (%r15,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups (%r14,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%r14,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups 0x0(%r13,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups 0x10(%r13,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    $0x4000,%rax
jne    12d0 <blocked+0x1d0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbp,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups (%r8,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups 0x10(%r8,%rax,1),%xmm2
addps  %xmm0,%xmm2
movups (%rbx,%rax,1),%xmm0
addps  %xmm1,%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    $0x4000,%rax
jne    1330 <blocked+0x230>
add    $0x4000,%rdi
add    $0x4000,%rsi
add    $0x4000,%rdx
add    $0x4000,%rcx
mov    %rbx,%r15
mov    %r8,%rax
mov    -0x20(%rsp),%r8
add    $0x4000,%r8
add    $0x4000,%r9
add    $0x4000,%r11
add    $0x4000,%r10
add    $0x4000,%r12
mov    -0x18(%rsp),%rbx
add    $0x4000,%rbx
mov    -0x30(%rsp),%r14
add    $0x4000,%r14
mov    -0x28(%rsp),%r13
add    $0x4000,%r13
addq   $0x4000,-0x50(%rsp)
add    $0x4000,%rbp
mov    %rbp,-0x48(%rsp)
add    $0x4000,%rax
mov    %rax,-0x40(%rsp)
add    $0x4000,%r15
mov    %r15,-0x38(%rsp)
mov    -0x10(%rsp),%rax
add    $0x1,%eax
cmp    $0x1000,%eax
jne    1160 <blocked+0x60>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @blocked(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 = %246, %16
%36 = load i32, i32* %33
%37 = icmp slt i32 %36, 4096
br i1 %37, label %38, label %249
38: ; preds = %35
store i32 0, i32* %34
br label %39
39: ; preds = %70, %38
%40 = load i32, i32* %34
%41 = icmp slt i32 %40, 4096
br i1 %41, label %42, label %73
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** %17
%67 = load i32, i32* %34
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %66, i64 %68
store float %65, float* %69
br label %70
70: ; preds = %42
%71 = load i32, i32* %34
%72 = add nsw i32 %71, 1
store i32 %72, i32* %34
br label %39
73: ; preds = %39
store i32 0, i32* %34
br label %74
74: ; preds = %105, %73
%75 = load i32, i32* %34
%76 = icmp slt i32 %75, 4096
br i1 %76, label %77, label %108
77: ; preds = %74
%78 = load float*, float** %17
%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 = load float*, float** %21
%84 = load i32, i32* %34
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
%87 = load float, float* %86
%88 = fadd float %82, %87
%89 = load float*, float** %22
%90 = load i32, i32* %34
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
%93 = load float, float* %92
%94 = fadd float %88, %93
%95 = load float*, float** %23
%96 = load i32, i32* %34
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
%100 = fadd float %94, %99
%101 = load float*, float** %17
%102 = load i32, i32* %34
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %101, i64 %103
store float %100, float* %104
br label %105
105: ; preds = %77
%106 = load i32, i32* %34
%107 = add nsw i32 %106, 1
store i32 %107, i32* %34
br label %74
108: ; preds = %74
store i32 0, i32* %34
br label %109
109: ; preds = %140, %108
%110 = load i32, i32* %34
%111 = icmp slt i32 %110, 4096
br i1 %111, label %112, label %143
112: ; preds = %109
%113 = load float*, float** %17
%114 = load i32, i32* %34
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = load float*, float** %24
%119 = load i32, i32* %34
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = fadd float %117, %122
%124 = load float*, float** %25
%125 = load i32, i32* %34
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = fadd float %123, %128
%130 = load float*, float** %26
%131 = load i32, i32* %34
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
%134 = load float, float* %133
%135 = fadd float %129, %134
%136 = load float*, float** %17
%137 = load i32, i32* %34
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %136, i64 %138
store float %135, float* %139
br label %140
140: ; preds = %112
%141 = load i32, i32* %34
%142 = add nsw i32 %141, 1
store i32 %142, i32* %34
br label %109
143: ; preds = %109
store i32 0, i32* %34
br label %144
144: ; preds = %175, %143
%145 = load i32, i32* %34
%146 = icmp slt i32 %145, 4096
br i1 %146, label %147, label %178
147: ; preds = %144
%148 = load float*, float** %17
%149 = load i32, i32* %34
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
%153 = load float*, float** %27
%154 = load i32, i32* %34
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
%157 = load float, float* %156
%158 = fadd float %152, %157
%159 = load float*, float** %28
%160 = load i32, i32* %34
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %159, i64 %161
%163 = load float, float* %162
%164 = fadd float %158, %163
%165 = load float*, float** %29
%166 = load i32, i32* %34
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %165, i64 %167
%169 = load float, float* %168
%170 = fadd float %164, %169
%171 = load float*, float** %17
%172 = load i32, i32* %34
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
store float %170, float* %174
br label %175
175: ; preds = %147
%176 = load i32, i32* %34
%177 = add nsw i32 %176, 1
store i32 %177, i32* %34
br label %144
178: ; preds = %144
store i32 0, i32* %34
br label %179
179: ; preds = %210, %178
%180 = load i32, i32* %34
%181 = icmp slt i32 %180, 4096
br i1 %181, label %182, label %213
182: ; preds = %179
%183 = load float*, float** %17
%184 = load i32, i32* %34
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
%187 = load float, float* %186
%188 = load float*, float** %30
%189 = load i32, i32* %34
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %188, i64 %190
%192 = load float, float* %191
%193 = fadd float %187, %192
%194 = load float*, float** %31
%195 = load i32, i32* %34
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %194, i64 %196
%198 = load float, float* %197
%199 = fadd float %193, %198
%200 = load float*, float** %32
%201 = load i32, i32* %34
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %200, i64 %202
%204 = load float, float* %203
%205 = fadd float %199, %204
%206 = load float*, float** %17
%207 = load i32, i32* %34
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %206, i64 %208
store float %205, float* %209
br label %210
210: ; preds = %182
%211 = load i32, i32* %34
%212 = add nsw i32 %211, 1
store i32 %212, i32* %34
br label %179
213: ; preds = %179
%214 = load float*, float** %17
%215 = getelementptr inbounds float, float* %214, i64 4096
store float* %215, float** %17
%216 = load float*, float** %18
%217 = getelementptr inbounds float, float* %216, i64 4096
store float* %217, float** %18
%218 = load float*, float** %19
%219 = getelementptr inbounds float, float* %218, i64 4096
store float* %219, float** %19
%220 = load float*, float** %20
%221 = getelementptr inbounds float, float* %220, i64 4096
store float* %221, float** %20
%222 = load float*, float** %21
%223 = getelementptr inbounds float, float* %222, i64 4096
store float* %223, float** %21
%224 = load float*, float** %22
%225 = getelementptr inbounds float, float* %224, i64 4096
store float* %225, float** %22
%226 = load float*, float** %23
%227 = getelementptr inbounds float, float* %226, i64 4096
store float* %227, float** %23
%228 = load float*, float** %24
%229 = getelementptr inbounds float, float* %228, i64 4096
store float* %229, float** %24
%230 = load float*, float** %25
%231 = getelementptr inbounds float, float* %230, i64 4096
store float* %231, float** %25
%232 = load float*, float** %26
%233 = getelementptr inbounds float, float* %232, i64 4096
store float* %233, float** %26
%234 = load float*, float** %27
%235 = getelementptr inbounds float, float* %234, i64 4096
store float* %235, float** %27
%236 = load float*, float** %28
%237 = getelementptr inbounds float, float* %236, i64 4096
store float* %237, float** %28
%238 = load float*, float** %29
%239 = getelementptr inbounds float, float* %238, i64 4096
store float* %239, float** %29
%240 = load float*, float** %30
%241 = getelementptr inbounds float, float* %240, i64 4096
store float* %241, float** %30
%242 = load float*, float** %31
%243 = getelementptr inbounds float, float* %242, i64 4096
store float* %243, float** %31
%244 = load float*, float** %32
%245 = getelementptr inbounds float, float* %244, i64 4096
store float* %245, float** %32
br label %246
246: ; preds = %213
%247 = load i32, i32* %33
%248 = add nsw i32 %247, 1
store i32 %248, i32* %33
br label %35
249: ; preds = %35
ret void
}

LLVM IR (-O2):
define void @blocked(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 = %215, %16
%18 = phi i32 [ 0, %16 ], [ %232, %215 ]
%19 = phi float* [ %15, %16 ], [ %231, %215 ]
%20 = phi float* [ %14, %16 ], [ %230, %215 ]
%21 = phi float* [ %13, %16 ], [ %229, %215 ]
%22 = phi float* [ %12, %16 ], [ %228, %215 ]
%23 = phi float* [ %11, %16 ], [ %227, %215 ]
%24 = phi float* [ %10, %16 ], [ %226, %215 ]
%25 = phi float* [ %9, %16 ], [ %225, %215 ]
%26 = phi float* [ %8, %16 ], [ %224, %215 ]
%27 = phi float* [ %7, %16 ], [ %223, %215 ]
%28 = phi float* [ %6, %16 ], [ %222, %215 ]
%29 = phi float* [ %5, %16 ], [ %221, %215 ]
%30 = phi float* [ %4, %16 ], [ %220, %215 ]
%31 = phi float* [ %3, %16 ], [ %219, %215 ]
%32 = phi float* [ %2, %16 ], [ %218, %215 ]
%33 = phi float* [ %1, %16 ], [ %217, %215 ]
%34 = phi float* [ %0, %16 ], [ %216, %215 ]
br label %35
35: ; preds = %35, %17
%36 = phi i64 [ 0, %17 ], [ %69, %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* %37, i64 4
%41 = bitcast float* %40 to <4 x float>*
%42 = load <4 x float>, <4 x float>* %41
%43 = getelementptr inbounds float, float* %33, i64 %36
%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 = fadd <4 x float> %39, %45
%50 = fadd <4 x float> %42, %48
%51 = getelementptr inbounds float, float* %32, i64 %36
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = getelementptr inbounds float, float* %51, i64 4
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = fadd <4 x float> %49, %53
%58 = fadd <4 x float> %50, %56
%59 = getelementptr inbounds float, float* %31, i64 %36
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = getelementptr inbounds float, float* %59, i64 4
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = fadd <4 x float> %57, %61
%66 = fadd <4 x float> %58, %64
%67 = bitcast float* %37 to <4 x float>*
store <4 x float> %65, <4 x float>* %67
%68 = bitcast float* %40 to <4 x float>*
store <4 x float> %66, <4 x float>* %68
%69 = add nuw i64 %36, 8
%70 = icmp eq i64 %69, 4096
br i1 %70, label %71, label %35
71: ; preds = %35, %71
%72 = phi i64 [ %105, %71 ], [ 0, %35 ]
%73 = getelementptr inbounds float, float* %34, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %73, i64 4
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = getelementptr inbounds float, float* %30, i64 %72
%80 = bitcast float* %79 to <4 x float>*
%81 = load <4 x float>, <4 x float>* %80
%82 = getelementptr inbounds float, float* %79, i64 4
%83 = bitcast float* %82 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = fadd <4 x float> %75, %81
%86 = fadd <4 x float> %78, %84
%87 = getelementptr inbounds float, float* %29, i64 %72
%88 = bitcast float* %87 to <4 x float>*
%89 = load <4 x float>, <4 x float>* %88
%90 = getelementptr inbounds float, float* %87, i64 4
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = fadd <4 x float> %85, %89
%94 = fadd <4 x float> %86, %92
%95 = getelementptr inbounds float, float* %28, i64 %72
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = getelementptr inbounds float, float* %95, i64 4
%99 = bitcast float* %98 to <4 x float>*
%100 = load <4 x float>, <4 x float>* %99
%101 = fadd <4 x float> %93, %97
%102 = fadd <4 x float> %94, %100
%103 = bitcast float* %73 to <4 x float>*
store <4 x float> %101, <4 x float>* %103
%104 = bitcast float* %76 to <4 x float>*
store <4 x float> %102, <4 x float>* %104
%105 = add nuw i64 %72, 8
%106 = icmp eq i64 %105, 4096
br i1 %106, label %107, label %71
107: ; preds = %71, %107
%108 = phi i64 [ %141, %107 ], [ 0, %71 ]
%109 = getelementptr inbounds float, float* %34, i64 %108
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr inbounds float, float* %109, i64 4
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = getelementptr inbounds float, float* %27, i64 %108
%116 = bitcast float* %115 to <4 x float>*
%117 = load <4 x float>, <4 x float>* %116
%118 = getelementptr inbounds float, float* %115, i64 4
%119 = bitcast float* %118 to <4 x float>*
%120 = load <4 x float>, <4 x float>* %119
%121 = fadd <4 x float> %111, %117
%122 = fadd <4 x float> %114, %120
%123 = getelementptr inbounds float, float* %26, i64 %108
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = getelementptr inbounds float, float* %123, i64 4
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = fadd <4 x float> %121, %125
%130 = fadd <4 x float> %122, %128
%131 = getelementptr inbounds float, float* %25, i64 %108
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = getelementptr inbounds float, float* %131, i64 4
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = fadd <4 x float> %129, %133
%138 = fadd <4 x float> %130, %136
%139 = bitcast float* %109 to <4 x float>*
store <4 x float> %137, <4 x float>* %139
%140 = bitcast float* %112 to <4 x float>*
store <4 x float> %138, <4 x float>* %140
%141 = add nuw i64 %108, 8
%142 = icmp eq i64 %141, 4096
br i1 %142, label %143, label %107
143: ; preds = %107, %143
%144 = phi i64 [ %177, %143 ], [ 0, %107 ]
%145 = getelementptr inbounds float, float* %34, i64 %144
%146 = bitcast float* %145 to <4 x float>*
%147 = load <4 x float>, <4 x float>* %146
%148 = getelementptr inbounds float, float* %145, i64 4
%149 = bitcast float* %148 to <4 x float>*
%150 = load <4 x float>, <4 x float>* %149
%151 = getelementptr inbounds float, float* %24, i64 %144
%152 = bitcast float* %151 to <4 x float>*
%153 = load <4 x float>, <4 x float>* %152
%154 = getelementptr inbounds float, float* %151, i64 4
%155 = bitcast float* %154 to <4 x float>*
%156 = load <4 x float>, <4 x float>* %155
%157 = fadd <4 x float> %147, %153
%158 = fadd <4 x float> %150, %156
%159 = getelementptr inbounds float, float* %23, i64 %144
%160 = bitcast float* %159 to <4 x float>*
%161 = load <4 x float>, <4 x float>* %160
%162 = getelementptr inbounds float, float* %159, i64 4
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = fadd <4 x float> %157, %161
%166 = fadd <4 x float> %158, %164
%167 = getelementptr inbounds float, float* %22, i64 %144
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = getelementptr inbounds float, float* %167, i64 4
%171 = bitcast float* %170 to <4 x float>*
%172 = load <4 x float>, <4 x float>* %171
%173 = fadd <4 x float> %165, %169
%174 = fadd <4 x float> %166, %172
%175 = bitcast float* %145 to <4 x float>*
store <4 x float> %173, <4 x float>* %175
%176 = bitcast float* %148 to <4 x float>*
store <4 x float> %174, <4 x float>* %176
%177 = add nuw i64 %144, 8
%178 = icmp eq i64 %177, 4096
br i1 %178, label %179, label %143
179: ; preds = %143, %179
%180 = phi i64 [ %213, %179 ], [ 0, %143 ]
%181 = getelementptr inbounds float, float* %34, i64 %180
%182 = bitcast float* %181 to <4 x float>*
%183 = load <4 x float>, <4 x float>* %182
%184 = getelementptr inbounds float, float* %181, i64 4
%185 = bitcast float* %184 to <4 x float>*
%186 = load <4 x float>, <4 x float>* %185
%187 = getelementptr inbounds float, float* %21, i64 %180
%188 = bitcast float* %187 to <4 x float>*
%189 = load <4 x float>, <4 x float>* %188
%190 = getelementptr inbounds float, float* %187, i64 4
%191 = bitcast float* %190 to <4 x float>*
%192 = load <4 x float>, <4 x float>* %191
%193 = fadd <4 x float> %183, %189
%194 = fadd <4 x float> %186, %192
%195 = getelementptr inbounds float, float* %20, i64 %180
%196 = bitcast float* %195 to <4 x float>*
%197 = load <4 x float>, <4 x float>* %196
%198 = getelementptr inbounds float, float* %195, i64 4
%199 = bitcast float* %198 to <4 x float>*
%200 = load <4 x float>, <4 x float>* %199
%201 = fadd <4 x float> %193, %197
%202 = fadd <4 x float> %194, %200
%203 = getelementptr inbounds float, float* %19, i64 %180
%204 = bitcast float* %203 to <4 x float>*
%205 = load <4 x float>, <4 x float>* %204
%206 = getelementptr inbounds float, float* %203, i64 4
%207 = bitcast float* %206 to <4 x float>*
%208 = load <4 x float>, <4 x float>* %207
%209 = fadd <4 x float> %201, %205
%210 = fadd <4 x float> %202, %208
%211 = bitcast float* %181 to <4 x float>*
store <4 x float> %209, <4 x float>* %211
%212 = bitcast float* %184 to <4 x float>*
store <4 x float> %210, <4 x float>* %212
%213 = add nuw i64 %180, 8
%214 = icmp eq i64 %213, 4096
br i1 %214, label %215, label %179
215: ; preds = %179
%216 = getelementptr inbounds float, float* %34, i64 4096
%217 = getelementptr inbounds float, float* %33, i64 4096
%218 = getelementptr inbounds float, float* %32, i64 4096
%219 = getelementptr inbounds float, float* %31, i64 4096
%220 = getelementptr inbounds float, float* %30, i64 4096
%221 = getelementptr inbounds float, float* %29, i64 4096
%222 = getelementptr inbounds float, float* %28, i64 4096
%223 = getelementptr inbounds float, float* %27, i64 4096
%224 = getelementptr inbounds float, float* %26, i64 4096
%225 = getelementptr inbounds float, float* %25, i64 4096
%226 = getelementptr inbounds float, float* %24, i64 4096
%227 = getelementptr inbounds float, float* %23, i64 4096
%228 = getelementptr inbounds float, float* %22, i64 4096
%229 = getelementptr inbounds float, float* %21, i64 4096
%230 = getelementptr inbounds float, float* %20, i64 4096
%231 = getelementptr inbounds float, float* %19, i64 4096
%232 = add nuw nsw i32 %18, 1
%233 = icmp eq i32 %232, 4096
br i1 %233, label %234, label %17
234: ; preds = %215
ret void
}