void blocked_multiplication(double A[][6144], double B[][6144],
                            double C[][6144]) {
  int i, j, k, kk, jj;
  double sum;
  const int NUMBER_OF_BLOCKS = 16 * (6144 / 16);
  for (kk = 0; kk < NUMBER_OF_BLOCKS; kk += 16) {
    for (jj = 0; jj < NUMBER_OF_BLOCKS; jj += 16) {
      for (i = 0; i < 6144; i++) {
        for (j = jj; j < jj + 16; j++) {
          for (k = kk; k < kk + 16; k++) {
            C[i][j] += A[i][k] * B[k][j];
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<blocked_multiplication>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x1800,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x1800,-0x28(%rbp)
jge    1239 <blocked_multiplication+0x139>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x1800,-0x2c(%rbp)
jge    1226 <blocked_multiplication+0x126>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x1800,-0x1c(%rbp)
jge    1213 <blocked_multiplication+0x113>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x10,%ecx
cmp    %ecx,%eax
jge    1200 <blocked_multiplication+0x100>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x10,%ecx
cmp    %ecx,%eax
jge    11ed <blocked_multiplication+0xed>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0xc000,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0xc000,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0xc000,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1170 <blocked_multiplication+0x70>
jmp    11f2 <blocked_multiplication+0xf2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1159 <blocked_multiplication+0x59>
jmp    1205 <blocked_multiplication+0x105>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1146 <blocked_multiplication+0x46>
jmp    1218 <blocked_multiplication+0x118>
mov    -0x2c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x2c(%rbp)
jmp    1132 <blocked_multiplication+0x32>
jmp    122b <blocked_multiplication+0x12b>
mov    -0x28(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x28(%rbp)
jmp    111e <blocked_multiplication+0x1e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<blocked_multiplication>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x60,%rsp
mov    %rdx,-0x80(%rsp)
mov    %rsi,%r9
mov    %rdi,-0x60(%rsp)
add    $0xb4000,%r9
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rax
or     $0x1,%rax
mov    %rax,0x18(%rsp)
mov    %rdx,%rax
or     $0x2,%rax
mov    %rax,0x10(%rsp)
mov    %rdx,%rax
or     $0x3,%rax
mov    %rax,0x8(%rsp)
mov    %rdx,%rax
or     $0x4,%rax
mov    %rax,(%rsp)
mov    %rdx,%rax
or     $0x5,%rax
mov    %rax,-0x8(%rsp)
mov    %rdx,%rax
or     $0x6,%rax
mov    %rax,-0x10(%rsp)
mov    %rdx,%rax
or     $0x7,%rax
mov    %rax,-0x18(%rsp)
mov    %rdx,%rax
or     $0x8,%rax
mov    %rax,-0x20(%rsp)
mov    %rdx,%rax
or     $0x9,%rax
mov    %rax,-0x28(%rsp)
mov    %rdx,%rax
or     $0xa,%rax
mov    %rax,-0x30(%rsp)
mov    %rdx,%rax
or     $0xb,%rax
mov    %rax,-0x38(%rsp)
mov    %rdx,%rax
or     $0xc,%rax
mov    %rax,-0x40(%rsp)
mov    %rdx,%rax
or     $0xd,%rax
mov    %rax,-0x48(%rsp)
mov    %rdx,%rax
or     $0xe,%rax
mov    %rax,-0x50(%rsp)
mov    %rdx,%rax
or     $0xf,%rax
mov    %rax,-0x58(%rsp)
mov    -0x80(%rsp),%r10
mov    %r9,-0x78(%rsp)
xor    %eax,%eax
mov    %rdx,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,-0x70(%rsp)
mov    %r10,-0x68(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
mov    %rax,0x30(%rsp)
lea    (%rax,%rax,2),%rcx
shl    $0xe,%rcx
add    -0x60(%rsp),%rcx
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x28(%rsp)
mov    0x18(%rsp),%rax
lea    (%rcx,%rax,8),%r13
mov    0x10(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x58(%rsp)
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x50(%rsp)
mov    (%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x48(%rsp)
mov    -0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x40(%rsp)
mov    -0x10(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x38(%rsp)
mov    -0x18(%rsp),%rdx
lea    (%rcx,%rdx,8),%rbp
mov    -0x20(%rsp),%rdx
lea    (%rcx,%rdx,8),%r8
mov    -0x28(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
mov    -0x30(%rsp),%rsi
lea    (%rcx,%rsi,8),%rsi
mov    -0x38(%rsp),%rdi
lea    (%rcx,%rdi,8),%rdi
mov    -0x40(%rsp),%rbx
lea    (%rcx,%rbx,8),%r11
mov    -0x48(%rsp),%rbx
lea    (%rcx,%rbx,8),%r14
mov    -0x50(%rsp),%rbx
lea    (%rcx,%rbx,8),%r15
mov    -0x58(%rsp),%rbx
lea    (%rcx,%rbx,8),%r12
mov    %r13,%rbx
mov    0x28(%rsp),%rcx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx),%xmm0
mulsd  -0xb4000(%r9,%r13,8),%xmm0
c0 f4 ff
addsd  (%r10,%r13,8),%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  (%rbx),%xmm1
mulsd  -0xa8000(%r9,%r13,8),%xmm1
80 f5 ff
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
mov    0x58(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  -0x9c000(%r9,%r13,8),%xmm0
40 f6 ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
mov    0x50(%rsp),%rax
movsd  (%rax),%xmm1
mulsd  -0x90000(%r9,%r13,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
mov    0x48(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  -0x84000(%r9,%r13,8),%xmm0
c0 f7 ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
mov    0x40(%rsp),%rax
movsd  (%rax),%xmm1
mulsd  -0x78000(%r9,%r13,8),%xmm1
80 f8 ff
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
mov    0x38(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  -0x6c000(%r9,%r13,8),%xmm0
40 f9 ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  0x0(%rbp),%xmm1
mulsd  -0x60000(%r9,%r13,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
movsd  (%r8),%xmm0
mulsd  -0x54000(%r9,%r13,8),%xmm0
c0 fa ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  (%rdx),%xmm1
mulsd  -0x48000(%r9,%r13,8),%xmm1
80 fb ff
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
movsd  (%rsi),%xmm0
mulsd  -0x3c000(%r9,%r13,8),%xmm0
40 fc ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  (%rdi),%xmm1
mulsd  -0x30000(%r9,%r13,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
movsd  (%r11),%xmm0
mulsd  -0x24000(%r9,%r13,8),%xmm0
c0 fd ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  (%r14),%xmm1
mulsd  -0x18000(%r9,%r13,8),%xmm1
80 fe ff
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
movsd  (%r15),%xmm0
mulsd  -0xc000(%r9,%r13,8),%xmm0
40 ff ff
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  (%r12),%xmm1
mulsd  (%r9,%r13,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r13,8)
add    $0x1,%r13
cmp    $0x10,%r13
jne    12e0 <blocked_multiplication+0x1e0>
mov    0x30(%rsp),%rax
add    $0x1,%rax
add    $0xc000,%r10
cmp    $0x1800,%rax
mov    0x20(%rsp),%rdx
jne    1210 <blocked_multiplication+0x110>
mov    -0x70(%rsp),%rcx
mov    %rcx,%rax
add    $0x10,%rax
sub    $0xffffffffffffff80,%r9
mov    -0x68(%rsp),%r10
sub    $0xffffffffffffff80,%r10
cmp    $0x17f0,%ecx
jb     1200 <blocked_multiplication+0x100>
mov    %rdx,%rax
add    $0x10,%rax
mov    -0x78(%rsp),%r9
add    $0xc0000,%r9
cmp    $0x17f0,%edx
mov    %rax,%rdx
jb     1130 <blocked_multiplication+0x30>
add    $0x60,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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