void mm(float **A, float **B, float **C, int ambn, int an, int bm) {
  int t6;
  int t4;
  int t2;
  int chill_t9;
  int chill_t8;
  int chill_t7;
  int chill_t6;
  int chill_t5;
  int chill_t4;
  int over1;
  int chill_t3;
  int chill_t2;
  int chill_t1;
  int i;
  int j;
  int n;
  over1 = 0;
  for (t2 = 0; t2 <= an - 1; t2 += 1)
    for (t4 = 0; t4 <= bm - 1; t4 += 1)
      C[t2][t4] = 0.0f;
  for (t2 = 0; t2 <= an - 1; t2 += 1)
    for (t4 = 0; t4 <= bm - 1; t4 += 1) {
      over1 = ambn % 4;
      for (t6 = 0; t6 <= -over1 + ambn - 1; t6 += 4) {
        C[t2][t4] += (A[t2][t6] * B[t6][t4]);
        C[t2][t4] += (A[t2][t6 + 1] * B[t6 + 1][t4]);
        C[t2][t4] += (A[t2][t6 + 2] * B[t6 + 2][t4]);
        C[t2][t4] += (A[t2][t6 + 3] * B[t6 + 3][t4]);
      }
      for (t6 = ((0) > (ambn - over1) ? (0) : (ambn - over1)); t6 <= ambn - 1;
           t6 += 1)
        C[t2][t4] += (A[t2][t6] * B[t6][t4]);
    }
}


x86 assembly (clang, -O0):
<mm>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     118b <mm+0x8b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1178 <mm+0x78>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1141 <mm+0x41>
jmp    117d <mm+0x7d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1129 <mm+0x29>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13fc <mm+0x2fc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13e9 <mm+0x2e9>
mov    -0x1c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x4c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
xor    %ecx,%ecx
sub    -0x4c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1342 <mm+0x242>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    11d0 <mm+0xd0>
mov    -0x1c(%rbp),%ecx
sub    -0x4c(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    135c <mm+0x25c>
xor    %eax,%eax
mov    %eax,-0x68(%rbp)
jmp    1365 <mm+0x265>
mov    -0x1c(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13d6 <mm+0x2d6>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    136b <mm+0x26b>
jmp    13db <mm+0x2db>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11aa <mm+0xaa>
jmp    13ee <mm+0x2ee>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1192 <mm+0x92>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,0xc(%rsp)
mov    %rcx,0x30(%rsp)
test   %r8d,%r8d
jle    1382 <mm+0x272>
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%r12
mov    0xc(%rsp),%r14d
mov    %r14d,%eax
mov    %rax,0x40(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x18(%rsp)
mov    %r8d,0x20(%rsp)
mov    %r8d,%edx
lea    -0x1(%rdx),%rax
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rcx,0x10(%rsp)
cmp    $0x3,%rax
mov    %rdx,0x38(%rsp)
jae    1391 <mm+0x281>
xor    %ebp,%ebp
cmpq   $0x0,0x10(%rsp)
je     11c2 <mm+0xb2>
lea    0x0(,%rbp,8),%r15
add    %r13,%r15
xor    %ebp,%ebp
jmp    11ab <mm+0x9b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %rbp,0x10(%rsp)
je     11c2 <mm+0xb2>
test   %r14d,%r14d
jle    11a0 <mm+0x90>
mov    (%r15,%rbp,8),%rdi
xor    %esi,%esi
mov    0x18(%rsp),%rdx
call   1030 <memset@plt>
jmp    11a0 <mm+0x90>
cmpl   $0x0,0x20(%rsp)
jle    1382 <mm+0x272>
mov    0x30(%rsp),%rax
lea    0x3(%rax),%r11d
test   %eax,%eax
cmovns %eax,%r11d
and    $0xfffffffc,%r11d
mov    %eax,%r9d
sub    %r11d,%r9d
not    %r9d
add    %eax,%r9d
xor    %r15d,%r15d
test   %r11d,%r11d
cmovs  %r15d,%r11d
movslq %r9d,%rsi
mov    %eax,%r14d
mov    %r14,%rax
sub    %r11,%rax
mov    %rax,0x18(%rsp)
mov    %r11,%rax
not    %rax
mov    %rax,0x10(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0x20(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x28(%rsp)
jmp    123f <mm+0x12f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x38(%rsp),%r15
je     1382 <mm+0x272>
cmpl   $0x0,0xc(%rsp)
jle    1230 <mm+0x120>
xor    %ebp,%ebp
jmp    125b <mm+0x14b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    0x40(%rsp),%rbp
je     1230 <mm+0x120>
test   %r9d,%r9d
js     12db <mm+0x1cb>
mov    (%r12,%r15,8),%rcx
mov    0x0(%r13,%r15,8),%rax
movss  (%rax,%rbp,4),%xmm0
xor    %edx,%edx
movss  (%rcx,%rdx,4),%xmm1
mov    (%rbx,%rdx,8),%rdi
mulss  (%rdi,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbp,4)
movss  0x4(%rcx,%rdx,4),%xmm0
mov    0x8(%rbx,%rdx,8),%rdi
mulss  (%rdi,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rbp,4)
movss  0x8(%rcx,%rdx,4),%xmm1
mov    0x10(%rbx,%rdx,8),%rdi
mulss  (%rdi,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rbp,4)
movss  0xc(%rcx,%rdx,4),%xmm0
mov    0x18(%rbx,%rdx,8),%rdi
mulss  (%rdi,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x4,%rdx
cmp    %rsi,%rdx
jle    1270 <mm+0x160>
cmp    0x30(%rsp),%r11d
jge    1250 <mm+0x140>
mov    (%r12,%r15,8),%r10
mov    0x0(%r13,%r15,8),%r8
movss  (%r8,%rbp,4),%xmm0
testb  $0x1,0x18(%rsp)
jne    1310 <mm+0x200>
mov    %r11,%rax
jmp    132e <mm+0x21e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r10,%r11,4),%xmm1
mov    (%rbx,%r11,8),%rax
mulss  (%rax,%rbp,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r8,%rbp,4)
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
je     1250 <mm+0x140>
xchg   %ax,%ax
movss  (%r10,%rax,4),%xmm1
mov    (%rbx,%rax,8),%rcx
mulss  (%rcx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rbp,4)
movss  0x4(%r10,%rax,4),%xmm0
mov    0x8(%rbx,%rax,8),%rcx
mulss  (%rcx,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r8,%rbp,4)
add    $0x2,%rax
cmp    %rax,%r14
jne    1340 <mm+0x230>
jmp    1250 <mm+0x140>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%edx
mov    %rdx,0x28(%rsp)
xor    %ebp,%ebp
mov    0x18(%rsp),%r15
jmp    13bf <mm+0x2af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x4,%rbp
cmp    %rbp,0x28(%rsp)
je     117b <mm+0x6b>
test   %r14d,%r14d
jle    13b0 <mm+0x2a0>
mov    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x8(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x10(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x18(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
jmp    13b0 <mm+0x2a0>

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

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