#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 int int32_t;

/* Variables and functions */
void mload(int32_t order, int32_t awins, int32_t awinf, float speech[],
           float phi[], float psi[]) {
  int32_t start;
  int i;
  int r;
  start = awins + order;
  for (r = 1; r <= order; r++) {
    phi[r - 1] = 0.0f;
    for (i = start; i <= awinf; i++)
      phi[r - 1] += speech[i - 2] * speech[i - r - 1];
  }
  psi[order - 1] = 0.0f;
  for (i = start - 1; i < awinf; i++)
    psi[order - 1] += speech[i] * speech[i - order];
  for (r = 1; r < order; r++) {
    for (i = 1; i <= r; i++) {
      phi[i * order + r] = phi[(i - 1) * order + r - 1] -
                           speech[awinf - (r + 1)] * speech[awinf - (i + 1)] +
                           speech[start - (r + 2)] * speech[start - (i + 2)];
    }
  }
  for (i = 0; i < order - 1; i++) {
    psi[i] = phi[i + 1] - speech[start - 2] * speech[start - i - 3] +
             speech[awinf - 1] * speech[awinf - i - 2];
  }
}


x86 assembly (clang, -O0):
<mload>:
push   %rbp
mov    %rsp,%rbp
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    -0x8(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     11c3 <mload+0xc3>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11b0 <mload+0xb0>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1150 <mload+0x50>
jmp    11b5 <mload+0xb5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1129 <mload+0x29>
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1239 <mload+0x139>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e1 <mload+0xe1>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    132b <mload+0x22b>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1318 <mload+0x218>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    $0x2,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x2,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1253 <mload+0x153>
jmp    131d <mload+0x21d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1240 <mload+0x140>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13db <mload+0x2db>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1332 <mload+0x232>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mload>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rsi,%rax
mov    %rsi,-0x40(%rsp)
lea    (%rsi,%rdi,1),%r13d
mov    %rdi,-0x60(%rsp)
test   %edi,%edi
jle    11ca <mload+0xca>
movslq %r13d,%rax
mov    -0x60(%rsp),%rsi
lea    0x1(%rsi),%r10d
lea    (%rcx,%rax,4),%r12
add    $0xfffffffffffffff8,%r12
mov    %edx,%esi
sub    %eax,%esi
shl    $0x20,%rax
movabs $0xfffffffe00000000,%r11
ff ff ff
add    %rax,%r11
add    $0x1,%esi
mov    $0x1,%ebp
movabs $0xffffffff00000000,%r15
ff ff ff
movabs $0x100000000,%r14
jmp    117c <mload+0x7c>
xchg   %ax,%ax
add    $0x1,%rbp
add    %r15,%r11
cmp    %r10,%rbp
je     11ca <mload+0xca>
movl   $0x0,-0x4(%r8,%rbp,4)
cmp    %edx,%r13d
jg     1170 <mload+0x70>
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    %r11,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r12,%rax,4),%xmm1
mov    %rbx,%rdi
sar    $0x1e,%rdi
mulss  (%rcx,%rdi,1),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%r8,%rbp,4)
add    %r14,%rbx
add    $0x1,%rax
cmp    %eax,%esi
jne    11a0 <mload+0xa0>
jmp    1170 <mload+0x70>
mov    -0x60(%rsp),%r10
movslq %r10d,%rdi
lea    -0x1(%rdi),%rbx
movl   $0x0,-0x4(%r9,%rdi,4)
cmp    %edx,%r13d
jg     122d <mload+0x12d>
lea    -0x1(%r13),%eax
movslq %eax,%rsi
lea    (%rcx,%rsi,4),%rax
sub    %rdi,%rsi
lea    (%rcx,%rsi,4),%rbp
mov    %edx,%esi
sub    -0x40(%rsp),%esi
sub    %r10d,%esi
add    $0x1,%esi
xorps  %xmm0,%xmm0
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm1
mulss  0x0(%rbp,%rdi,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r9,%rbx,4)
add    $0x1,%rdi
cmp    %edi,%esi
jne    1210 <mload+0x110>
mov    %r13,-0x30(%rsp)
cmp    $0x2,%r10d
jl     16a0 <mload+0x5a0>
mov    %rbx,0x8(%rsp)
mov    %r9,-0x68(%rsp)
mov    -0x30(%rsp),%rax
add    $0xfffffffe,%eax
mov    %eax,-0xc(%rsp)
movslq %edx,%rdi
mov    %r10d,%r12d
mov    -0x40(%rsp),%rsi
lea    -0x2(%rsi),%eax
lea    0x1(%r12),%rbp
mov    %rbp,0x50(%rsp)
lea    0x4(%r8,%r12,4),%rbp
lea    0x4(,%r12,4),%rbx
mov    %rbx,0x40(%rsp)
mov    %eax,-0x44(%rsp)
cltq
mov    %rax,0x30(%rsp)
lea    0x4(%rcx,%rax,4),%rax
mov    %rax,0x28(%rsp)
lea    0x4(%rcx),%rax
mov    %rax,0x20(%rsp)
lea    -0x2(%rdi),%rax
mov    %rax,0x18(%rsp)
mov    %rdi,-0x8(%rsp)
lea    -0x4(%rcx,%rdi,4),%r14
mov    %rdx,%rax
mov    %rdx,-0x70(%rsp)
lea    -0x2(%rdx),%eax
mov    %rax,-0x28(%rsp)
lea    -0x3(%rsi,%r10,1),%eax
mov    %rax,0x10(%rsp)
lea    (%r10,%r10,1),%eax
mov    %eax,-0x14(%rsp)
movaps 0xd2a(%rip),%xmm0
lea    0x0(,%r12,8),%r9
lea    -0x2(%rsi,%r10,1),%eax
mov    %eax,-0x10(%rsp)
lea    0x4(%r8),%rax
mov    %rax,-0x38(%rsp)
mov    $0x2,%r13d
mov    $0x1,%ebx
xor    %esi,%esi
mov    %rbp,0x48(%rsp)
mov    %rbp,(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    0x40(%rsp),%rax
imul   %rsi,%rax
add    0x48(%rsp),%rax
mov    0x50(%rsp),%rdx
mov    %rsi,-0x78(%rsp)
add    %rsi,%rdx
lea    (%r8,%rdx,4),%rdi
cmp    %rdi,%rax
mov    %rdi,%r11
cmovb  %rax,%r11
cmova  %rax,%rdi
mov    -0xc(%rsp),%eax
sub    %ebx,%eax
mov    %ebx,%edx
not    %edx
add    -0x70(%rsp),%edx
movslq %edx,%r15
movslq %eax,%rsi
mov    $0x1,%r10d
mov    %rbx,-0x58(%rsp)
cmp    $0x2,%rbx
jae    1420 <mload+0x320>
lea    -0x1(%r10),%edi
imul   -0x60(%rsp),%edi
add    -0x78(%rsp),%edi
mov    -0x10(%rsp),%eax
mov    %eax,%edx
sub    %r10d,%edx
mov    %r12,%rax
imul   %r10,%rax
mov    -0x38(%rsp),%rbp
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
neg    %r10
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbx,1),%ebp
movslq %ebp,%rbp
movss  (%rcx,%r15,4),%xmm1
mulss  (%r14,%r10,4),%xmm1
movss  (%r8,%rbp,4),%xmm2
subss  %xmm1,%xmm2
movss  (%rcx,%rsi,4),%xmm1
movslq %edx,%rdx
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rax,%rbx,4)
add    %r12,%rbx
add    $0xffffffff,%edx
add    $0xffffffffffffffff,%r10
mov    %r13,%rbp
add    %r10,%rbp
jne    13a0 <mload+0x2a0>
mov    -0x58(%rsp),%rbx
add    $0x1,%rbx
add    $0x1,%r13
mov    -0x78(%rsp),%rsi
add    $0x1,%rsi
addq   $0x4,(%rsp)
addq   $0x4,-0x38(%rsp)
cmp    %r12,%rbx
jne    1310 <mload+0x210>
jmp    160e <mload+0x50e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x1,%r10d
cmpl   $0x1,-0x60(%rsp)
jne    1366 <mload+0x266>
mov    -0x78(%rsp),%rdx
lea    (%rdx,%rdx,1),%eax
mov    $0x1,%r10d
cmp    %edx,%eax
jl     1366 <mload+0x266>
mov    -0x78(%rsp),%rax
shr    $0x20,%rax
mov    $0x1,%r10d
jne    1366 <mload+0x266>
mov    -0x44(%rsp),%ebx
mov    %ebx,%edx
sub    -0x78(%rsp),%edx
mov    $0x1,%r10d
cmp    %ebx,%edx
jg     1366 <mload+0x266>
mov    $0x1,%r10d
test   %rax,%rax
jne    1366 <mload+0x266>
add    $0x4,%rdi
mov    0x30(%rsp),%rax
mov    -0x78(%rsp),%rbp
sub    %rbp,%rax
lea    (%rcx,%rax,4),%r10
mov    -0x44(%rsp),%edx
sub    %ebp,%edx
movslq %edx,%rdx
mov    0x18(%rsp),%rbx
sub    %rbp,%rbx
mov    -0x28(%rsp),%rax
sub    %ebp,%eax
cmp    0x28(%rsp),%r11
setb   -0x50(%rsp)
cmp    %r10,%rdi
lea    (%rcx,%rdx,4),%r10
mov    0x20(%rsp),%rbp
lea    0x0(%rbp,%rdx,4),%rdx
lea    (%rcx,%rbx,4),%rbx
mov    %rbx,0x38(%rsp)
seta   -0x20(%rsp)
cltq
cmp    %rdx,%r11
setb   %bl
cmp    %r10,%rdi
seta   -0x79(%rsp)
cmp    %r14,%r11
setb   -0x7a(%rsp)
cmp    0x38(%rsp),%rdi
lea    0x0(%rbp,%rax,4),%rdx
seta   %bpl
cmp    %rdx,%r11
lea    (%rcx,%rax,4),%rdx
setb   %al
cmp    %rdx,%rdi
seta   %dil
mov    $0x1,%r10d
mov    -0x20(%rsp),%dl
test   %dl,-0x50(%rsp)
jne    1366 <mload+0x266>
mov    $0x1,%r10d
and    -0x79(%rsp),%bl
jne    1366 <mload+0x266>
mov    $0x1,%r10d
and    %bpl,-0x7a(%rsp)
jne    1366 <mload+0x266>
mov    $0x1,%r10d
and    %dil,%al
jne    1366 <mload+0x266>
mov    -0x58(%rsp),%r10
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
mov    %rax,-0x50(%rsp)
mov    %r10,%rdx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,-0x20(%rsp)
or     $0x1,%r10
movss  (%rcx,%r15,4),%xmm1
shufps $0x0,%xmm1,%xmm1
xorps  %xmm0,%xmm1
movss  (%rcx,%rsi,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mov    (%rsp),%rax
mov    -0x78(%rsp),%rdx
xor    %r11d,%r11d
mov    0x10(%rsp),%rbp
mov    %r9,%rdi
mov    -0x14(%rsp),%r9d
movslq %edx,%rdx
movsd  (%r8,%rdx,4),%xmm3
movsd  -0x8(%r14,%r11,4),%xmm4
shufps $0xe1,%xmm4,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm3,%xmm4
lea    0x0(%rbp,%r11,1),%ebx
movslq %ebx,%rbx
movsd  -0x4(%rcx,%rbx,4),%xmm3
shufps $0xe1,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm4,%xmm3
movlps %xmm3,(%rax)
add    $0xfffffffffffffffe,%r11
add    %r9d,%edx
add    %rdi,%rax
cmp    %r11,-0x50(%rsp)
jne    15b0 <mload+0x4b0>
mov    -0x20(%rsp),%rax
cmp    %rax,-0x58(%rsp)
mov    %rdi,%r9
jne    1366 <mload+0x266>
jmp    13e4 <mload+0x2e4>
mov    -0x60(%rsp),%r11
cmp    $0x2,%r11d
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%r12
mov    0x8(%rsp),%rax
jl     16a0 <mload+0x5a0>
movslq -0x30(%rsp),%r9
lea    (%rcx,%r9,4),%r13
add    $0xfffffffffffffff8,%r13
mov    %eax,%r15d
cmp    $0x4,%eax
jae    16af <mload+0x5af>
xor    %ebp,%ebp
xor    %edi,%edi
lea    (%r12,%rdi,1),%eax
add    $0xfffffffe,%eax
mov    -0x30(%rsp),%rdx
add    %edx,%edi
add    $0xfffffffd,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%r13),%xmm0
movslq %edi,%rdi
mulss  (%rcx,%rdi,4),%xmm0
movss  0x4(%r8,%rbp,4),%xmm1
subss  %xmm0,%xmm1
movss  (%r14),%xmm0
cltq
mulss  (%rcx,%rax,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rbp,4)
lea    0x1(%rbp),%rdx
add    $0xffffffff,%eax
add    $0xffffffff,%edi
mov    %rdx,%rbp
cmp    %rdx,%r15
jne    1660 <mload+0x560>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r15),%r10
mov    -0x40(%rsp),%rax
lea    (%rax,%r11,1),%ebx
add    $0xfffffffd,%ebx
mov    %ebx,%eax
sub    %r10d,%eax
xor    %ebp,%ebp
cmp    %ebx,%eax
jg     163f <mload+0x53f>
mov    %r10,%rax
shr    $0x20,%rax
jne    163f <mload+0x53f>
mov    -0x28(%rsp),%rdx
mov    %edx,%edi
sub    %r10d,%edi
cmp    %edx,%edi
jg     163f <mload+0x53f>
mov    $0x0,%edi
test   %rax,%rax
jne    1641 <mload+0x541>
add    $0xfffffffffffffffe,%r9
addq   $0xffffffffffffffff,-0x8(%rsp)
lea    (%rsi,%r15,4),%rax
lea    (%r8,%r15,4),%r10
add    $0x4,%r10
lea    -0x2(%r12),%edi
mov    %r11,%rbp
movslq %edi,%r11
lea    0x1(%r11),%rdx
sub    %r15,%rdx
mov    -0x40(%rsp),%rdi
add    %ebp,%edi
add    $0xfffffffd,%edi
movslq %edi,%rdi
mov    %rsi,%rbp
lea    0x1(%rdi),%r12
sub    %r15,%r12
cmp    %rsi,%r10
lea    0x4(%r8),%r10
seta   -0x78(%rsp)
cmp    %rax,%r10
lea    0x4(%rcx,%r11,4),%r10
setb   -0x50(%rsp)
cmp    %rsi,%r10
seta   %sil
lea    (%rcx,%rdx,4),%rdx
cmp    %rax,%rdx
mov    -0x8(%rsp),%rdx
lea    0x4(%rcx,%rdx,4),%rdx
lea    0x4(%rcx,%rdi,4),%rdi
setb   -0x58(%rsp)
cmp    %rbp,%rdx
seta   %r10b
cmp    %rax,%r14
setb   -0x38(%rsp)
cmp    %rbp,%rdi
lea    (%rcx,%r12,4),%rdx
seta   %r11b
cmp    %rax,%rdx
lea    0x4(%rcx,%r9,4),%rdx
setb   %r12b
cmp    %rbp,%rdx
seta   %r9b
cmp    %rax,%r13
setb   %al
xor    %ebp,%ebp
mov    -0x50(%rsp),%dl
test   %dl,-0x78(%rsp)
jne    186b <mload+0x76b>
and    -0x58(%rsp),%sil
jne    186b <mload+0x76b>
and    -0x38(%rsp),%r10b
jne    186b <mload+0x76b>
and    %r12b,%r11b
jne    186b <mload+0x76b>
mov    $0x0,%edi
and    %al,%r9b
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%r12
jne    1641 <mload+0x541>
mov    %r15d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,%rdi
movss  0x0(%r13),%xmm0
shufps $0x0,%xmm0,%xmm0
xorps  0x7f7(%rip),%xmm0
neg    %rdi
movss  (%r14),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %eax,%eax
mov    -0x28(%rsp),%rdx
nopl   0x0(%rax)
movups 0x4(%r8,%rax,4),%xmm2
movslq %ebx,%rbx
movups -0xc(%rcx,%rbx,4),%xmm3
shufps $0x1b,%xmm3,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movslq %edx,%rdx
movups -0xc(%rcx,%rdx,4),%xmm2
shufps $0x1b,%xmm2,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm3,%xmm2
movups %xmm2,(%rsi,%rax,4)
add    $0x4,%rax
add    $0xfffffffc,%edx
add    $0xfffffffc,%ebx
cmp    %rax,%rbp
jne    1820 <mload+0x720>
cmp    %r15,%rbp
jne    1641 <mload+0x541>
jmp    16a0 <mload+0x5a0>
xor    %edi,%edi
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%r12
jmp    1641 <mload+0x541>

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

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