#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef float uint8_t;

/* Variables and functions */
int /*<<< orphan*/ __pencil_kill(float ***);
void convolution(const int rows, const int cols, const int step,
                 const uint8_t src[rows][step][3], float kernel[3][3],
                 uint8_t conv[rows][step][3]) {
#pragma scop
  __pencil_kill(conv);
  for (int q = 0; q < rows - 2; q++) {
    for (int w = 0; w < cols - 2; w++) {
      for (int cc = 0; cc < 3; cc++) {
        float prod = 0.;
        for (int kq = 0; kq < 3; kq++) {
          for (int kw = 0; kw < 3; kw++) {
            prod += src[q + kq][w + kw][cc] * kernel[kq][kw];
          }
        }
        conv[q][w][cc] = prod;
      }
    }
  }
#pragma endscop
}


x86 assembly (clang, -O0):
<convolution>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <__pencil_kill@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1293 <convolution+0x183>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1280 <convolution+0x170>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    126d <convolution+0x15d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    122f <convolution+0x11f>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    121c <convolution+0x10c>
mov    -0x50(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11a5 <convolution+0x95>
jmp    1221 <convolution+0x111>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1194 <convolution+0x84>
mov    -0x48(%rbp),%rdx
movss  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117b <convolution+0x6b>
jmp    1272 <convolution+0x162>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1163 <convolution+0x53>
jmp    1285 <convolution+0x175>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114b <convolution+0x3b>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,%rbx
mov    %rcx,0x38(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%r12d
mov    %r9,0x40(%rsp)
mov    %r9,%rdi
call   1030 <__pencil_kill@plt>
cmp    $0x3,%r12d
jl     1974 <convolution+0x864>
mov    %rbp,%r9
mov    %r14d,%eax
add    $0xfffffffe,%r12d
lea    -0x2(%rbp),%r14d
mov    %rax,0x68(%rsp)
lea    (%rax,%rax,2),%rax
mov    %rax,0x48(%rsp)
lea    0x2(%r14),%rax
mov    %rax,0x60(%rsp)
lea    0x24(%rbx),%rax
mov    %rax,0x58(%rsp)
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
mov    0x38(%rsp),%rax
lea    0x44(%rax),%rcx
mov    %rcx,0x50(%rsp)
add    $0x20,%rax
mov    %rax,0x78(%rsp)
mov    0x40(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x70(%rsp)
xor    %r8d,%r8d
xorps  %xmm3,%xmm3
mov    %rbp,0x28(%rsp)
mov    %r12,0x8(%rsp)
mov    %r14,0x18(%rsp)
jmp    11d3 <convolution+0xc3>
nopl   (%rax)
add    $0x1,%r8
mov    %r8,%r11
mov    %r11,%r8
cmp    %r12,%r11
je     1974 <convolution+0x864>
cmp    $0x2,%r9d
jle    11c0 <convolution+0xb0>
lea    0x2(%r8),%rcx
lea    0x1(%r8),%r11
cmp    $0x4,%r14d
jae    11f0 <convolution+0xe0>
xor    %edi,%edi
jmp    1760 <convolution+0x650>
xchg   %ax,%ax
mov    %r8,%rax
mov    0x68(%rsp),%rdx
imul   %rdx,%rax
shl    $0x2,%rax
lea    (%rax,%rax,2),%r12
mov    0x40(%rsp),%rdi
lea    (%rdi,%r12,1),%r10
mov    %rcx,%rax
imul   %rdx,%rax
mov    %r14,%rbp
mov    %rcx,%r14
mov    0x38(%rsp),%rsi
add    %rsi,%r12
mov    %r11,%rcx
imul   %rdx,%rcx
lea    (%rax,%rax,2),%rax
mov    %r11,%r9
lea    (%rsi,%rax,4),%r11
mov    0x48(%rsp),%r13
mov    %r13,%rax
imul   %r8,%rax
lea    0x0(,%rbp,2),%rdx
add    %rbp,%rdx
lea    (%rdi,%rdx,4),%rdx
lea    (%rdx,%rax,4),%rbp
mov    %r13,%r15
mov    %r14,0x10(%rsp)
imul   %r14,%r15
mov    0x60(%rsp),%rdx
lea    (%rdx,%rdx,2),%rdx
lea    (%rsi,%rdx,4),%rdi
lea    (%rdi,%r15,4),%r14
mov    %r9,0x20(%rsp)
imul   %r9,%r13
cmp    %r14,%r10
setb   %r9b
cmp    %rbp,%r11
lea    (%rdi,%r13,4),%rdx
setb   %r11b
cmp    %rdx,%r10
lea    (%rcx,%rcx,2),%rcx
lea    (%rsi,%rcx,4),%rdx
setb   %cl
cmp    %rbp,%rdx
lea    (%rdi,%rax,4),%rdx
setb   %r14b
cmp    %rdx,%r10
setb   %dil
cmp    %rbp,%r12
setb   %r12b
cmp    0x58(%rsp),%r10
setb   %sil
cmp    %rbx,%rbp
seta   %dl
test   %r11b,%r9b
jne    173b <convolution+0x62b>
and    %r14b,%cl
jne    173b <convolution+0x62b>
and    %r12b,%dil
mov    0x28(%rsp),%r9
mov    0x18(%rsp),%r14
mov    0x20(%rsp),%r11
jne    1753 <convolution+0x643>
mov    $0x0,%edi
and    %dl,%sil
mov    0x8(%rsp),%r12
mov    0x10(%rsp),%rcx
jne    1760 <convolution+0x650>
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%r11
lea    (%rcx,%r13,4),%rsi
lea    (%rcx,%r15,4),%r14
mov    0x30(%rsp),%rax
xor    %r12d,%r12d
nopl   0x0(%rax)
movss  -0x20(%r11,%r12,1),%xmm2
movss  -0x2c(%r11,%r12,1),%xmm0
movss  -0x44(%r11,%r12,1),%xmm3
movss  -0x38(%r11,%r12,1),%xmm1
unpcklps %xmm1,%xmm3
unpcklps %xmm0,%xmm1
unpcklps %xmm2,%xmm0
movss  -0x40(%r11,%r12,1),%xmm5
movlhps %xmm0,%xmm3
movss  (%rbx),%xmm13
movss  0x4(%rbx),%xmm12
movss  0x8(%rbx),%xmm11
movss  0xc(%rbx),%xmm6
shufps $0x0,%xmm13,%xmm13
mulps  %xmm13,%xmm3
xorps  %xmm4,%xmm4
addps  %xmm4,%xmm3
movss  -0x14(%r11,%r12,1),%xmm4
unpcklps %xmm4,%xmm2
movlhps %xmm2,%xmm1
shufps $0x0,%xmm12,%xmm12
mulps  %xmm12,%xmm1
addps  %xmm3,%xmm1
movss  -0x8(%r11,%r12,1),%xmm2
unpcklps %xmm2,%xmm4
movlhps %xmm4,%xmm0
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm0
addps  %xmm1,%xmm0
movss  -0x20(%rsi,%r12,1),%xmm1
movss  -0x2c(%rsi,%r12,1),%xmm2
movss  -0x44(%rsi,%r12,1),%xmm4
movss  -0x38(%rsi,%r12,1),%xmm3
unpcklps %xmm3,%xmm4
unpcklps %xmm2,%xmm3
unpcklps %xmm1,%xmm2
movlhps %xmm2,%xmm4
shufps $0x0,%xmm6,%xmm6
movaps %xmm6,0x80(%rsp)
mulps  %xmm6,%xmm4
addps  %xmm0,%xmm4
movss  -0x14(%rsi,%r12,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm1,%xmm3
movss  0x10(%rbx),%xmm14
shufps $0x0,%xmm14,%xmm14
mulps  %xmm14,%xmm3
addps  %xmm4,%xmm3
movss  -0x8(%rsi,%r12,1),%xmm1
unpcklps %xmm1,%xmm0
movlhps %xmm0,%xmm2
movss  0x14(%rbx),%xmm15
shufps $0x0,%xmm15,%xmm15
mulps  %xmm15,%xmm2
addps  %xmm3,%xmm2
movss  -0x20(%r14,%r12,1),%xmm1
movss  -0x2c(%r14,%r12,1),%xmm3
movss  -0x44(%r14,%r12,1),%xmm4
movss  -0x38(%r14,%r12,1),%xmm6
unpcklps %xmm6,%xmm4
unpcklps %xmm3,%xmm6
unpcklps %xmm1,%xmm3
movlhps %xmm3,%xmm4
movss  0x18(%rbx),%xmm10
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm4
addps  %xmm2,%xmm4
movss  -0x14(%r14,%r12,1),%xmm7
unpcklps %xmm7,%xmm1
movlhps %xmm1,%xmm6
movss  0x1c(%rbx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm6
addps  %xmm4,%xmm6
movss  -0x8(%r14,%r12,1),%xmm1
unpcklps %xmm1,%xmm7
movlhps %xmm7,%xmm3
movss  0x20(%rbx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm3
addps  %xmm6,%xmm3
movss  -0x1c(%r11,%r12,1),%xmm1
movss  -0x28(%r11,%r12,1),%xmm7
movss  -0x34(%r11,%r12,1),%xmm8
unpcklps %xmm8,%xmm5
unpcklps %xmm7,%xmm8
unpcklps %xmm1,%xmm7
movss  -0x10(%r11,%r12,1),%xmm9
unpcklps %xmm9,%xmm1
movlhps %xmm1,%xmm8
movss  -0x40(%rsi,%r12,1),%xmm6
movlhps %xmm7,%xmm5
mulps  %xmm13,%xmm5
addps  0xb2c(%rip),%xmm5
mulps  %xmm12,%xmm8
addps  %xmm5,%xmm8
movss  -0x4(%r11,%r12,1),%xmm1
unpcklps %xmm1,%xmm9
movlhps %xmm9,%xmm7
mulps  %xmm11,%xmm7
addps  %xmm8,%xmm7
movss  -0x1c(%rsi,%r12,1),%xmm8
movss  -0x28(%rsi,%r12,1),%xmm1
movss  -0x34(%rsi,%r12,1),%xmm5
unpcklps %xmm5,%xmm6
unpcklps %xmm1,%xmm5
unpcklps %xmm8,%xmm1
movlhps %xmm1,%xmm6
movaps 0x80(%rsp),%xmm0
mulps  %xmm0,%xmm6
addps  %xmm7,%xmm6
movss  -0x10(%rsi,%r12,1),%xmm9
unpcklps %xmm9,%xmm8
movlhps %xmm8,%xmm5
movss  -0x40(%r14,%r12,1),%xmm7
mulps  %xmm14,%xmm5
addps  %xmm6,%xmm5
movss  -0x4(%rsi,%r12,1),%xmm6
unpcklps %xmm6,%xmm9
movlhps %xmm9,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm5,%xmm1
movss  -0x1c(%r14,%r12,1),%xmm8
movss  -0x28(%r14,%r12,1),%xmm5
movss  -0x34(%r14,%r12,1),%xmm6
unpcklps %xmm6,%xmm7
unpcklps %xmm5,%xmm6
unpcklps %xmm8,%xmm5
movlhps %xmm5,%xmm7
mulps  %xmm10,%xmm7
addps  %xmm1,%xmm7
movss  -0x10(%r14,%r12,1),%xmm9
unpcklps %xmm9,%xmm8
movlhps %xmm8,%xmm6
movss  -0x3c(%r11,%r12,1),%xmm1
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movss  -0x4(%r14,%r12,1),%xmm7
unpcklps %xmm7,%xmm9
movlhps %xmm9,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm6,%xmm5
movss  -0x18(%r11,%r12,1),%xmm8
movss  -0x24(%r11,%r12,1),%xmm6
movss  -0x30(%r11,%r12,1),%xmm7
unpcklps %xmm7,%xmm1
unpcklps %xmm6,%xmm7
unpcklps %xmm8,%xmm6
movlhps %xmm6,%xmm1
mulps  %xmm13,%xmm1
movss  -0xc(%r11,%r12,1),%xmm9
unpcklps %xmm9,%xmm8
movlhps %xmm8,%xmm7
mulps  %xmm12,%xmm7
addps  0xa10(%rip),%xmm1
addps  %xmm1,%xmm7
movss  (%r11,%r12,1),%xmm1
unpcklps %xmm1,%xmm9
movss  -0x3c(%rsi,%r12,1),%xmm8
movlhps %xmm9,%xmm6
mulps  %xmm11,%xmm6
addps  %xmm7,%xmm6
movss  -0x18(%rsi,%r12,1),%xmm9
movss  -0x24(%rsi,%r12,1),%xmm1
movss  -0x30(%rsi,%r12,1),%xmm7
unpcklps %xmm7,%xmm8
unpcklps %xmm1,%xmm7
unpcklps %xmm9,%xmm1
movlhps %xmm1,%xmm8
mulps  %xmm0,%xmm8
addps  %xmm6,%xmm8
movss  -0xc(%rsi,%r12,1),%xmm6
unpcklps %xmm6,%xmm9
movlhps %xmm9,%xmm7
mulps  %xmm14,%xmm7
addps  %xmm8,%xmm7
movss  (%rsi,%r12,1),%xmm0
unpcklps %xmm0,%xmm6
movss  -0x3c(%r14,%r12,1),%xmm0
movlhps %xmm6,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm7,%xmm1
movss  -0x18(%r14,%r12,1),%xmm6
movss  -0x24(%r14,%r12,1),%xmm8
movss  -0x30(%r14,%r12,1),%xmm7
unpcklps %xmm7,%xmm0
unpcklps %xmm8,%xmm7
unpcklps %xmm6,%xmm8
movlhps %xmm8,%xmm0
mulps  %xmm10,%xmm0
addps  %xmm1,%xmm0
movss  -0xc(%r14,%r12,1),%xmm1
unpcklps %xmm1,%xmm6
movlhps %xmm6,%xmm7
mulps  %xmm2,%xmm7
addps  %xmm0,%xmm7
movss  (%r14,%r12,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm1,%xmm8
mulps  %xmm4,%xmm8
addps  %xmm7,%xmm8
movaps %xmm8,%xmm0
shufps $0xd4,%xmm3,%xmm0
movaps %xmm5,%xmm1
movlhps %xmm3,%xmm1
shufps $0x82,%xmm0,%xmm1
movaps %xmm3,%xmm0
unpckhpd %xmm5,%xmm0
movaps %xmm8,%xmm2
shufps $0x11,%xmm5,%xmm2
shufps $0x82,%xmm0,%xmm2
shufps $0xff,%xmm8,%xmm5
shufps $0x23,%xmm8,%xmm3
shufps $0x82,%xmm5,%xmm3
movups %xmm3,0x20(%r10,%r12,1)
movups %xmm2,0x10(%r10,%r12,1)
movups %xmm1,(%r10,%r12,1)
add    $0x30,%r12
add    $0xfffffffffffffffc,%rax
jne    1320 <convolution+0x210>
mov    0x30(%rsp),%rax
mov    %rax,%rdi
mov    0x18(%rsp),%r14
cmp    %r14,%rax
mov    0x8(%rsp),%r12
xorps  %xmm3,%xmm3
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%rcx
je     11c7 <convolution+0xb7>
jmp    1760 <convolution+0x650>
xor    %edi,%edi
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%r12
mov    0x18(%rsp),%r14
mov    0x20(%rsp),%r11
jmp    175a <convolution+0x64a>
xor    %edi,%edi
mov    0x8(%rsp),%r12
mov    0x10(%rsp),%rcx
nop
mov    %r14,%rax
sub    %rdi,%rax
mov    0x48(%rsp),%rdx
imul   %rdx,%rcx
mov    0x78(%rsp),%rbp
lea    0x0(,%rcx,4),%rsi
add    %rbp,%rsi
shl    $0x2,%rdi
lea    (%rdi,%rdi,2),%rdi
mov    %rdx,%rcx
imul   %r11,%rcx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
imul   %rdx,%r8
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
mov    0x70(%rsp),%rbp
lea    0x0(%rbp,%r8,4),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x20(%rdx,%rdi,1),%xmm0
movss  -0x14(%rdx,%rdi,1),%xmm1
mulss  (%rbx),%xmm0
addss  %xmm3,%xmm0
mulss  0x4(%rbx),%xmm1
addss  %xmm0,%xmm1
movss  -0x8(%rdx,%rdi,1),%xmm0
mulss  0x8(%rbx),%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rcx,%rdi,1),%xmm1
movss  -0x14(%rcx,%rdi,1),%xmm2
mulss  0xc(%rbx),%xmm1
addss  %xmm0,%xmm1
mulss  0x10(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  -0x8(%rcx,%rdi,1),%xmm0
mulss  0x14(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  -0x20(%rsi,%rdi,1),%xmm1
movss  -0x14(%rsi,%rdi,1),%xmm2
mulss  0x18(%rbx),%xmm1
addss  %xmm0,%xmm1
mulss  0x1c(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  -0x8(%rsi,%rdi,1),%xmm0
mulss  0x20(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,-0x8(%rbp,%rdi,1)
movss  -0x1c(%rdx,%rdi,1),%xmm0
movss  -0x10(%rdx,%rdi,1),%xmm1
mulss  (%rbx),%xmm0
addss  %xmm3,%xmm0
mulss  0x4(%rbx),%xmm1
addss  %xmm0,%xmm1
movss  -0x4(%rdx,%rdi,1),%xmm0
mulss  0x8(%rbx),%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rcx,%rdi,1),%xmm1
movss  -0x10(%rcx,%rdi,1),%xmm2
mulss  0xc(%rbx),%xmm1
addss  %xmm0,%xmm1
mulss  0x10(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rcx,%rdi,1),%xmm0
mulss  0x14(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  -0x1c(%rsi,%rdi,1),%xmm1
movss  -0x10(%rsi,%rdi,1),%xmm2
mulss  0x18(%rbx),%xmm1
addss  %xmm0,%xmm1
mulss  0x1c(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rsi,%rdi,1),%xmm0
mulss  0x20(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,-0x4(%rbp,%rdi,1)
movss  -0x18(%rdx,%rdi,1),%xmm0
mulss  (%rbx),%xmm0
movss  -0xc(%rdx,%rdi,1),%xmm1
addss  %xmm3,%xmm0
mulss  0x4(%rbx),%xmm1
addss  %xmm0,%xmm1
movss  (%rdx,%rdi,1),%xmm0
mulss  0x8(%rbx),%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rcx,%rdi,1),%xmm1
mulss  0xc(%rbx),%xmm1
movss  -0xc(%rcx,%rdi,1),%xmm2
addss  %xmm0,%xmm1
mulss  0x10(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  (%rcx,%rdi,1),%xmm0
mulss  0x14(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  -0x18(%rsi,%rdi,1),%xmm1
mulss  0x18(%rbx),%xmm1
movss  -0xc(%rsi,%rdi,1),%xmm2
addss  %xmm0,%xmm1
mulss  0x1c(%rbx),%xmm2
addss  %xmm1,%xmm2
movss  (%rsi,%rdi,1),%xmm0
mulss  0x20(%rbx),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0x0(%rbp,%rdi,1)
add    $0xc,%rdi
add    $0xffffffffffffffff,%rax
jne    17c0 <convolution+0x6b0>
jmp    11c7 <convolution+0xb7>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @convolution(i32 %0, i32 %1, i32 %2, [3 x float]* nocapture %3, [3 x float]* nocapture %4, [3 x float]* %5) {
%7 = zext i32 %2 to i64
%8 = bitcast [3 x float]* %5 to float***
%9 = tail call i32 @__pencil_kill(float*** %8)
%10 = icmp sgt i32 %0, 2
br i1 %10, label %11, label %572
11: ; preds = %6
%12 = add nsw i32 %0, -2
%13 = add i32 %1, -2
%14 = icmp sgt i32 %1, 2
%15 = zext i32 %12 to i64
%16 = zext i32 %13 to i64
%17 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 0
%18 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 1
%19 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 2
%20 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 1, i64 0
%21 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 1, i64 1
%22 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 1, i64 2
%23 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 2, i64 0
%24 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 2, i64 1
%25 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 2, i64 2
%26 = mul nuw nsw i64 %7, 3
%27 = add nuw nsw i64 %16, 2
%28 = mul nuw nsw i64 %7, 3
%29 = mul nuw nsw i64 %7, 3
%30 = getelementptr [3 x float], [3 x float]* %4, i64 3, i64 0
%31 = icmp ult i32 %13, 4
%32 = bitcast float* %30 to [3 x float]*
%33 = and i64 %16, 4294967292
%34 = icmp eq i64 %33, %16
br label %35
35: ; preds = %11, %699
%36 = phi i64 [ 0, %11 ], [ %700, %699 ]
br i1 %14, label %39, label %37
37: ; preds = %35
%38 = add nuw nsw i64 %36, 1
br label %699
39: ; preds = %35
%40 = mul nuw nsw i64 %36, %7
%41 = getelementptr [3 x float], [3 x float]* %5, i64 %40
%42 = add i64 %36, 2
%43 = mul nuw nsw i64 %42, %7
%44 = getelementptr [3 x float], [3 x float]* %3, i64 %43
%45 = getelementptr inbounds [3 x float], [3 x float]* %3, i64 %40
%46 = add i64 %36, 1
%47 = mul nuw nsw i64 %46, %7
%48 = getelementptr inbounds [3 x float], [3 x float]* %3, i64 %47
br i1 %31, label %570, label %49
49: ; preds = %39
%50 = mul i64 %26, %36
%51 = getelementptr [3 x float], [3 x float]* %5, i64 %16, i64 %50
%52 = mul i64 %28, %42
%53 = getelementptr [3 x float], [3 x float]* %3, i64 %27, i64 %52
%54 = mul i64 %29, %46
%55 = getelementptr [3 x float], [3 x float]* %3, i64 %27, i64 %54
%56 = getelementptr [3 x float], [3 x float]* %3, i64 %27, i64 %50
%57 = bitcast float* %53 to [3 x float]*
%58 = icmp ult [3 x float]* %41, %57
%59 = bitcast float* %51 to [3 x float]*
%60 = icmp ult [3 x float]* %44, %59
%61 = and i1 %58, %60
%62 = bitcast float* %55 to [3 x float]*
%63 = icmp ult [3 x float]* %41, %62
%64 = bitcast float* %51 to [3 x float]*
%65 = icmp ult [3 x float]* %48, %64
%66 = and i1 %63, %65
%67 = or i1 %61, %66
%68 = bitcast float* %56 to [3 x float]*
%69 = icmp ult [3 x float]* %41, %68
%70 = bitcast float* %51 to [3 x float]*
%71 = icmp ult [3 x float]* %45, %70
%72 = and i1 %69, %71
%73 = or i1 %67, %72
%74 = icmp ult [3 x float]* %41, %32
%75 = bitcast float* %51 to [3 x float]*
%76 = icmp ugt [3 x float]* %75, %4
%77 = and i1 %74, %76
%78 = or i1 %73, %77
br i1 %78, label %570, label %79
79: ; preds = %49, %79
%80 = phi i64 [ %567, %79 ], [ 0, %49 ]
%81 = or i64 %80, 1
%82 = or i64 %80, 2
%83 = or i64 %80, 3
%84 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 %80
%85 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %80
%86 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %81
%87 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %82
%88 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %83
%89 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %80
%90 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %81
%91 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %82
%92 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %83
%93 = getelementptr inbounds [3 x float], [3 x float]* %89, i64 0, i64 0
%94 = getelementptr inbounds [3 x float], [3 x float]* %90, i64 0, i64 0
%95 = getelementptr inbounds [3 x float], [3 x float]* %91, i64 0, i64 0
%96 = getelementptr inbounds [3 x float], [3 x float]* %92, i64 0, i64 0
%97 = load float, float* %93
%98 = load float, float* %94
%99 = load float, float* %95
%100 = load float, float* %96
%101 = insertelement <4 x float> poison, float %97, i64 0
%102 = insertelement <4 x float> %101, float %98, i64 1
%103 = insertelement <4 x float> %102, float %99, i64 2
%104 = insertelement <4 x float> %103, float %100, i64 3
%105 = load float, float* %17
%106 = insertelement <4 x float> poison, float %105, i64 0
%107 = shufflevector <4 x float> %106, <4 x float> poison, <4 x i32> zeroinitializer
%108 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %104, <4 x float> %107, <4 x float> zeroinitializer)
%109 = or i64 %80, 1
%110 = or i64 %80, 2
%111 = or i64 %80, 3
%112 = add i64 %80, 4
%113 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %109
%114 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %110
%115 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %111
%116 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %112
%117 = getelementptr inbounds [3 x float], [3 x float]* %113, i64 0, i64 0
%118 = getelementptr inbounds [3 x float], [3 x float]* %114, i64 0, i64 0
%119 = getelementptr inbounds [3 x float], [3 x float]* %115, i64 0, i64 0
%120 = getelementptr inbounds [3 x float], [3 x float]* %116, i64 0, i64 0
%121 = load float, float* %117
%122 = load float, float* %118
%123 = load float, float* %119
%124 = load float, float* %120
%125 = insertelement <4 x float> poison, float %121, i64 0
%126 = insertelement <4 x float> %125, float %122, i64 1
%127 = insertelement <4 x float> %126, float %123, i64 2
%128 = insertelement <4 x float> %127, float %124, i64 3
%129 = load float, float* %18
%130 = insertelement <4 x float> poison, float %129, i64 0
%131 = shufflevector <4 x float> %130, <4 x float> poison, <4 x i32> zeroinitializer
%132 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> %131, <4 x float> %108)
%133 = or i64 %80, 2
%134 = or i64 %80, 3
%135 = add i64 %80, 4
%136 = add i64 %80, 5
%137 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %133
%138 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %134
%139 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %135
%140 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %136
%141 = getelementptr inbounds [3 x float], [3 x float]* %137, i64 0, i64 0
%142 = getelementptr inbounds [3 x float], [3 x float]* %138, i64 0, i64 0
%143 = getelementptr inbounds [3 x float], [3 x float]* %139, i64 0, i64 0
%144 = getelementptr inbounds [3 x float], [3 x float]* %140, i64 0, i64 0
%145 = load float, float* %141
%146 = load float, float* %142
%147 = load float, float* %143
%148 = load float, float* %144
%149 = insertelement <4 x float> poison, float %145, i64 0
%150 = insertelement <4 x float> %149, float %146, i64 1
%151 = insertelement <4 x float> %150, float %147, i64 2
%152 = insertelement <4 x float> %151, float %148, i64 3
%153 = load float, float* %19
%154 = insertelement <4 x float> poison, float %153, i64 0
%155 = shufflevector <4 x float> %154, <4 x float> poison, <4 x i32> zeroinitializer
%156 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %152, <4 x float> %155, <4 x float> %132)
%157 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %80
%158 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %81
%159 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %82
%160 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %83
%161 = getelementptr inbounds [3 x float], [3 x float]* %157, i64 0, i64 0
%162 = getelementptr inbounds [3 x float], [3 x float]* %158, i64 0, i64 0
%163 = getelementptr inbounds [3 x float], [3 x float]* %159, i64 0, i64 0
%164 = getelementptr inbounds [3 x float], [3 x float]* %160, i64 0, i64 0
%165 = load float, float* %161
%166 = load float, float* %162
%167 = load float, float* %163
%168 = load float, float* %164
%169 = insertelement <4 x float> poison, float %165, i64 0
%170 = insertelement <4 x float> %169, float %166, i64 1
%171 = insertelement <4 x float> %170, float %167, i64 2
%172 = insertelement <4 x float> %171, float %168, i64 3
%173 = load float, float* %20
%174 = insertelement <4 x float> poison, float %173, i64 0
%175 = shufflevector <4 x float> %174, <4 x float> poison, <4 x i32> zeroinitializer
%176 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %172, <4 x float> %175, <4 x float> %156)
%177 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %109
%178 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %110
%179 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %111
%180 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %112
%181 = getelementptr inbounds [3 x float], [3 x float]* %177, i64 0, i64 0
%182 = getelementptr inbounds [3 x float], [3 x float]* %178, i64 0, i64 0
%183 = getelementptr inbounds [3 x float], [3 x float]* %179, i64 0, i64 0
%184 = getelementptr inbounds [3 x float], [3 x float]* %180, i64 0, i64 0
%185 = load float, float* %181
%186 = load float, float* %182
%187 = load float, float* %183
%188 = load float, float* %184
%189 = insertelement <4 x float> poison, float %185, i64 0
%190 = insertelement <4 x float> %189, float %186, i64 1
%191 = insertelement <4 x float> %190, float %187, i64 2
%192 = insertelement <4 x float> %191, float %188, i64 3
%193 = load float, float* %21
%194 = insertelement <4 x float> poison, float %193, i64 0
%195 = shufflevector <4 x float> %194, <4 x float> poison, <4 x i32> zeroinitializer
%196 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %192, <4 x float> %195, <4 x float> %176)
%197 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %133
%198 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %134
%199 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %135
%200 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %136
%201 = getelementptr inbounds [3 x float], [3 x float]* %197, i64 0, i64 0
%202 = getelementptr inbounds [3 x float], [3 x float]* %198, i64 0, i64 0
%203 = getelementptr inbounds [3 x float], [3 x float]* %199, i64 0, i64 0
%204 = getelementptr inbounds [3 x float], [3 x float]* %200, i64 0, i64 0
%205 = load float, float* %201
%206 = load float, float* %202
%207 = load float, float* %203
%208 = load float, float* %204
%209 = insertelement <4 x float> poison, float %205, i64 0
%210 = insertelement <4 x float> %209, float %206, i64 1
%211 = insertelement <4 x float> %210, float %207, i64 2
%212 = insertelement <4 x float> %211, float %208, i64 3
%213 = load float, float* %22
%214 = insertelement <4 x float> poison, float %213, i64 0
%215 = shufflevector <4 x float> %214, <4 x float> poison, <4 x i32> zeroinitializer
%216 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %212, <4 x float> %215, <4 x float> %196)
%217 = getelementptr inbounds [3 x float], [3 x float]* %85, i64 0, i64 0
%218 = getelementptr inbounds [3 x float], [3 x float]* %86, i64 0, i64 0
%219 = getelementptr inbounds [3 x float], [3 x float]* %87, i64 0, i64 0
%220 = getelementptr inbounds [3 x float], [3 x float]* %88, i64 0, i64 0
%221 = load float, float* %217
%222 = load float, float* %218
%223 = load float, float* %219
%224 = load float, float* %220
%225 = insertelement <4 x float> poison, float %221, i64 0
%226 = insertelement <4 x float> %225, float %222, i64 1
%227 = insertelement <4 x float> %226, float %223, i64 2
%228 = insertelement <4 x float> %227, float %224, i64 3
%229 = load float, float* %23
%230 = insertelement <4 x float> poison, float %229, i64 0
%231 = shufflevector <4 x float> %230, <4 x float> poison, <4 x i32> zeroinitializer
%232 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %228, <4 x float> %231, <4 x float> %216)
%233 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %109
%234 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %110
%235 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %111
%236 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %112
%237 = getelementptr inbounds [3 x float], [3 x float]* %233, i64 0, i64 0
%238 = getelementptr inbounds [3 x float], [3 x float]* %234, i64 0, i64 0
%239 = getelementptr inbounds [3 x float], [3 x float]* %235, i64 0, i64 0
%240 = getelementptr inbounds [3 x float], [3 x float]* %236, i64 0, i64 0
%241 = load float, float* %237
%242 = load float, float* %238
%243 = load float, float* %239
%244 = load float, float* %240
%245 = insertelement <4 x float> poison, float %241, i64 0
%246 = insertelement <4 x float> %245, float %242, i64 1
%247 = insertelement <4 x float> %246, float %243, i64 2
%248 = insertelement <4 x float> %247, float %244, i64 3
%249 = load float, float* %24
%250 = insertelement <4 x float> poison, float %249, i64 0
%251 = shufflevector <4 x float> %250, <4 x float> poison, <4 x i32> zeroinitializer
%252 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %248, <4 x float> %251, <4 x float> %232)
%253 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %133
%254 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %134
%255 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %135
%256 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %136
%257 = getelementptr inbounds [3 x float], [3 x float]* %253, i64 0, i64 0
%258 = getelementptr inbounds [3 x float], [3 x float]* %254, i64 0, i64 0
%259 = getelementptr inbounds [3 x float], [3 x float]* %255, i64 0, i64 0
%260 = getelementptr inbounds [3 x float], [3 x float]* %256, i64 0, i64 0
%261 = load float, float* %257
%262 = load float, float* %258
%263 = load float, float* %259
%264 = load float, float* %260
%265 = insertelement <4 x float> poison, float %261, i64 0
%266 = insertelement <4 x float> %265, float %262, i64 1
%267 = insertelement <4 x float> %266, float %263, i64 2
%268 = insertelement <4 x float> %267, float %264, i64 3
%269 = load float, float* %25
%270 = insertelement <4 x float> poison, float %269, i64 0
%271 = shufflevector <4 x float> %270, <4 x float> poison, <4 x i32> zeroinitializer
%272 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %268, <4 x float> %271, <4 x float> %252)
%273 = getelementptr inbounds [3 x float], [3 x float]* %89, i64 0, i64 1
%274 = getelementptr inbounds [3 x float], [3 x float]* %90, i64 0, i64 1
%275 = getelementptr inbounds [3 x float], [3 x float]* %91, i64 0, i64 1
%276 = getelementptr inbounds [3 x float], [3 x float]* %92, i64 0, i64 1
%277 = load float, float* %273
%278 = load float, float* %274
%279 = load float, float* %275
%280 = load float, float* %276
%281 = insertelement <4 x float> poison, float %277, i64 0
%282 = insertelement <4 x float> %281, float %278, i64 1
%283 = insertelement <4 x float> %282, float %279, i64 2
%284 = insertelement <4 x float> %283, float %280, i64 3
%285 = load float, float* %17
%286 = insertelement <4 x float> poison, float %285, i64 0
%287 = shufflevector <4 x float> %286, <4 x float> poison, <4 x i32> zeroinitializer
%288 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %284, <4 x float> %287, <4 x float> zeroinitializer)
%289 = getelementptr inbounds [3 x float], [3 x float]* %113, i64 0, i64 1
%290 = getelementptr inbounds [3 x float], [3 x float]* %114, i64 0, i64 1
%291 = getelementptr inbounds [3 x float], [3 x float]* %115, i64 0, i64 1
%292 = getelementptr inbounds [3 x float], [3 x float]* %116, i64 0, i64 1
%293 = load float, float* %289
%294 = load float, float* %290
%295 = load float, float* %291
%296 = load float, float* %292
%297 = insertelement <4 x float> poison, float %293, i64 0
%298 = insertelement <4 x float> %297, float %294, i64 1
%299 = insertelement <4 x float> %298, float %295, i64 2
%300 = insertelement <4 x float> %299, float %296, i64 3
%301 = load float, float* %18
%302 = insertelement <4 x float> poison, float %301, i64 0
%303 = shufflevector <4 x float> %302, <4 x float> poison, <4 x i32> zeroinitializer
%304 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %300, <4 x float> %303, <4 x float> %288)
%305 = getelementptr inbounds [3 x float], [3 x float]* %137, i64 0, i64 1
%306 = getelementptr inbounds [3 x float], [3 x float]* %138, i64 0, i64 1
%307 = getelementptr inbounds [3 x float], [3 x float]* %139, i64 0, i64 1
%308 = getelementptr inbounds [3 x float], [3 x float]* %140, i64 0, i64 1
%309 = load float, float* %305
%310 = load float, float* %306
%311 = load float, float* %307
%312 = load float, float* %308
%313 = insertelement <4 x float> poison, float %309, i64 0
%314 = insertelement <4 x float> %313, float %310, i64 1
%315 = insertelement <4 x float> %314, float %311, i64 2
%316 = insertelement <4 x float> %315, float %312, i64 3
%317 = load float, float* %19
%318 = insertelement <4 x float> poison, float %317, i64 0
%319 = shufflevector <4 x float> %318, <4 x float> poison, <4 x i32> zeroinitializer
%320 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %316, <4 x float> %319, <4 x float> %304)
%321 = getelementptr inbounds [3 x float], [3 x float]* %157, i64 0, i64 1
%322 = getelementptr inbounds [3 x float], [3 x float]* %158, i64 0, i64 1
%323 = getelementptr inbounds [3 x float], [3 x float]* %159, i64 0, i64 1
%324 = getelementptr inbounds [3 x float], [3 x float]* %160, i64 0, i64 1
%325 = load float, float* %321
%326 = load float, float* %322
%327 = load float, float* %323
%328 = load float, float* %324
%329 = insertelement <4 x float> poison, float %325, i64 0
%330 = insertelement <4 x float> %329, float %326, i64 1
%331 = insertelement <4 x float> %330, float %327, i64 2
%332 = insertelement <4 x float> %331, float %328, i64 3
%333 = load float, float* %20
%334 = insertelement <4 x float> poison, float %333, i64 0
%335 = shufflevector <4 x float> %334, <4 x float> poison, <4 x i32> zeroinitializer
%336 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %332, <4 x float> %335, <4 x float> %320)
%337 = getelementptr inbounds [3 x float], [3 x float]* %177, i64 0, i64 1
%338 = getelementptr inbounds [3 x float], [3 x float]* %178, i64 0, i64 1
%339 = getelementptr inbounds [3 x float], [3 x float]* %179, i64 0, i64 1
%340 = getelementptr inbounds [3 x float], [3 x float]* %180, i64 0, i64 1
%341 = load float, float* %337
%342 = load float, float* %338
%343 = load float, float* %339
%344 = load float, float* %340
%345 = insertelement <4 x float> poison, float %341, i64 0
%346 = insertelement <4 x float> %345, float %342, i64 1
%347 = insertelement <4 x float> %346, float %343, i64 2
%348 = insertelement <4 x float> %347, float %344, i64 3
%349 = load float, float* %21
%350 = insertelement <4 x float> poison, float %349, i64 0
%351 = shufflevector <4 x float> %350, <4 x float> poison, <4 x i32> zeroinitializer
%352 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %348, <4 x float> %351, <4 x float> %336)
%353 = getelementptr inbounds [3 x float], [3 x float]* %197, i64 0, i64 1
%354 = getelementptr inbounds [3 x float], [3 x float]* %198, i64 0, i64 1
%355 = getelementptr inbounds [3 x float], [3 x float]* %199, i64 0, i64 1
%356 = getelementptr inbounds [3 x float], [3 x float]* %200, i64 0, i64 1
%357 = load float, float* %353
%358 = load float, float* %354
%359 = load float, float* %355
%360 = load float, float* %356
%361 = insertelement <4 x float> poison, float %357, i64 0
%362 = insertelement <4 x float> %361, float %358, i64 1
%363 = insertelement <4 x float> %362, float %359, i64 2
%364 = insertelement <4 x float> %363, float %360, i64 3
%365 = load float, float* %22
%366 = insertelement <4 x float> poison, float %365, i64 0
%367 = shufflevector <4 x float> %366, <4 x float> poison, <4 x i32> zeroinitializer
%368 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %364, <4 x float> %367, <4 x float> %352)
%369 = getelementptr inbounds [3 x float], [3 x float]* %85, i64 0, i64 1
%370 = getelementptr inbounds [3 x float], [3 x float]* %86, i64 0, i64 1
%371 = getelementptr inbounds [3 x float], [3 x float]* %87, i64 0, i64 1
%372 = getelementptr inbounds [3 x float], [3 x float]* %88, i64 0, i64 1
%373 = load float, float* %369
%374 = load float, float* %370
%375 = load float, float* %371
%376 = load float, float* %372
%377 = insertelement <4 x float> poison, float %373, i64 0
%378 = insertelement <4 x float> %377, float %374, i64 1
%379 = insertelement <4 x float> %378, float %375, i64 2
%380 = insertelement <4 x float> %379, float %376, i64 3
%381 = load float, float* %23
%382 = insertelement <4 x float> poison, float %381, i64 0
%383 = shufflevector <4 x float> %382, <4 x float> poison, <4 x i32> zeroinitializer
%384 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %380, <4 x float> %383, <4 x float> %368)
%385 = getelementptr inbounds [3 x float], [3 x float]* %233, i64 0, i64 1
%386 = getelementptr inbounds [3 x float], [3 x float]* %234, i64 0, i64 1
%387 = getelementptr inbounds [3 x float], [3 x float]* %235, i64 0, i64 1
%388 = getelementptr inbounds [3 x float], [3 x float]* %236, i64 0, i64 1
%389 = load float, float* %385
%390 = load float, float* %386
%391 = load float, float* %387
%392 = load float, float* %388
%393 = insertelement <4 x float> poison, float %389, i64 0
%394 = insertelement <4 x float> %393, float %390, i64 1
%395 = insertelement <4 x float> %394, float %391, i64 2
%396 = insertelement <4 x float> %395, float %392, i64 3
%397 = load float, float* %24
%398 = insertelement <4 x float> poison, float %397, i64 0
%399 = shufflevector <4 x float> %398, <4 x float> poison, <4 x i32> zeroinitializer
%400 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %396, <4 x float> %399, <4 x float> %384)
%401 = getelementptr inbounds [3 x float], [3 x float]* %253, i64 0, i64 1
%402 = getelementptr inbounds [3 x float], [3 x float]* %254, i64 0, i64 1
%403 = getelementptr inbounds [3 x float], [3 x float]* %255, i64 0, i64 1
%404 = getelementptr inbounds [3 x float], [3 x float]* %256, i64 0, i64 1
%405 = load float, float* %401
%406 = load float, float* %402
%407 = load float, float* %403
%408 = load float, float* %404
%409 = insertelement <4 x float> poison, float %405, i64 0
%410 = insertelement <4 x float> %409, float %406, i64 1
%411 = insertelement <4 x float> %410, float %407, i64 2
%412 = insertelement <4 x float> %411, float %408, i64 3
%413 = load float, float* %25
%414 = insertelement <4 x float> poison, float %413, i64 0
%415 = shufflevector <4 x float> %414, <4 x float> poison, <4 x i32> zeroinitializer
%416 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %412, <4 x float> %415, <4 x float> %400)
%417 = getelementptr inbounds [3 x float], [3 x float]* %89, i64 0, i64 2
%418 = getelementptr inbounds [3 x float], [3 x float]* %90, i64 0, i64 2
%419 = getelementptr inbounds [3 x float], [3 x float]* %91, i64 0, i64 2
%420 = getelementptr inbounds [3 x float], [3 x float]* %92, i64 0, i64 2
%421 = load float, float* %417
%422 = load float, float* %418
%423 = load float, float* %419
%424 = load float, float* %420
%425 = insertelement <4 x float> poison, float %421, i64 0
%426 = insertelement <4 x float> %425, float %422, i64 1
%427 = insertelement <4 x float> %426, float %423, i64 2
%428 = insertelement <4 x float> %427, float %424, i64 3
%429 = load float, float* %17
%430 = insertelement <4 x float> poison, float %429, i64 0
%431 = shufflevector <4 x float> %430, <4 x float> poison, <4 x i32> zeroinitializer
%432 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %428, <4 x float> %431, <4 x float> zeroinitializer)
%433 = getelementptr inbounds [3 x float], [3 x float]* %113, i64 0, i64 2
%434 = getelementptr inbounds [3 x float], [3 x float]* %114, i64 0, i64 2
%435 = getelementptr inbounds [3 x float], [3 x float]* %115, i64 0, i64 2
%436 = getelementptr inbounds [3 x float], [3 x float]* %116, i64 0, i64 2
%437 = load float, float* %433
%438 = load float, float* %434
%439 = load float, float* %435
%440 = load float, float* %436
%441 = insertelement <4 x float> poison, float %437, i64 0
%442 = insertelement <4 x float> %441, float %438, i64 1
%443 = insertelement <4 x float> %442, float %439, i64 2
%444 = insertelement <4 x float> %443, float %440, i64 3
%445 = load float, float* %18
%446 = insertelement <4 x float> poison, float %445, i64 0
%447 = shufflevector <4 x float> %446, <4 x float> poison, <4 x i32> zeroinitializer
%448 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %444, <4 x float> %447, <4 x float> %432)
%449 = getelementptr inbounds [3 x float], [3 x float]* %137, i64 0, i64 2
%450 = getelementptr inbounds [3 x float], [3 x float]* %138, i64 0, i64 2
%451 = getelementptr inbounds [3 x float], [3 x float]* %139, i64 0, i64 2
%452 = getelementptr inbounds [3 x float], [3 x float]* %140, i64 0, i64 2
%453 = load float, float* %449
%454 = load float, float* %450
%455 = load float, float* %451
%456 = load float, float* %452
%457 = insertelement <4 x float> poison, float %453, i64 0
%458 = insertelement <4 x float> %457, float %454, i64 1
%459 = insertelement <4 x float> %458, float %455, i64 2
%460 = insertelement <4 x float> %459, float %456, i64 3
%461 = load float, float* %19
%462 = insertelement <4 x float> poison, float %461, i64 0
%463 = shufflevector <4 x float> %462, <4 x float> poison, <4 x i32> zeroinitializer
%464 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %460, <4 x float> %463, <4 x float> %448)
%465 = getelementptr inbounds [3 x float], [3 x float]* %157, i64 0, i64 2
%466 = getelementptr inbounds [3 x float], [3 x float]* %158, i64 0, i64 2
%467 = getelementptr inbounds [3 x float], [3 x float]* %159, i64 0, i64 2
%468 = getelementptr inbounds [3 x float], [3 x float]* %160, i64 0, i64 2
%469 = load float, float* %465
%470 = load float, float* %466
%471 = load float, float* %467
%472 = load float, float* %468
%473 = insertelement <4 x float> poison, float %469, i64 0
%474 = insertelement <4 x float> %473, float %470, i64 1
%475 = insertelement <4 x float> %474, float %471, i64 2
%476 = insertelement <4 x float> %475, float %472, i64 3
%477 = load float, float* %20
%478 = insertelement <4 x float> poison, float %477, i64 0
%479 = shufflevector <4 x float> %478, <4 x float> poison, <4 x i32> zeroinitializer
%480 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %476, <4 x float> %479, <4 x float> %464)
%481 = getelementptr inbounds [3 x float], [3 x float]* %177, i64 0, i64 2
%482 = getelementptr inbounds [3 x float], [3 x float]* %178, i64 0, i64 2
%483 = getelementptr inbounds [3 x float], [3 x float]* %179, i64 0, i64 2
%484 = getelementptr inbounds [3 x float], [3 x float]* %180, i64 0, i64 2
%485 = load float, float* %481
%486 = load float, float* %482
%487 = load float, float* %483
%488 = load float, float* %484
%489 = insertelement <4 x float> poison, float %485, i64 0
%490 = insertelement <4 x float> %489, float %486, i64 1
%491 = insertelement <4 x float> %490, float %487, i64 2
%492 = insertelement <4 x float> %491, float %488, i64 3
%493 = load float, float* %21
%494 = insertelement <4 x float> poison, float %493, i64 0
%495 = shufflevector <4 x float> %494, <4 x float> poison, <4 x i32> zeroinitializer
%496 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %492, <4 x float> %495, <4 x float> %480)
%497 = getelementptr inbounds [3 x float], [3 x float]* %197, i64 0, i64 2
%498 = getelementptr inbounds [3 x float], [3 x float]* %198, i64 0, i64 2
%499 = getelementptr inbounds [3 x float], [3 x float]* %199, i64 0, i64 2
%500 = getelementptr inbounds [3 x float], [3 x float]* %200, i64 0, i64 2
%501 = load float, float* %497
%502 = load float, float* %498
%503 = load float, float* %499
%504 = load float, float* %500
%505 = insertelement <4 x float> poison, float %501, i64 0
%506 = insertelement <4 x float> %505, float %502, i64 1
%507 = insertelement <4 x float> %506, float %503, i64 2
%508 = insertelement <4 x float> %507, float %504, i64 3
%509 = load float, float* %22
%510 = insertelement <4 x float> poison, float %509, i64 0
%511 = shufflevector <4 x float> %510, <4 x float> poison, <4 x i32> zeroinitializer
%512 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %508, <4 x float> %511, <4 x float> %496)
%513 = getelementptr inbounds [3 x float], [3 x float]* %85, i64 0, i64 2
%514 = getelementptr inbounds [3 x float], [3 x float]* %86, i64 0, i64 2
%515 = getelementptr inbounds [3 x float], [3 x float]* %87, i64 0, i64 2
%516 = getelementptr inbounds [3 x float], [3 x float]* %88, i64 0, i64 2
%517 = load float, float* %513
%518 = load float, float* %514
%519 = load float, float* %515
%520 = load float, float* %516
%521 = insertelement <4 x float> poison, float %517, i64 0
%522 = insertelement <4 x float> %521, float %518, i64 1
%523 = insertelement <4 x float> %522, float %519, i64 2
%524 = insertelement <4 x float> %523, float %520, i64 3
%525 = load float, float* %23
%526 = insertelement <4 x float> poison, float %525, i64 0
%527 = shufflevector <4 x float> %526, <4 x float> poison, <4 x i32> zeroinitializer
%528 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %524, <4 x float> %527, <4 x float> %512)
%529 = getelementptr inbounds [3 x float], [3 x float]* %233, i64 0, i64 2
%530 = getelementptr inbounds [3 x float], [3 x float]* %234, i64 0, i64 2
%531 = getelementptr inbounds [3 x float], [3 x float]* %235, i64 0, i64 2
%532 = getelementptr inbounds [3 x float], [3 x float]* %236, i64 0, i64 2
%533 = load float, float* %529
%534 = load float, float* %530
%535 = load float, float* %531
%536 = load float, float* %532
%537 = insertelement <4 x float> poison, float %533, i64 0
%538 = insertelement <4 x float> %537, float %534, i64 1
%539 = insertelement <4 x float> %538, float %535, i64 2
%540 = insertelement <4 x float> %539, float %536, i64 3
%541 = load float, float* %24
%542 = insertelement <4 x float> poison, float %541, i64 0
%543 = shufflevector <4 x float> %542, <4 x float> poison, <4 x i32> zeroinitializer
%544 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %540, <4 x float> %543, <4 x float> %528)
%545 = getelementptr inbounds [3 x float], [3 x float]* %253, i64 0, i64 2
%546 = getelementptr inbounds [3 x float], [3 x float]* %254, i64 0, i64 2
%547 = getelementptr inbounds [3 x float], [3 x float]* %255, i64 0, i64 2
%548 = getelementptr inbounds [3 x float], [3 x float]* %256, i64 0, i64 2
%549 = load float, float* %545
%550 = load float, float* %546
%551 = load float, float* %547
%552 = load float, float* %548
%553 = insertelement <4 x float> poison, float %549, i64 0
%554 = insertelement <4 x float> %553, float %550, i64 1
%555 = insertelement <4 x float> %554, float %551, i64 2
%556 = insertelement <4 x float> %555, float %552, i64 3
%557 = load float, float* %25
%558 = insertelement <4 x float> poison, float %557, i64 0
%559 = shufflevector <4 x float> %558, <4 x float> poison, <4 x i32> zeroinitializer
%560 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %556, <4 x float> %559, <4 x float> %544)
%561 = getelementptr inbounds [3 x float], [3 x float]* %84, i64 0, i64 2
%562 = getelementptr inbounds float, float* %561, i64 -2
%563 = bitcast float* %562 to <12 x float>*
%564 = shufflevector <4 x float> %272, <4 x float> %416, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%565 = shufflevector <4 x float> %560, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%566 = shufflevector <8 x float> %564, <8 x float> %565, <12 x i32> <i32 0, i32 4, i32 8, i32 1, i32 5, i32 9, i32 2, i32 6, i32 10, i32 3, i32 7, i32 11>
store <12 x float> %566, <12 x float>* %563
%567 = add nuw i64 %80, 4
%568 = icmp eq i64 %567, %33
br i1 %568, label %569, label %79
569: ; preds = %79
br i1 %34, label %699, label %570
570: ; preds = %49, %39, %569
%571 = phi i64 [ 0, %49 ], [ 0, %39 ], [ %33, %569 ]
br label %573
572: ; preds = %699, %6
ret void
573: ; preds = %570, %573
%574 = phi i64 [ %582, %573 ], [ %571, %570 ]
%575 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 %574
%576 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %574
%577 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %574
%578 = getelementptr inbounds [3 x float], [3 x float]* %577, i64 0, i64 0
%579 = load float, float* %578
%580 = load float, float* %17
%581 = tail call float @llvm.fmuladd.f32(float %579, float %580, float 0.000000e+00)
%582 = add nuw nsw i64 %574, 1
%583 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %582
%584 = getelementptr inbounds [3 x float], [3 x float]* %583, i64 0, i64 0
%585 = load float, float* %584
%586 = load float, float* %18
%587 = tail call float @llvm.fmuladd.f32(float %585, float %586, float %581)
%588 = add nuw nsw i64 %574, 2
%589 = getelementptr inbounds [3 x float], [3 x float]* %45, i64 %588
%590 = getelementptr inbounds [3 x float], [3 x float]* %589, i64 0, i64 0
%591 = load float, float* %590
%592 = load float, float* %19
%593 = tail call float @llvm.fmuladd.f32(float %591, float %592, float %587)
%594 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %574
%595 = getelementptr inbounds [3 x float], [3 x float]* %594, i64 0, i64 0
%596 = load float, float* %595
%597 = load float, float* %20
%598 = tail call float @llvm.fmuladd.f32(float %596, float %597, float %593)
%599 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %582
%600 = getelementptr inbounds [3 x float], [3 x float]* %599, i64 0, i64 0
%601 = load float, float* %600
%602 = load float, float* %21
%603 = tail call float @llvm.fmuladd.f32(float %601, float %602, float %598)
%604 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %588
%605 = getelementptr inbounds [3 x float], [3 x float]* %604, i64 0, i64 0
%606 = load float, float* %605
%607 = load float, float* %22
%608 = tail call float @llvm.fmuladd.f32(float %606, float %607, float %603)
%609 = getelementptr inbounds [3 x float], [3 x float]* %576, i64 0, i64 0
%610 = load float, float* %609
%611 = load float, float* %23
%612 = tail call float @llvm.fmuladd.f32(float %610, float %611, float %608)
%613 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %582
%614 = getelementptr inbounds [3 x float], [3 x float]* %613, i64 0, i64 0
%615 = load float, float* %614
%616 = load float, float* %24
%617 = tail call float @llvm.fmuladd.f32(float %615, float %616, float %612)
%618 = getelementptr inbounds [3 x float], [3 x float]* %44, i64 %588
%619 = getelementptr inbounds [3 x float], [3 x float]* %618, i64 0, i64 0
%620 = load float, float* %619
%621 = load float, float* %25
%622 = tail call float @llvm.fmuladd.f32(float %620, float %621, float %617)
%623 = getelementptr inbounds [3 x float], [3 x float]* %575, i64 0, i64 0
store float %622, float* %623
%624 = getelementptr inbounds [3 x float], [3 x float]* %577, i64 0, i64 1
%625 = load float, float* %624
%626 = load float, float* %17
%627 = tail call float @llvm.fmuladd.f32(float %625, float %626, float 0.000000e+00)
%628 = getelementptr inbounds [3 x float], [3 x float]* %583, i64 0, i64 1
%629 = load float, float* %628
%630 = load float, float* %18
%631 = tail call float @llvm.fmuladd.f32(float %629, float %630, float %627)
%632 = getelementptr inbounds [3 x float], [3 x float]* %589, i64 0, i64 1
%633 = load float, float* %632
%634 = load float, float* %19
%635 = tail call float @llvm.fmuladd.f32(float %633, float %634, float %631)
%636 = getelementptr inbounds [3 x float], [3 x float]* %594, i64 0, i64 1
%637 = load float, float* %636
%638 = load float, float* %20
%639 = tail call float @llvm.fmuladd.f32(float %637, float %638, float %635)
%640 = getelementptr inbounds [3 x float], [3 x float]* %599, i64 0, i64 1
%641 = load float, float* %640
%642 = load float, float* %21
%643 = tail call float @llvm.fmuladd.f32(float %641, float %642, float %639)
%644 = getelementptr inbounds [3 x float], [3 x float]* %604, i64 0, i64 1
%645 = load float, float* %644
%646 = load float, float* %22
%647 = tail call float @llvm.fmuladd.f32(float %645, float %646, float %643)
%648 = getelementptr inbounds [3 x float], [3 x float]* %576, i64 0, i64 1
%649 = load float, float* %648
%650 = load float, float* %23
%651 = tail call float @llvm.fmuladd.f32(float %649, float %650, float %647)
%652 = getelementptr inbounds [3 x float], [3 x float]* %613, i64 0, i64 1
%653 = load float, float* %652
%654 = load float, float* %24
%655 = tail call float @llvm.fmuladd.f32(float %653, float %654, float %651)
%656 = getelementptr inbounds [3 x float], [3 x float]* %618, i64 0, i64 1
%657 = load float, float* %656
%658 = load float, float* %25
%659 = tail call float @llvm.fmuladd.f32(float %657, float %658, float %655)
%660 = getelementptr inbounds [3 x float], [3 x float]* %575, i64 0, i64 1
store float %659, float* %660
%661 = getelementptr inbounds [3 x float], [3 x float]* %577, i64 0, i64 2
%662 = load float, float* %661
%663 = load float, float* %17
%664 = tail call float @llvm.fmuladd.f32(float %662, float %663, float 0.000000e+00)
%665 = getelementptr inbounds [3 x float], [3 x float]* %583, i64 0, i64 2
%666 = load float, float* %665
%667 = load float, float* %18
%668 = tail call float @llvm.fmuladd.f32(float %666, float %667, float %664)
%669 = getelementptr inbounds [3 x float], [3 x float]* %589, i64 0, i64 2
%670 = load float, float* %669
%671 = load float, float* %19
%672 = tail call float @llvm.fmuladd.f32(float %670, float %671, float %668)
%673 = getelementptr inbounds [3 x float], [3 x float]* %594, i64 0, i64 2
%674 = load float, float* %673
%675 = load float, float* %20
%676 = tail call float @llvm.fmuladd.f32(float %674, float %675, float %672)
%677 = getelementptr inbounds [3 x float], [3 x float]* %599, i64 0, i64 2
%678 = load float, float* %677
%679 = load float, float* %21
%680 = tail call float @llvm.fmuladd.f32(float %678, float %679, float %676)
%681 = getelementptr inbounds [3 x float], [3 x float]* %604, i64 0, i64 2
%682 = load float, float* %681
%683 = load float, float* %22
%684 = tail call float @llvm.fmuladd.f32(float %682, float %683, float %680)
%685 = getelementptr inbounds [3 x float], [3 x float]* %576, i64 0, i64 2
%686 = load float, float* %685
%687 = load float, float* %23
%688 = tail call float @llvm.fmuladd.f32(float %686, float %687, float %684)
%689 = getelementptr inbounds [3 x float], [3 x float]* %613, i64 0, i64 2
%690 = load float, float* %689
%691 = load float, float* %24
%692 = tail call float @llvm.fmuladd.f32(float %690, float %691, float %688)
%693 = getelementptr inbounds [3 x float], [3 x float]* %618, i64 0, i64 2
%694 = load float, float* %693
%695 = load float, float* %25
%696 = tail call float @llvm.fmuladd.f32(float %694, float %695, float %692)
%697 = getelementptr inbounds [3 x float], [3 x float]* %575, i64 0, i64 2
store float %696, float* %697
%698 = icmp eq i64 %582, %16
br i1 %698, label %699, label %573
699: ; preds = %573, %569, %37
%700 = phi i64 [ %38, %37 ], [ %46, %569 ], [ %46, %573 ]
%701 = icmp eq i64 %700, %15
br i1 %701, label %572, label %35
}