void mm(float **A, float **B, float **C, int ambn, int an, int bm) {
  int t6;
  int t4;
  int t2;
  int _t12;
  int _t11;
  int _t10;
  int _t9;
  int _t8;
  int _t7;
  int _t6;
  int _t5;
  int _t4;
  int over1;
  int _t3;
  int _t2;
  int _t1;
  int i;
  int j;
  int n;
  over1 = 0;
  for (t2 = 0; t2 <= an - 1; t2 += 1) {
    over1 = bm % 4;
    for (t4 = 0; t4 <= -over1 + bm - 1; t4 += 4) {
      C[t2][t4] = 0.0f;
      C[t2][t4] += (A[t2][0] * B[0][t4]);
      C[t2][t4 + 1] = 0.0f;
      C[t2][t4 + 1] += (A[t2][0] * B[0][t4 + 1]);
      C[t2][t4 + 2] = 0.0f;
      C[t2][t4 + 2] += (A[t2][0] * B[0][t4 + 2]);
      C[t2][t4 + 3] = 0.0f;
      C[t2][t4 + 3] += (A[t2][0] * B[0][t4 + 3]);
      for (t6 = 1; t6 <= ambn - 1; t6 += 1) {
        C[t2][t4] += (A[t2][t6] * B[t6][t4]);
        C[t2][t4 + 1] += (A[t2][t6] * B[t6][t4 + 1]);
        C[t2][t4 + 2] += (A[t2][t6] * B[t6][t4 + 2]);
        C[t2][t4 + 3] += (A[t2][t6] * B[t6][t4 + 3]);
      }
    }
    for (t4 = ((bm - over1) > (0) ? (bm - over1) : (0)); t4 <= bm - 1;
         t4 += 1) {
      C[t2][t4] = 0.0f;
      C[t2][t4] += (A[t2][0] * B[0][t4]);
      for (t6 = 1; 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,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     15b1 <mm+0x4b1>
mov    -0x24(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
xor    %ecx,%ecx
sub    -0x58(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1481 <mm+0x381>
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    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%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    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     146e <mm+0x36e>
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
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%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
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%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    1301 <mm+0x201>
jmp    1473 <mm+0x373>
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    114f <mm+0x4f>
mov    -0x24(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jle    149e <mm+0x39e>
mov    -0x24(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    14a8 <mm+0x3a8>
xor    %eax,%eax
mov    %eax,-0x74(%rbp)
jmp    14a8 <mm+0x3a8>
mov    -0x74(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     159e <mm+0x49e>
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    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%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)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     158b <mm+0x48b>
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    1520 <mm+0x420>
jmp    1590 <mm+0x490>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14ae <mm+0x3ae>
jmp    15a3 <mm+0x4a3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1129 <mm+0x29>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x38(%rsp)
mov    %rdx,-0x28(%rsp)
mov    %rdi,-0x30(%rsp)
test   %r8d,%r8d
jle    13e8 <mm+0x2e8>
mov    -0x38(%rsp),%rax
lea    0x3(%rax),%edx
test   %eax,%eax
cmovns %eax,%edx
and    $0xfffffffc,%edx
mov    %eax,%edi
sub    %edx,%edi
not    %edi
add    %eax,%edi
xor    %ebx,%ebx
test   %edx,%edx
mov    $0x0,%ebp
mov    %rbp,-0x48(%rsp)
cmovs  %ebx,%edx
mov    %rdx,-0x20(%rsp)
mov    %edi,-0x3c(%rsp)
movslq %edi,%r13
mov    %r8d,%edx
mov    %rdx,-0x8(%rsp)
mov    %ecx,%r15d
mov    %eax,%r9d
lea    -0x1(%r15),%r10
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
neg    %r14
xorps  %xmm0,%xmm0
mov    %r9,-0x10(%rsp)
mov    %r10,-0x18(%rsp)
jmp    11ac <mm+0xac>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x48(%rsp),%rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,-0x48(%rsp)
cmp    -0x8(%rsp),%rdx
je     13e8 <mm+0x2e8>
cmpl   $0x0,-0x3c(%rsp)
js     1300 <mm+0x200>
mov    -0x28(%rsp),%rax
mov    -0x48(%rsp),%rdx
mov    (%rax,%rdx,8),%rbp
mov    -0x30(%rsp),%rax
mov    (%rax,%rdx,8),%r8
mov    (%rsi),%r10
xor    %edx,%edx
jmp    11ed <mm+0xed>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%rdx
cmp    %r13,%rdx
jg     1300 <mm+0x200>
mov    %rdx,%rdi
or     $0x1,%rdi
mov    %rdx,%r9
or     $0x2,%r9
mov    %rdx,%r11
or     $0x3,%r11
movl   $0x0,0x0(%rbp,%rdx,4)
movss  (%r8),%xmm1
mulss  (%r10,%rdx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movl   $0x0,0x0(%rbp,%rdi,4)
movss  (%r8),%xmm2
mulss  (%r10,%rdi,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x0(%rbp,%rdi,4)
movl   $0x0,0x0(%rbp,%r9,4)
movss  (%r8),%xmm3
mulss  (%r10,%r9,4),%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x0(%rbp,%r9,4)
movl   $0x0,0x0(%rbp,%r11,4)
movss  (%r8),%xmm4
mulss  (%r10,%r11,4),%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,0x0(%rbp,%r11,4)
cmp    $0x2,%ecx
jl     11e0 <mm+0xe0>
mov    $0x1,%r12d
nopl   0x0(%rax)
movss  (%r8,%r12,4),%xmm5
mov    (%rsi,%r12,8),%rbx
mulss  (%rbx,%rdx,4),%xmm5
addss  %xmm5,%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movss  (%r8,%r12,4),%xmm5
mulss  (%rbx,%rdi,4),%xmm5
addss  %xmm5,%xmm2
movss  %xmm2,0x0(%rbp,%rdi,4)
movss  (%r8,%r12,4),%xmm5
mulss  (%rbx,%r9,4),%xmm5
addss  %xmm5,%xmm3
movss  %xmm3,0x0(%rbp,%r9,4)
movss  (%r8,%r12,4),%xmm5
mulss  (%rbx,%r11,4),%xmm5
addss  %xmm5,%xmm4
movss  %xmm4,0x0(%rbp,%r11,4)
add    $0x1,%r12
cmp    %r12,%r15
jne    1290 <mm+0x190>
jmp    11e0 <mm+0xe0>
nopw   0x0(%rax,%rax,1)
mov    -0x20(%rsp),%rax
cmp    -0x38(%rsp),%eax
mov    -0x10(%rsp),%r9
mov    -0x18(%rsp),%r10
jge    1190 <mm+0x90>
mov    -0x28(%rsp),%rax
mov    -0x48(%rsp),%rdi
mov    (%rax,%rdi,8),%rdx
mov    -0x30(%rsp),%rax
mov    (%rax,%rdi,8),%rdi
mov    (%rsi),%r8
mov    -0x20(%rsp),%rbp
jmp    134d <mm+0x24d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r9,%rbp
je     1190 <mm+0x90>
movl   $0x0,(%rdx,%rbp,4)
movss  (%rdi),%xmm1
mulss  (%r8,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rbp,4)
cmp    $0x2,%ecx
jl     1340 <mm+0x240>
mov    $0x1,%ebx
je     13c2 <mm+0x2c2>
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rbx,4),%xmm2
mov    (%rsi,%rbx,8),%rax
mulss  (%rax,%rbp,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rbp,4)
movss  0x4(%rdi,%rbx,4),%xmm1
mov    0x8(%rsi,%rbx,8),%rax
mulss  (%rax,%rbp,4),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rdx,%rbp,4)
lea    (%r14,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
jne    1380 <mm+0x280>
test   $0x1,%r10b
je     1340 <mm+0x240>
movss  (%rdi,%rbx,4),%xmm2
mov    (%rsi,%rbx,8),%rax
mulss  (%rax,%rbp,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rbp,4)
jmp    1340 <mm+0x240>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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
%29 = alloca i32
%30 = alloca i32
%31 = 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* %25
store i32 0, i32* %15
br label %32
32: ; preds = %409, %6
%33 = load i32, i32* %15
%34 = load i32, i32* %11
%35 = sub nsw i32 %34, 1
%36 = icmp sle i32 %33, %35
br i1 %36, label %37, label %412
37: ; preds = %32
%38 = load i32, i32* %12
%39 = srem i32 %38, 4
store i32 %39, i32* %25
store i32 0, i32* %14
br label %40
40: ; preds = %314, %37
%41 = load i32, i32* %14
%42 = load i32, i32* %25
%43 = sub nsw i32 0, %42
%44 = load i32, i32* %12
%45 = add nsw i32 %43, %44
%46 = sub nsw i32 %45, 1
%47 = icmp sle i32 %41, %46
br i1 %47, label %48, label %317
48: ; preds = %40
%49 = load float**, float*** %9
%50 = load i32, i32* %15
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float*, float** %49, i64 %51
%53 = load float*, float** %52
%54 = load i32, i32* %14
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
store float 0.000000e+00, float* %56
%57 = load float**, float*** %7
%58 = load i32, i32* %15
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float*, float** %57, i64 %59
%61 = load float*, float** %60
%62 = getelementptr inbounds float, float* %61, i64 0
%63 = load float, float* %62
%64 = load float**, float*** %8
%65 = getelementptr inbounds float*, float** %64, i64 0
%66 = load float*, float** %65
%67 = load i32, i32* %14
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %66, i64 %68
%70 = load float, float* %69
%71 = load float**, float*** %9
%72 = load i32, i32* %15
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float*, float** %71, i64 %73
%75 = load float*, float** %74
%76 = load i32, i32* %14
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
%79 = load float, float* %78
%80 = call float @llvm.fmuladd.f32(float %63, float %70, float %79)
store float %80, float* %78
%81 = load float**, float*** %9
%82 = load i32, i32* %15
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float*, float** %81, i64 %83
%85 = load float*, float** %84
%86 = load i32, i32* %14
%87 = add nsw i32 %86, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %85, i64 %88
store float 0.000000e+00, float* %89
%90 = load float**, float*** %7
%91 = load i32, i32* %15
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float*, float** %90, i64 %92
%94 = load float*, float** %93
%95 = getelementptr inbounds float, float* %94, i64 0
%96 = load float, float* %95
%97 = load float**, float*** %8
%98 = getelementptr inbounds float*, float** %97, i64 0
%99 = load float*, float** %98
%100 = load i32, i32* %14
%101 = add nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %99, i64 %102
%104 = load float, float* %103
%105 = load float**, float*** %9
%106 = load i32, i32* %15
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float*, float** %105, i64 %107
%109 = load float*, float** %108
%110 = load i32, i32* %14
%111 = add nsw i32 %110, 1
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %109, i64 %112
%114 = load float, float* %113
%115 = call float @llvm.fmuladd.f32(float %96, float %104, float %114)
store float %115, float* %113
%116 = load float**, float*** %9
%117 = load i32, i32* %15
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float*, float** %116, i64 %118
%120 = load float*, float** %119
%121 = load i32, i32* %14
%122 = add nsw i32 %121, 2
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %120, i64 %123
store float 0.000000e+00, float* %124
%125 = load float**, float*** %7
%126 = load i32, i32* %15
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float*, float** %125, i64 %127
%129 = load float*, float** %128
%130 = getelementptr inbounds float, float* %129, i64 0
%131 = load float, float* %130
%132 = load float**, float*** %8
%133 = getelementptr inbounds float*, float** %132, i64 0
%134 = load float*, float** %133
%135 = load i32, i32* %14
%136 = add nsw i32 %135, 2
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %134, i64 %137
%139 = load float, float* %138
%140 = load float**, float*** %9
%141 = load i32, i32* %15
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float*, float** %140, i64 %142
%144 = load float*, float** %143
%145 = load i32, i32* %14
%146 = add nsw i32 %145, 2
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %144, i64 %147
%149 = load float, float* %148
%150 = call float @llvm.fmuladd.f32(float %131, float %139, float %149)
store float %150, float* %148
%151 = load float**, float*** %9
%152 = load i32, i32* %15
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float*, float** %151, i64 %153
%155 = load float*, float** %154
%156 = load i32, i32* %14
%157 = add nsw i32 %156, 3
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds float, float* %155, i64 %158
store float 0.000000e+00, float* %159
%160 = load float**, float*** %7
%161 = load i32, i32* %15
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float*, float** %160, i64 %162
%164 = load float*, float** %163
%165 = getelementptr inbounds float, float* %164, i64 0
%166 = load float, float* %165
%167 = load float**, float*** %8
%168 = getelementptr inbounds float*, float** %167, i64 0
%169 = load float*, float** %168
%170 = load i32, i32* %14
%171 = add nsw i32 %170, 3
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %169, i64 %172
%174 = load float, float* %173
%175 = load float**, float*** %9
%176 = load i32, i32* %15
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float*, float** %175, i64 %177
%179 = load float*, float** %178
%180 = load i32, i32* %14
%181 = add nsw i32 %180, 3
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %179, i64 %182
%184 = load float, float* %183
%185 = call float @llvm.fmuladd.f32(float %166, float %174, float %184)
store float %185, float* %183
store i32 1, i32* %13
br label %186
186: ; preds = %310, %48
%187 = load i32, i32* %13
%188 = load i32, i32* %10
%189 = sub nsw i32 %188, 1
%190 = icmp sle i32 %187, %189
br i1 %190, label %191, label %313
191: ; preds = %186
%192 = load float**, float*** %7
%193 = load i32, i32* %15
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float*, float** %192, i64 %194
%196 = load float*, float** %195
%197 = load i32, i32* %13
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
%201 = load float**, float*** %8
%202 = load i32, i32* %13
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float*, float** %201, i64 %203
%205 = load float*, float** %204
%206 = load i32, i32* %14
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
%209 = load float, float* %208
%210 = load float**, float*** %9
%211 = load i32, i32* %15
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float*, float** %210, i64 %212
%214 = load float*, float** %213
%215 = load i32, i32* %14
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %214, i64 %216
%218 = load float, float* %217
%219 = call float @llvm.fmuladd.f32(float %200, float %209, float %218)
store float %219, float* %217
%220 = load float**, float*** %7
%221 = load i32, i32* %15
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float*, float** %220, i64 %222
%224 = load float*, float** %223
%225 = load i32, i32* %13
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float, float* %224, i64 %226
%228 = load float, float* %227
%229 = load float**, float*** %8
%230 = load i32, i32* %13
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds float*, float** %229, i64 %231
%233 = load float*, float** %232
%234 = load i32, i32* %14
%235 = add nsw i32 %234, 1
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %233, i64 %236
%238 = load float, float* %237
%239 = load float**, float*** %9
%240 = load i32, i32* %15
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float*, float** %239, i64 %241
%243 = load float*, float** %242
%244 = load i32, i32* %14
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %243, i64 %246
%248 = load float, float* %247
%249 = call float @llvm.fmuladd.f32(float %228, float %238, float %248)
store float %249, float* %247
%250 = load float**, float*** %7
%251 = load i32, i32* %15
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float*, float** %250, i64 %252
%254 = load float*, float** %253
%255 = load i32, i32* %13
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %254, i64 %256
%258 = load float, float* %257
%259 = load float**, float*** %8
%260 = load i32, i32* %13
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float*, float** %259, i64 %261
%263 = load float*, float** %262
%264 = load i32, i32* %14
%265 = add nsw i32 %264, 2
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds float, float* %263, i64 %266
%268 = load float, float* %267
%269 = load float**, float*** %9
%270 = load i32, i32* %15
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float*, float** %269, i64 %271
%273 = load float*, float** %272
%274 = load i32, i32* %14
%275 = add nsw i32 %274, 2
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds float, float* %273, i64 %276
%278 = load float, float* %277
%279 = call float @llvm.fmuladd.f32(float %258, float %268, float %278)
store float %279, float* %277
%280 = load float**, float*** %7
%281 = load i32, i32* %15
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float*, float** %280, i64 %282
%284 = load float*, float** %283
%285 = load i32, i32* %13
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %284, i64 %286
%288 = load float, float* %287
%289 = load float**, float*** %8
%290 = load i32, i32* %13
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds float*, float** %289, i64 %291
%293 = load float*, float** %292
%294 = load i32, i32* %14
%295 = add nsw i32 %294, 3
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %293, i64 %296
%298 = load float, float* %297
%299 = load float**, float*** %9
%300 = load i32, i32* %15
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float*, float** %299, i64 %301
%303 = load float*, float** %302
%304 = load i32, i32* %14
%305 = add nsw i32 %304, 3
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %303, i64 %306
%308 = load float, float* %307
%309 = call float @llvm.fmuladd.f32(float %288, float %298, float %308)
store float %309, float* %307
br label %310
310: ; preds = %191
%311 = load i32, i32* %13
%312 = add nsw i32 %311, 1
store i32 %312, i32* %13
br label %186
313: ; preds = %186
br label %314
314: ; preds = %313
%315 = load i32, i32* %14
%316 = add nsw i32 %315, 4
store i32 %316, i32* %14
br label %40
317: ; preds = %40
%318 = load i32, i32* %12
%319 = load i32, i32* %25
%320 = sub nsw i32 %318, %319
%321 = icmp sgt i32 %320, 0
br i1 %321, label %322, label %326
322: ; preds = %317
%323 = load i32, i32* %12
%324 = load i32, i32* %25
%325 = sub nsw i32 %323, %324
br label %327
326: ; preds = %317
br label %327
327: ; preds = %326, %322
%328 = phi i32 [ %325, %322 ], [ 0, %326 ]
store i32 %328, i32* %14
br label %329
329: ; preds = %405, %327
%330 = load i32, i32* %14
%331 = load i32, i32* %12
%332 = sub nsw i32 %331, 1
%333 = icmp sle i32 %330, %332
br i1 %333, label %334, label %408
334: ; preds = %329
%335 = load float**, float*** %9
%336 = load i32, i32* %15
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float*, float** %335, i64 %337
%339 = load float*, float** %338
%340 = load i32, i32* %14
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %339, i64 %341
store float 0.000000e+00, float* %342
%343 = load float**, float*** %7
%344 = load i32, i32* %15
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float*, float** %343, i64 %345
%347 = load float*, float** %346
%348 = getelementptr inbounds float, float* %347, i64 0
%349 = load float, float* %348
%350 = load float**, float*** %8
%351 = getelementptr inbounds float*, float** %350, i64 0
%352 = load float*, float** %351
%353 = load i32, i32* %14
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = load float**, float*** %9
%358 = load i32, i32* %15
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds float*, float** %357, i64 %359
%361 = load float*, float** %360
%362 = load i32, i32* %14
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float, float* %361, i64 %363
%365 = load float, float* %364
%366 = call float @llvm.fmuladd.f32(float %349, float %356, float %365)
store float %366, float* %364
store i32 1, i32* %13
br label %367
367: ; preds = %401, %334
%368 = load i32, i32* %13
%369 = load i32, i32* %10
%370 = sub nsw i32 %369, 1
%371 = icmp sle i32 %368, %370
br i1 %371, label %372, label %404
372: ; preds = %367
%373 = load float**, float*** %7
%374 = load i32, i32* %15
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds float*, float** %373, i64 %375
%377 = load float*, float** %376
%378 = load i32, i32* %13
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %377, i64 %379
%381 = load float, float* %380
%382 = load float**, float*** %8
%383 = load i32, i32* %13
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float*, float** %382, i64 %384
%386 = load float*, float** %385
%387 = load i32, i32* %14
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %386, i64 %388
%390 = load float, float* %389
%391 = load float**, float*** %9
%392 = load i32, i32* %15
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float*, float** %391, i64 %393
%395 = load float*, float** %394
%396 = load i32, i32* %14
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float, float* %395, i64 %397
%399 = load float, float* %398
%400 = call float @llvm.fmuladd.f32(float %381, float %390, float %399)
store float %400, float* %398
br label %401
401: ; preds = %372
%402 = load i32, i32* %13
%403 = add nsw i32 %402, 1
store i32 %403, i32* %13
br label %367
404: ; preds = %367
br label %405
405: ; preds = %404
%406 = load i32, i32* %14
%407 = add nsw i32 %406, 1
store i32 %407, i32* %14
br label %329
408: ; preds = %329
br label %409
409: ; preds = %408
%410 = load i32, i32* %15
%411 = add nsw i32 %410, 1
store i32 %411, i32* %15
br label %32
412: ; preds = %32
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 %145
8: ; preds = %6
%9 = srem i32 %5, 4
%10 = xor i32 %9, -1
%11 = add i32 %10, %5
%12 = icmp slt i32 %11, 0
%13 = icmp sgt i32 %3, 1
%14 = sub nsw i32 %5, %9
%15 = icmp sgt i32 %14, 0
%16 = select i1 %15, i32 %14, i32 0
%17 = icmp slt i32 %16, %5
%18 = sext i32 %11 to i64
%19 = zext i32 %16 to i64
%20 = zext i32 %4 to i64
%21 = zext i32 %3 to i64
%22 = zext i32 %5 to i64
%23 = add nsw i64 %21, -1
%24 = and i64 %23, 1
%25 = icmp eq i32 %3, 2
%26 = and i64 %23, -2
%27 = icmp eq i64 %24, 0
br label %28
28: ; preds = %8, %142
%29 = phi i64 [ 0, %8 ], [ %143, %142 ]
br i1 %12, label %91, label %30
30: ; preds = %28
%31 = getelementptr inbounds float*, float** %2, i64 %29
%32 = load float*, float** %31
%33 = getelementptr inbounds float*, float** %0, i64 %29
%34 = load float*, float** %33
%35 = load float*, float** %1
br label %36
36: ; preds = %30, %88
%37 = phi i64 [ 0, %30 ], [ %89, %88 ]
%38 = getelementptr inbounds float, float* %32, i64 %37
store float 0.000000e+00, float* %38
%39 = load float, float* %34
%40 = getelementptr inbounds float, float* %35, i64 %37
%41 = load float, float* %40
%42 = tail call float @llvm.fmuladd.f32(float %39, float %41, float 0.000000e+00)
store float %42, float* %38
%43 = or i64 %37, 1
%44 = getelementptr inbounds float, float* %32, i64 %43
store float 0.000000e+00, float* %44
%45 = load float, float* %34
%46 = getelementptr inbounds float, float* %35, i64 %43
%47 = load float, float* %46
%48 = tail call float @llvm.fmuladd.f32(float %45, float %47, float 0.000000e+00)
store float %48, float* %44
%49 = or i64 %37, 2
%50 = getelementptr inbounds float, float* %32, i64 %49
store float 0.000000e+00, float* %50
%51 = load float, float* %34
%52 = getelementptr inbounds float, float* %35, i64 %49
%53 = load float, float* %52
%54 = tail call float @llvm.fmuladd.f32(float %51, float %53, float 0.000000e+00)
store float %54, float* %50
%55 = or i64 %37, 3
%56 = getelementptr inbounds float, float* %32, i64 %55
store float 0.000000e+00, float* %56
%57 = load float, float* %34
%58 = getelementptr inbounds float, float* %35, i64 %55
%59 = load float, float* %58
%60 = tail call float @llvm.fmuladd.f32(float %57, float %59, float 0.000000e+00)
store float %60, float* %56
br i1 %13, label %61, label %88
61: ; preds = %36, %61
%62 = phi float [ %85, %61 ], [ %60, %36 ]
%63 = phi float [ %81, %61 ], [ %54, %36 ]
%64 = phi float [ %77, %61 ], [ %48, %36 ]
%65 = phi float [ %73, %61 ], [ %42, %36 ]
%66 = phi i64 [ %86, %61 ], [ 1, %36 ]
%67 = getelementptr inbounds float, float* %34, i64 %66
%68 = load float, float* %67
%69 = getelementptr inbounds float*, float** %1, i64 %66
%70 = load float*, float** %69
%71 = getelementptr inbounds float, float* %70, i64 %37
%72 = load float, float* %71
%73 = tail call float @llvm.fmuladd.f32(float %68, float %72, float %65)
store float %73, float* %38
%74 = load float, float* %67
%75 = getelementptr inbounds float, float* %70, i64 %43
%76 = load float, float* %75
%77 = tail call float @llvm.fmuladd.f32(float %74, float %76, float %64)
store float %77, float* %44
%78 = load float, float* %67
%79 = getelementptr inbounds float, float* %70, i64 %49
%80 = load float, float* %79
%81 = tail call float @llvm.fmuladd.f32(float %78, float %80, float %63)
store float %81, float* %50
%82 = load float, float* %67
%83 = getelementptr inbounds float, float* %70, i64 %55
%84 = load float, float* %83
%85 = tail call float @llvm.fmuladd.f32(float %82, float %84, float %62)
store float %85, float* %56
%86 = add nuw nsw i64 %66, 1
%87 = icmp eq i64 %86, %21
br i1 %87, label %88, label %61
88: ; preds = %61, %36
%89 = add nuw nsw i64 %37, 4
%90 = icmp sgt i64 %89, %18
br i1 %90, label %91, label %36
91: ; preds = %88, %28
br i1 %17, label %92, label %142
92: ; preds = %91
%93 = getelementptr inbounds float*, float** %2, i64 %29
%94 = load float*, float** %93
%95 = getelementptr inbounds float*, float** %0, i64 %29
%96 = load float*, float** %95
%97 = load float*, float** %1
br label %98
98: ; preds = %92, %139
%99 = phi i64 [ %19, %92 ], [ %140, %139 ]
%100 = getelementptr inbounds float, float* %94, i64 %99
store float 0.000000e+00, float* %100
%101 = load float, float* %96
%102 = getelementptr inbounds float, float* %97, i64 %99
%103 = load float, float* %102
%104 = tail call float @llvm.fmuladd.f32(float %101, float %103, float 0.000000e+00)
store float %104, float* %100
br i1 %13, label %105, label %139
105: ; preds = %98
br i1 %25, label %128, label %106
106: ; preds = %105, %106
%107 = phi float [ %124, %106 ], [ %104, %105 ]
%108 = phi i64 [ %125, %106 ], [ 1, %105 ]
%109 = phi i64 [ %126, %106 ], [ 0, %105 ]
%110 = getelementptr inbounds float, float* %96, i64 %108
%111 = load float, float* %110
%112 = getelementptr inbounds float*, float** %1, i64 %108
%113 = load float*, float** %112
%114 = getelementptr inbounds float, float* %113, i64 %99
%115 = load float, float* %114
%116 = tail call float @llvm.fmuladd.f32(float %111, float %115, float %107)
store float %116, float* %100
%117 = add nuw nsw i64 %108, 1
%118 = getelementptr inbounds float, float* %96, 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 %99
%123 = load float, float* %122
%124 = tail call float @llvm.fmuladd.f32(float %119, float %123, float %116)
store float %124, float* %100
%125 = add nuw nsw i64 %108, 2
%126 = add i64 %109, 2
%127 = icmp eq i64 %126, %26
br i1 %127, label %128, label %106
128: ; preds = %106, %105
%129 = phi float [ %104, %105 ], [ %124, %106 ]
%130 = phi i64 [ 1, %105 ], [ %125, %106 ]
br i1 %27, label %139, label %131
131: ; preds = %128
%132 = getelementptr inbounds float, float* %96, i64 %130
%133 = load float, float* %132
%134 = getelementptr inbounds float*, float** %1, i64 %130
%135 = load float*, float** %134
%136 = getelementptr inbounds float, float* %135, i64 %99
%137 = load float, float* %136
%138 = tail call float @llvm.fmuladd.f32(float %133, float %137, float %129)
store float %138, float* %100
br label %139
139: ; preds = %131, %128, %98
%140 = add nuw nsw i64 %99, 1
%141 = icmp eq i64 %140, %22
br i1 %141, label %142, label %98
142: ; preds = %139, %91
%143 = add nuw nsw i64 %29, 1
%144 = icmp eq i64 %143, %20
br i1 %144, label %145, label %28
145: ; preds = %142, %6
ret void
}