void iir_mem2(float *x, float *_den, float *y, int N, int ord, float *_mem) {
  float __den[20], __mem[20];
  float *den, *mem;
  int i;
  den = (float *)(((int)(__den + 4)) & 0xfffffff0) - 1;
  mem = (float *)(((int)(__mem + 4)) & 0xfffffff0) - 1;
  for (i = 0; i <= 10; i++)
    den[i] = 0;
  for (i = 0; i < 10; i++)
    mem[i] = 0;
  for (i = 0; i < ord + 1; i++) {
    den[i] = _den[i];
  }
  for (i = 0; i < ord; i++)
    mem[i] = _mem[i];
  for (i = 0; i < N; i++) {
    __asm__ __volatile__("\tmovss (%1), %%xmm0\n"
                         "\tmovss (%0), %%xmm1\n"
                         "\taddss %%xmm0, %%xmm1\n"
                         "\tmovss %%xmm1, (%2)\n"
                         "\tshufps $0x00, %%xmm0, %%xmm0\n"
                         "\tshufps $0x00, %%xmm1, %%xmm1\n"
                         "\tmovaps 4(%3),  %%xmm2\n"
                         "\tmovaps 20(%3), %%xmm3\n"
                         "\tmulps  %%xmm1, %%xmm2\n"
                         "\tmulps  %%xmm1, %%xmm3\n"
                         "\tmovss  36(%3), %%xmm4\n"
                         "\tmovss  40(%3), %%xmm5\n"
                         "\tmulss  %%xmm1, %%xmm4\n"
                         "\tmulss  %%xmm1, %%xmm5\n"
                         "\tmovaps 4(%0),  %%xmm6\n"
                         "\tsubps  %%xmm2, %%xmm6\n"
                         "\tmovups %%xmm6, (%0)\n"
                         "\tmovaps 20(%0), %%xmm7\n"
                         "\tsubps  %%xmm3, %%xmm7\n"
                         "\tmovups %%xmm7, 16(%0)\n"
                         "\tmovss  36(%0), %%xmm7\n"
                         "\tsubss  %%xmm4, %%xmm7\n"
                         "\tmovss  %%xmm7, 32(%0)       \n"
                         "\txorps  %%xmm2, %%xmm2\n"
                         "\tsubss  %%xmm5, %%xmm2\n"
                         "\tmovss  %%xmm2, 36(%0)\n"
                         :
                         : "r"(mem), "r"(x + i), "r"(y + i), "r"(den)
                         : "memory");
  }
  for (i = 0; i < ord; i++)
    _mem[i] = mem[i];
}


x86 assembly (clang, -O0):
<iir_mem2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
lea    -0x80(%rbp),%rax
add    $0x10,%rax
and    $0xfffffff0,%eax
mov    %eax,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xd8(%rbp)
lea    -0xd0(%rbp),%rax
add    $0x10,%rax
and    $0xfffffff0,%eax
mov    %eax,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xe0(%rbp)
movl   $0x0,-0xe4(%rbp)
cmpl   $0xa,-0xe4(%rbp)
jg     1193 <iir_mem2+0x93>
mov    -0xd8(%rbp),%rax
movslq -0xe4(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    115c <iir_mem2+0x5c>
movl   $0x0,-0xe4(%rbp)
cmpl   $0xa,-0xe4(%rbp)
jge    11d4 <iir_mem2+0xd4>
mov    -0xe0(%rbp),%rax
movslq -0xe4(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    119d <iir_mem2+0x9d>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1229 <iir_mem2+0x129>
mov    -0x10(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    11de <iir_mem2+0xde>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1279 <iir_mem2+0x179>
mov    -0x28(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1233 <iir_mem2+0x133>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133f <iir_mem2+0x23f>
mov    -0xe0(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0xe4(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x18(%rbp),%rdx
movslq -0xe4(%rbp),%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
mov    -0xd8(%rbp),%rsi
movss  (%rcx),%xmm0
movss  (%rax),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rsi),%xmm2
movaps 0x14(%rsi),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movss  0x24(%rsi),%xmm4
movss  0x28(%rsi),%xmm5
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm5
movaps 0x4(%rax),%xmm6
subps  %xmm2,%xmm6
movups %xmm6,(%rax)
movaps 0x14(%rax),%xmm7
subps  %xmm3,%xmm7
movups %xmm7,0x10(%rax)
movss  0x24(%rax),%xmm7
subss  %xmm4,%xmm7
movss  %xmm7,0x20(%rax)
xorps  %xmm2,%xmm2
subss  %xmm5,%xmm2
movss  %xmm2,0x24(%rax)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1283 <iir_mem2+0x183>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    138f <iir_mem2+0x28f>
mov    -0xe0(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xe4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1349 <iir_mem2+0x249>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iir_mem2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    -0x20(%rsp),%rbx
add    $0x10,%ebx
lea    -0x4(%rbx),%r11
lea    -0x70(%rsp),%r15
add    $0x10,%r15d
xorps  %xmm0,%xmm0
movups %xmm0,0x18(%rbx)
movups %xmm0,0xc(%rbx)
movups %xmm0,-0x4(%rbx)
lea    -0x4(%r15),%r10
movups %xmm0,0xc(%r15)
movups %xmm0,-0x4(%r15)
movq   $0x0,0x1c(%r15)
test   %r8d,%r8d
js     1381 <iir_mem2+0x281>
lea    0x1(%r8),%r14d
cmp    $0x7,%r8d
jb     1175 <iir_mem2+0x75>
lea    (%rsi,%r14,4),%rax
cmp    %rax,%r11
jae    11ec <iir_mem2+0xec>
lea    (%rbx,%r14,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    %rsi,%rax
jbe    11ec <iir_mem2+0xec>
xor    %eax,%eax
mov    %rax,%r12
not    %r12
add    %r14,%r12
mov    %r14,%rbp
and    $0x3,%rbp
je     11a5 <iir_mem2+0xa5>
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%r11,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    1190 <iir_mem2+0x90>
cmp    $0x3,%r12
jb     12ce <iir_mem2+0x1ce>
nop
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0xc(%rsi,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    11b0 <iir_mem2+0xb0>
jmp    12ce <iir_mem2+0x1ce>
mov    %ecx,-0x74(%rsp)
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbp
mov    %rbp,%r13
shr    $0x3,%r13
add    $0x1,%r13
mov    %r13d,%ecx
and    $0x3,%ecx
cmp    $0x18,%rbp
jae    1215 <iir_mem2+0x115>
xor    %ebp,%ebp
jmp    1279 <iir_mem2+0x179>
and    $0xfffffffffffffffc,%r13
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rbp,4),%xmm0
movups 0x10(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x4(%rbx,%rbp,4)
movups %xmm1,0xc(%rbx,%rbp,4)
movups 0x20(%rsi,%rbp,4),%xmm0
movups 0x30(%rsi,%rbp,4),%xmm1
movups %xmm0,0x1c(%rbx,%rbp,4)
movups %xmm1,0x2c(%rbx,%rbp,4)
movups 0x40(%rsi,%rbp,4),%xmm0
movups 0x50(%rsi,%rbp,4),%xmm1
movups %xmm0,0x3c(%rbx,%rbp,4)
movups %xmm1,0x4c(%rbx,%rbp,4)
movups 0x60(%rsi,%rbp,4),%xmm0
movups 0x70(%rsi,%rbp,4),%xmm1
movups %xmm0,0x5c(%rbx,%rbp,4)
movups %xmm1,0x6c(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r13
jne    1220 <iir_mem2+0x120>
test   %rcx,%rcx
je     12c1 <iir_mem2+0x1c1>
lea    (%rbx,%rbp,4),%r13
add    $0xc,%r13
lea    (%rsi,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rcx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rbp,%r12,1),%xmm0
movups 0x0(%rbp,%r12,1),%xmm1
movups %xmm0,-0x10(%r13,%r12,1)
movups %xmm1,0x0(%r13,%r12,1)
add    $0x20,%r12
cmp    %r12,%rcx
jne    12a0 <iir_mem2+0x1a0>
cmp    %r14,%rax
mov    -0x74(%rsp),%ecx
jne    1177 <iir_mem2+0x77>
test   %r8d,%r8d
setg   %r14b
jle    1381 <iir_mem2+0x281>
mov    %r8d,%r13d
cmp    $0x8,%r8d
jb     1302 <iir_mem2+0x202>
lea    (%r9,%r13,4),%rax
cmp    %rax,%r10
jae    14ea <iir_mem2+0x3ea>
lea    (%r15,%r13,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r9,%rax
jbe    14ea <iir_mem2+0x3ea>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r13,%rsi
mov    %r13,%rbx
and    $0x3,%rbx
je     1336 <iir_mem2+0x236>
cs nopw 0x0(%rax,%rax,1)
movss  (%r9,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1320 <iir_mem2+0x220>
cmp    $0x3,%rsi
jb     1384 <iir_mem2+0x284>
nopl   0x0(%rax)
movss  (%r9,%rax,4),%xmm0
movss  %xmm0,-0x4(%r15,%rax,4)
movss  0x4(%r9,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  0x8(%r9,%rax,4),%xmm0
movss  %xmm0,0x4(%r15,%rax,4)
movss  0xc(%r9,%rax,4),%xmm0
movss  %xmm0,0x8(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    1340 <iir_mem2+0x240>
jmp    1384 <iir_mem2+0x284>
xor    %r14d,%r14d
test   %ecx,%ecx
jle    1415 <iir_mem2+0x315>
mov    %ecx,%eax
xchg   %ax,%ax
movss  (%rdi),%xmm0
movss  (%r10),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%r11),%xmm2
movaps 0x14(%r11),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movss  0x24(%r11),%xmm4
movss  0x28(%r11),%xmm5
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm5
movaps 0x4(%r10),%xmm6
subps  %xmm2,%xmm6
movups %xmm6,(%r10)
movaps 0x14(%r10),%xmm7
subps  %xmm3,%xmm7
movups %xmm7,0x10(%r10)
movss  0x24(%r10),%xmm7
subss  %xmm4,%xmm7
movss  %xmm7,0x20(%r10)
xorps  %xmm2,%xmm2
subss  %xmm5,%xmm2
movss  %xmm2,0x24(%r10)
add    $0x4,%rdx
add    $0x4,%rdi
add    $0xffffffffffffffff,%rax
jne    1390 <iir_mem2+0x290>
test   %r14b,%r14b
je     15e4 <iir_mem2+0x4e4>
mov    %r8d,%ecx
cmp    $0x8,%r8d
jb     1445 <iir_mem2+0x345>
lea    (%r15,%rcx,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r9,%rax
jbe    14c4 <iir_mem2+0x3c4>
lea    (%r9,%rcx,4),%rax
cmp    %rax,%r10
jae    14c4 <iir_mem2+0x3c4>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     1476 <iir_mem2+0x376>
nopl   0x0(%rax)
movss  (%r10,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1460 <iir_mem2+0x360>
cmp    $0x3,%rdx
jb     15e4 <iir_mem2+0x4e4>
movss  -0x4(%r15,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%r9,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%r9,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%r9,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1480 <iir_mem2+0x380>
jmp    15e4 <iir_mem2+0x4e4>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    151b <iir_mem2+0x41b>
xor    %edi,%edi
jmp    1599 <iir_mem2+0x499>
mov    %ecx,-0x74(%rsp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r12d
and    $0x3,%r12d
cmp    $0x18,%rcx
jae    15f3 <iir_mem2+0x4f3>
xor    %ebp,%ebp
jmp    1669 <iir_mem2+0x569>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x4(%r15,%rdi,4),%xmm0
movups 0xc(%r15,%rdi,4),%xmm1
movups %xmm0,(%r9,%rdi,4)
movups %xmm1,0x10(%r9,%rdi,4)
movups 0x1c(%r15,%rdi,4),%xmm0
movups 0x2c(%r15,%rdi,4),%xmm1
movups %xmm0,0x20(%r9,%rdi,4)
movups %xmm1,0x30(%r9,%rdi,4)
movups 0x3c(%r15,%rdi,4),%xmm0
movups 0x4c(%r15,%rdi,4),%xmm1
movups %xmm0,0x40(%r9,%rdi,4)
movups %xmm1,0x50(%r9,%rdi,4)
movups 0x5c(%r15,%rdi,4),%xmm0
movups 0x6c(%r15,%rdi,4),%xmm1
movups %xmm0,0x60(%r9,%rdi,4)
movups %xmm1,0x70(%r9,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1530 <iir_mem2+0x430>
test   %rdx,%rdx
je     15db <iir_mem2+0x4db>
lea    (%r9,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r15,%rdi,4),%rdi
add    $0xc,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    15c0 <iir_mem2+0x4c0>
cmp    %rcx,%rax
jne    1447 <iir_mem2+0x347>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups (%r9,%rbp,4),%xmm0
movups 0x10(%r9,%rbp,4),%xmm1
movups %xmm0,-0x4(%r15,%rbp,4)
movups %xmm1,0xc(%r15,%rbp,4)
movups 0x20(%r9,%rbp,4),%xmm0
movups 0x30(%r9,%rbp,4),%xmm1
movups %xmm0,0x1c(%r15,%rbp,4)
movups %xmm1,0x2c(%r15,%rbp,4)
movups 0x40(%r9,%rbp,4),%xmm0
movups 0x50(%r9,%rbp,4),%xmm1
movups %xmm0,0x3c(%r15,%rbp,4)
movups %xmm1,0x4c(%r15,%rbp,4)
movups 0x60(%r9,%rbp,4),%xmm0
movups 0x70(%r9,%rbp,4),%xmm1
movups %xmm0,0x5c(%r15,%rbp,4)
movups %xmm1,0x6c(%r15,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1600 <iir_mem2+0x500>
test   %r12,%r12
je     16ab <iir_mem2+0x5ab>
lea    (%r15,%rbp,4),%rsi
add    $0xc,%rsi
lea    (%r9,%rbp,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r12
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r12
jne    1690 <iir_mem2+0x590>
cmp    %r13,%rax
mov    -0x74(%rsp),%ecx
je     1384 <iir_mem2+0x284>
jmp    1304 <iir_mem2+0x204>

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

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