void matmul_depend(float A[128][128], float B[128][128], float C[128][128]) {
  int i, j, k, ii, jj, kk;
  for (i = 0; i < 128; i += 16)
    for (j = 0; j < 128; j += 16)
      for (k = 0; k < 128; k += 16)
#pragma omp task private(ii, jj, kk)                                           \
    depend(in                                                                  \
           : A [i:BS] [k:BS], B [k:BS] [j:BS]) depend(inout                    \
                                                      : C [i:BS] [j:BS])
        for (ii = i; ii < i + 16; ii++)
          for (jj = j; jj < j + 16; jj++)
            for (kk = k; kk < k + 16; kk++)
              C[ii][jj] = C[ii][jj] + A[ii][kk] * B[kk][jj];
}


x86 assembly (clang, -O0):
<matmul_depend>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x80,-0x1c(%rbp)
jge    1266 <matmul_depend+0x166>
movl   $0x0,-0x20(%rbp)
cmpl   $0x80,-0x20(%rbp)
jge    1253 <matmul_depend+0x153>
movl   $0x0,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jge    1240 <matmul_depend+0x140>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x10,%ecx
cmp    %ecx,%eax
jge    122d <matmul_depend+0x12d>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x10,%ecx
cmp    %ecx,%eax
jge    121a <matmul_depend+0x11a>
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x10,%ecx
cmp    %ecx,%eax
jge    1207 <matmul_depend+0x107>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1180 <matmul_depend+0x80>
jmp    120c <matmul_depend+0x10c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1169 <matmul_depend+0x69>
jmp    121f <matmul_depend+0x11f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1152 <matmul_depend+0x52>
jmp    1232 <matmul_depend+0x132>
mov    -0x24(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x24(%rbp)
jmp    113f <matmul_depend+0x3f>
jmp    1245 <matmul_depend+0x145>
mov    -0x20(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x20(%rbp)
jmp    112b <matmul_depend+0x2b>
jmp    1258 <matmul_depend+0x158>
mov    -0x1c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x1c(%rbp)
jmp    1117 <matmul_depend+0x17>
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmul_depend>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdi,-0x48(%rsp)
add    $0x1e00,%rsi
mov    %rsi,-0x68(%rsp)
mov    $0x10,%eax
mov    %rax,-0x70(%rsp)
xor    %eax,%eax
mov    %rax,-0x80(%rsp)
mov    %rdx,-0x60(%rsp)
mov    %rdx,-0x78(%rsp)
mov    -0x68(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,-0x58(%rsp)
mov    %rcx,-0x50(%rsp)
xor    %esi,%esi
nopl   0x0(%rax)
mov    %rsi,%rax
or     $0x1,%rax
mov    %rax,0x30(%rsp)
mov    %rsi,%rax
or     $0x2,%rax
mov    %rax,0x28(%rsp)
mov    %rsi,%rax
or     $0x3,%rax
mov    %rax,0x20(%rsp)
mov    %rsi,%rax
or     $0x4,%rax
mov    %rax,0x18(%rsp)
mov    %rsi,%rax
or     $0x5,%rax
mov    %rax,0x10(%rsp)
mov    %rsi,%rax
or     $0x6,%rax
mov    %rax,0x8(%rsp)
mov    %rsi,%rax
or     $0x7,%rax
mov    %rax,(%rsp)
mov    %rsi,%rax
or     $0x8,%rax
mov    %rax,-0x8(%rsp)
mov    %rsi,%rax
or     $0x9,%rax
mov    %rax,-0x10(%rsp)
mov    %rsi,%rax
or     $0xa,%rax
mov    %rax,-0x18(%rsp)
mov    %rsi,%rax
or     $0xb,%rax
mov    %rax,-0x20(%rsp)
mov    %rsi,%rax
or     $0xc,%rax
mov    %rax,-0x28(%rsp)
mov    %rsi,%rax
or     $0xd,%rax
mov    %rax,-0x30(%rsp)
mov    %rsi,%rax
or     $0xe,%rax
mov    %rax,-0x38(%rsp)
mov    %rsi,%rax
or     $0xf,%rax
mov    %rax,-0x40(%rsp)
mov    -0x78(%rsp),%r13
mov    -0x80(%rsp),%rdx
mov    %rsi,0x38(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,0x40(%rsp)
shl    $0x9,%rdx
add    -0x48(%rsp),%rdx
lea    (%rdx,%rsi,4),%rax
mov    %rax,0x70(%rsp)
mov    0x30(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    %rax,0x68(%rsp)
mov    0x28(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    %rax,0x60(%rsp)
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    %rax,0x58(%rsp)
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    %rax,0x50(%rsp)
mov    0x10(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    %rax,0x48(%rsp)
mov    0x8(%rsp),%rax
lea    (%rdx,%rax,4),%r11
mov    (%rsp),%rax
lea    (%rdx,%rax,4),%r14
mov    -0x8(%rsp),%rax
lea    (%rdx,%rax,4),%r8
mov    -0x10(%rsp),%rax
lea    (%rdx,%rax,4),%r15
mov    -0x18(%rsp),%rax
lea    (%rdx,%rax,4),%r12
mov    -0x20(%rsp),%rax
lea    (%rdx,%rax,4),%rbx
mov    -0x28(%rsp),%rax
lea    (%rdx,%rax,4),%rax
mov    -0x30(%rsp),%rsi
lea    (%rdx,%rsi,4),%rbp
mov    -0x38(%rsp),%rsi
lea    (%rdx,%rsi,4),%r10
mov    -0x40(%rsp),%rsi
lea    (%rdx,%rsi,4),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%r9
movss  (%r9),%xmm0
mulss  -0x1e00(%rcx,%rdx,4),%xmm0
ff ff
addss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x68(%rsp),%rdi
movss  (%rdi),%xmm1
mulss  -0x1c00(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
mov    0x60(%rsp),%rdi
movss  (%rdi),%xmm0
mulss  -0x1a00(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x58(%rsp),%rdi
movss  (%rdi),%xmm1
mulss  -0x1800(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
mov    0x50(%rsp),%rdi
movss  (%rdi),%xmm0
mulss  -0x1600(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
mov    0x48(%rsp),%rdi
movss  (%rdi),%xmm1
mulss  -0x1400(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
movss  (%r11),%xmm0
mulss  -0x1200(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  (%r14),%xmm1
mulss  -0x1000(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
movss  (%r8),%xmm0
mulss  -0xe00(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  (%r15),%xmm1
mulss  -0xc00(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
movss  (%r12),%xmm0
mulss  -0xa00(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  (%rbx),%xmm1
mulss  -0x800(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
movss  (%rax),%xmm0
mulss  -0x600(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  0x0(%rbp),%xmm1
mulss  -0x400(%rcx,%rdx,4),%xmm1
ff ff
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
movss  (%r10),%xmm0
mulss  -0x200(%rcx,%rdx,4),%xmm0
ff ff
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
movss  (%rsi),%xmm1
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rdx,4)
add    $0x1,%rdx
cmp    $0x10,%rdx
jne    12f0 <matmul_depend+0x1f0>
mov    0x40(%rsp),%rdx
add    $0x1,%rdx
add    $0x200,%r13
cmp    -0x70(%rsp),%rdx
mov    0x38(%rsp),%rsi
jne    1230 <matmul_depend+0x130>
mov    %rsi,%rax
add    $0x10,%rax
add    $0x2000,%rcx
cmp    $0x70,%esi
mov    %rax,%rsi
jb     1160 <matmul_depend+0x60>
mov    -0x58(%rsp),%rdx
mov    %rdx,%rax
add    $0x10,%rax
mov    -0x50(%rsp),%rcx
add    $0x40,%rcx
addq   $0x40,-0x78(%rsp)
cmp    $0x70,%edx
jb     1150 <matmul_depend+0x50>
mov    -0x80(%rsp),%rcx
mov    %rcx,%rax
add    $0x10,%rax
addq   $0x10,-0x70(%rsp)
mov    -0x60(%rsp),%rdx
add    $0x2000,%rdx
cmp    $0x70,%ecx
mov    %rax,-0x80(%rsp)
jb     1130 <matmul_depend+0x30>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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