int transform(float p_matrix[4][4], float p_vectors[][4], float p_outputs[][4],
              int length) {
  int i, j, k;
  for (i = 0; i < length; i++) {
    for (j = 0; j < 4; j++) {
      for (k = 0; k < 4; k++) {
        p_outputs[i][j] += (p_matrix[j][k] * p_vectors[i][k]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<transform>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11d1 <transform+0xd1>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    11be <transform+0xbe>
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    11ab <transform+0xab>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    113e <transform+0x3e>
jmp    11b0 <transform+0xb0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <transform+0x2d>
jmp    11c3 <transform+0xc3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <transform+0x1a>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<transform>:
push   %rbx
test   %ecx,%ecx
jle    196c <transform+0x86c>
mov    %ecx,%r9d
cmp    $0x4,%ecx
jae    1118 <transform+0x18>
xor    %ecx,%ecx
jmp    17f8 <transform+0x6f8>
mov    %r9,%r8
shl    $0x4,%r8
lea    (%rdx,%r8,1),%rcx
lea    0x40(%rdi),%rax
cmp    %rdx,%rax
seta   %r11b
lea    (%rsi,%r8,1),%rax
cmp    %rdi,%rcx
seta   %bl
cmp    %rdx,%rax
seta   %al
cmp    %rsi,%rcx
seta   %r10b
xor    %ecx,%ecx
test   %bl,%r11b
jne    17f8 <transform+0x6f8>
and    %r10b,%al
jne    17f8 <transform+0x6f8>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    0x3c(%rdx),%r11
lea    0x3c(%rsi),%r10
and    $0xffffffffffffffc0,%r8
xor    %eax,%eax
nopl   (%rax)
movss  (%rdi),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  -0x3c(%r10,%rax,1),%xmm2
movss  -0x2c(%r10,%rax,1),%xmm1
unpcklps %xmm1,%xmm2
movss  -0x1c(%r10,%rax,1),%xmm1
movss  -0xc(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm1
movlhps %xmm1,%xmm2
mulps  %xmm0,%xmm2
movss  -0x3c(%r11,%rax,1),%xmm1
movss  -0x2c(%r11,%rax,1),%xmm0
unpcklps %xmm0,%xmm1
movss  -0x1c(%r11,%rax,1),%xmm0
movss  -0xc(%r11,%rax,1),%xmm3
unpcklps %xmm3,%xmm0
movlhps %xmm0,%xmm1
addps  %xmm2,%xmm1
movss  %xmm1,-0x3c(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movss  %xmm0,-0x2c(%r11,%rax,1)
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movss  %xmm0,-0x1c(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movss  %xmm0,-0xc(%r11,%rax,1)
movss  0x4(%rdi),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  -0x38(%r10,%rax,1),%xmm0
movss  -0x28(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm0
movss  -0x18(%r10,%rax,1),%xmm3
movss  -0x8(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  %xmm0,-0x3c(%r11,%rax,1)
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movss  %xmm1,-0x2c(%r11,%rax,1)
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movss  %xmm1,-0x1c(%r11,%rax,1)
movaps %xmm0,%xmm1
shufps $0xff,%xmm0,%xmm1
movss  %xmm1,-0xc(%r11,%rax,1)
movss  0x8(%rdi),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  -0x34(%r10,%rax,1),%xmm1
movss  -0x24(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm1
movss  -0x14(%r10,%rax,1),%xmm3
movss  -0x4(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  %xmm1,-0x3c(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movss  %xmm0,-0x2c(%r11,%rax,1)
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movss  %xmm0,-0x1c(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movss  %xmm0,-0xc(%r11,%rax,1)
movss  0xc(%rdi),%xmm2
movss  0x10(%rdi),%xmm4
shufps $0x0,%xmm2,%xmm2
movss  (%r10,%rax,1),%xmm0
movss  -0x10(%r10,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  -0x3c(%r10,%rax,1),%xmm3
movss  -0x30(%r10,%rax,1),%xmm8
movss  -0x2c(%r10,%rax,1),%xmm6
unpcklps %xmm6,%xmm3
movss  -0x20(%r10,%rax,1),%xmm6
unpcklps %xmm6,%xmm8
movlhps %xmm5,%xmm8
mulps  %xmm2,%xmm8
addps  %xmm1,%xmm8
shufps $0x0,%xmm4,%xmm4
movss  -0xc(%r10,%rax,1),%xmm1
movss  -0x1c(%r10,%rax,1),%xmm2
unpcklps %xmm1,%xmm2
movlhps %xmm2,%xmm3
mulps  %xmm4,%xmm3
movss  -0x38(%r11,%rax,1),%xmm2
movss  -0x28(%r11,%rax,1),%xmm1
unpcklps %xmm1,%xmm2
movss  -0x18(%r11,%rax,1),%xmm1
movss  -0x8(%r11,%rax,1),%xmm4
unpcklps %xmm4,%xmm1
movlhps %xmm1,%xmm2
addps  %xmm3,%xmm2
movss  %xmm2,-0x38(%r11,%rax,1)
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
movss  %xmm1,-0x28(%r11,%rax,1)
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movss  %xmm1,-0x18(%r11,%rax,1)
movaps %xmm2,%xmm1
shufps $0xff,%xmm2,%xmm1
movss  %xmm1,-0x8(%r11,%rax,1)
movss  0x14(%rdi),%xmm3
shufps $0x0,%xmm3,%xmm3
movss  -0x38(%r10,%rax,1),%xmm1
movss  -0x28(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm1
movss  -0x18(%r10,%rax,1),%xmm4
movss  -0x8(%r10,%rax,1),%xmm5
unpcklps %xmm5,%xmm4
movlhps %xmm4,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm2,%xmm1
movss  %xmm1,-0x38(%r11,%rax,1)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movss  %xmm2,-0x28(%r11,%rax,1)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movss  %xmm2,-0x18(%r11,%rax,1)
movaps %xmm1,%xmm2
shufps $0xff,%xmm1,%xmm2
movss  %xmm2,-0x8(%r11,%rax,1)
movss  0x18(%rdi),%xmm3
shufps $0x0,%xmm3,%xmm3
movss  -0x34(%r10,%rax,1),%xmm2
movss  -0x24(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm2
movss  -0x14(%r10,%rax,1),%xmm4
movss  -0x4(%r10,%rax,1),%xmm5
unpcklps %xmm5,%xmm4
movlhps %xmm4,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movss  %xmm2,-0x38(%r11,%rax,1)
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
movss  %xmm1,-0x28(%r11,%rax,1)
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movss  %xmm1,-0x18(%r11,%rax,1)
movaps %xmm2,%xmm1
shufps $0xff,%xmm2,%xmm1
movss  %xmm1,-0x8(%r11,%rax,1)
movss  0x1c(%rdi),%xmm4
movss  0x20(%rdi),%xmm5
shufps $0x0,%xmm4,%xmm4
movss  (%r10,%rax,1),%xmm1
movss  -0x10(%r10,%rax,1),%xmm6
unpcklps %xmm1,%xmm6
movss  -0x3c(%r10,%rax,1),%xmm3
movss  -0x30(%r10,%rax,1),%xmm1
movss  -0x2c(%r10,%rax,1),%xmm7
unpcklps %xmm7,%xmm3
movss  -0x20(%r10,%rax,1),%xmm7
unpcklps %xmm7,%xmm1
movlhps %xmm6,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
shufps $0x0,%xmm5,%xmm5
movss  -0xc(%r10,%rax,1),%xmm2
movss  -0x1c(%r10,%rax,1),%xmm4
unpcklps %xmm2,%xmm4
movlhps %xmm4,%xmm3
mulps  %xmm5,%xmm3
movss  -0x34(%r11,%rax,1),%xmm2
movss  -0x24(%r11,%rax,1),%xmm4
unpcklps %xmm4,%xmm2
movss  -0x14(%r11,%rax,1),%xmm4
movss  -0x4(%r11,%rax,1),%xmm5
unpcklps %xmm5,%xmm4
movlhps %xmm4,%xmm2
addps  %xmm3,%xmm2
movss  %xmm2,-0x34(%r11,%rax,1)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movss  %xmm3,-0x24(%r11,%rax,1)
movaps %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movss  %xmm3,-0x14(%r11,%rax,1)
movaps %xmm2,%xmm3
shufps $0xff,%xmm2,%xmm3
movss  %xmm3,-0x4(%r11,%rax,1)
movss  0x24(%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
movss  -0x38(%r10,%rax,1),%xmm3
movss  -0x28(%r10,%rax,1),%xmm5
unpcklps %xmm5,%xmm3
movss  -0x18(%r10,%rax,1),%xmm5
movss  -0x8(%r10,%rax,1),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm5,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm2,%xmm3
movss  %xmm3,-0x34(%r11,%rax,1)
movaps %xmm3,%xmm2
shufps $0x55,%xmm3,%xmm2
movss  %xmm2,-0x24(%r11,%rax,1)
movaps %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
movss  %xmm2,-0x14(%r11,%rax,1)
movaps %xmm3,%xmm2
shufps $0xff,%xmm3,%xmm2
movss  %xmm2,-0x4(%r11,%rax,1)
movss  0x28(%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
movss  -0x34(%r10,%rax,1),%xmm2
movss  -0x24(%r10,%rax,1),%xmm5
unpcklps %xmm5,%xmm2
movss  -0x14(%r10,%rax,1),%xmm5
movss  -0x4(%r10,%rax,1),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm5,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm3,%xmm2
movss  %xmm2,-0x34(%r11,%rax,1)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movss  %xmm3,-0x24(%r11,%rax,1)
movaps %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movss  %xmm3,-0x14(%r11,%rax,1)
movaps %xmm2,%xmm3
shufps $0xff,%xmm2,%xmm3
movss  %xmm3,-0x4(%r11,%rax,1)
movss  0x2c(%rdi),%xmm5
movss  0x30(%rdi),%xmm6
shufps $0x0,%xmm5,%xmm5
movss  (%r10,%rax,1),%xmm3
movss  -0x10(%r10,%rax,1),%xmm7
unpcklps %xmm3,%xmm7
movss  -0x3c(%r10,%rax,1),%xmm4
movss  -0x30(%r10,%rax,1),%xmm3
movss  -0x2c(%r10,%rax,1),%xmm0
unpcklps %xmm0,%xmm4
movss  -0x20(%r10,%rax,1),%xmm0
unpcklps %xmm0,%xmm3
movlhps %xmm7,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm2,%xmm3
shufps $0x0,%xmm6,%xmm6
movss  -0xc(%r10,%rax,1),%xmm0
movss  -0x1c(%r10,%rax,1),%xmm2
unpcklps %xmm0,%xmm2
movlhps %xmm2,%xmm4
mulps  %xmm6,%xmm4
movss  -0x30(%r11,%rax,1),%xmm2
movss  -0x20(%r11,%rax,1),%xmm0
unpcklps %xmm0,%xmm2
movss  -0x10(%r11,%rax,1),%xmm0
movss  (%r11,%rax,1),%xmm5
unpcklps %xmm5,%xmm0
movlhps %xmm0,%xmm2
addps  %xmm4,%xmm2
movaps %xmm1,%xmm0
shufps $0x11,%xmm8,%xmm0
movaps %xmm3,%xmm4
unpcklps %xmm2,%xmm4
shufps $0xe2,%xmm4,%xmm0
movaps %xmm8,%xmm4
unpcklps %xmm1,%xmm4
movaps %xmm2,%xmm5
movlhps %xmm3,%xmm5
shufps $0x24,%xmm5,%xmm4
movaps %xmm1,%xmm5
shufps $0x33,%xmm8,%xmm5
movaps %xmm2,%xmm6
unpckhpd %xmm3,%xmm6
unpckhps %xmm2,%xmm3
shufps $0xe2,%xmm3,%xmm5
unpckhps %xmm1,%xmm8
shufps $0x24,%xmm6,%xmm8
movups %xmm8,-0x1c(%r11,%rax,1)
movups %xmm5,-0xc(%r11,%rax,1)
movups %xmm4,-0x3c(%r11,%rax,1)
movups %xmm0,-0x2c(%r11,%rax,1)
movss  0x34(%rdi),%xmm1
shufps $0x0,%xmm1,%xmm1
movss  -0x38(%r10,%rax,1),%xmm0
movss  -0x28(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm0
movss  -0x18(%r10,%rax,1),%xmm3
movss  -0x8(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm2,%xmm0
movss  %xmm0,-0x30(%r11,%rax,1)
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movss  %xmm1,-0x20(%r11,%rax,1)
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movss  %xmm1,-0x10(%r11,%rax,1)
movaps %xmm0,%xmm1
shufps $0xff,%xmm0,%xmm1
movss  %xmm1,(%r11,%rax,1)
movss  0x38(%rdi),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  -0x34(%r10,%rax,1),%xmm1
movss  -0x24(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm1
movss  -0x14(%r10,%rax,1),%xmm3
movss  -0x4(%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  %xmm1,-0x30(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movss  %xmm0,-0x20(%r11,%rax,1)
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movss  %xmm0,-0x10(%r11,%rax,1)
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movss  %xmm0,(%r11,%rax,1)
movss  0x3c(%rdi),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  -0x30(%r10,%rax,1),%xmm2
movss  -0x20(%r10,%rax,1),%xmm3
unpcklps %xmm3,%xmm2
movss  -0x10(%r10,%rax,1),%xmm3
movss  (%r10,%rax,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movss  %xmm2,-0x30(%r11,%rax,1)
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movss  %xmm0,-0x20(%r11,%rax,1)
movaps %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movss  %xmm0,-0x10(%r11,%rax,1)
shufps $0xff,%xmm2,%xmm2
movss  %xmm2,(%r11,%rax,1)
add    $0x40,%rax
cmp    %rax,%r8
jne    1170 <transform+0x70>
cmp    %r9,%rcx
je     196c <transform+0x86c>
sub    %rcx,%r9
shl    $0x4,%rcx
or     $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdi),%xmm0
mulss  -0xc(%rsi,%rcx,1),%xmm0
addss  -0xc(%rdx,%rcx,1),%xmm0
movss  %xmm0,-0xc(%rdx,%rcx,1)
movss  0x4(%rdi),%xmm1
mulss  -0x8(%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0xc(%rdx,%rcx,1)
movss  0x8(%rdi),%xmm0
mulss  -0x4(%rsi,%rcx,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc(%rdx,%rcx,1)
movss  0xc(%rdi),%xmm1
mulss  (%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0xc(%rdx,%rcx,1)
movss  0x10(%rdi),%xmm0
mulss  -0xc(%rsi,%rcx,1),%xmm0
addss  -0x8(%rdx,%rcx,1),%xmm0
movss  %xmm0,-0x8(%rdx,%rcx,1)
movss  0x14(%rdi),%xmm1
mulss  -0x8(%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rcx,1)
movss  0x18(%rdi),%xmm0
mulss  -0x4(%rsi,%rcx,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8(%rdx,%rcx,1)
movss  0x1c(%rdi),%xmm1
mulss  (%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rcx,1)
movss  0x20(%rdi),%xmm0
mulss  -0xc(%rsi,%rcx,1),%xmm0
addss  -0x4(%rdx,%rcx,1),%xmm0
movss  %xmm0,-0x4(%rdx,%rcx,1)
movss  0x24(%rdi),%xmm1
mulss  -0x8(%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rcx,1)
movss  0x28(%rdi),%xmm0
mulss  -0x4(%rsi,%rcx,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rdx,%rcx,1)
movss  0x2c(%rdi),%xmm1
mulss  (%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rcx,1)
movss  0x30(%rdi),%xmm0
mulss  -0xc(%rsi,%rcx,1),%xmm0
addss  (%rdx,%rcx,1),%xmm0
movss  %xmm0,(%rdx,%rcx,1)
movss  0x34(%rdi),%xmm1
mulss  -0x8(%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,1)
movss  0x38(%rdi),%xmm0
mulss  -0x4(%rsi,%rcx,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rcx,1)
movss  0x3c(%rdi),%xmm1
mulss  (%rsi,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,1)
add    $0x10,%rcx
add    $0xffffffffffffffff,%r9
jne    1810 <transform+0x710>
xor    %eax,%eax
pop    %rbx
ret

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

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