#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free_fvector(float *, int);
int /*<<< orphan*/ ftlipc(int, int /*<<< orphan*/, float *, float *, int, int,
                          float *, float *, int, int, float);
float *fvector(int, int);
void wafil5(float *xr, float *xi, int n, int kc, float *fcv) {
  float *tmpr, *tmpi, toler = 10e-5;
  int i, j, nd, m;
  tmpr = fvector(1, n);
  tmpi = fvector(1, n);
  for (i = kc + 1; i <= n - kc; i++) {
    tmpr[i] = 0.0;
    tmpi[i] = 0.0;
    for (j = 1; j <= 2 * kc + 1; j++) {
      tmpr[i] += fcv[j] * xr[i + j - kc - 1];
      tmpi[i] += fcv[j] * xi[i + j - kc - 1];
    }
  }
  nd = (((n - kc - kc) < (kc * 2)) ? (n - kc - kc) : (kc * 2));
  j = (((nd) < (kc)) ? (nd) : (kc));
  m = (((256) < (j)) ? (256) : (j));
  m = (((m) < (24)) ? (m) : (24));
  ftlipc(0, 0, tmpr + 1 + (n - nd - kc), tmpi + 1 + (n - nd - kc), 1, nd,
         tmpr + 1 + (n - kc), tmpi + 1 + (n - kc), kc, m, toler);
  ftlipc(1, 0, tmpr + 1 + (n - nd - kc), tmpi + 1 + (n - nd - kc), 1, nd,
         tmpr + 1, tmpi + 1, kc, m, toler);
  for (i = 1; i <= n; i++)
    xr[i] -= tmpr[i];
  for (i = 1; i <= n; i++)
    xi[i] -= tmpi[i];
  free_fvector(tmpr, 1);
  free_fvector(tmpi, 1);
}


x86 assembly (clang, -O0):
<wafil5>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x78,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  0xead(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1040 <fvector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1040 <fvector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jg     126e <wafil5+0x13e>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     125b <wafil5+0x12b>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11bb <wafil5+0x8b>
jmp    1260 <wafil5+0x130>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1183 <wafil5+0x53>
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1296 <wafil5+0x166>
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    129f <wafil5+0x16f>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12bc <wafil5+0x18c>
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    12c2 <wafil5+0x192>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    $0x100,%eax
cmp    -0x44(%rbp),%eax
jge    12e3 <wafil5+0x1b3>
mov    $0x100,%eax
mov    %eax,-0x58(%rbp)
jmp    12e9 <wafil5+0x1b9>
mov    -0x44(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x18,-0x4c(%rbp)
jge    1304 <wafil5+0x1d4>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1311 <wafil5+0x1e1>
mov    $0x18,%eax
mov    %eax,-0x5c(%rbp)
jmp    1311 <wafil5+0x1e1>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rdx
add    $0x4,%rdx
mov    -0x1c(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rcx
add    $0x4,%rcx
mov    -0x1c(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x48(%rbp),%r9d
mov    -0x30(%rbp),%rbx
add    $0x4,%rbx
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rbx
mov    -0x38(%rbp),%r11
add    $0x4,%r11
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%r11
mov    -0x20(%rbp),%r10d
mov    -0x4c(%rbp),%eax
movss  -0x3c(%rbp),%xmm0
xor    %esi,%esi
mov    $0x1,%r8d
mov    %esi,%edi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1050 <ftlipc@plt>
mov    -0x30(%rbp),%rdx
add    $0x4,%rdx
mov    -0x1c(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rcx
add    $0x4,%rcx
mov    -0x1c(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x48(%rbp),%r9d
mov    -0x30(%rbp),%rbx
add    $0x4,%rbx
mov    -0x38(%rbp),%r11
add    $0x4,%r11
mov    -0x20(%rbp),%r10d
mov    -0x4c(%rbp),%eax
movss  -0x3c(%rbp),%xmm0
mov    $0x1,%r8d
xor    %esi,%esi
mov    %r8d,%edi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
call   1050 <ftlipc@plt>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1464 <wafil5+0x334>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1427 <wafil5+0x2f7>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     14a8 <wafil5+0x378>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    146b <wafil5+0x33b>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
call   1030 <free_fvector@plt>
add    $0x78,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<wafil5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,%r13
mov    %ecx,%r12d
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,%rbp
mov    $0x1,%edi
mov    %edx,%esi
call   1040 <fvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r15d,%esi
call   1040 <fvector@plt>
mov    %r12,%r11
mov    %r15d,%edx
mov    %rax,%r15
mov    %edx,0xc(%rsp)
mov    %edx,%eax
sub    %r11d,%eax
add    %r12d,%r12d
mov    %eax,%r8d
sub    %r11d,%r8d
mov    %r11,0x10(%rsp)
jle    1221 <wafil5+0xf1>
mov    %r12d,%r10d
or     $0x1,%r10d
lea    0x2(%r12),%esi
movslq %r11d,%rcx
movslq %eax,%r9
xor    %edi,%edi
jmp    11b9 <wafil5+0x89>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %r9,%rcx
je     1226 <wafil5+0xf6>
movl   $0x0,0x4(%rbx,%rcx,4)
movl   $0x0,0x4(%r15,%rcx,4)
add    $0x1,%rcx
test   %r10d,%r10d
jle    11b0 <wafil5+0x80>
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm0
lea    (%rdi,%rax,1),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x0(%r13,%rax,4),%xmm0
mulss  (%r14,%rdx,4),%xmm0
addss  (%r15,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    11e0 <wafil5+0xb0>
jmp    11b0 <wafil5+0x80>
movslq %eax,%r9
jmp    122b <wafil5+0xfb>
mov    0x10(%rsp),%r11
cmp    %r12d,%r8d
cmovl  %r8d,%r12d
cmp    %r11d,%r12d
mov    %r11d,%eax
cmovl  %r12d,%eax
cmp    $0x18,%eax
mov    $0x18,%r13d
cmovl  %eax,%r13d
lea    0x4(%rbx),%rax
mov    %rax,0x30(%rsp)
mov    0xc(%rsp),%ecx
sub    %r12d,%ecx
sub    %r11d,%ecx
movslq %ecx,%rax
lea    (%rbx,%rax,4),%rdx
add    $0x4,%rdx
mov    %rdx,0x20(%rsp)
lea    0x4(%r15),%rcx
mov    %rcx,0x28(%rsp)
lea    0x4(%r15,%rax,4),%rcx
mov    %rcx,0x18(%rsp)
lea    (%rbx,%r9,4),%r10
add    $0x4,%r10
lea    (%r15,%r9,4),%rax
add    $0x4,%rax
movss  0xd69(%rip),%xmm0
xor    %edi,%edi
xor    %esi,%esi
mov    $0x1,%r8d
mov    %r12d,%r9d
push   %r13
push   %r11
push   %rax
push   %r10
call   1050 <ftlipc@plt>
add    $0x20,%rsp
mov    $0x1,%edi
xor    %esi,%esi
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    $0x1,%r8d
mov    %r12d,%r9d
mov    0x28(%rsp),%r12
movss  0xd25(%rip),%xmm0
push   %r13
mov    0x38(%rsp),%r13
push   0x18(%rsp)
push   %r12
push   %r13
call   1050 <ftlipc@plt>
mov    0x2c(%rsp),%r9d
add    $0x20,%rsp
test   %r9d,%r9d
jle    163a <wafil5+0x50a>
mov    %r9d,%r8d
lea    0x1(%r8),%rax
mov    $0x1,%ecx
cmp    $0x8,%r9d
jb     13ef <wafil5+0x2bf>
lea    0x4(%rbp),%rdx
lea    (%rbx,%rax,4),%rsi
cmp    %rsi,%rdx
jae    1338 <wafil5+0x208>
lea    0x0(,%rax,4),%rdx
add    %rbp,%rdx
cmp    %rdx,%r13
jb     13ef <wafil5+0x2bf>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1662 <wafil5+0x532>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nop
movups 0x4(%rbx,%rsi,4),%xmm0
movups 0x14(%rbx,%rsi,4),%xmm1
movups 0x4(%rbp,%rsi,4),%xmm2
subps  %xmm0,%xmm2
movups 0x14(%rbp,%rsi,4),%xmm0
subps  %xmm1,%xmm0
movups 0x24(%rbp,%rsi,4),%xmm1
movups 0x34(%rbp,%rsi,4),%xmm3
movups %xmm2,0x4(%rbp,%rsi,4)
movups %xmm0,0x14(%rbp,%rsi,4)
movups 0x24(%rbx,%rsi,4),%xmm0
subps  %xmm0,%xmm1
movups 0x34(%rbx,%rsi,4),%xmm0
subps  %xmm0,%xmm3
movups %xmm1,0x24(%rbp,%rsi,4)
movups %xmm3,0x34(%rbp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1360 <wafil5+0x230>
test   $0x1,%dl
je     13e2 <wafil5+0x2b2>
shl    $0x2,%rsi
or     $0x4,%rsi
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups 0x0(%rbp,%rsi,1),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%rbp,%rsi,1),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rsi,1)
movups %xmm0,0x10(%rbp,%rsi,1)
cmp    %rcx,%r8
je     1490 <wafil5+0x360>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     142b <wafil5+0x2fb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm0
subss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1410 <wafil5+0x2e0>
cmp    $0x3,%rdx
jb     1490 <wafil5+0x360>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
subss  (%rbx,%rcx,4),%xmm0
movss  0x4(%rbp,%rcx,4),%xmm1
movss  %xmm0,0x0(%rbp,%rcx,4)
subss  0x4(%rbx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbp,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm0
subss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbp,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm0
subss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1440 <wafil5+0x310>
test   %r9d,%r9d
jle    163a <wafil5+0x50a>
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1595 <wafil5+0x465>
lea    0x4(%r14),%rsi
lea    (%r15,%rax,4),%rdi
cmp    %rdi,%rsi
jae    14c6 <wafil5+0x396>
lea    (%r14,%rax,4),%rsi
cmp    %rsi,%r12
jb     1595 <wafil5+0x465>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1672 <wafil5+0x542>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups (%r14,%rsi,4),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%r14,%rsi,4),%xmm0
subps  %xmm1,%xmm0
movups 0x20(%r14,%rsi,4),%xmm1
movups 0x30(%r14,%rsi,4),%xmm3
movups %xmm2,(%r14,%rsi,4)
movups %xmm0,0x10(%r14,%rsi,4)
movups 0x20(%r15,%rsi,4),%xmm0
subps  %xmm0,%xmm1
movups 0x30(%r15,%rsi,4),%xmm0
subps  %xmm0,%xmm3
movups %xmm1,0x20(%r14,%rsi,4)
movups %xmm3,0x30(%r14,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1500 <wafil5+0x3d0>
test   $0x1,%bpl
je     1588 <wafil5+0x458>
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups (%r14,%rsi,4),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%r14,%rsi,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,(%r14,%rsi,4)
movups %xmm0,0x10(%r14,%rsi,4)
cmp    %rcx,%rdx
je     163a <wafil5+0x50a>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     15cc <wafil5+0x49c>
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rcx,4),%xmm0
subss  (%r15,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    15b0 <wafil5+0x480>
cmp    $0x3,%rdx
jb     163a <wafil5+0x50a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rcx,4),%xmm0
subss  (%r15,%rcx,4),%xmm0
movss  0x4(%r14,%rcx,4),%xmm1
movss  %xmm0,(%r14,%rcx,4)
subss  0x4(%r15,%rcx,4),%xmm1
movss  %xmm1,0x4(%r14,%rcx,4)
movss  0x8(%r14,%rcx,4),%xmm0
subss  0x8(%r15,%rcx,4),%xmm0
movss  %xmm0,0x8(%r14,%rcx,4)
movss  0xc(%r14,%rcx,4),%xmm0
subss  0xc(%r15,%rcx,4),%xmm0
movss  %xmm0,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    15e0 <wafil5+0x4b0>
mov    %rbx,%rdi
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_fvector@plt>
xor    %esi,%esi
test   $0x1,%dl
jne    13b7 <wafil5+0x287>
jmp    13e2 <wafil5+0x2b2>
mov    $0x1,%esi
test   $0x1,%bpl
jne    1561 <wafil5+0x431>
jmp    1588 <wafil5+0x458>

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

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