#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*/ RealFFT(float *, int);
int /*<<< orphan*/ RealIFFT(float *, int);
long nextpow2(unsigned long);
int /*<<< orphan*/ safe_free(float *);
scalar_t__ safe_malloc(int);
unsigned long FFTNXCorr(float *x1, unsigned long n1, float *x2,
                        unsigned long n2, float *y) {
  register float r1, i1;
  float *tmp1;
  float *tmp2;
  long C, D, Nx, Ny;
  Nx = nextpow2((((n1) > (n2)) ? (n1) : (n2)));
  tmp1 = (float *)safe_malloc(sizeof(float) * (2 * Nx + 2));
  tmp2 = (float *)safe_malloc(sizeof(float) * (2 * Nx + 2));
  for (C = n1 - 1; C >= 0; C--) {
    tmp1[C] = *(x1++);
  }
  for (C = n1; C < 2 * Nx; C++)
    tmp1[C] = 0.0;
  RealFFT(tmp1, 2 * Nx);
  for (C = 0; C < (long)n2; C++) {
    tmp2[C] = x2[C];
  }
  for (C = n2; C < 2 * Nx; C++)
    tmp2[C] = 0.0;
  RealFFT(tmp2, 2 * Nx);
  for (C = 0; C <= Nx; C++) {
    D = C << 1;
    r1 = tmp1[D];
    i1 = tmp1[1 + D];
    tmp1[D] = r1 * tmp2[D] - i1 * tmp2[1 + D];
    tmp1[1 + D] = r1 * tmp2[1 + D] + i1 * tmp2[D];
  }
  RealIFFT(tmp1, 2 * Nx);
  Ny = n1 + n2 - 1;
  for (C = 0; C < Ny; C++)
    y[C] = tmp1[C];
  safe_free(tmp1);
  safe_free(tmp2);
  return Ny;
}


x86 assembly (clang, -O0):
<FFTNXCorr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1187 <FFTNXCorr+0x37>
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
jmp    118f <FFTNXCorr+0x3f>
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
call   1060 <nextpow2@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <safe_malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <safe_malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jl     121a <FFTNXCorr+0xca>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    11de <FFTNXCorr+0x8e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jge    1258 <FFTNXCorr+0x108>
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1222 <FFTNXCorr+0xd2>
mov    -0x38(%rbp),%rdi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%esi
call   1030 <RealFFT@plt>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    12ac <FFTNXCorr+0x15c>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1273 <FFTNXCorr+0x123>
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jge    12ea <FFTNXCorr+0x19a>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    12b4 <FFTNXCorr+0x164>
mov    -0x40(%rbp),%rdi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%esi
call   1030 <RealFFT@plt>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x58(%rbp),%rax
jg     13e3 <FFTNXCorr+0x293>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1305 <FFTNXCorr+0x1b5>
mov    -0x38(%rbp),%rdi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%esi
call   1050 <RealIFFT@plt>
mov    -0x10(%rbp),%rax
add    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x60(%rbp),%rax
jge    1447 <FFTNXCorr+0x2f7>
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    140e <FFTNXCorr+0x2be>
mov    -0x38(%rbp),%rdi
call   1070 <safe_free@plt>
mov    -0x40(%rbp),%rdi
call   1070 <safe_free@plt>
mov    -0x60(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FFTNXCorr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r15
mov    %rdx,%rbp
mov    %rsi,%r14
mov    %rdi,%r13
cmp    %rcx,%rsi
mov    %rcx,0x20(%rsp)
mov    %rcx,%rdi
cmova  %rsi,%rdi
call   1060 <nextpow2@plt>
mov    %rax,%rcx
add    %rax,%rax
mov    %rax,0x10(%rsp)
mov    %rcx,0x18(%rsp)
lea    0x8(,%rcx,8),%ebx
mov    %ebx,%edi
call   1040 <safe_malloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
call   1040 <safe_malloc@plt>
mov    %rax,%rbx
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x8(%rsp)
js     121a <FFTNXCorr+0xba>
cmp    $0x8,%r14
jb     11ee <FFTNXCorr+0x8e>
lea    0x0(,%r14,4),%rax
add    %r13,%rax
cmp    %rax,%r12
jae    12fd <FFTNXCorr+0x19d>
lea    (%r12,%r14,4),%rax
cmp    %r13,%rax
jbe    12fd <FFTNXCorr+0x19d>
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13),%xmm0
add    $0x4,%r13
movss  %xmm0,-0x4(%r12,%rcx,4)
add    $0xffffffffffffffff,%rcx
test   %rcx,%rcx
jg     1200 <FFTNXCorr+0xa0>
cmp    %r14,0x10(%rsp)
jle    1240 <FFTNXCorr+0xe0>
lea    (%r12,%r14,4),%rdi
shl    $0x2,%r14
mov    0x18(%rsp),%rax
lea    0x0(,%rax,8),%rdx
sub    %r14,%rdx
xor    %esi,%esi
call   1070 <memset@plt>
mov    %r12,%rdi
mov    0x10(%rsp),%rsi
call   1030 <RealFFT@plt>
mov    0x20(%rsp),%r13
test   %r13,%r13
mov    0x8(%rsp),%r14
jle    14a4 <FFTNXCorr+0x344>
cmp    $0x8,%r13
jb     1287 <FFTNXCorr+0x127>
lea    0x0(,%r13,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    13cd <FFTNXCorr+0x26d>
lea    (%rbx,%r13,4),%rax
cmp    %rbp,%rax
jbe    13cd <FFTNXCorr+0x26d>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
mov    %r13,%rdx
and    $0x3,%rdx
je     12b5 <FFTNXCorr+0x155>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12a0 <FFTNXCorr+0x140>
cmp    $0x3,%rcx
jb     14a4 <FFTNXCorr+0x344>
nop
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
movss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    12c0 <FFTNXCorr+0x160>
jmp    14a4 <FFTNXCorr+0x344>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     15ce <FFTNXCorr+0x46e>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
or     $0x2,%rsi
and    %rcx,%rsi
lea    (%r12,%r14,4),%rdi
add    $0xfffffffffffffff0,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rdx,4),%xmm0
movups 0x10(%r13,%rdx,4),%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,(%rdi)
shufps $0x1b,%xmm1,%xmm1
movups %xmm1,-0x10(%rdi)
movups 0x20(%r13,%rdx,4),%xmm0
movups 0x30(%r13,%rdx,4),%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,-0x20(%rdi)
shufps $0x1b,%xmm1,%xmm1
movups %xmm1,-0x30(%rdi)
add    $0x10,%rdx
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1340 <FFTNXCorr+0x1e0>
test   $0x1,%cl
je     13b2 <FFTNXCorr+0x252>
mov    0x8(%rsp),%rcx
sub    %rdx,%rcx
movups 0x0(%r13,%rdx,4),%xmm0
movups 0x10(%r13,%rdx,4),%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,-0xc(%r12,%rcx,4)
shufps $0x1b,%xmm1,%xmm1
movups %xmm1,-0x1c(%r12,%rcx,4)
cmp    %r14,%rax
je     121a <FFTNXCorr+0xba>
mov    0x8(%rsp),%rcx
sub    %rax,%rcx
lea    0x0(%r13,%rax,4),%r13
jmp    11f3 <FFTNXCorr+0x93>
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    13f2 <FFTNXCorr+0x292>
xor    %esi,%esi
jmp    1459 <FFTNXCorr+0x2f9>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rsi,4),%xmm0
movups 0x10(%rbp,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,4)
movups %xmm1,0x10(%rbx,%rsi,4)
movups 0x20(%rbp,%rsi,4),%xmm0
movups 0x30(%rbp,%rsi,4),%xmm1
movups %xmm0,0x20(%rbx,%rsi,4)
movups %xmm1,0x30(%rbx,%rsi,4)
movups 0x40(%rbp,%rsi,4),%xmm0
movups 0x50(%rbp,%rsi,4),%xmm1
movups %xmm0,0x40(%rbx,%rsi,4)
movups %xmm1,0x50(%rbx,%rsi,4)
movups 0x60(%rbp,%rsi,4),%xmm0
movups 0x70(%rbp,%rsi,4),%xmm1
movups %xmm0,0x60(%rbx,%rsi,4)
movups %xmm1,0x70(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1400 <FFTNXCorr+0x2a0>
test   %rcx,%rcx
je     149b <FFTNXCorr+0x33b>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
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,%rcx
jne    1480 <FFTNXCorr+0x320>
cmp    %r13,%rax
jne    1289 <FFTNXCorr+0x129>
cmp    %r13,0x10(%rsp)
mov    0x18(%rsp),%rbp
jle    14ce <FFTNXCorr+0x36e>
lea    (%rbx,%r13,4),%rdi
lea    0x0(,%r13,4),%rax
lea    0x0(,%rbp,8),%rdx
sub    %rax,%rdx
xor    %esi,%esi
call   1070 <memset@plt>
mov    %rbx,%rdi
mov    0x10(%rsp),%rsi
call   1030 <RealFFT@plt>
test   %rbp,%rbp
js     1627 <FFTNXCorr+0x4c7>
lea    0x1(%rbp),%rcx
cmp    $0x4,%rcx
jae    14f5 <FFTNXCorr+0x395>
xor    %edx,%edx
jmp    15de <FFTNXCorr+0x47e>
lea    0x4(%r12),%rdi
mov    $0x8,%edx
mov    %rbp,%rax
mul    %rdx
seto   %sil
lea    (%r12,%rax,1),%rbp
add    $0x4,%rbp
xor    %edx,%edx
cmp    %rdi,%rbp
jb     15de <FFTNXCorr+0x47e>
test   %sil,%sil
jne    15de <FFTNXCorr+0x47e>
add    %r12,%rax
cmp    %r12,%rax
jb     15de <FFTNXCorr+0x47e>
test   %sil,%sil
mov    0x18(%rsp),%rsi
jne    15de <FFTNXCorr+0x47e>
lea    (%rbx,%rsi,8),%rax
add    $0x8,%rax
cmp    %rax,%r12
jae    1559 <FFTNXCorr+0x3f9>
lea    (%r12,%rsi,8),%rax
add    $0x8,%rax
cmp    %rax,%rbx
jb     14ee <FFTNXCorr+0x38e>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movups (%rbx,%rax,8),%xmm1
movups 0x10(%rbx,%rax,8),%xmm3
movaps %xmm1,%xmm4
shufps $0x88,%xmm3,%xmm4
shufps $0xdd,%xmm3,%xmm1
movaps %xmm1,%xmm3
mulps  %xmm0,%xmm3
mulps  %xmm2,%xmm1
mulps  %xmm4,%xmm2
subps  %xmm3,%xmm2
mulps  %xmm0,%xmm4
addps  %xmm4,%xmm1
movaps %xmm2,%xmm0
unpckhps %xmm1,%xmm0
unpcklps %xmm1,%xmm2
movups %xmm2,(%r12,%rax,8)
movups %xmm0,0x10(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1570 <FFTNXCorr+0x410>
jmp    1622 <FFTNXCorr+0x4c2>
xor    %edx,%edx
test   $0x1,%cl
jne    138a <FFTNXCorr+0x22a>
jmp    13b2 <FFTNXCorr+0x252>
movss  (%r12,%rdx,8),%xmm0
movss  0x4(%r12,%rdx,8),%xmm1
movss  0x4(%rbx,%rdx,8),%xmm2
mulss  %xmm1,%xmm2
movss  (%rbx,%rdx,8),%xmm3
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%r12,%rdx,8)
mulss  (%rbx,%rdx,8),%xmm1
mulss  0x4(%rbx,%rdx,8),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%r12,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    15de <FFTNXCorr+0x47e>
mov    %r12,%rdi
mov    0x10(%rsp),%rsi
call   1050 <RealIFFT@plt>
add    %r13,%r14
test   %r14,%r14
jle    1752 <FFTNXCorr+0x5f2>
cmp    $0x8,%r14
jb     1658 <FFTNXCorr+0x4f8>
lea    (%r12,%r14,4),%rax
cmp    %r15,%rax
jbe    165f <FFTNXCorr+0x4ff>
lea    (%r15,%r14,4),%rax
cmp    %rax,%r12
jae    165f <FFTNXCorr+0x4ff>
xor    %eax,%eax
jmp    173d <FFTNXCorr+0x5dd>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1684 <FFTNXCorr+0x524>
xor    %esi,%esi
jmp    16f8 <FFTNXCorr+0x598>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r12,%rsi,4),%xmm0
movups 0x10(%r12,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups 0x20(%r12,%rsi,4),%xmm0
movups 0x30(%r12,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups 0x40(%r12,%rsi,4),%xmm0
movups 0x50(%r12,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movups 0x60(%r12,%rsi,4),%xmm0
movups 0x70(%r12,%rsi,4),%xmm1
movups %xmm0,0x60(%r15,%rsi,4)
movups %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1690 <FFTNXCorr+0x530>
test   %rcx,%rcx
je     174d <FFTNXCorr+0x5ed>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r12,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
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,%rcx
jne    1720 <FFTNXCorr+0x5c0>
jmp    174d <FFTNXCorr+0x5ed>
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    173d <FFTNXCorr+0x5dd>
mov    %r12,%rdi
call   1080 <safe_free@plt>
mov    %rbx,%rdi
call   1080 <safe_free@plt>
mov    %r14,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i64 @FFTNXCorr(float* %0, i64 %1, float* %2, i64 %3, float* %4) {
%6 = alloca float*
%7 = alloca i64
%8 = alloca float*
%9 = alloca i64
%10 = alloca float*
%11 = alloca float
%12 = alloca float
%13 = alloca float*
%14 = alloca float*
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
store float* %0, float** %6
store i64 %1, i64* %7
store float* %2, float** %8
store i64 %3, i64* %9
store float* %4, float** %10
%19 = load i64, i64* %7
%20 = load i64, i64* %9
%21 = icmp ugt i64 %19, %20
br i1 %21, label %22, label %24
22: ; preds = %5
%23 = load i64, i64* %7
br label %26
24: ; preds = %5
%25 = load i64, i64* %9
br label %26
26: ; preds = %24, %22
%27 = phi i64 [ %23, %22 ], [ %25, %24 ]
%28 = call i64 @nextpow2(i64 %27)
store i64 %28, i64* %17
%29 = load i64, i64* %17
%30 = mul nsw i64 2, %29
%31 = add nsw i64 %30, 2
%32 = mul i64 4, %31
%33 = trunc i64 %32 to i32
%34 = call i64 @safe_malloc(i32 %33)
%35 = inttoptr i64 %34 to float*
store float* %35, float** %13
%36 = load i64, i64* %17
%37 = mul nsw i64 2, %36
%38 = add nsw i64 %37, 2
%39 = mul i64 4, %38
%40 = trunc i64 %39 to i32
%41 = call i64 @safe_malloc(i32 %40)
%42 = inttoptr i64 %41 to float*
store float* %42, float** %14
%43 = load i64, i64* %7
%44 = sub i64 %43, 1
store i64 %44, i64* %15
br label %45
45: ; preds = %55, %26
%46 = load i64, i64* %15
%47 = icmp sge i64 %46, 0
br i1 %47, label %48, label %58
48: ; preds = %45
%49 = load float*, float** %6
%50 = getelementptr inbounds float, float* %49, i32 1
store float* %50, float** %6
%51 = load float, float* %49
%52 = load float*, float** %13
%53 = load i64, i64* %15
%54 = getelementptr inbounds float, float* %52, i64 %53
store float %51, float* %54
br label %55
55: ; preds = %48
%56 = load i64, i64* %15
%57 = add nsw i64 %56, -1
store i64 %57, i64* %15
br label %45
58: ; preds = %45
%59 = load i64, i64* %7
store i64 %59, i64* %15
br label %60
60: ; preds = %69, %58
%61 = load i64, i64* %15
%62 = load i64, i64* %17
%63 = mul nsw i64 2, %62
%64 = icmp slt i64 %61, %63
br i1 %64, label %65, label %72
65: ; preds = %60
%66 = load float*, float** %13
%67 = load i64, i64* %15
%68 = getelementptr inbounds float, float* %66, i64 %67
store float 0.000000e+00, float* %68
br label %69
69: ; preds = %65
%70 = load i64, i64* %15
%71 = add nsw i64 %70, 1
store i64 %71, i64* %15
br label %60
72: ; preds = %60
%73 = load float*, float** %13
%74 = load i64, i64* %17
%75 = mul nsw i64 2, %74
%76 = trunc i64 %75 to i32
%77 = call i32 @RealFFT(float* %73, i32 %76)
store i64 0, i64* %15
br label %78
78: ; preds = %90, %72
%79 = load i64, i64* %15
%80 = load i64, i64* %9
%81 = icmp slt i64 %79, %80
br i1 %81, label %82, label %93
82: ; preds = %78
%83 = load float*, float** %8
%84 = load i64, i64* %15
%85 = getelementptr inbounds float, float* %83, i64 %84
%86 = load float, float* %85
%87 = load float*, float** %14
%88 = load i64, i64* %15
%89 = getelementptr inbounds float, float* %87, i64 %88
store float %86, float* %89
br label %90
90: ; preds = %82
%91 = load i64, i64* %15
%92 = add nsw i64 %91, 1
store i64 %92, i64* %15
br label %78
93: ; preds = %78
%94 = load i64, i64* %9
store i64 %94, i64* %15
br label %95
95: ; preds = %104, %93
%96 = load i64, i64* %15
%97 = load i64, i64* %17
%98 = mul nsw i64 2, %97
%99 = icmp slt i64 %96, %98
br i1 %99, label %100, label %107
100: ; preds = %95
%101 = load float*, float** %14
%102 = load i64, i64* %15
%103 = getelementptr inbounds float, float* %101, i64 %102
store float 0.000000e+00, float* %103
br label %104
104: ; preds = %100
%105 = load i64, i64* %15
%106 = add nsw i64 %105, 1
store i64 %106, i64* %15
br label %95
107: ; preds = %95
%108 = load float*, float** %14
%109 = load i64, i64* %17
%110 = mul nsw i64 2, %109
%111 = trunc i64 %110 to i32
%112 = call i32 @RealFFT(float* %108, i32 %111)
store i64 0, i64* %15
br label %113
113: ; preds = %163, %107
%114 = load i64, i64* %15
%115 = load i64, i64* %17
%116 = icmp sle i64 %114, %115
br i1 %116, label %117, label %166
117: ; preds = %113
%118 = load i64, i64* %15
%119 = shl i64 %118, 1
store i64 %119, i64* %16
%120 = load float*, float** %13
%121 = load i64, i64* %16
%122 = getelementptr inbounds float, float* %120, i64 %121
%123 = load float, float* %122
store float %123, float* %11
%124 = load float*, float** %13
%125 = load i64, i64* %16
%126 = add nsw i64 1, %125
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
store float %128, float* %12
%129 = load float, float* %11
%130 = load float*, float** %14
%131 = load i64, i64* %16
%132 = getelementptr inbounds float, float* %130, i64 %131
%133 = load float, float* %132
%134 = load float, float* %12
%135 = load float*, float** %14
%136 = load i64, i64* %16
%137 = add nsw i64 1, %136
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
%140 = fmul float %134, %139
%141 = fneg float %140
%142 = call float @llvm.fmuladd.f32(float %129, float %133, float %141)
%143 = load float*, float** %13
%144 = load i64, i64* %16
%145 = getelementptr inbounds float, float* %143, i64 %144
store float %142, float* %145
%146 = load float, float* %11
%147 = load float*, float** %14
%148 = load i64, i64* %16
%149 = add nsw i64 1, %148
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = load float, float* %12
%153 = load float*, float** %14
%154 = load i64, i64* %16
%155 = getelementptr inbounds float, float* %153, i64 %154
%156 = load float, float* %155
%157 = fmul float %152, %156
%158 = call float @llvm.fmuladd.f32(float %146, float %151, float %157)
%159 = load float*, float** %13
%160 = load i64, i64* %16
%161 = add nsw i64 1, %160
%162 = getelementptr inbounds float, float* %159, i64 %161
store float %158, float* %162
br label %163
163: ; preds = %117
%164 = load i64, i64* %15
%165 = add nsw i64 %164, 1
store i64 %165, i64* %15
br label %113
166: ; preds = %113
%167 = load float*, float** %13
%168 = load i64, i64* %17
%169 = mul nsw i64 2, %168
%170 = trunc i64 %169 to i32
%171 = call i32 @RealIFFT(float* %167, i32 %170)
%172 = load i64, i64* %7
%173 = load i64, i64* %9
%174 = add i64 %172, %173
%175 = sub i64 %174, 1
store i64 %175, i64* %18
store i64 0, i64* %15
br label %176
176: ; preds = %188, %166
%177 = load i64, i64* %15
%178 = load i64, i64* %18
%179 = icmp slt i64 %177, %178
br i1 %179, label %180, label %191
180: ; preds = %176
%181 = load float*, float** %13
%182 = load i64, i64* %15
%183 = getelementptr inbounds float, float* %181, i64 %182
%184 = load float, float* %183
%185 = load float*, float** %10
%186 = load i64, i64* %15
%187 = getelementptr inbounds float, float* %185, i64 %186
store float %184, float* %187
br label %188
188: ; preds = %180
%189 = load i64, i64* %15
%190 = add nsw i64 %189, 1
store i64 %190, i64* %15
br label %176
191: ; preds = %176
%192 = load float*, float** %13
%193 = call i32 @safe_free(float* %192)
%194 = load float*, float** %14
%195 = call i32 @safe_free(float* %194)
%196 = load i64, i64* %18
ret i64 %196
}

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