void filter_mem2(float *x, float *_num, float *_den, float *y, int N, int ord,
                 float *_mem) {
  float __num[20], __den[20], __mem[20];
  float *num, *den, *mem;
  int i;
  num = (float *)(((int)(__num + 4)) & 0xfffffff0) - 1;
  den = (float *)(((int)(__den + 4)) & 0xfffffff0) - 1;
  mem = (float *)(((int)(__mem + 4)) & 0xfffffff0) - 1;
  for (i = 0; i <= 10; i++)
    num[i] = den[i] = 0;
  for (i = 0; i < 10; i++)
    mem[i] = 0;
  for (i = 0; i < ord + 1; i++) {
    num[i] = _num[i];
    den[i] = _den[i];
  }
  for (i = 0; i < ord; i++)
    mem[i] = _mem[i];
  for (i = 0; i < N; i += 4) {
    __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 4(%4),  %%xmm3\n"
                         "\tmulps  %%xmm0, %%xmm2\n"
                         "\tmulps  %%xmm1, %%xmm3\n"
                         "\tmovaps 20(%3), %%xmm4\n"
                         "\tmulps  %%xmm0, %%xmm4\n"
                         "\taddps  4(%0),  %%xmm2\n"
                         "\tmovaps 20(%4), %%xmm5\n"
                         "\tmulps  %%xmm1, %%xmm5\n"
                         "\taddps  20(%0), %%xmm4\n"
                         "\tsubps  %%xmm3, %%xmm2\n"
                         "\tmovups %%xmm2, (%0)\n"
                         "\tsubps  %%xmm5, %%xmm4\n"
                         "\tmovups %%xmm4, 16(%0)\n"
                         "\tmovss  36(%3), %%xmm2\n"
                         "\tmulss  %%xmm0, %%xmm2\n"
                         "\tmovss  36(%4), %%xmm3\n"
                         "\tmulss  %%xmm1, %%xmm3\n"
                         "\taddss  36(%0), %%xmm2\n"
                         "\tmovss  40(%3), %%xmm4\n"
                         "\tmulss  %%xmm0, %%xmm4\n"
                         "\tmovss  40(%4), %%xmm5\n"
                         "\tmulss  %%xmm1, %%xmm5\n"
                         "\tsubss  %%xmm3, %%xmm2\n"
                         "\tmovss  %%xmm2, 32(%0)       \n"
                         "\tsubss  %%xmm5, %%xmm4\n"
                         "\tmovss  %%xmm4, 36(%0)\n"
                         "\tmovss 4(%1), %%xmm0\n"
                         "\tmovss (%0), %%xmm1\n"
                         "\taddss %%xmm0, %%xmm1\n"
                         "\tmovss %%xmm1, 4(%2)\n"
                         "\tshufps $0x00, %%xmm0, %%xmm0\n"
                         "\tshufps $0x00, %%xmm1, %%xmm1\n"
                         "\tmovaps 4(%3),  %%xmm2\n"
                         "\tmovaps 4(%4),  %%xmm3\n"
                         "\tmulps  %%xmm0, %%xmm2\n"
                         "\tmulps  %%xmm1, %%xmm3\n"
                         "\tmovaps 20(%3), %%xmm4\n"
                         "\tmulps  %%xmm0, %%xmm4\n"
                         "\taddps  4(%0),  %%xmm2\n"
                         "\tmovaps 20(%4), %%xmm5\n"
                         "\tmulps  %%xmm1, %%xmm5\n"
                         "\taddps  20(%0), %%xmm4\n"
                         "\tsubps  %%xmm3, %%xmm2\n"
                         "\tmovups %%xmm2, (%0)\n"
                         "\tsubps  %%xmm5, %%xmm4\n"
                         "\tmovups %%xmm4, 16(%0)\n"
                         "\tmovss  36(%3), %%xmm2\n"
                         "\tmulss  %%xmm0, %%xmm2\n"
                         "\tmovss  36(%4), %%xmm3\n"
                         "\tmulss  %%xmm1, %%xmm3\n"
                         "\taddss  36(%0), %%xmm2\n"
                         "\tmovss  40(%3), %%xmm4\n"
                         "\tmulss  %%xmm0, %%xmm4\n"
                         "\tmovss  40(%4), %%xmm5\n"
                         "\tmulss  %%xmm1, %%xmm5\n"
                         "\tsubss  %%xmm3, %%xmm2\n"
                         "\tmovss  %%xmm2, 32(%0)       \n"
                         "\tsubss  %%xmm5, %%xmm4\n"
                         "\tmovss  %%xmm4, 36(%0)\n"
                         "\tmovss 8(%1), %%xmm0\n"
                         "\tmovss (%0), %%xmm1\n"
                         "\taddss %%xmm0, %%xmm1\n"
                         "\tmovss %%xmm1, 8(%2)\n"
                         "\tshufps $0x00, %%xmm0, %%xmm0\n"
                         "\tshufps $0x00, %%xmm1, %%xmm1\n"
                         "\tmovaps 4(%3),  %%xmm2\n"
                         "\tmovaps 4(%4),  %%xmm3\n"
                         "\tmulps  %%xmm0, %%xmm2\n"
                         "\tmulps  %%xmm1, %%xmm3\n"
                         "\tmovaps 20(%3), %%xmm4\n"
                         "\tmulps  %%xmm0, %%xmm4\n"
                         "\taddps  4(%0),  %%xmm2\n"
                         "\tmovaps 20(%4), %%xmm5\n"
                         "\tmulps  %%xmm1, %%xmm5\n"
                         "\taddps  20(%0), %%xmm4\n"
                         "\tsubps  %%xmm3, %%xmm2\n"
                         "\tmovups %%xmm2, (%0)\n"
                         "\tsubps  %%xmm5, %%xmm4\n"
                         "\tmovups %%xmm4, 16(%0)\n"
                         "\tmovss  36(%3), %%xmm2\n"
                         "\tmulss  %%xmm0, %%xmm2\n"
                         "\tmovss  36(%4), %%xmm3\n"
                         "\tmulss  %%xmm1, %%xmm3\n"
                         "\taddss  36(%0), %%xmm2\n"
                         "\tmovss  40(%3), %%xmm4\n"
                         "\tmulss  %%xmm0, %%xmm4\n"
                         "\tmovss  40(%4), %%xmm5\n"
                         "\tmulss  %%xmm1, %%xmm5\n"
                         "\tsubss  %%xmm3, %%xmm2\n"
                         "\tmovss  %%xmm2, 32(%0)       \n"
                         "\tsubss  %%xmm5, %%xmm4\n"
                         "\tmovss  %%xmm4, 36(%0)\n"
                         "\tmovss 12(%1), %%xmm0\n"
                         "\tmovss (%0), %%xmm1\n"
                         "\taddss %%xmm0, %%xmm1\n"
                         "\tmovss %%xmm1, 12(%2)\n"
                         "\tshufps $0x00, %%xmm0, %%xmm0\n"
                         "\tshufps $0x00, %%xmm1, %%xmm1\n"
                         "\tmovaps 4(%3),  %%xmm2\n"
                         "\tmovaps 4(%4),  %%xmm3\n"
                         "\tmulps  %%xmm0, %%xmm2\n"
                         "\tmulps  %%xmm1, %%xmm3\n"
                         "\tmovaps 20(%3), %%xmm4\n"
                         "\tmulps  %%xmm0, %%xmm4\n"
                         "\taddps  4(%0),  %%xmm2\n"
                         "\tmovaps 20(%4), %%xmm5\n"
                         "\tmulps  %%xmm1, %%xmm5\n"
                         "\taddps  20(%0), %%xmm4\n"
                         "\tsubps  %%xmm3, %%xmm2\n"
                         "\tmovups %%xmm2, (%0)\n"
                         "\tsubps  %%xmm5, %%xmm4\n"
                         "\tmovups %%xmm4, 16(%0)\n"
                         "\tmovss  36(%3), %%xmm2\n"
                         "\tmulss  %%xmm0, %%xmm2\n"
                         "\tmovss  36(%4), %%xmm3\n"
                         "\tmulss  %%xmm1, %%xmm3\n"
                         "\taddss  36(%0), %%xmm2\n"
                         "\tmovss  40(%3), %%xmm4\n"
                         "\tmulss  %%xmm0, %%xmm4\n"
                         "\tmovss  40(%4), %%xmm5\n"
                         "\tmulss  %%xmm1, %%xmm5\n"
                         "\tsubss  %%xmm3, %%xmm2\n"
                         "\tmovss  %%xmm2, 32(%0)       \n"
                         "\tsubss  %%xmm5, %%xmm4\n"
                         "\tmovss  %%xmm4, 36(%0)\n"
                         :
                         : "r"(mem), "r"(x + i), "r"(y + i), "r"(num), "r"(den)
                         : "memory");
  }
  for (i = 0; i < ord; i++)
    _mem[i] = mem[i];
}


x86 assembly (clang, -O0):
<filter_mem2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
lea    -0x80(%rbp),%rax
add    $0x10,%rax
and    $0xfffffff0,%eax
mov    %eax,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x128(%rbp)
lea    -0xd0(%rbp),%rax
add    $0x10,%rax
and    $0xfffffff0,%eax
mov    %eax,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x130(%rbp)
lea    -0x120(%rbp),%rax
add    $0x10,%rax
and    $0xfffffff0,%eax
mov    %eax,%eax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x138(%rbp)
movl   $0x0,-0x13c(%rbp)
cmpl   $0xa,-0x13c(%rbp)
jg     11cc <filter_mem2+0xcc>
mov    -0x130(%rbp),%rax
movslq -0x13c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x128(%rbp),%rax
movslq -0x13c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    117f <filter_mem2+0x7f>
movl   $0x0,-0x13c(%rbp)
cmpl   $0xa,-0x13c(%rbp)
jge    120d <filter_mem2+0x10d>
mov    -0x138(%rbp),%rax
movslq -0x13c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    11d6 <filter_mem2+0xd6>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1285 <filter_mem2+0x185>
mov    -0x10(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x128(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x130(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    1217 <filter_mem2+0x117>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12d5 <filter_mem2+0x1d5>
mov    0x10(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x138(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    128f <filter_mem2+0x18f>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1551 <filter_mem2+0x451>
mov    -0x138(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x13c(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x20(%rbp),%rdx
movslq -0x13c(%rbp),%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
mov    -0x128(%rbp),%rsi
mov    -0x130(%rbp),%rdi
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 0x4(%rdi),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rsi),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%rax),%xmm2
movaps 0x14(%rdi),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%rax),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%rax)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%rax)
movss  0x24(%rsi),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%rdi),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%rax),%xmm2
movss  0x28(%rsi),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%rdi),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%rax)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%rax)
movss  0x4(%rcx),%xmm0
movss  (%rax),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rsi),%xmm2
movaps 0x4(%rdi),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rsi),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%rax),%xmm2
movaps 0x14(%rdi),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%rax),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%rax)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%rax)
movss  0x24(%rsi),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%rdi),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%rax),%xmm2
movss  0x28(%rsi),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%rdi),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%rax)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%rax)
movss  0x8(%rcx),%xmm0
movss  (%rax),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rsi),%xmm2
movaps 0x4(%rdi),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rsi),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%rax),%xmm2
movaps 0x14(%rdi),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%rax),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%rax)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%rax)
movss  0x24(%rsi),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%rdi),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%rax),%xmm2
movss  0x28(%rsi),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%rdi),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%rax)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%rax)
movss  0xc(%rcx),%xmm0
movss  (%rax),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rsi),%xmm2
movaps 0x4(%rdi),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rsi),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%rax),%xmm2
movaps 0x14(%rdi),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%rax),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%rax)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%rax)
movss  0x24(%rsi),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%rdi),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%rax),%xmm2
movss  0x28(%rsi),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%rdi),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%rax)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%rax)
mov    -0x13c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x13c(%rbp)
jmp    12df <filter_mem2+0x1df>
movl   $0x0,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15a1 <filter_mem2+0x4a1>
mov    -0x138(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    155b <filter_mem2+0x45b>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<filter_mem2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9d,%r15d
mov    0xf0(%rsp),%r10
lea    0x60(%rsp),%r9
add    $0x10,%r9d
lea    -0x4(%r9),%rbp
lea    0x10(%rsp),%rax
add    $0x10,%eax
lea    -0x4(%rax),%r13
lea    -0x40(%rsp),%r12
add    $0x10,%r12d
movl   $0x0,-0x4(%rax)
movl   $0x0,-0x4(%r9)
movl   $0x0,(%rax)
movl   $0x0,(%r9)
movl   $0x0,0x4(%rax)
movl   $0x0,0x4(%r9)
movl   $0x0,0x8(%rax)
movl   $0x0,0x8(%r9)
movl   $0x0,0xc(%rax)
movl   $0x0,0xc(%r9)
movl   $0x0,0x10(%rax)
movl   $0x0,0x10(%r9)
movl   $0x0,0x14(%rax)
movl   $0x0,0x14(%r9)
movl   $0x0,0x18(%rax)
movl   $0x0,0x18(%r9)
movl   $0x0,0x1c(%rax)
movl   $0x0,0x1c(%r9)
movl   $0x0,0x20(%rax)
movl   $0x0,0x20(%r9)
movl   $0x0,0x24(%rax)
movl   $0x0,0x24(%r9)
lea    -0x4(%r12),%r11
xorps  %xmm0,%xmm0
movups %xmm0,0xc(%r12)
movups %xmm0,-0x4(%r12)
movq   $0x0,0x1c(%r12)
test   %r15d,%r15d
js     121e <filter_mem2+0x11e>
mov    %rbp,-0x70(%rsp)
lea    0x1(%r15),%ebx
cmp    $0x7,%r15d
mov    %r15,-0x50(%rsp)
jae    1226 <filter_mem2+0x126>
xor    %ebp,%ebp
jmp    1418 <filter_mem2+0x318>
xor    %r9d,%r9d
jmp    1549 <filter_mem2+0x449>
lea    (%r9,%rbx,4),%r15
add    $0xfffffffffffffffc,%r15
lea    -0x4(%rax,%rbx,4),%rbp
mov    %rbp,-0x48(%rsp)
lea    (%rsi,%rbx,4),%rbp
mov    %rbp,-0x58(%rsp)
mov    %rbx,-0x60(%rsp)
lea    (%rdx,%rbx,4),%rbx
mov    %rbx,-0x68(%rsp)
mov    -0x70(%rsp),%r14
mov    -0x48(%rsp),%rbp
cmp    %rbp,%r14
setb   -0x77(%rsp)
cmp    %r15,%r13
setb   -0x71(%rsp)
mov    -0x58(%rsp),%rbx
cmp    %rbx,%r14
setb   -0x72(%rsp)
cmp    %rsi,%r15
seta   -0x73(%rsp)
cmp    -0x68(%rsp),%r14
setb   %r14b
cmp    %rdx,%r15
seta   -0x74(%rsp)
cmp    %rbx,%r13
setb   -0x75(%rsp)
mov    %rbp,%rbx
cmp    %rsi,%rbp
seta   -0x76(%rsp)
mov    %r13,-0x58(%rsp)
cmp    -0x68(%rsp),%r13
setb   -0x68(%rsp)
cmp    %rdx,%rbp
seta   %r15b
xor    %ebp,%ebp
mov    -0x71(%rsp),%bl
test   %bl,-0x77(%rsp)
jne    1409 <filter_mem2+0x309>
mov    %r15b,-0x77(%rsp)
mov    -0x73(%rsp),%bl
and    %bl,-0x72(%rsp)
mov    -0x50(%rsp),%r15
mov    -0x58(%rsp),%r13
jne    1413 <filter_mem2+0x313>
and    -0x74(%rsp),%r14b
jne    1413 <filter_mem2+0x313>
mov    -0x76(%rsp),%bl
and    %bl,-0x75(%rsp)
jne    1413 <filter_mem2+0x313>
mov    -0x77(%rsp),%bl
and    %bl,-0x68(%rsp)
mov    -0x60(%rsp),%rbx
jne    1418 <filter_mem2+0x318>
mov    %r8d,-0x68(%rsp)
mov    %ebx,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%r8
mov    %r8,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %r8,%r8
je     13ba <filter_mem2+0x2ba>
movabs $0x3ffffffffffffffc,%r14
ff ff 3f
or     $0x2,%r14
and    %r15,%r14
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
movups (%rsi,%r8,4),%xmm0
movups 0x10(%rsi,%r8,4),%xmm1
movups %xmm0,-0x4(%r9,%r8,4)
movups %xmm1,0xc(%r9,%r8,4)
movups (%rdx,%r8,4),%xmm0
movups 0x10(%rdx,%r8,4),%xmm1
movups %xmm0,-0x4(%rax,%r8,4)
movups %xmm1,0xc(%rax,%r8,4)
movups 0x20(%rsi,%r8,4),%xmm0
movups 0x30(%rsi,%r8,4),%xmm1
movups %xmm0,0x1c(%r9,%r8,4)
movups %xmm1,0x2c(%r9,%r8,4)
movups 0x20(%rdx,%r8,4),%xmm0
movups 0x30(%rdx,%r8,4),%xmm1
movups %xmm0,0x1c(%rax,%r8,4)
movups %xmm1,0x2c(%rax,%r8,4)
add    $0x10,%r8
add    $0xfffffffffffffffe,%r14
jne    1350 <filter_mem2+0x250>
jmp    13bd <filter_mem2+0x2bd>
xor    %r8d,%r8d
test   $0x1,%r15b
mov    -0x50(%rsp),%r15
je     13fa <filter_mem2+0x2fa>
movups (%rsi,%r8,4),%xmm0
movups 0x10(%rsi,%r8,4),%xmm1
mov    -0x70(%rsp),%r14
movups %xmm0,(%r14,%r8,4)
movups %xmm1,0x10(%r14,%r8,4)
movups (%rdx,%r8,4),%xmm0
movups 0x10(%rdx,%r8,4),%xmm1
movups %xmm0,0x0(%r13,%r8,4)
movups %xmm1,0x10(%r13,%r8,4)
cmp    %rbx,%rbp
mov    -0x68(%rsp),%r8d
jne    1418 <filter_mem2+0x318>
jmp    1487 <filter_mem2+0x387>
mov    -0x50(%rsp),%r15
mov    -0x58(%rsp),%r13
mov    -0x60(%rsp),%rbx
mov    %rbp,%r14
not    %r14
test   $0x1,%bl
je     1448 <filter_mem2+0x348>
movss  (%rsi,%rbp,4),%xmm0
mov    -0x70(%rsp),%r15
movss  %xmm0,(%r15,%rbp,4)
mov    -0x50(%rsp),%r15
movss  (%rdx,%rbp,4),%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
or     $0x1,%rbp
add    %rbx,%r14
je     1487 <filter_mem2+0x387>
nopl   (%rax)
movss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,-0x4(%r9,%rbp,4)
movss  (%rdx,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rax,%rbp,4)
movss  0x4(%rsi,%rbp,4),%xmm0
movss  %xmm0,(%r9,%rbp,4)
movss  0x4(%rdx,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rbx
jne    1450 <filter_mem2+0x350>
test   %r15d,%r15d
setg   %r9b
jle    1541 <filter_mem2+0x441>
mov    %r15d,%edx
cmp    $0x8,%r15d
jb     14bb <filter_mem2+0x3bb>
lea    (%r10,%rdx,4),%rax
cmp    %rax,%r11
jae    188a <filter_mem2+0x78a>
lea    (%r12,%rdx,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r10,%rax
jbe    188a <filter_mem2+0x78a>
xor    %esi,%esi
mov    -0x70(%rsp),%rbp
mov    %rsi,%rax
not    %rax
add    %rdx,%rax
mov    %rdx,%rbx
and    $0x3,%rbx
je     14f6 <filter_mem2+0x3f6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r10,%rsi,4),%xmm0
movss  %xmm0,(%r11,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    14e0 <filter_mem2+0x3e0>
cmp    $0x3,%rax
jb     1549 <filter_mem2+0x449>
nopl   0x0(%rax)
movss  (%r10,%rsi,4),%xmm0
movss  %xmm0,-0x4(%r12,%rsi,4)
movss  0x4(%r10,%rsi,4),%xmm0
movss  %xmm0,(%r12,%rsi,4)
movss  0x8(%r10,%rsi,4),%xmm0
movss  %xmm0,0x4(%r12,%rsi,4)
movss  0xc(%r10,%rsi,4),%xmm0
movss  %xmm0,0x8(%r12,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1500 <filter_mem2+0x400>
jmp    1549 <filter_mem2+0x449>
xor    %r9d,%r9d
mov    -0x70(%rsp),%rbp
test   %r8d,%r8d
jle    17ba <filter_mem2+0x6ba>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdi),%xmm0
movss  (%r11),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rbp),%xmm2
movaps 0x4(%r13),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rbp),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%r11),%xmm2
movaps 0x14(%r13),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%r11),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%r11)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%r11)
movss  0x24(%rbp),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%r13),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%r11),%xmm2
movss  0x28(%rbp),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%r13),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%r11)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%r11)
movss  0x4(%rdi),%xmm0
movss  (%r11),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rbp),%xmm2
movaps 0x4(%r13),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rbp),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%r11),%xmm2
movaps 0x14(%r13),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%r11),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%r11)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%r11)
movss  0x24(%rbp),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%r13),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%r11),%xmm2
movss  0x28(%rbp),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%r13),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%r11)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%r11)
movss  0x8(%rdi),%xmm0
movss  (%r11),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rbp),%xmm2
movaps 0x4(%r13),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rbp),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%r11),%xmm2
movaps 0x14(%r13),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%r11),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%r11)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%r11)
movss  0x24(%rbp),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%r13),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%r11),%xmm2
movss  0x28(%rbp),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%r13),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%r11)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%r11)
movss  0xc(%rdi),%xmm0
movss  (%r11),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx)
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps 0x4(%rbp),%xmm2
movaps 0x4(%r13),%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movaps 0x14(%rbp),%xmm4
mulps  %xmm0,%xmm4
addps  0x4(%r11),%xmm2
movaps 0x14(%r13),%xmm5
mulps  %xmm1,%xmm5
addps  0x14(%r11),%xmm4
subps  %xmm3,%xmm2
movups %xmm2,(%r11)
subps  %xmm5,%xmm4
movups %xmm4,0x10(%r11)
movss  0x24(%rbp),%xmm2
mulss  %xmm0,%xmm2
movss  0x24(%r13),%xmm3
mulss  %xmm1,%xmm3
addss  0x24(%r11),%xmm2
movss  0x28(%rbp),%xmm4
mulss  %xmm0,%xmm4
movss  0x28(%r13),%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm2
movss  %xmm2,0x20(%r11)
subss  %xmm5,%xmm4
movss  %xmm4,0x24(%r11)
add    $0x10,%rcx
add    $0x10,%rdi
add    $0x4,%eax
cmp    %r8d,%eax
jl     1560 <filter_mem2+0x460>
test   %r9b,%r9b
je     1974 <filter_mem2+0x874>
mov    %r15d,%eax
cmp    $0x8,%r15d
jb     17e6 <filter_mem2+0x6e6>
lea    (%r12,%rax,4),%rcx
add    $0xfffffffffffffffc,%rcx
cmp    %r10,%rcx
jbe    1864 <filter_mem2+0x764>
lea    (%r10,%rax,4),%rcx
cmp    %rcx,%r11
jae    1864 <filter_mem2+0x764>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1816 <filter_mem2+0x716>
nopw   0x0(%rax,%rax,1)
movss  (%r11,%rcx,4),%xmm0
movss  %xmm0,(%r10,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1800 <filter_mem2+0x700>
cmp    $0x3,%rdx
jb     1974 <filter_mem2+0x874>
movss  -0x4(%r12,%rcx,4),%xmm0
movss  %xmm0,(%r10,%rcx,4)
movss  (%r12,%rcx,4),%xmm0
movss  %xmm0,0x4(%r10,%rcx,4)
movss  0x4(%r12,%rcx,4),%xmm0
movss  %xmm0,0x8(%r10,%rcx,4)
movss  0x8(%r12,%rcx,4),%xmm0
movss  %xmm0,0xc(%r10,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1820 <filter_mem2+0x720>
jmp    1974 <filter_mem2+0x874>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    18b6 <filter_mem2+0x7b6>
xor    %edi,%edi
jmp    1929 <filter_mem2+0x829>
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r14d
and    $0x3,%r14d
cmp    $0x18,%rax
jae    1986 <filter_mem2+0x886>
xor    %eax,%eax
jmp    19f9 <filter_mem2+0x8f9>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x4(%r12,%rdi,4),%xmm0
movups 0xc(%r12,%rdi,4),%xmm1
movups %xmm0,(%r10,%rdi,4)
movups %xmm1,0x10(%r10,%rdi,4)
movups 0x1c(%r12,%rdi,4),%xmm0
movups 0x2c(%r12,%rdi,4),%xmm1
movups %xmm0,0x20(%r10,%rdi,4)
movups %xmm1,0x30(%r10,%rdi,4)
movups 0x3c(%r12,%rdi,4),%xmm0
movups 0x4c(%r12,%rdi,4),%xmm1
movups %xmm0,0x40(%r10,%rdi,4)
movups %xmm1,0x50(%r10,%rdi,4)
movups 0x5c(%r12,%rdi,4),%xmm0
movups 0x6c(%r12,%rdi,4),%xmm1
movups %xmm0,0x60(%r10,%rdi,4)
movups %xmm1,0x70(%r10,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    18c0 <filter_mem2+0x7c0>
test   %rdx,%rdx
je     196b <filter_mem2+0x86b>
lea    (%r10,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r12,%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    1950 <filter_mem2+0x850>
cmp    %rax,%rcx
jne    17e8 <filter_mem2+0x6e8>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rbx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%r10,%rax,4),%xmm0
movups 0x10(%r10,%rax,4),%xmm1
movups %xmm0,-0x4(%r12,%rax,4)
movups %xmm1,0xc(%r12,%rax,4)
movups 0x20(%r10,%rax,4),%xmm0
movups 0x30(%r10,%rax,4),%xmm1
movups %xmm0,0x1c(%r12,%rax,4)
movups %xmm1,0x2c(%r12,%rax,4)
movups 0x40(%r10,%rax,4),%xmm0
movups 0x50(%r10,%rax,4),%xmm1
movups %xmm0,0x3c(%r12,%rax,4)
movups %xmm1,0x4c(%r12,%rax,4)
movups 0x60(%r10,%rax,4),%xmm0
movups 0x70(%r10,%rax,4),%xmm1
movups %xmm0,0x5c(%r12,%rax,4)
movups %xmm1,0x6c(%r12,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rbx
jne    1990 <filter_mem2+0x890>
test   %r14,%r14
je     1a3b <filter_mem2+0x93b>
lea    (%r12,%rax,4),%rbx
add    $0xc,%rbx
lea    (%r10,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rax,%rbp,1),%xmm0
movups (%rax,%rbp,1),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,1)
movups %xmm1,(%rbx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1a20 <filter_mem2+0x920>
cmp    %rdx,%rsi
mov    -0x70(%rsp),%rbp
jne    14c2 <filter_mem2+0x3c2>
jmp    1549 <filter_mem2+0x449>

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

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