long fir_upsampling_kernel(lenx, x, y, lenh0, h0, T, iupfac)
long lenx;
float *x, *y;
long lenh0;
float *h0, *T;
long iupfac;
{
  long ktrans, iup, kx, kStart, ky, kappa;
  ky = 0;
  kStart = 0;
  ktrans = (lenh0 / iupfac > lenx ? lenx : lenh0 / iupfac);
  for (kx = 0; kx <= ktrans - 1; kx++) {
    for (iup = 0; iup <= iupfac - 1; iup++) {
      y[ky] = x[kx] * h0[iup];
      for (kappa = 1; kappa <= kx; kappa++) {
        y[ky] += x[kx - kappa] * h0[iup + kappa * iupfac];
      }
      for (kappa = kx + 1; kappa < lenh0 / iupfac; kappa++) {
        y[ky] +=
            T[lenh0 / iupfac - 2 + kx + 1 - kappa] * h0[iup + kappa * iupfac];
      }
      ky++;
    }
    kStart = kx;
  }
  for (kx = kStart + 1; kx <= lenx - 1; kx++) {
    for (iup = 0; iup <= iupfac - 1; iup++) {
      y[ky] = x[kx] * h0[iup];
      for (kappa = 1; kappa <= lenh0 / iupfac - 1; kappa++) {
        y[ky] += x[kx - kappa] * h0[iup + kappa * iupfac];
      }
      ky++;
    }
  }
  if (lenx >= lenh0 / iupfac - 1) {
    for (kappa = 0; kappa <= lenh0 / iupfac - 2; kappa++) {
      T[kappa] = x[lenx + 1 - lenh0 / iupfac + kappa];
    }
  } else {
    for (kappa = 0; kappa <= lenh0 / iupfac - 2 - lenx; kappa++) {
      T[kappa] = T[kappa + lenx];
    }
    for (kappa = lenh0 / iupfac - 1 - lenx; kappa <= lenh0 / iupfac - 2;
         kappa++) {
      T[kappa] = x[lenx - 1 + kappa - (lenh0 / iupfac - 2)];
    }
  }
  return ky;
}


x86 assembly (clang, -O0):
<fir_upsampling_kernel>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
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)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
cmp    -0x8(%rbp),%rax
jle    1155 <fir_upsampling_kernel+0x55>
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
jmp    1163 <fir_upsampling_kernel+0x63>
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     130d <fir_upsampling_kernel+0x20d>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     12f4 <fir_upsampling_kernel+0x1f4>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     1237 <fir_upsampling_kernel+0x137>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    -0x60(%rbp),%rdx
imul   0x10(%rbp),%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11d4 <fir_upsampling_kernel+0xd4>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0x70(%rbp),%rax
cmp    %rcx,%rax
jge    12d7 <fir_upsampling_kernel+0x1d7>
mov    -0x30(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0x78(%rbp),%rax
sub    $0x2,%rcx
add    -0x48(%rbp),%rcx
add    $0x1,%rcx
sub    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    -0x60(%rbp),%rdx
imul   0x10(%rbp),%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1243 <fir_upsampling_kernel+0x143>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1190 <fir_upsampling_kernel+0x90>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1173 <fir_upsampling_kernel+0x73>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1428 <fir_upsampling_kernel+0x328>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1412 <fir_upsampling_kernel+0x312>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     13f5 <fir_upsampling_kernel+0x2f5>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    -0x60(%rbp),%rdx
imul   0x10(%rbp),%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    137a <fir_upsampling_kernel+0x27a>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1336 <fir_upsampling_kernel+0x236>
jmp    1417 <fir_upsampling_kernel+0x317>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1319 <fir_upsampling_kernel+0x219>
mov    -0x8(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
sub    $0x1,%rcx
cmp    %rcx,%rax
jl     14de <fir_upsampling_kernel+0x3de>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
sub    $0x2,%rcx
cmp    %rcx,%rax
jg     14d9 <fir_upsampling_kernel+0x3d9>
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rcx
add    $0x1,%rcx
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rdx
mov    -0x98(%rbp),%rax
sub    %rdx,%rcx
add    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    145c <fir_upsampling_kernel+0x35c>
jmp    15e1 <fir_upsampling_kernel+0x4e1>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0xa0(%rbp),%rax
sub    $0x2,%rcx
sub    -0x8(%rbp),%rcx
cmp    %rcx,%rax
jg     1545 <fir_upsampling_kernel+0x445>
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
add    -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    14e6 <fir_upsampling_kernel+0x3e6>
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
sub    $0x1,%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rcx
mov    -0xa8(%rbp),%rax
sub    $0x2,%rcx
cmp    %rcx,%rax
jg     15dc <fir_upsampling_kernel+0x4dc>
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
add    -0x60(%rbp),%rcx
mov    -0x20(%rbp),%rax
cqto
idivq  0x10(%rbp)
mov    %rax,%rdx
mov    -0xb0(%rbp),%rax
sub    $0x2,%rdx
sub    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    155b <fir_upsampling_kernel+0x45b>
jmp    15e1 <fir_upsampling_kernel+0x4e1>
mov    -0x58(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fir_upsampling_kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %r8,-0x70(%rsp)
mov    %rcx,%rax
mov    %rdx,%r11
mov    0x58(%rsp),%r15
mov    %rcx,%rdx
or     %r15,%rdx
shr    $0x20,%rdx
je     1134 <fir_upsampling_kernel+0x34>
cqto
idiv   %r15
mov    %rax,%r10
jmp    113c <fir_upsampling_kernel+0x3c>
xor    %edx,%edx
div    %r15d
mov    %eax,%r10d
mov    %r10,%rax
sub    %rdi,%rax
mov    %r10,%rdx
cmovg  %rdi,%rdx
mov    %rdx,-0x20(%rsp)
test   %rdx,%rdx
mov    %rsi,-0x80(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %r9,-0x50(%rsp)
mov    %rax,-0x48(%rsp)
jle    1420 <fir_upsampling_kernel+0x320>
lea    -0x1(%r10),%rax
mov    %rax,-0x28(%rsp)
lea    -0x2(%r10),%rax
mov    %rax,0x8(%rsp)
mov    -0x70(%rsp),%rax
lea    (%rax,%r15,8),%rdx
mov    %rdx,-0x30(%rsp)
lea    0x0(,%r15,8),%rdi
lea    (%rax,%r15,4),%rax
mov    %rax,-0x38(%rsp)
lea    -0x4(%r9),%rax
mov    %rax,-0x40(%rsp)
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
xor    %eax,%eax
xor    %r8d,%r8d
jmp    11d5 <fir_upsampling_kernel+0xd5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r13),%r8
addq   $0x1,-0x68(%rsp)
cmp    -0x20(%rsp),%r8
je     1425 <fir_upsampling_kernel+0x325>
mov    %r8,%r13
test   %r15,%r15
jle    11c0 <fir_upsampling_kernel+0xc0>
mov    -0x68(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
lea    0x1(%r13),%r8
mov    -0x28(%rsp),%rdx
add    %r13,%rdx
mov    %r13,%rbx
not    %rbx
add    %r10,%rbx
mov    %rbx,0x10(%rsp)
sub    %r8,%rdx
mov    %rdx,(%rsp)
mov    %r8,%rdx
imul   %r15,%rdx
mov    %rdx,-0x8(%rsp)
lea    0x2(%r13),%rdx
mov    %rdx,-0x10(%rsp)
lea    (%rsi,%r13,4),%r9
lea    (%r10,%r13,1),%rdx
mov    -0x40(%rsp),%rbx
lea    (%rbx,%rdx,4),%rdx
mov    %rdx,-0x18(%rsp)
mov    -0x70(%rsp),%rdx
mov    %rdx,-0x60(%rsp)
mov    -0x38(%rsp),%r12
mov    -0x30(%rsp),%r14
xor    %ebp,%ebp
mov    %rcx,0x18(%rsp)
mov    %r8,-0x58(%rsp)
jmp    1294 <fir_upsampling_kernel+0x194>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
add    $0x1,%rbp
add    $0x4,%r14
add    $0x4,%r12
addq   $0x4,-0x60(%rsp)
mov    0x58(%rsp),%r15
cmp    %r15,%rbp
mov    %r8,%r10
mov    %rcx,%r13
mov    -0x58(%rsp),%r8
mov    0x18(%rsp),%rcx
je     11c4 <fir_upsampling_kernel+0xc4>
movss  (%rsi,%r13,4),%xmm0
mov    -0x70(%rsp),%rdx
mulss  (%rdx,%rbp,4),%xmm0
movss  %xmm0,(%r11,%rax,4)
test   %r13,%r13
je     1347 <fir_upsampling_kernel+0x247>
mov    $0x1,%edx
cmpq   $0x1,-0x68(%rsp)
je     131a <fir_upsampling_kernel+0x21a>
mov    $0xffffffffffffffff,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  (%r9,%rdx,4),%xmm1
mulss  (%r12,%rbx,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
movss  -0x4(%r9,%rdx,4),%xmm0
mulss  (%r14,%rbx,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rax,4)
add    %rdi,%rbx
lea    (%rcx,%rdx,1),%rsi
add    $0xfffffffffffffffe,%rsi
add    $0xfffffffffffffffe,%rdx
cmp    $0xffffffffffffffff,%rsi
jne    12d0 <fir_upsampling_kernel+0x1d0>
neg    %rdx
mov    -0x80(%rsp),%rsi
testb  $0x1,-0x68(%rsp)
je     1347 <fir_upsampling_kernel+0x247>
mov    %r13,%rbx
sub    %rdx,%rbx
movss  (%rsi,%rbx,4),%xmm1
imul   %r15,%rdx
add    %rbp,%rdx
mov    -0x70(%rsp),%rbx
mulss  (%rbx,%rdx,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rax,4)
mov    %r13,%rcx
cmp    %r10,%r8
mov    %r10,%r8
jge    1260 <fir_upsampling_kernel+0x160>
testb  $0x1,0x10(%rsp)
jne    1370 <fir_upsampling_kernel+0x270>
mov    -0x58(%rsp),%rdx
cmp    %rcx,0x8(%rsp)
je     1260 <fir_upsampling_kernel+0x160>
jmp    13aa <fir_upsampling_kernel+0x2aa>
nop
mov    -0x50(%rsp),%rdx
mov    (%rsp),%rbx
movss  (%rdx,%rbx,4),%xmm1
mov    -0x8(%rsp),%rdx
add    %rbp,%rdx
mov    -0x70(%rsp),%rbx
mulss  (%rbx,%rdx,4),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rax,4)
mov    -0x10(%rsp),%rdx
cmp    %rcx,0x8(%rsp)
je     1260 <fir_upsampling_kernel+0x160>
lea    0x0(,%rdx,4),%rbx
mov    -0x18(%rsp),%r10
sub    %rbx,%r10
lea    0x1(%rdx),%rbx
mov    0x58(%rsp),%rsi
imul   %rsi,%rbx
mov    -0x60(%rsp),%r15
lea    (%r15,%rbx,4),%rbx
imul   %rdx,%rsi
lea    (%r15,%rsi,4),%r15
mov    -0x80(%rsp),%rsi
xor    %r13d,%r13d
movss  (%r10),%xmm1
mulss  (%r15,%r13,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
movss  -0x4(%r10),%xmm0
mulss  (%rbx,%r13,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rax,4)
add    $0x2,%rdx
add    $0xfffffffffffffff8,%r10
add    %rdi,%r13
cmp    %r8,%rdx
jl     13e0 <fir_upsampling_kernel+0x2e0>
jmp    1260 <fir_upsampling_kernel+0x160>
xor    %r13d,%r13d
xor    %eax,%eax
mov    -0x78(%rsp),%rdx
lea    -0x1(%rdx),%rcx
cmp    %rcx,%r13
jge    157b <fir_upsampling_kernel+0x47b>
mov    %r10,%r9
lea    -0x1(%r10),%r14
mov    %r14,%r12
and    $0xfffffffffffffffe,%r12
mov    -0x70(%rsp),%rdx
lea    (%rdx,%r15,8),%rdi
mov    %rdi,-0x58(%rsp)
lea    0x0(,%r15,8),%r10
lea    (%rsi,%r13,4),%rbp
lea    (%rdx,%r15,4),%rdx
mov    %rdx,-0x60(%rsp)
mov    %rcx,-0x68(%rsp)
jmp    147f <fir_upsampling_kernel+0x37f>
nop
add    $0x4,%rbp
cmp    -0x68(%rsp),%r13
je     157e <fir_upsampling_kernel+0x47e>
add    $0x1,%r13
cmpq   $0x0,0x58(%rsp)
jle    1470 <fir_upsampling_kernel+0x370>
mov    -0x60(%rsp),%rbx
mov    -0x58(%rsp),%rdx
xor    %ecx,%ecx
jmp    14ba <fir_upsampling_kernel+0x3ba>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%rcx
add    $0x4,%rdx
add    $0x4,%rbx
cmp    0x58(%rsp),%rcx
mov    %r15,%r13
je     1470 <fir_upsampling_kernel+0x370>
mov    %r13,%r15
movss  (%rsi,%r13,4),%xmm0
mov    -0x70(%rsp),%rdi
mulss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%r11,%rax,4)
cmp    $0x2,%r9
jl     14a0 <fir_upsampling_kernel+0x3a0>
mov    $0x1,%r8d
je     1539 <fir_upsampling_kernel+0x439>
mov    $0xffffffffffffffff,%r8
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movss  0x4(%rbp,%r8,4),%xmm1
mulss  (%rbx,%rsi,1),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
movss  0x0(%rbp,%r8,4),%xmm0
mulss  (%rdx,%rsi,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rax,4)
add    %r10,%rsi
lea    (%r12,%r8,1),%rdi
add    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffffe,%r8
cmp    $0xffffffffffffffff,%rdi
jne    14f0 <fir_upsampling_kernel+0x3f0>
neg    %r8
mov    -0x80(%rsp),%rsi
test   $0x1,%r14b
je     14a0 <fir_upsampling_kernel+0x3a0>
mov    %r15,%rsi
sub    %r8,%rsi
mov    -0x80(%rsp),%rdi
movss  (%rdi,%rsi,4),%xmm1
mov    -0x80(%rsp),%rsi
imul   0x58(%rsp),%r8
add    %rcx,%r8
mov    -0x70(%rsp),%rdi
mulss  (%rdi,%r8,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
jmp    14a0 <fir_upsampling_kernel+0x3a0>
mov    %r10,%r9
mov    %r9,%r10
lea    -0x1(%r9),%r11
mov    %r11,%rcx
mov    -0x78(%rsp),%rdx
sub    %rdx,%rcx
jle    17bd <fir_upsampling_kernel+0x6bd>
lea    -0x2(%r10),%r8
cmp    %rdx,%r8
mov    -0x50(%rsp),%rbp
jl     1614 <fir_upsampling_kernel+0x514>
cmp    $0x8,%rcx
jb     15e2 <fir_upsampling_kernel+0x4e2>
lea    0x0(,%r11,4),%rdx
add    %rbp,%rdx
cmp    %rbp,%rdx
jbe    188c <fir_upsampling_kernel+0x78c>
lea    0x0(,%rcx,4),%rdx
add    %rbp,%rdx
mov    -0x78(%rsp),%rsi
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
cmp    %rdx,%rsi
jae    188c <fir_upsampling_kernel+0x78c>
xor    %edi,%edi
mov    -0x78(%rsp),%rdx
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1600 <fir_upsampling_kernel+0x500>
cmp    %r8,%rcx
jg     1a8a <fir_upsampling_kernel+0x98a>
mov    -0x78(%rsp),%rdi
mov    %rdi,%rsi
sub    %r10,%rsi
cmp    $0x8,%rdi
jb     1720 <fir_upsampling_kernel+0x620>
lea    0x0(,%rcx,4),%rdx
add    %rbp,%rdx
mov    -0x80(%rsp),%rbx
lea    (%rbx,%rdi,4),%rdi
cmp    %rdi,%rdx
jae    165f <fir_upsampling_kernel+0x55f>
lea    0x0(,%r11,4),%rdx
add    %rbp,%rdx
cmp    %rbx,%rdx
ja     1720 <fir_upsampling_kernel+0x620>
mov    %r10,%r14
mov    -0x78(%rsp),%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1a99 <fir_upsampling_kernel+0x999>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
and    %r9,%rdx
mov    %rbp,%r10
mov    -0x48(%rsp),%rdi
lea    0x2c(,%rdi,4),%rdi
add    %rbp,%rdi
xor    %ebp,%ebp
mov    -0x80(%rsp),%rbx
xchg   %ax,%ax
movups (%rbx,%rbp,4),%xmm0
movups 0x10(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdi,%rbp,4)
movups %xmm1,-0x20(%rdi,%rbp,4)
movups 0x20(%rbx,%rbp,4),%xmm0
movups 0x30(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,4)
movups %xmm1,(%rdi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdx
jne    16b0 <fir_upsampling_kernel+0x5b0>
test   $0x1,%r9b
je     170c <fir_upsampling_kernel+0x60c>
lea    0x1(%rsi),%rdx
add    %rcx,%rbp
add    %rbp,%rdx
mov    -0x80(%rsp),%rdi
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
mov    %r10,%rdx
movups %xmm0,(%r10,%rbp,4)
movups %xmm1,0x10(%r10,%rbp,4)
cmp    -0x78(%rsp),%r8
je     1a8a <fir_upsampling_kernel+0x98a>
mov    %r10,%rbp
mov    %r14,%r10
add    %r8,%rcx
mov    %ecx,%edx
not    %edx
add    %r10d,%edx
sub    %rcx,%r10
add    $0xfffffffffffffffe,%r10
and    $0x3,%rdx
je     1765 <fir_upsampling_kernel+0x665>
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rsi,4),%rdi
add    $0x4,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1750 <fir_upsampling_kernel+0x650>
cmp    $0x3,%r10
jb     1a8a <fir_upsampling_kernel+0x98a>
mov    -0x80(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
add    $0x10,%rdx
nopl   0x0(%rax)
movss  -0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  -0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbp,%rcx,4)
movss  -0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbp,%rcx,4)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1780 <fir_upsampling_kernel+0x680>
jmp    1a8a <fir_upsampling_kernel+0x98a>
cmp    $0x2,%r10
mov    -0x50(%rsp),%rdi
jl     1a8a <fir_upsampling_kernel+0x98a>
mov    -0x78(%rsp),%rcx
mov    %rcx,%r9
sub    %r10,%r9
lea    0x1(%r9),%r8
cmp    $0x8,%r11
jb     1804 <fir_upsampling_kernel+0x704>
mov    -0x80(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
cmp    %rdi,%rcx
jbe    18b9 <fir_upsampling_kernel+0x7b9>
lea    (%rdi,%r11,4),%rcx
lea    (%rdx,%r8,4),%rdx
cmp    %rcx,%rdx
jae    18b9 <fir_upsampling_kernel+0x7b9>
xor    %ecx,%ecx
lea    -0x1(%r10),%edx
sub    %rcx,%r10
add    $0xfffffffffffffffe,%r10
and    $0x3,%rdx
je     1834 <fir_upsampling_kernel+0x734>
mov    -0x80(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1820 <fir_upsampling_kernel+0x720>
cmp    $0x3,%r10
jb     1a8a <fir_upsampling_kernel+0x98a>
mov    -0x80(%rsp),%rdx
lea    (%rdx,%r9,4),%rdx
add    $0x10,%rdx
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  -0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
movss  -0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rcx,4)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1850 <fir_upsampling_kernel+0x750>
jmp    1a8a <fir_upsampling_kernel+0x98a>
mov    %rcx,%rdi
and    $0xfffffffffffffff8,%rdi
lea    -0x8(%rdi),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x3,%r9d
cmp    $0x18,%rsi
jae    18eb <fir_upsampling_kernel+0x7eb>
xor    %esi,%esi
mov    %rbp,%rbx
jmp    1959 <fir_upsampling_kernel+0x859>
mov    %r10,%r14
mov    %rdi,%r10
mov    %r11,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x18,%rsi
jae    19ac <fir_upsampling_kernel+0x8ac>
xor    %edi,%edi
jmp    1a28 <fir_upsampling_kernel+0x928>
and    $0xfffffffffffffffc,%rdx
mov    %rbp,%rbx
mov    -0x78(%rsp),%rsi
lea    0x70(%rbp,%rsi,4),%rbp
xor    %esi,%esi
xchg   %ax,%ax
movups -0x70(%rbp,%rsi,4),%xmm0
movups -0x60(%rbp,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,4)
movups %xmm1,0x10(%rbx,%rsi,4)
movups -0x50(%rbp,%rsi,4),%xmm0
movups -0x40(%rbp,%rsi,4),%xmm1
movups %xmm0,0x20(%rbx,%rsi,4)
movups %xmm1,0x30(%rbx,%rsi,4)
movups -0x30(%rbp,%rsi,4),%xmm0
movups -0x20(%rbp,%rsi,4),%xmm1
movups %xmm0,0x40(%rbx,%rsi,4)
movups %xmm1,0x50(%rbx,%rsi,4)
movups -0x10(%rbp,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
movups %xmm0,0x60(%rbx,%rsi,4)
movups %xmm1,0x70(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1900 <fir_upsampling_kernel+0x800>
test   %r9,%r9
je     199b <fir_upsampling_kernel+0x89b>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
mov    -0x78(%rsp),%rsi
lea    (%rdx,%rsi,4),%rsi
shl    $0x5,%r9
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1980 <fir_upsampling_kernel+0x880>
cmp    %rdi,%rcx
mov    %rbx,%rbp
je     1614 <fir_upsampling_kernel+0x514>
jmp    15e4 <fir_upsampling_kernel+0x4e4>
and    $0xfffffffffffffffc,%rdx
mov    -0x80(%rsp),%rsi
lea    (%rsi,%r9,4),%rsi
add    $0x74,%rsi
xor    %edi,%edi
mov    %r10,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rsi,%rdi,4),%xmm0
movups -0x60(%rsi,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups -0x50(%rsi,%rdi,4),%xmm0
movups -0x40(%rsi,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rdx
jne    19d0 <fir_upsampling_kernel+0x8d0>
test   %rbp,%rbp
je     1a7b <fir_upsampling_kernel+0x97b>
lea    (%r10,%rdi,4),%rdx
add    $0x10,%rdx
mov    -0x78(%rsp),%rbx
add    %rdi,%rbx
sub    %r14,%rbx
mov    -0x80(%rsp),%rsi
lea    (%rsi,%rbx,4),%rsi
add    $0x14,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1a60 <fir_upsampling_kernel+0x960>
cmp    %rcx,%r11
mov    %r10,%rdi
mov    %r14,%r10
jne    1806 <fir_upsampling_kernel+0x706>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbp,%r10
xor    %ebp,%ebp
test   $0x1,%r9b
jne    16e6 <fir_upsampling_kernel+0x5e6>
jmp    170c <fir_upsampling_kernel+0x60c>

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

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