void matmul8x8(float *m1, int p1, float *m2, int p2, float *mo) {
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {
      float val = 0.0f;
      for (int idx = 0; idx < p1; idx++) {
        val += (*(m1 + y * p1 + idx)) * (*(m2 + idx * p2 + x));
      }
      *(mo + y * p2 + x) = val;
    }
  }
}


x86 assembly (clang, -O0):
<matmul8x8>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    11f3 <matmul8x8+0xf3>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    11e0 <matmul8x8+0xe0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11af <matmul8x8+0xaf>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1147 <matmul8x8+0x47>
movss  -0x34(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    112e <matmul8x8+0x2e>
jmp    11e5 <matmul8x8+0xe5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    111d <matmul8x8+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmul8x8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%r10d
movslq %ecx,%rax
movslq %esi,%rcx
mov    %ecx,%r14d
lea    -0x1(%r14),%rsi
mov    %rsi,-0x58(%rsp)
mov    %r14d,%r11d
and    $0x3,%r11d
mov    %r14,-0x50(%rsp)
and    $0xfffffffc,%r14d
lea    0xc(%rdi),%rbx
shl    $0x2,%rcx
mov    %rcx,-0x8(%rsp)
mov    %rax,%r15
shl    $0x4,%r15
lea    0x0(,%rax,4),%r12
lea    (%r12,%r12,2),%r13
lea    0x4(%rdx),%rcx
mov    %rcx,-0x10(%rsp)
lea    0x8(%rdx),%rcx
mov    %rcx,-0x18(%rsp)
lea    0xc(%rdx),%rcx
mov    %rcx,-0x20(%rsp)
lea    0x10(%rdx),%rcx
mov    %rcx,-0x28(%rsp)
lea    0x14(%rdx),%rcx
mov    %rcx,-0x30(%rsp)
lea    0x18(%rdx),%rcx
mov    %rcx,-0x38(%rsp)
mov    %rdx,-0x60(%rsp)
lea    0x1c(%rdx),%rcx
mov    %rcx,-0x40(%rsp)
xor    %esi,%esi
mov    %r10d,-0x44(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rsi,%r9
imul   %rax,%r9
test   %r10d,%r10d
jle    11c0 <matmul8x8+0xc0>
cmpq   $0x3,-0x58(%rsp)
jae    11d0 <matmul8x8+0xd0>
xorps  %xmm0,%xmm0
xor    %r10d,%r10d
jmp    122b <matmul8x8+0x12b>
nopl   0x0(%rax)
movl   $0x0,(%r8,%r9,4)
jmp    1290 <matmul8x8+0x190>
nopl   (%rax)
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rdx
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rbx,%r10,4),%xmm1
mulss  (%rdx),%xmm1
movss  -0x8(%rbx,%r10,4),%xmm2
addss  %xmm0,%xmm1
mulss  (%rdx,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%r10,4),%xmm1
mulss  (%rdx,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%r10,4),%xmm0
mulss  (%rdx,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%r10
add    %r15,%rdx
cmp    %r10,%r14
jne    11e0 <matmul8x8+0xe0>
test   %r11,%r11
je     126a <matmul8x8+0x16a>
mov    %rax,%rcx
imul   %r10,%rcx
mov    -0x60(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
lea    (%rdi,%r10,4),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm1
mulss  (%rdx),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rdx
cmp    %rcx,%r11
jne    1250 <matmul8x8+0x150>
movss  %xmm0,(%r8,%r9,4)
mov    -0x44(%rsp),%r10d
test   %r10d,%r10d
jle    1290 <matmul8x8+0x190>
cmpq   $0x3,-0x58(%rsp)
jae    12ee <matmul8x8+0x1ee>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    134b <matmul8x8+0x24b>
nopl   0x0(%rax)
movl   $0x0,0x4(%r8,%r9,4)
movl   $0x0,0x8(%r8,%r9,4)
movl   $0x0,0xc(%r8,%r9,4)
movl   $0x0,0x10(%r8,%r9,4)
movl   $0x0,0x14(%r8,%r9,4)
movl   $0x0,0x18(%r8,%r9,4)
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%r8,%r9,4)
add    $0x1,%rsi
mov    -0x8(%rsp),%rcx
add    %rcx,%rbx
add    %rcx,%rdi
cmp    $0x8,%rsi
jne    11a0 <matmul8x8+0xa0>
jmp    180f <matmul8x8+0x70f>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x4(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x4(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x4(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x4(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    1300 <matmul8x8+0x200>
testb  $0x3,-0x50(%rsp)
je     138a <matmul8x8+0x28a>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x10(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    1370 <matmul8x8+0x270>
movss  %xmm0,0x4(%r8,%r9,4)
test   %r10d,%r10d
jle    1299 <matmul8x8+0x199>
cmpq   $0x3,-0x58(%rsp)
jae    13a9 <matmul8x8+0x2a9>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    140b <matmul8x8+0x30b>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x8(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x8(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x8(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x8(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    13c0 <matmul8x8+0x2c0>
testb  $0x3,-0x50(%rsp)
je     144a <matmul8x8+0x34a>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x18(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    1430 <matmul8x8+0x330>
movss  %xmm0,0x8(%r8,%r9,4)
test   %r10d,%r10d
jle    12a2 <matmul8x8+0x1a2>
cmpq   $0x3,-0x58(%rsp)
jae    1469 <matmul8x8+0x369>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    14cb <matmul8x8+0x3cb>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0xc(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0xc(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0xc(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0xc(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    1480 <matmul8x8+0x380>
testb  $0x3,-0x50(%rsp)
je     150a <matmul8x8+0x40a>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x20(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    14f0 <matmul8x8+0x3f0>
movss  %xmm0,0xc(%r8,%r9,4)
test   %r10d,%r10d
jle    12ab <matmul8x8+0x1ab>
cmpq   $0x3,-0x58(%rsp)
jae    1529 <matmul8x8+0x429>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    158b <matmul8x8+0x48b>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x10(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x10(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x10(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x10(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    1540 <matmul8x8+0x440>
testb  $0x3,-0x50(%rsp)
je     15ca <matmul8x8+0x4ca>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x28(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    15b0 <matmul8x8+0x4b0>
movss  %xmm0,0x10(%r8,%r9,4)
test   %r10d,%r10d
jle    12b4 <matmul8x8+0x1b4>
cmpq   $0x3,-0x58(%rsp)
jae    15e9 <matmul8x8+0x4e9>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    164b <matmul8x8+0x54b>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x14(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x14(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x14(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x14(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    1600 <matmul8x8+0x500>
testb  $0x3,-0x50(%rsp)
je     168a <matmul8x8+0x58a>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x30(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    1670 <matmul8x8+0x570>
movss  %xmm0,0x14(%r8,%r9,4)
test   %r10d,%r10d
jle    12bd <matmul8x8+0x1bd>
cmpq   $0x3,-0x58(%rsp)
jae    16a9 <matmul8x8+0x5a9>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    170b <matmul8x8+0x60b>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x18(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x18(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x18(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x18(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    16c0 <matmul8x8+0x5c0>
testb  $0x3,-0x50(%rsp)
je     174a <matmul8x8+0x64a>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x38(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    1730 <matmul8x8+0x630>
movss  %xmm0,0x18(%r8,%r9,4)
test   %r10d,%r10d
jle    12c6 <matmul8x8+0x1c6>
cmpq   $0x3,-0x58(%rsp)
jae    1769 <matmul8x8+0x669>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    17cb <matmul8x8+0x6cb>
xorps  %xmm0,%xmm0
mov    -0x60(%rsp),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rbx,%rdx,4),%xmm1
mulss  0x1c(%rbp),%xmm1
movss  -0x8(%rbx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x1c(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rbx,%rdx,4),%xmm1
mulss  0x1c(%rbp,%rax,8),%xmm1
addss  %xmm2,%xmm1
movss  (%rbx,%rdx,4),%xmm0
mulss  0x1c(%rbp,%r13,1),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
add    %r15,%rbp
cmp    %rdx,%r14
jne    1780 <matmul8x8+0x680>
testb  $0x3,-0x50(%rsp)
je     12c9 <matmul8x8+0x1c9>
mov    %rax,%rcx
imul   %rdx,%rcx
mov    -0x40(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
lea    (%rdi,%rdx,4),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    %r12,%rbp
cmp    %rcx,%r11
jne    17f0 <matmul8x8+0x6f0>
jmp    12c9 <matmul8x8+0x1c9>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @matmul8x8(float* %0, i32 %1, float* %2, i32 %3, float* %4) {
%6 = alloca float*
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca i32
store float* %0, float** %6
store i32 %1, i32* %7
store float* %2, float** %8
store i32 %3, i32* %9
store float* %4, float** %10
store i32 0, i32* %11
br label %15
15: ; preds = %68, %5
%16 = load i32, i32* %11
%17 = icmp slt i32 %16, 8
br i1 %17, label %18, label %71
18: ; preds = %15
store i32 0, i32* %12
br label %19
19: ; preds = %64, %18
%20 = load i32, i32* %12
%21 = icmp slt i32 %20, 8
br i1 %21, label %22, label %67
22: ; preds = %19
store float 0.000000e+00, float* %13
store i32 0, i32* %14
br label %23
23: ; preds = %50, %22
%24 = load i32, i32* %14
%25 = load i32, i32* %7
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %53
27: ; preds = %23
%28 = load float*, float** %6
%29 = load i32, i32* %11
%30 = load i32, i32* %7
%31 = mul nsw i32 %29, %30
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %28, i64 %32
%34 = load i32, i32* %14
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
%37 = load float, float* %36
%38 = load float*, float** %8
%39 = load i32, i32* %14
%40 = load i32, i32* %9
%41 = mul nsw i32 %39, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %38, i64 %42
%44 = load i32, i32* %12
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %43, i64 %45
%47 = load float, float* %46
%48 = load float, float* %13
%49 = call float @llvm.fmuladd.f32(float %37, float %47, float %48)
store float %49, float* %13
br label %50
50: ; preds = %27
%51 = load i32, i32* %14
%52 = add nsw i32 %51, 1
store i32 %52, i32* %14
br label %23
53: ; preds = %23
%54 = load float, float* %13
%55 = load float*, float** %10
%56 = load i32, i32* %11
%57 = load i32, i32* %9
%58 = mul nsw i32 %56, %57
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %55, i64 %59
%61 = load i32, i32* %12
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
store float %54, float* %63
br label %64
64: ; preds = %53
%65 = load i32, i32* %12
%66 = add nsw i32 %65, 1
store i32 %66, i32* %12
br label %19
67: ; preds = %19
br label %68
68: ; preds = %67
%69 = load i32, i32* %11
%70 = add nsw i32 %69, 1
store i32 %70, i32* %11
br label %15
71: ; preds = %15
ret void
}

LLVM IR (-O2):
define void @matmul8x8(float* nocapture %0, i32 %1, float* nocapture %2, i32 %3, float* nocapture writeonly %4) {
%6 = icmp sgt i32 %1, 0
%7 = sext i32 %3 to i64
%8 = sext i32 %1 to i64
%9 = zext i32 %1 to i64
%10 = getelementptr inbounds float, float* %2, i64 1
%11 = getelementptr inbounds float, float* %2, i64 2
%12 = getelementptr inbounds float, float* %2, i64 3
%13 = getelementptr inbounds float, float* %2, i64 4
%14 = getelementptr inbounds float, float* %2, i64 5
%15 = getelementptr inbounds float, float* %2, i64 6
%16 = getelementptr inbounds float, float* %2, i64 7
%17 = add nsw i64 %9, -1
%18 = and i64 %9, 3
%19 = icmp ult i64 %17, 3
%20 = and i64 %9, 4294967292
%21 = icmp eq i64 %18, 0
%22 = and i64 %9, 3
%23 = icmp ult i64 %17, 3
%24 = and i64 %9, 4294967292
%25 = icmp eq i64 %22, 0
%26 = and i64 %9, 3
%27 = icmp ult i64 %17, 3
%28 = and i64 %9, 4294967292
%29 = icmp eq i64 %26, 0
%30 = and i64 %9, 3
%31 = icmp ult i64 %17, 3
%32 = and i64 %9, 4294967292
%33 = icmp eq i64 %30, 0
%34 = and i64 %9, 3
%35 = icmp ult i64 %17, 3
%36 = and i64 %9, 4294967292
%37 = icmp eq i64 %34, 0
%38 = and i64 %9, 3
%39 = icmp ult i64 %17, 3
%40 = and i64 %9, 4294967292
%41 = icmp eq i64 %38, 0
%42 = and i64 %9, 3
%43 = icmp ult i64 %17, 3
%44 = and i64 %9, 4294967292
%45 = icmp eq i64 %42, 0
%46 = and i64 %9, 3
%47 = icmp ult i64 %17, 3
%48 = and i64 %9, 4294967292
%49 = icmp eq i64 %46, 0
br label %50
50: ; preds = %5, %472
%51 = phi i64 [ 0, %5 ], [ %475, %472 ]
%52 = mul nsw i64 %51, %7
%53 = getelementptr inbounds float, float* %4, i64 %52
%54 = mul nsw i64 %51, %8
%55 = getelementptr inbounds float, float* %0, i64 %54
br i1 %6, label %56, label %57
56: ; preds = %50
br i1 %19, label %59, label %477
57: ; preds = %50
store float 0.000000e+00, float* %53
br label %113
58: ; preds = %472
ret void
59: ; preds = %477, %56
%60 = phi float [ undef, %56 ], [ %507, %477 ]
%61 = phi i64 [ 0, %56 ], [ %508, %477 ]
%62 = phi float [ 0.000000e+00, %56 ], [ %507, %477 ]
br i1 %21, label %76, label %63
63: ; preds = %59, %63
%64 = phi i64 [ %73, %63 ], [ %61, %59 ]
%65 = phi float [ %72, %63 ], [ %62, %59 ]
%66 = phi i64 [ %74, %63 ], [ 0, %59 ]
%67 = getelementptr inbounds float, float* %55, i64 %64
%68 = load float, float* %67
%69 = mul nsw i64 %64, %7
%70 = getelementptr inbounds float, float* %2, i64 %69
%71 = load float, float* %70
%72 = tail call float @llvm.fmuladd.f32(float %68, float %71, float %65)
%73 = add nuw nsw i64 %64, 1
%74 = add i64 %66, 1
%75 = icmp eq i64 %74, %18
br i1 %75, label %76, label %63
76: ; preds = %63, %59
%77 = phi float [ %60, %59 ], [ %72, %63 ]
store float %77, float* %53
br i1 %6, label %78, label %113
78: ; preds = %76
br i1 %23, label %115, label %79
79: ; preds = %78, %79
%80 = phi i64 [ %110, %79 ], [ 0, %78 ]
%81 = phi float [ %109, %79 ], [ 0.000000e+00, %78 ]
%82 = phi i64 [ %111, %79 ], [ 0, %78 ]
%83 = getelementptr inbounds float, float* %55, i64 %80
%84 = load float, float* %83
%85 = mul nsw i64 %80, %7
%86 = getelementptr inbounds float, float* %10, i64 %85
%87 = load float, float* %86
%88 = tail call float @llvm.fmuladd.f32(float %84, float %87, float %81)
%89 = or i64 %80, 1
%90 = getelementptr inbounds float, float* %55, i64 %89
%91 = load float, float* %90
%92 = mul nsw i64 %89, %7
%93 = getelementptr inbounds float, float* %10, i64 %92
%94 = load float, float* %93
%95 = tail call float @llvm.fmuladd.f32(float %91, float %94, float %88)
%96 = or i64 %80, 2
%97 = getelementptr inbounds float, float* %55, i64 %96
%98 = load float, float* %97
%99 = mul nsw i64 %96, %7
%100 = getelementptr inbounds float, float* %10, i64 %99
%101 = load float, float* %100
%102 = tail call float @llvm.fmuladd.f32(float %98, float %101, float %95)
%103 = or i64 %80, 3
%104 = getelementptr inbounds float, float* %55, i64 %103
%105 = load float, float* %104
%106 = mul nsw i64 %103, %7
%107 = getelementptr inbounds float, float* %10, i64 %106
%108 = load float, float* %107
%109 = tail call float @llvm.fmuladd.f32(float %105, float %108, float %102)
%110 = add nuw nsw i64 %80, 4
%111 = add i64 %82, 4
%112 = icmp eq i64 %111, %24
br i1 %112, label %115, label %79
113: ; preds = %57, %76
%114 = getelementptr inbounds float, float* %53, i64 1
store float 0.000000e+00, float* %114
br label %170
115: ; preds = %79, %78
%116 = phi float [ undef, %78 ], [ %109, %79 ]
%117 = phi i64 [ 0, %78 ], [ %110, %79 ]
%118 = phi float [ 0.000000e+00, %78 ], [ %109, %79 ]
br i1 %25, label %132, label %119
119: ; preds = %115, %119
%120 = phi i64 [ %129, %119 ], [ %117, %115 ]
%121 = phi float [ %128, %119 ], [ %118, %115 ]
%122 = phi i64 [ %130, %119 ], [ 0, %115 ]
%123 = getelementptr inbounds float, float* %55, i64 %120
%124 = load float, float* %123
%125 = mul nsw i64 %120, %7
%126 = getelementptr inbounds float, float* %10, i64 %125
%127 = load float, float* %126
%128 = tail call float @llvm.fmuladd.f32(float %124, float %127, float %121)
%129 = add nuw nsw i64 %120, 1
%130 = add i64 %122, 1
%131 = icmp eq i64 %130, %22
br i1 %131, label %132, label %119
132: ; preds = %119, %115
%133 = phi float [ %116, %115 ], [ %128, %119 ]
%134 = getelementptr inbounds float, float* %53, i64 1
store float %133, float* %134
br i1 %6, label %135, label %170
135: ; preds = %132
br i1 %27, label %172, label %136
136: ; preds = %135, %136
%137 = phi i64 [ %167, %136 ], [ 0, %135 ]
%138 = phi float [ %166, %136 ], [ 0.000000e+00, %135 ]
%139 = phi i64 [ %168, %136 ], [ 0, %135 ]
%140 = getelementptr inbounds float, float* %55, i64 %137
%141 = load float, float* %140
%142 = mul nsw i64 %137, %7
%143 = getelementptr inbounds float, float* %11, i64 %142
%144 = load float, float* %143
%145 = tail call float @llvm.fmuladd.f32(float %141, float %144, float %138)
%146 = or i64 %137, 1
%147 = getelementptr inbounds float, float* %55, i64 %146
%148 = load float, float* %147
%149 = mul nsw i64 %146, %7
%150 = getelementptr inbounds float, float* %11, i64 %149
%151 = load float, float* %150
%152 = tail call float @llvm.fmuladd.f32(float %148, float %151, float %145)
%153 = or i64 %137, 2
%154 = getelementptr inbounds float, float* %55, i64 %153
%155 = load float, float* %154
%156 = mul nsw i64 %153, %7
%157 = getelementptr inbounds float, float* %11, i64 %156
%158 = load float, float* %157
%159 = tail call float @llvm.fmuladd.f32(float %155, float %158, float %152)
%160 = or i64 %137, 3
%161 = getelementptr inbounds float, float* %55, i64 %160
%162 = load float, float* %161
%163 = mul nsw i64 %160, %7
%164 = getelementptr inbounds float, float* %11, i64 %163
%165 = load float, float* %164
%166 = tail call float @llvm.fmuladd.f32(float %162, float %165, float %159)
%167 = add nuw nsw i64 %137, 4
%168 = add i64 %139, 4
%169 = icmp eq i64 %168, %28
br i1 %169, label %172, label %136
170: ; preds = %113, %132
%171 = getelementptr inbounds float, float* %53, i64 2
store float 0.000000e+00, float* %171
br label %227
172: ; preds = %136, %135
%173 = phi float [ undef, %135 ], [ %166, %136 ]
%174 = phi i64 [ 0, %135 ], [ %167, %136 ]
%175 = phi float [ 0.000000e+00, %135 ], [ %166, %136 ]
br i1 %29, label %189, label %176
176: ; preds = %172, %176
%177 = phi i64 [ %186, %176 ], [ %174, %172 ]
%178 = phi float [ %185, %176 ], [ %175, %172 ]
%179 = phi i64 [ %187, %176 ], [ 0, %172 ]
%180 = getelementptr inbounds float, float* %55, i64 %177
%181 = load float, float* %180
%182 = mul nsw i64 %177, %7
%183 = getelementptr inbounds float, float* %11, i64 %182
%184 = load float, float* %183
%185 = tail call float @llvm.fmuladd.f32(float %181, float %184, float %178)
%186 = add nuw nsw i64 %177, 1
%187 = add i64 %179, 1
%188 = icmp eq i64 %187, %26
br i1 %188, label %189, label %176
189: ; preds = %176, %172
%190 = phi float [ %173, %172 ], [ %185, %176 ]
%191 = getelementptr inbounds float, float* %53, i64 2
store float %190, float* %191
br i1 %6, label %192, label %227
192: ; preds = %189
br i1 %31, label %229, label %193
193: ; preds = %192, %193
%194 = phi i64 [ %224, %193 ], [ 0, %192 ]
%195 = phi float [ %223, %193 ], [ 0.000000e+00, %192 ]
%196 = phi i64 [ %225, %193 ], [ 0, %192 ]
%197 = getelementptr inbounds float, float* %55, i64 %194
%198 = load float, float* %197
%199 = mul nsw i64 %194, %7
%200 = getelementptr inbounds float, float* %12, i64 %199
%201 = load float, float* %200
%202 = tail call float @llvm.fmuladd.f32(float %198, float %201, float %195)
%203 = or i64 %194, 1
%204 = getelementptr inbounds float, float* %55, i64 %203
%205 = load float, float* %204
%206 = mul nsw i64 %203, %7
%207 = getelementptr inbounds float, float* %12, i64 %206
%208 = load float, float* %207
%209 = tail call float @llvm.fmuladd.f32(float %205, float %208, float %202)
%210 = or i64 %194, 2
%211 = getelementptr inbounds float, float* %55, i64 %210
%212 = load float, float* %211
%213 = mul nsw i64 %210, %7
%214 = getelementptr inbounds float, float* %12, i64 %213
%215 = load float, float* %214
%216 = tail call float @llvm.fmuladd.f32(float %212, float %215, float %209)
%217 = or i64 %194, 3
%218 = getelementptr inbounds float, float* %55, i64 %217
%219 = load float, float* %218
%220 = mul nsw i64 %217, %7
%221 = getelementptr inbounds float, float* %12, i64 %220
%222 = load float, float* %221
%223 = tail call float @llvm.fmuladd.f32(float %219, float %222, float %216)
%224 = add nuw nsw i64 %194, 4
%225 = add i64 %196, 4
%226 = icmp eq i64 %225, %32
br i1 %226, label %229, label %193
227: ; preds = %170, %189
%228 = getelementptr inbounds float, float* %53, i64 3
store float 0.000000e+00, float* %228
br label %284
229: ; preds = %193, %192
%230 = phi float [ undef, %192 ], [ %223, %193 ]
%231 = phi i64 [ 0, %192 ], [ %224, %193 ]
%232 = phi float [ 0.000000e+00, %192 ], [ %223, %193 ]
br i1 %33, label %246, label %233
233: ; preds = %229, %233
%234 = phi i64 [ %243, %233 ], [ %231, %229 ]
%235 = phi float [ %242, %233 ], [ %232, %229 ]
%236 = phi i64 [ %244, %233 ], [ 0, %229 ]
%237 = getelementptr inbounds float, float* %55, i64 %234
%238 = load float, float* %237
%239 = mul nsw i64 %234, %7
%240 = getelementptr inbounds float, float* %12, i64 %239
%241 = load float, float* %240
%242 = tail call float @llvm.fmuladd.f32(float %238, float %241, float %235)
%243 = add nuw nsw i64 %234, 1
%244 = add i64 %236, 1
%245 = icmp eq i64 %244, %30
br i1 %245, label %246, label %233
246: ; preds = %233, %229
%247 = phi float [ %230, %229 ], [ %242, %233 ]
%248 = getelementptr inbounds float, float* %53, i64 3
store float %247, float* %248
br i1 %6, label %249, label %284
249: ; preds = %246
br i1 %35, label %286, label %250
250: ; preds = %249, %250
%251 = phi i64 [ %281, %250 ], [ 0, %249 ]
%252 = phi float [ %280, %250 ], [ 0.000000e+00, %249 ]
%253 = phi i64 [ %282, %250 ], [ 0, %249 ]
%254 = getelementptr inbounds float, float* %55, i64 %251
%255 = load float, float* %254
%256 = mul nsw i64 %251, %7
%257 = getelementptr inbounds float, float* %13, i64 %256
%258 = load float, float* %257
%259 = tail call float @llvm.fmuladd.f32(float %255, float %258, float %252)
%260 = or i64 %251, 1
%261 = getelementptr inbounds float, float* %55, i64 %260
%262 = load float, float* %261
%263 = mul nsw i64 %260, %7
%264 = getelementptr inbounds float, float* %13, i64 %263
%265 = load float, float* %264
%266 = tail call float @llvm.fmuladd.f32(float %262, float %265, float %259)
%267 = or i64 %251, 2
%268 = getelementptr inbounds float, float* %55, i64 %267
%269 = load float, float* %268
%270 = mul nsw i64 %267, %7
%271 = getelementptr inbounds float, float* %13, i64 %270
%272 = load float, float* %271
%273 = tail call float @llvm.fmuladd.f32(float %269, float %272, float %266)
%274 = or i64 %251, 3
%275 = getelementptr inbounds float, float* %55, i64 %274
%276 = load float, float* %275
%277 = mul nsw i64 %274, %7
%278 = getelementptr inbounds float, float* %13, i64 %277
%279 = load float, float* %278
%280 = tail call float @llvm.fmuladd.f32(float %276, float %279, float %273)
%281 = add nuw nsw i64 %251, 4
%282 = add i64 %253, 4
%283 = icmp eq i64 %282, %36
br i1 %283, label %286, label %250
284: ; preds = %227, %246
%285 = getelementptr inbounds float, float* %53, i64 4
store float 0.000000e+00, float* %285
br label %341
286: ; preds = %250, %249
%287 = phi float [ undef, %249 ], [ %280, %250 ]
%288 = phi i64 [ 0, %249 ], [ %281, %250 ]
%289 = phi float [ 0.000000e+00, %249 ], [ %280, %250 ]
br i1 %37, label %303, label %290
290: ; preds = %286, %290
%291 = phi i64 [ %300, %290 ], [ %288, %286 ]
%292 = phi float [ %299, %290 ], [ %289, %286 ]
%293 = phi i64 [ %301, %290 ], [ 0, %286 ]
%294 = getelementptr inbounds float, float* %55, i64 %291
%295 = load float, float* %294
%296 = mul nsw i64 %291, %7
%297 = getelementptr inbounds float, float* %13, i64 %296
%298 = load float, float* %297
%299 = tail call float @llvm.fmuladd.f32(float %295, float %298, float %292)
%300 = add nuw nsw i64 %291, 1
%301 = add i64 %293, 1
%302 = icmp eq i64 %301, %34
br i1 %302, label %303, label %290
303: ; preds = %290, %286
%304 = phi float [ %287, %286 ], [ %299, %290 ]
%305 = getelementptr inbounds float, float* %53, i64 4
store float %304, float* %305
br i1 %6, label %306, label %341
306: ; preds = %303
br i1 %39, label %343, label %307
307: ; preds = %306, %307
%308 = phi i64 [ %338, %307 ], [ 0, %306 ]
%309 = phi float [ %337, %307 ], [ 0.000000e+00, %306 ]
%310 = phi i64 [ %339, %307 ], [ 0, %306 ]
%311 = getelementptr inbounds float, float* %55, i64 %308
%312 = load float, float* %311
%313 = mul nsw i64 %308, %7
%314 = getelementptr inbounds float, float* %14, i64 %313
%315 = load float, float* %314
%316 = tail call float @llvm.fmuladd.f32(float %312, float %315, float %309)
%317 = or i64 %308, 1
%318 = getelementptr inbounds float, float* %55, i64 %317
%319 = load float, float* %318
%320 = mul nsw i64 %317, %7
%321 = getelementptr inbounds float, float* %14, i64 %320
%322 = load float, float* %321
%323 = tail call float @llvm.fmuladd.f32(float %319, float %322, float %316)
%324 = or i64 %308, 2
%325 = getelementptr inbounds float, float* %55, i64 %324
%326 = load float, float* %325
%327 = mul nsw i64 %324, %7
%328 = getelementptr inbounds float, float* %14, i64 %327
%329 = load float, float* %328
%330 = tail call float @llvm.fmuladd.f32(float %326, float %329, float %323)
%331 = or i64 %308, 3
%332 = getelementptr inbounds float, float* %55, i64 %331
%333 = load float, float* %332
%334 = mul nsw i64 %331, %7
%335 = getelementptr inbounds float, float* %14, i64 %334
%336 = load float, float* %335
%337 = tail call float @llvm.fmuladd.f32(float %333, float %336, float %330)
%338 = add nuw nsw i64 %308, 4
%339 = add i64 %310, 4
%340 = icmp eq i64 %339, %40
br i1 %340, label %343, label %307
341: ; preds = %284, %303
%342 = getelementptr inbounds float, float* %53, i64 5
store float 0.000000e+00, float* %342
br label %398
343: ; preds = %307, %306
%344 = phi float [ undef, %306 ], [ %337, %307 ]
%345 = phi i64 [ 0, %306 ], [ %338, %307 ]
%346 = phi float [ 0.000000e+00, %306 ], [ %337, %307 ]
br i1 %41, label %360, label %347
347: ; preds = %343, %347
%348 = phi i64 [ %357, %347 ], [ %345, %343 ]
%349 = phi float [ %356, %347 ], [ %346, %343 ]
%350 = phi i64 [ %358, %347 ], [ 0, %343 ]
%351 = getelementptr inbounds float, float* %55, i64 %348
%352 = load float, float* %351
%353 = mul nsw i64 %348, %7
%354 = getelementptr inbounds float, float* %14, i64 %353
%355 = load float, float* %354
%356 = tail call float @llvm.fmuladd.f32(float %352, float %355, float %349)
%357 = add nuw nsw i64 %348, 1
%358 = add i64 %350, 1
%359 = icmp eq i64 %358, %38
br i1 %359, label %360, label %347
360: ; preds = %347, %343
%361 = phi float [ %344, %343 ], [ %356, %347 ]
%362 = getelementptr inbounds float, float* %53, i64 5
store float %361, float* %362
br i1 %6, label %363, label %398
363: ; preds = %360
br i1 %43, label %400, label %364
364: ; preds = %363, %364
%365 = phi i64 [ %395, %364 ], [ 0, %363 ]
%366 = phi float [ %394, %364 ], [ 0.000000e+00, %363 ]
%367 = phi i64 [ %396, %364 ], [ 0, %363 ]
%368 = getelementptr inbounds float, float* %55, i64 %365
%369 = load float, float* %368
%370 = mul nsw i64 %365, %7
%371 = getelementptr inbounds float, float* %15, i64 %370
%372 = load float, float* %371
%373 = tail call float @llvm.fmuladd.f32(float %369, float %372, float %366)
%374 = or i64 %365, 1
%375 = getelementptr inbounds float, float* %55, i64 %374
%376 = load float, float* %375
%377 = mul nsw i64 %374, %7
%378 = getelementptr inbounds float, float* %15, i64 %377
%379 = load float, float* %378
%380 = tail call float @llvm.fmuladd.f32(float %376, float %379, float %373)
%381 = or i64 %365, 2
%382 = getelementptr inbounds float, float* %55, i64 %381
%383 = load float, float* %382
%384 = mul nsw i64 %381, %7
%385 = getelementptr inbounds float, float* %15, i64 %384
%386 = load float, float* %385
%387 = tail call float @llvm.fmuladd.f32(float %383, float %386, float %380)
%388 = or i64 %365, 3
%389 = getelementptr inbounds float, float* %55, i64 %388
%390 = load float, float* %389
%391 = mul nsw i64 %388, %7
%392 = getelementptr inbounds float, float* %15, i64 %391
%393 = load float, float* %392
%394 = tail call float @llvm.fmuladd.f32(float %390, float %393, float %387)
%395 = add nuw nsw i64 %365, 4
%396 = add i64 %367, 4
%397 = icmp eq i64 %396, %44
br i1 %397, label %400, label %364
398: ; preds = %341, %360
%399 = getelementptr inbounds float, float* %53, i64 6
store float 0.000000e+00, float* %399
br label %472
400: ; preds = %364, %363
%401 = phi float [ undef, %363 ], [ %394, %364 ]
%402 = phi i64 [ 0, %363 ], [ %395, %364 ]
%403 = phi float [ 0.000000e+00, %363 ], [ %394, %364 ]
br i1 %45, label %417, label %404
404: ; preds = %400, %404
%405 = phi i64 [ %414, %404 ], [ %402, %400 ]
%406 = phi float [ %413, %404 ], [ %403, %400 ]
%407 = phi i64 [ %415, %404 ], [ 0, %400 ]
%408 = getelementptr inbounds float, float* %55, i64 %405
%409 = load float, float* %408
%410 = mul nsw i64 %405, %7
%411 = getelementptr inbounds float, float* %15, i64 %410
%412 = load float, float* %411
%413 = tail call float @llvm.fmuladd.f32(float %409, float %412, float %406)
%414 = add nuw nsw i64 %405, 1
%415 = add i64 %407, 1
%416 = icmp eq i64 %415, %42
br i1 %416, label %417, label %404
417: ; preds = %404, %400
%418 = phi float [ %401, %400 ], [ %413, %404 ]
%419 = getelementptr inbounds float, float* %53, i64 6
store float %418, float* %419
br i1 %6, label %420, label %472
420: ; preds = %417
br i1 %47, label %455, label %421
421: ; preds = %420, %421
%422 = phi i64 [ %452, %421 ], [ 0, %420 ]
%423 = phi float [ %451, %421 ], [ 0.000000e+00, %420 ]
%424 = phi i64 [ %453, %421 ], [ 0, %420 ]
%425 = getelementptr inbounds float, float* %55, i64 %422
%426 = load float, float* %425
%427 = mul nsw i64 %422, %7
%428 = getelementptr inbounds float, float* %16, i64 %427
%429 = load float, float* %428
%430 = tail call float @llvm.fmuladd.f32(float %426, float %429, float %423)
%431 = or i64 %422, 1
%432 = getelementptr inbounds float, float* %55, i64 %431
%433 = load float, float* %432
%434 = mul nsw i64 %431, %7
%435 = getelementptr inbounds float, float* %16, i64 %434
%436 = load float, float* %435
%437 = tail call float @llvm.fmuladd.f32(float %433, float %436, float %430)
%438 = or i64 %422, 2
%439 = getelementptr inbounds float, float* %55, i64 %438
%440 = load float, float* %439
%441 = mul nsw i64 %438, %7
%442 = getelementptr inbounds float, float* %16, i64 %441
%443 = load float, float* %442
%444 = tail call float @llvm.fmuladd.f32(float %440, float %443, float %437)
%445 = or i64 %422, 3
%446 = getelementptr inbounds float, float* %55, i64 %445
%447 = load float, float* %446
%448 = mul nsw i64 %445, %7
%449 = getelementptr inbounds float, float* %16, i64 %448
%450 = load float, float* %449
%451 = tail call float @llvm.fmuladd.f32(float %447, float %450, float %444)
%452 = add nuw nsw i64 %422, 4
%453 = add i64 %424, 4
%454 = icmp eq i64 %453, %48
br i1 %454, label %455, label %421
455: ; preds = %421, %420
%456 = phi float [ undef, %420 ], [ %451, %421 ]
%457 = phi i64 [ 0, %420 ], [ %452, %421 ]
%458 = phi float [ 0.000000e+00, %420 ], [ %451, %421 ]
br i1 %49, label %472, label %459
459: ; preds = %455, %459
%460 = phi i64 [ %469, %459 ], [ %457, %455 ]
%461 = phi float [ %468, %459 ], [ %458, %455 ]
%462 = phi i64 [ %470, %459 ], [ 0, %455 ]
%463 = getelementptr inbounds float, float* %55, i64 %460
%464 = load float, float* %463
%465 = mul nsw i64 %460, %7
%466 = getelementptr inbounds float, float* %16, i64 %465
%467 = load float, float* %466
%468 = tail call float @llvm.fmuladd.f32(float %464, float %467, float %461)
%469 = add nuw nsw i64 %460, 1
%470 = add i64 %462, 1
%471 = icmp eq i64 %470, %46
br i1 %471, label %472, label %459
472: ; preds = %455, %459, %398, %417
%473 = phi float [ 0.000000e+00, %417 ], [ 0.000000e+00, %398 ], [ %456, %455 ], [ %468, %459 ]
%474 = getelementptr inbounds float, float* %53, i64 7
store float %473, float* %474
%475 = add nuw nsw i64 %51, 1
%476 = icmp eq i64 %475, 8
br i1 %476, label %58, label %50
477: ; preds = %56, %477
%478 = phi i64 [ %508, %477 ], [ 0, %56 ]
%479 = phi float [ %507, %477 ], [ 0.000000e+00, %56 ]
%480 = phi i64 [ %509, %477 ], [ 0, %56 ]
%481 = getelementptr inbounds float, float* %55, i64 %478
%482 = load float, float* %481
%483 = mul nsw i64 %478, %7
%484 = getelementptr inbounds float, float* %2, i64 %483
%485 = load float, float* %484
%486 = tail call float @llvm.fmuladd.f32(float %482, float %485, float %479)
%487 = or i64 %478, 1
%488 = getelementptr inbounds float, float* %55, i64 %487
%489 = load float, float* %488
%490 = mul nsw i64 %487, %7
%491 = getelementptr inbounds float, float* %2, i64 %490
%492 = load float, float* %491
%493 = tail call float @llvm.fmuladd.f32(float %489, float %492, float %486)
%494 = or i64 %478, 2
%495 = getelementptr inbounds float, float* %55, i64 %494
%496 = load float, float* %495
%497 = mul nsw i64 %494, %7
%498 = getelementptr inbounds float, float* %2, i64 %497
%499 = load float, float* %498
%500 = tail call float @llvm.fmuladd.f32(float %496, float %499, float %493)
%501 = or i64 %478, 3
%502 = getelementptr inbounds float, float* %55, i64 %501
%503 = load float, float* %502
%504 = mul nsw i64 %501, %7
%505 = getelementptr inbounds float, float* %2, i64 %504
%506 = load float, float* %505
%507 = tail call float @llvm.fmuladd.f32(float %503, float %506, float %500)
%508 = add nuw nsw i64 %478, 4
%509 = add i64 %480, 4
%510 = icmp eq i64 %509, %20
br i1 %510, label %59, label %477
}