long fir_downsampling_kernel(lenx, x, y, lenh0, h0, T, downfac, k0)
long lenx;
float *x;
float *y;
long lenh0;
float *h0;
float *T;
long downfac;
long *k0;
{
  long ktrans, kx, kStart, ky, kappa;
  kStart = *k0;
  ky = 0;
  ktrans = lenh0 - 1;
  if (ktrans > lenx - 1)
    ktrans = lenx - 1;
  for (kx = *k0; kx <= ktrans; kx += downfac) {
    y[ky] = x[kx] * h0[0];
    for (kappa = 1; kappa <= kx; kappa++) {
      y[ky] += x[kx - kappa] * h0[kappa];
    }
    for (kappa = kx + 1; kappa < lenh0; kappa++) {
      y[ky] += T[lenh0 - 2 + kx + 1 - kappa] * h0[kappa];
    }
    ky++;
    kStart = kx;
  }
  *k0 = kStart;
  for (kx = kStart + downfac; kx <= lenx - 1; kx += downfac) {
    y[ky] = x[kx] * h0[0];
    for (kappa = 1; kappa <= lenh0 - 1; kappa++) {
      y[ky] += x[kx - kappa] * h0[kappa];
    }
    ky++;
    *k0 = kx;
  }
  *k0 = *k0 + downfac;
  *k0 = *k0 - lenx;
  if (lenx >= lenh0 - 1) {
    for (kappa = 0; kappa <= lenh0 - 2; kappa++) {
      T[kappa] = x[lenx + 1 - lenh0 + kappa];
    }
  } else {
    for (kappa = 0; kappa <= lenh0 - 2 - lenx; kappa++) {
      T[kappa] = T[kappa + lenx];
    }
    for (kappa = lenh0 - 1 - lenx; kappa <= lenh0 - 2; kappa++) {
      T[kappa] = x[lenx - 1 + kappa - (lenh0 - 2)];
    }
  }
  return ky;
}


x86 assembly (clang, -O0):
<fir_downsampling_kernel>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jle    1164 <fir_downsampling_kernel+0x64>
mov    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jg     1292 <fir_downsampling_kernel+0x192>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x40(%rbp),%rax
jg     11fe <fir_downsampling_kernel+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11a7 <fir_downsampling_kernel+0xa7>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    126d <fir_downsampling_kernel+0x16d>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
add    -0x40(%rbp),%rcx
add    $0x1,%rcx
sub    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    120a <fir_downsampling_kernel+0x10a>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    0x10(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    116f <fir_downsampling_kernel+0x6f>
mov    -0x48(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
add    0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     136e <fir_downsampling_kernel+0x26e>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1346 <fir_downsampling_kernel+0x246>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    12e8 <fir_downsampling_kernel+0x1e8>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    12a9 <fir_downsampling_kernel+0x1a9>
mov    0x18(%rbp),%rax
mov    (%rax),%rcx
add    0x10(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    0x18(%rbp),%rax
mov    (%rax),%rcx
sub    -0x8(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jl     1400 <fir_downsampling_kernel+0x300>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jg     13fb <fir_downsampling_kernel+0x2fb>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0x1,%rcx
sub    -0x20(%rbp),%rcx
add    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    13af <fir_downsampling_kernel+0x2af>
jmp    14b8 <fir_downsampling_kernel+0x3b8>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x8(%rbp),%rcx
cmp    %rcx,%rax
jg     1450 <fir_downsampling_kernel+0x350>
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
add    -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1408 <fir_downsampling_kernel+0x308>
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jg     14b3 <fir_downsampling_kernel+0x3b3>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
add    -0x58(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    $0x2,%rdx
sub    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1460 <fir_downsampling_kernel+0x360>
jmp    14b8 <fir_downsampling_kernel+0x3b8>
mov    -0x50(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<fir_downsampling_kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r13
mov    0x40(%rsp),%rax
mov    0x38(%rsp),%r10
mov    (%rax),%r15
lea    -0x1(%rcx),%rax
lea    -0x1(%rdi),%r12
mov    %rdi,%rsi
mov    %rdi,-0x20(%rsp)
sub    %rcx,%rsi
mov    %rsi,-0x18(%rsp)
mov    %rax,-0x10(%rsp)
cmovge %rax,%r12
cmp    %r12,%r15
jle    114a <fir_downsampling_kernel+0x4a>
add    %r10,%r15
xor    %eax,%eax
jmp    1279 <fir_downsampling_kernel+0x179>
lea    -0x1(%r15),%rax
mov    %rax,-0x8(%rsp)
lea    -0x4(,%r15,4),%rbx
ff
add    %r13,%rbx
lea    0x0(,%r10,4),%r14
lea    (%r9,%rcx,4),%r11
add    $0xfffffffffffffff8,%r11
xor    %eax,%eax
mov    %r13,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%r13,%r15,4),%xmm0
mulss  (%r8),%xmm0
movss  %xmm0,(%rdx,%rax,4)
test   %r15,%r15
jle    1234 <fir_downsampling_kernel+0x134>
mov    %rax,%rdi
imul   %r10,%rdi
mov    $0x1,%r10d
add    -0x8(%rsp),%rdi
je     120f <fir_downsampling_kernel+0x10f>
mov    %r15,%r13
and    $0xfffffffffffffffe,%r13
neg    %r13
mov    $0x1,%r10d
mov    %rbx,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp),%xmm1
mulss  (%r8,%r10,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  -0x4(%rbp),%xmm0
mulss  0x4(%r8,%r10,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0xfffffffffffffff8,%rbp
lea    (%r10,%r13,1),%rdi
add    $0x2,%rdi
add    $0x2,%r10
cmp    $0x1,%rdi
jne    11d0 <fir_downsampling_kernel+0xd0>
test   $0x1,%r15b
mov    %rsi,%r13
je     1234 <fir_downsampling_kernel+0x134>
mov    %r15,%rdi
sub    %r10,%rdi
movss  0x0(%r13,%rdi,4),%xmm1
mulss  (%r8,%r10,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rax,4)
lea    0x1(%r15),%rdi
mov    %r11,%rbp
cmp    %rcx,%rdi
jge    1261 <fir_downsampling_kernel+0x161>
movss  0x0(%rbp),%xmm1
mulss  (%r8,%rdi,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbp
cmp    %rcx,%rdi
jl     1240 <fir_downsampling_kernel+0x140>
add    $0x1,%rax
mov    0x38(%rsp),%r10
add    %r10,%r15
add    %r14,%rbx
cmp    %r12,%r15
jle    1180 <fir_downsampling_kernel+0x80>
mov    -0x20(%rsp),%rsi
cmp    %rsi,%r15
jge    1363 <fir_downsampling_kernel+0x263>
lea    -0x4(,%r15,4),%r14
ff
add    %r13,%r14
lea    0x0(,%r10,4),%r11
mov    -0x10(%rsp),%r12
mov    %r12,%rbp
and    $0xfffffffffffffffe,%rbp
neg    %rbp
jmp    12c3 <fir_downsampling_kernel+0x1c3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r10,%r15
add    %r11,%r14
cmp    %rsi,%r15
jge    1368 <fir_downsampling_kernel+0x268>
movss  0x0(%r13,%r15,4),%xmm0
mulss  (%r8),%xmm0
movss  %xmm0,(%rdx,%rax,4)
cmp    $0x2,%rcx
jl     12b0 <fir_downsampling_kernel+0x1b0>
mov    $0x1,%ebx
je     132e <fir_downsampling_kernel+0x22e>
mov    $0x1,%ebx
mov    %r14,%rdi
nopl   0x0(%rax)
movss  (%rdi),%xmm1
mulss  (%r8,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  -0x4(%rdi),%xmm0
mulss  0x4(%r8,%rbx,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0xfffffffffffffff8,%rdi
lea    (%rbx,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rbx
cmp    $0x1,%rsi
jne    12f0 <fir_downsampling_kernel+0x1f0>
test   $0x1,%r12b
mov    -0x20(%rsp),%rsi
je     12b0 <fir_downsampling_kernel+0x1b0>
mov    %r15,%rsi
sub    %rbx,%rsi
movss  0x0(%r13,%rsi,4),%xmm1
mov    -0x20(%rsp),%rsi
mulss  (%r8,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
jmp    12b0 <fir_downsampling_kernel+0x1b0>
mov    -0x10(%rsp),%r12
sub    %rsi,%r15
mov    0x40(%rsp),%rdx
mov    %r15,(%rdx)
mov    %r12,%rbx
sub    %rsi,%rbx
jle    1570 <fir_downsampling_kernel+0x470>
lea    -0x2(%rcx),%r8
cmp    %rsi,%r8
jl     13d4 <fir_downsampling_kernel+0x2d4>
cmp    $0x8,%rbx
jb     13b1 <fir_downsampling_kernel+0x2b1>
lea    (%r9,%r12,4),%rdx
cmp    %r9,%rdx
jbe    1650 <fir_downsampling_kernel+0x550>
lea    (%r9,%rbx,4),%rdx
mov    -0x20(%rsp),%rsi
lea    (%r9,%rsi,4),%rsi
cmp    %rdx,%rsi
jae    1650 <fir_downsampling_kernel+0x550>
xor    %edx,%edx
mov    -0x20(%rsp),%rsi
lea    (%r9,%rsi,4),%rsi
nopl   0x0(%rax)
movss  (%rsi,%rdx,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    13c0 <fir_downsampling_kernel+0x2c0>
cmp    %r8,%rbx
mov    -0x20(%rsp),%rsi
jg     1834 <fir_downsampling_kernel+0x734>
cmp    $0x8,%rsi
jb     14cf <fir_downsampling_kernel+0x3cf>
lea    (%r9,%rbx,4),%rdx
lea    0x0(,%rsi,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rdx
jae    140d <fir_downsampling_kernel+0x30d>
lea    (%r9,%r12,4),%rdx
cmp    %r13,%rdx
ja     14cf <fir_downsampling_kernel+0x3cf>
mov    -0x20(%rsp),%rdi
mov    %rdi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     183f <fir_downsampling_kernel+0x73f>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
or     $0x2,%rsi
and    %rbp,%rsi
mov    %rcx,%rdx
sub    %rdi,%rdx
lea    (%r9,%rdx,4),%rdi
add    $0x2c,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%r13,%rdx,4),%xmm0
movups 0x10(%r13,%rdx,4),%xmm1
movups %xmm0,-0x30(%rdi,%rdx,4)
movups %xmm1,-0x20(%rdi,%rdx,4)
movups 0x20(%r13,%rdx,4),%xmm0
movups 0x30(%r13,%rdx,4),%xmm1
movups %xmm0,-0x10(%rdi,%rdx,4)
movups %xmm1,(%rdi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1460 <fir_downsampling_kernel+0x360>
test   $0x1,%bpl
je     14c1 <fir_downsampling_kernel+0x3c1>
mov    -0x18(%rsp),%rsi
add    $0x1,%rsi
add    %rbx,%rdx
add    %rdx,%rsi
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%r9,%rdx,4)
movups %xmm1,0x10(%r9,%rdx,4)
cmp    -0x20(%rsp),%r8
je     1834 <fir_downsampling_kernel+0x734>
add    %r8,%rbx
mov    %ebx,%edx
not    %edx
add    %ecx,%edx
sub    %rbx,%rcx
add    $0xfffffffffffffffe,%rcx
and    $0x3,%rdx
je     1515 <fir_downsampling_kernel+0x415>
mov    -0x18(%rsp),%rsi
lea    0x4(,%rsi,4),%rsi
add    %r13,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%r9,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1500 <fir_downsampling_kernel+0x400>
cmp    $0x3,%rcx
jb     1834 <fir_downsampling_kernel+0x734>
mov    -0x18(%rsp),%rcx
lea    0x10(,%rcx,4),%rcx
add    %r13,%rcx
nop
movss  -0xc(%rcx,%rbx,4),%xmm0
movss  %xmm0,(%r9,%rbx,4)
movss  -0x8(%rcx,%rbx,4),%xmm0
movss  %xmm0,0x4(%r9,%rbx,4)
movss  -0x4(%rcx,%rbx,4),%xmm0
movss  %xmm0,0x8(%r9,%rbx,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,0xc(%r9,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    1530 <fir_downsampling_kernel+0x430>
jmp    1834 <fir_downsampling_kernel+0x734>
cmp    $0x2,%rcx
jl     1834 <fir_downsampling_kernel+0x734>
mov    -0x18(%rsp),%rdx
lea    0x1(%rdx),%r8
cmp    $0x8,%r12
jb     15b5 <fir_downsampling_kernel+0x4b5>
lea    0x0(,%rsi,4),%rdx
add    %r13,%rdx
cmp    %r9,%rdx
jbe    167a <fir_downsampling_kernel+0x57a>
lea    (%r9,%r12,4),%rdx
lea    0x0(,%r8,4),%rsi
add    %r13,%rsi
cmp    %rdx,%rsi
jae    167a <fir_downsampling_kernel+0x57a>
xor    %edx,%edx
lea    -0x1(%rcx),%esi
sub    %rdx,%rcx
add    $0xfffffffffffffffe,%rcx
and    $0x3,%rsi
je     15f5 <fir_downsampling_kernel+0x4f5>
lea    0x0(,%r8,4),%rdi
add    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    15e0 <fir_downsampling_kernel+0x4e0>
cmp    $0x3,%rcx
jb     1834 <fir_downsampling_kernel+0x734>
mov    -0x18(%rsp),%rcx
lea    0x10(,%rcx,4),%rcx
add    %r13,%rcx
nop
movss  -0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
movss  -0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r9,%rdx,4)
movss  -0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%r9,%rdx,4)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%r9,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r12
jne    1610 <fir_downsampling_kernel+0x510>
jmp    1834 <fir_downsampling_kernel+0x734>
mov    %rbx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rsi
jae    16a8 <fir_downsampling_kernel+0x5a8>
xor    %ebp,%ebp
jmp    1720 <fir_downsampling_kernel+0x620>
mov    %r12,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rsi
jae    1769 <fir_downsampling_kernel+0x669>
xor    %ebp,%ebp
jmp    17e0 <fir_downsampling_kernel+0x6e0>
and    $0xfffffffffffffffc,%r11
mov    -0x20(%rsp),%rsi
lea    (%r9,%rsi,4),%rdi
add    $0x70,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdi,%rbp,4),%xmm0
movups -0x60(%rdi,%rbp,4),%xmm1
movups %xmm0,(%r9,%rbp,4)
movups %xmm1,0x10(%r9,%rbp,4)
movups -0x50(%rdi,%rbp,4),%xmm0
movups -0x40(%rdi,%rbp,4),%xmm1
movups %xmm0,0x20(%r9,%rbp,4)
movups %xmm1,0x30(%r9,%rbp,4)
movups -0x30(%rdi,%rbp,4),%xmm0
movups -0x20(%rdi,%rbp,4),%xmm1
movups %xmm0,0x40(%r9,%rbp,4)
movups %xmm1,0x50(%r9,%rbp,4)
movups -0x10(%rdi,%rbp,4),%xmm0
movups (%rdi,%rbp,4),%xmm1
movups %xmm0,0x60(%r9,%rbp,4)
movups %xmm1,0x70(%r9,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r11
jne    16c0 <fir_downsampling_kernel+0x5c0>
test   %r10,%r10
je     175b <fir_downsampling_kernel+0x65b>
lea    (%r9,%rbp,4),%rsi
add    $0x10,%rsi
mov    -0x20(%rsp),%rdi
lea    (%rsi,%rdi,4),%rdi
shl    $0x5,%r10
xor    %ebp,%ebp
nopl   0x0(%rax)
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,%r10
jne    1740 <fir_downsampling_kernel+0x640>
cmp    %rdx,%rbx
je     13d4 <fir_downsampling_kernel+0x2d4>
jmp    13b3 <fir_downsampling_kernel+0x2b3>
and    $0xfffffffffffffffc,%rbx
mov    -0x18(%rsp),%rsi
lea    0x74(,%rsi,4),%rdi
add    %r13,%rdi
xor    %ebp,%ebp
nop
movups -0x70(%rdi,%rbp,4),%xmm0
movups -0x60(%rdi,%rbp,4),%xmm1
movups %xmm0,(%r9,%rbp,4)
movups %xmm1,0x10(%r9,%rbp,4)
movups -0x50(%rdi,%rbp,4),%xmm0
movups -0x40(%rdi,%rbp,4),%xmm1
movups %xmm0,0x20(%r9,%rbp,4)
movups %xmm1,0x30(%r9,%rbp,4)
movups -0x30(%rdi,%rbp,4),%xmm0
movups -0x20(%rdi,%rbp,4),%xmm1
movups %xmm0,0x40(%r9,%rbp,4)
movups %xmm1,0x50(%r9,%rbp,4)
movups -0x10(%rdi,%rbp,4),%xmm0
movups (%rdi,%rbp,4),%xmm1
movups %xmm0,0x60(%r9,%rbp,4)
movups %xmm1,0x70(%r9,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rbx
jne    1780 <fir_downsampling_kernel+0x680>
test   %r10,%r10
je     182b <fir_downsampling_kernel+0x72b>
lea    (%r9,%rbp,4),%rsi
add    $0x10,%rsi
mov    -0x20(%rsp),%rdi
add    %rbp,%rdi
sub    %rcx,%rdi
lea    0x14(,%rdi,4),%rdi
add    %r13,%rdi
shl    $0x5,%r10
xor    %ebp,%ebp
nopl   0x0(%rax)
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,%r10
jne    1810 <fir_downsampling_kernel+0x710>
cmp    %rdx,%r12
jne    15b7 <fir_downsampling_kernel+0x4b7>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%bpl
jne    149b <fir_downsampling_kernel+0x39b>
jmp    14c1 <fir_downsampling_kernel+0x3c1>

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

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