#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*/ fftn(int, int *, double *, double *, int, double);
void fft_conv(int it, int n, double *values, double *yy, double *fftr,
              double *ffti, double *dr, double *di) {
  int i;
  int dims[2];
  double x, y;
  int n2 = 2 * n;
  switch (it) {
  case 0:
    dims[0] = n;
    for (i = 0; i < n; i++) {
      di[i] = 0.0;
      dr[i] = yy[i];
    }
    fftn(1, dims, dr, di, 1, -2.0);
    for (i = 0; i < n; i++) {
      x = dr[i] * fftr[i] - di[i] * ffti[i];
      y = dr[i] * ffti[i] + di[i] * fftr[i];
      dr[i] = x;
      di[i] = y;
    }
    fftn(1, dims, dr, di, -1, -2.0);
    for (i = 0; i < n; i++)
      values[i] = dr[i];
    return;
  case 1:
    dims[0] = n2;
    for (i = 0; i < n2; i++) {
      di[i] = 0.0;
      if (i < n)
        dr[i] = yy[i];
      else
        dr[i] = 0.0;
    }
    fftn(1, dims, dr, di, 1, -2.0);
    for (i = 0; i < n2; i++) {
      x = dr[i] * fftr[i] - di[i] * ffti[i];
      y = dr[i] * ffti[i] + di[i] * fftr[i];
      dr[i] = x;
      di[i] = y;
    }
    fftn(1, dims, dr, di, -1, -2.0);
    for (i = 0; i < n; i++)
      values[i] = dr[i];
    return;
  }
}


x86 assembly (clang, -O0):
<fft_conv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%eax
add    %eax,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
test   %eax,%eax
je     1162 <fft_conv+0x52>
jmp    1151 <fft_conv+0x41>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
je     1317 <fft_conv+0x207>
jmp    14f2 <fft_conv+0x3e2>
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11b3 <fft_conv+0xa3>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116f <fft_conv+0x5f>
lea    -0x34(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    $0x1,%r8d
movsd  0xe33(%rip),%xmm0
mov    %r8d,%edi
call   1030 <fftn@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12b3 <fft_conv+0x1a3>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11dc <fft_conv+0xcc>
lea    -0x34(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    $0x1,%edi
mov    $0xffffffff,%r8d
movsd  0xd2e(%rip),%xmm0
call   1030 <fftn@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1312 <fft_conv+0x202>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12de <fft_conv+0x1ce>
jmp    14f2 <fft_conv+0x3e2>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    138e <fft_conv+0x27e>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    136b <fft_conv+0x25b>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    137b <fft_conv+0x26b>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1380 <fft_conv+0x270>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1324 <fft_conv+0x214>
lea    -0x34(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    $0x1,%r8d
movsd  0xc58(%rip),%xmm0
mov    %r8d,%edi
call   1030 <fftn@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    148e <fft_conv+0x37e>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13b7 <fft_conv+0x2a7>
lea    -0x34(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    $0x1,%edi
mov    $0xffffffff,%r8d
movsd  0xb53(%rip),%xmm0
call   1030 <fftn@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14ed <fft_conv+0x3dd>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b9 <fft_conv+0x3a9>
jmp    14f2 <fft_conv+0x3e2>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fft_conv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r12
mov    %rdx,%r14
mov    %esi,%r13d
mov    0x68(%rsp),%rbx
mov    0x60(%rsp),%r15
cmp    $0x1,%edi
je     115d <fft_conv+0x4d>
test   %edi,%edi
jne    15a4 <fft_conv+0x494>
mov    %r13d,0x18(%rsp)
test   %r13d,%r13d
jle    118d <fft_conv+0x7d>
mov    %r13d,%ebp
cmp    $0x4,%r13d
mov    %r9,0x10(%rsp)
jae    11b5 <fft_conv+0xa5>
xor    %eax,%eax
jmp    12bb <fft_conv+0x1ab>
lea    0x0(%r13,%r13,1),%eax
mov    %eax,0x18(%rsp)
test   %r13d,%r13d
jle    118d <fft_conv+0x7d>
mov    %r13,0x20(%rsp)
mov    %r13d,%ebp
mov    $0x1,%r13d
cmp    $0x2,%eax
cmovge %eax,%r13d
jge    13a0 <fft_conv+0x290>
xor    %eax,%eax
jmp    1400 <fft_conv+0x2f0>
lea    0x18(%rsp),%rsi
movsd  0xe66(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x1,%r8d
call   1030 <fftn@plt>
jmp    1581 <fft_conv+0x471>
lea    (%r15,%rbp,8),%rax
cmp    %rbx,%rax
seta   %r9b
lea    (%rbx,%rbp,8),%rsi
cmp    %r15,%rsi
seta   %r10b
lea    (%rcx,%rbp,8),%rdi
cmp    %rbx,%rdi
seta   %dl
cmp    %rcx,%rsi
seta   %r11b
cmp    %r15,%rdi
seta   %sil
cmp    %rcx,%rax
seta   %r8b
xor    %eax,%eax
test   %r10b,%r9b
jne    12bb <fft_conv+0x1ab>
and    %r11b,%dl
jne    12bb <fft_conv+0x1ab>
and    %r8b,%sil
jne    12bb <fft_conv+0x1ab>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1904 <fft_conv+0x7f4>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %rdx,%rdi
xor    %esi,%esi
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movups %xmm0,(%rbx,%rsi,8)
movups %xmm0,0x10(%rbx,%rsi,8)
movups (%rcx,%rsi,8),%xmm1
movups 0x10(%rcx,%rsi,8),%xmm2
movups %xmm1,(%r15,%rsi,8)
movups %xmm2,0x10(%r15,%rsi,8)
movups %xmm0,0x20(%rbx,%rsi,8)
movups %xmm0,0x30(%rbx,%rsi,8)
movupd 0x20(%rcx,%rsi,8),%xmm1
movupd 0x30(%rcx,%rsi,8),%xmm2
movupd %xmm1,0x20(%r15,%rsi,8)
movupd %xmm2,0x30(%r15,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1240 <fft_conv+0x130>
test   $0x1,%dl
je     12b2 <fft_conv+0x1a2>
xorps  %xmm0,%xmm0
movups %xmm0,(%rbx,%rsi,8)
movups %xmm0,0x10(%rbx,%rsi,8)
movups (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm1
movups %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
cmp    %rbp,%rax
je     135e <fft_conv+0x24e>
mov    %rax,%rdx
not    %rdx
add    %rbp,%rdx
mov    %rbp,%rsi
and    $0x3,%rsi
je     12ed <fft_conv+0x1dd>
nopl   (%rax)
movq   $0x0,(%rbx,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    12d0 <fft_conv+0x1c0>
cmp    $0x3,%rdx
jb     135e <fft_conv+0x24e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,(%rbx,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1300 <fft_conv+0x1f0>
lea    0x18(%rsp),%rsi
movsd  0xc95(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x1,%r8d
call   1030 <fftn@plt>
test   %r13d,%r13d
jle    1581 <fft_conv+0x471>
cmp    $0x1,%r13d
jne    15b3 <fft_conv+0x4a3>
xor    %eax,%eax
mov    0x10(%rsp),%rdi
jmp    16a0 <fft_conv+0x590>
mov    %r13d,%edx
and    $0x7ffffffe,%edx
xor    %esi,%esi
jmp    13c0 <fft_conv+0x2b0>
nopl   (%rax)
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x1,%rsi
cmp    %rdx,%rsi
je     13fc <fft_conv+0x2ec>
mov    %rsi,%rax
movq   $0x0,(%rbx,%rsi,8)
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
cmp    %rbp,%rsi
jae    13dc <fft_conv+0x2cc>
movsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
lea    0x1(%rax),%rsi
cmp    %rbp,%rsi
jae    13b0 <fft_conv+0x2a0>
movsd  0x8(%rcx,%rax,8),%xmm0
jmp    13b0 <fft_conv+0x2a0>
add    $0x2,%rax
mov    %r9,0x10(%rsp)
test   $0x1,%r13b
je     1426 <fft_conv+0x316>
movq   $0x0,(%rbx,%rax,8)
xorps  %xmm0,%xmm0
cmp    %rbp,%rax
jae    1420 <fft_conv+0x310>
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
lea    0x18(%rsp),%rsi
movsd  0xbcd(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0x1,%r8d
call   1030 <fftn@plt>
cmpl   $0x0,0x20(%rsp)
jle    1581 <fft_conv+0x471>
cmp    $0x2,%r13d
jae    17b4 <fft_conv+0x6a4>
xor    %eax,%eax
mov    0x10(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
movsd  (%rbx,%rax,8),%xmm2
movsd  (%rdi,%rax,8),%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm4
subsd  %xmm3,%xmm4
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm4,(%r15,%rax,8)
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1470 <fft_conv+0x360>
lea    0x18(%rsp),%rsi
movsd  0xb3d(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0xffffffff,%r8d
call   1030 <fftn@plt>
mov    0x20(%rsp),%rcx
test   %ecx,%ecx
jle    15a4 <fft_conv+0x494>
mov    %ebp,%eax
cmp    $0x4,%ecx
jb     1507 <fft_conv+0x3f7>
lea    (%r15,%rax,8),%rcx
cmp    %r14,%rcx
jbe    18b4 <fft_conv+0x7a4>
lea    (%r14,%rax,8),%rcx
cmp    %r15,%rcx
jbe    18b4 <fft_conv+0x7a4>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rbp
je     1536 <fft_conv+0x426>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbp
jne    1520 <fft_conv+0x410>
cmp    $0x3,%rdx
jb     15a4 <fft_conv+0x494>
nopl   0x0(%rax)
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
movsd  0x10(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1540 <fft_conv+0x430>
jmp    15a4 <fft_conv+0x494>
lea    0x18(%rsp),%rsi
movsd  0xa72(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0xffffffff,%r8d
call   1030 <fftn@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13,0x20(%rsp)
lea    (%rbx,%rbp,8),%rax
cmp    %r15,%rax
seta   %r13b
lea    (%r15,%rbp,8),%rsi
cmp    %rbx,%rsi
seta   %r11b
lea    (%r12,%rbp,8),%r9
cmp    %r15,%r9
seta   %cl
cmp    %r12,%rsi
seta   %r8b
mov    0x10(%rsp),%rdi
lea    (%rdi,%rbp,8),%r10
cmp    %r15,%r10
seta   %dl
cmp    %rdi,%rsi
seta   0xf(%rsp)
cmp    %rbx,%r9
seta   %sil
cmp    %r12,%rax
seta   %r9b
cmp    %rbx,%r10
seta   %r10b
cmp    %rdi,%rax
seta   0xe(%rsp)
xor    %eax,%eax
test   %r11b,%r13b
jne    1aab <fft_conv+0x99b>
and    %r8b,%cl
mov    0x20(%rsp),%r13
jne    16a0 <fft_conv+0x590>
and    0xf(%rsp),%dl
jne    16a0 <fft_conv+0x590>
and    %r9b,%sil
jne    16a0 <fft_conv+0x590>
and    0xe(%rsp),%r10b
jne    16a0 <fft_conv+0x590>
mov    %ebp,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm0
movupd (%r12,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
movupd (%rdi,%rcx,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm0
mulpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm4
subpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm1
addpd  %xmm1,%xmm0
movupd %xmm4,(%r15,%rcx,8)
movupd %xmm0,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1650 <fft_conv+0x540>
cmp    %rbp,%rax
je     16e6 <fft_conv+0x5d6>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
movsd  (%rbx,%rax,8),%xmm2
movsd  (%rdi,%rax,8),%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm4
subsd  %xmm3,%xmm4
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm4,(%r15,%rax,8)
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    16a0 <fft_conv+0x590>
lea    0x18(%rsp),%rsi
movsd  0x90d(%rip),%xmm0
mov    $0x1,%edi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    $0xffffffff,%r8d
call   1030 <fftn@plt>
test   %r13d,%r13d
jle    15a4 <fft_conv+0x494>
cmp    $0x4,%r13d
jb     1732 <fft_conv+0x622>
lea    (%r15,%rbp,8),%rax
cmp    %r14,%rax
jbe    18da <fft_conv+0x7ca>
lea    (%r14,%rbp,8),%rax
cmp    %r15,%rax
jbe    18da <fft_conv+0x7ca>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1766 <fft_conv+0x656>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1750 <fft_conv+0x640>
cmp    $0x3,%rcx
jb     15a4 <fft_conv+0x494>
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1770 <fft_conv+0x660>
jmp    15a4 <fft_conv+0x494>
lea    (%rbx,%r13,8),%rax
cmp    %r15,%rax
seta   0xf(%rsp)
lea    (%r15,%r13,8),%rsi
cmp    %rbx,%rsi
seta   %r10b
lea    (%r12,%r13,8),%rdi
cmp    %r15,%rdi
seta   %cl
cmp    %r12,%rsi
seta   %r8b
mov    0x10(%rsp),%r11
lea    (%r11,%r13,8),%r9
cmp    %r15,%r9
seta   %dl
cmp    %r11,%rsi
seta   0xe(%rsp)
cmp    %rbx,%rdi
seta   %sil
cmp    %r12,%rax
seta   %dil
cmp    %rbx,%r9
seta   %r9b
cmp    %r11,%rax
seta   %r11b
xor    %eax,%eax
test   %r10b,0xf(%rsp)
jne    1ab5 <fft_conv+0x9a5>
mov    %edi,%r10d
and    %r8b,%cl
mov    0x10(%rsp),%rdi
jne    1470 <fft_conv+0x360>
and    0xe(%rsp),%dl
jne    1470 <fft_conv+0x360>
and    %r10b,%sil
jne    1470 <fft_conv+0x360>
and    %r11b,%r9b
jne    1470 <fft_conv+0x360>
mov    %r13d,%eax
and    $0x7ffffffe,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r15,%rcx,8),%xmm0
movupd (%r12,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
movupd (%rdi,%rcx,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm0
mulpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm4
subpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm1
addpd  %xmm1,%xmm0
movupd %xmm4,(%r15,%rcx,8)
movupd %xmm0,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1860 <fft_conv+0x750>
cmp    %r13,%rax
jne    1470 <fft_conv+0x360>
jmp    14b6 <fft_conv+0x3a6>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    1914 <fft_conv+0x804>
xor    %edi,%edi
jmp    198a <fft_conv+0x87a>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0xc,%rsi
jae    19db <fft_conv+0x8cb>
xor    %esi,%esi
jmp    1a5a <fft_conv+0x94a>
xor    %esi,%esi
test   $0x1,%dl
jne    1290 <fft_conv+0x180>
jmp    12b2 <fft_conv+0x1a2>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%r15,%rdi,8),%xmm0
movups 0x10(%r15,%rdi,8),%xmm1
movups %xmm0,(%r14,%rdi,8)
movups %xmm1,0x10(%r14,%rdi,8)
movups 0x20(%r15,%rdi,8),%xmm0
movups 0x30(%r15,%rdi,8),%xmm1
movups %xmm0,0x20(%r14,%rdi,8)
movups %xmm1,0x30(%r14,%rdi,8)
movups 0x40(%r15,%rdi,8),%xmm0
movups 0x50(%r15,%rdi,8),%xmm1
movups %xmm0,0x40(%r14,%rdi,8)
movups %xmm1,0x50(%r14,%rdi,8)
movups 0x60(%r15,%rdi,8),%xmm0
movupd 0x70(%r15,%rdi,8),%xmm1
movups %xmm0,0x60(%r14,%rdi,8)
movupd %xmm1,0x70(%r14,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1920 <fft_conv+0x810>
test   %rdx,%rdx
je     19cd <fft_conv+0x8bd>
lea    (%r14,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r15,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rdi,%rbx,1),%xmm0
movupd (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movupd %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    19b0 <fft_conv+0x8a0>
cmp    %rax,%rcx
je     15a4 <fft_conv+0x494>
jmp    1509 <fft_conv+0x3f9>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r15,%rsi,8),%xmm0
movups 0x10(%r15,%rsi,8),%xmm1
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
movups 0x20(%r15,%rsi,8),%xmm0
movups 0x30(%r15,%rsi,8),%xmm1
movups %xmm0,0x20(%r14,%rsi,8)
movups %xmm1,0x30(%r14,%rsi,8)
movups 0x40(%r15,%rsi,8),%xmm0
movups 0x50(%r15,%rsi,8),%xmm1
movups %xmm0,0x40(%r14,%rsi,8)
movups %xmm1,0x50(%r14,%rsi,8)
movups 0x60(%r15,%rsi,8),%xmm0
movupd 0x70(%r15,%rsi,8),%xmm1
movups %xmm0,0x60(%r14,%rsi,8)
movupd %xmm1,0x70(%r14,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    19f0 <fft_conv+0x8e0>
test   %rcx,%rcx
je     1a9d <fft_conv+0x98d>
lea    (%r14,%rsi,8),%rdx
add    $0x10,%rdx
lea    (%r15,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1a80 <fft_conv+0x970>
cmp    %rbp,%rax
je     15a4 <fft_conv+0x494>
jmp    1734 <fft_conv+0x624>
mov    0x20(%rsp),%r13
jmp    16a0 <fft_conv+0x590>
mov    0x10(%rsp),%rdi
jmp    1470 <fft_conv+0x360>

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

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