#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*/ cfftb(size_t, double *, double *);
int /*<<< orphan*/ cfftf(size_t, double *, double *);
void bluestein(size_t n, double *data, double *tstorage, int isign) {
  size_t n2 = *((size_t *)tstorage);
  size_t m;
  double *bk, *bkf, *akf, *work;
  bk = tstorage + 2;
  bkf = tstorage + 2 + 2 * n;
  work = tstorage + 2 + 2 * (n + n2);
  akf = tstorage + 2 + 2 * n + 6 * n2 + 16;
  if (isign > 0)
    for (m = 0; m < 2 * n; m += 2) {
      akf[m] = data[m] * bk[m] - data[m + 1] * bk[m + 1];
      akf[m + 1] = data[m] * bk[m + 1] + data[m + 1] * bk[m];
    }
  else
    for (m = 0; m < 2 * n; m += 2) {
      akf[m] = data[m] * bk[m] + data[m + 1] * bk[m + 1];
      akf[m + 1] = -data[m] * bk[m + 1] + data[m + 1] * bk[m];
    }
  for (m = 2 * n; m < 2 * n2; ++m)
    akf[m] = 0;
  cfftf(n2, akf, work);
  if (isign > 0)
    for (m = 0; m < 2 * n2; m += 2) {
      double im = -akf[m] * bkf[m + 1] + akf[m + 1] * bkf[m];
      akf[m] = akf[m] * bkf[m] + akf[m + 1] * bkf[m + 1];
      akf[m + 1] = im;
    }
  else
    for (m = 0; m < 2 * n2; m += 2) {
      double im = akf[m] * bkf[m + 1] + akf[m + 1] * bkf[m];
      akf[m] = akf[m] * bkf[m] - akf[m + 1] * bkf[m + 1];
      akf[m + 1] = im;
    }
  cfftb(n2, akf, work);
  if (isign > 0)
    for (m = 0; m < 2 * n; m += 2) {
      data[m] = bk[m] * akf[m] - bk[m + 1] * akf[m + 1];
      data[m + 1] = bk[m + 1] * akf[m] + bk[m] * akf[m + 1];
    }
  else
    for (m = 0; m < 2 * n; m += 2) {
      data[m] = bk[m] * akf[m] + bk[m + 1] * akf[m + 1];
      data[m + 1] = -bk[m + 1] * akf[m] + bk[m] * akf[m + 1];
    }
}


x86 assembly (clang, -O0):
<bluestein>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    -0x8(%rbp),%rcx
add    -0x28(%rbp),%rcx
shl    $0x1,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
imul   $0x6,-0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x80,%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    12a0 <bluestein+0x180>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    129b <bluestein+0x17b>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    11c7 <bluestein+0xa7>
jmp    1381 <bluestein+0x261>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    137c <bluestein+0x25c>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    12a8 <bluestein+0x188>
jmp    1381 <bluestein+0x261>
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    13c3 <bluestein+0x2a3>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    138d <bluestein+0x26d>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
call   1030 <cfftf@plt>
cmpl   $0x0,-0x1c(%rbp)
jle    14c9 <bluestein+0x3a9>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    14c4 <bluestein+0x3a4>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    13e6 <bluestein+0x2c6>
jmp    15b4 <bluestein+0x494>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    15af <bluestein+0x48f>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    14d1 <bluestein+0x3b1>
jmp    15b4 <bluestein+0x494>
mov    -0x28(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
call   1040 <cfftb@plt>
cmpl   $0x0,-0x1c(%rbp)
jle    16b0 <bluestein+0x590>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    16ab <bluestein+0x58b>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    15d7 <bluestein+0x4b7>
jmp    1791 <bluestein+0x671>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    178c <bluestein+0x66c>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%rcx
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    16b8 <bluestein+0x598>
jmp    1791 <bluestein+0x671>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bluestein>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    (%rdx),%rsi
lea    0x10(%rdx),%r12
lea    (%rdi,%rdi,1),%r13
mov    %rdi,%rax
shl    $0x4,%rax
lea    (%rdx,%rax,1),%r9
add    $0x10,%r9
lea    (%rsi,%rdi,1),%rax
shl    $0x4,%rax
lea    (%rsi,%rsi,1),%rbp
lea    0x0(,%rbp,2),%r8
add    %rbp,%r8
mov    %ecx,0x24(%rsp)
test   %ecx,%ecx
jle    11eb <bluestein+0xbb>
test   %r13,%r13
je     1259 <bluestein+0x129>
lea    (%r8,%r13,1),%rcx
lea    (%r14,%rcx,8),%rcx
add    $0x98,%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  0x8(%r12,%rdx,8),%xmm1
movsd  0x8(%rbx,%rdx,8),%xmm2
mulsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
mulsd  (%r12,%rdx,8),%xmm0
mulsd  (%rbx,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %r13,%rdx
jb     11a0 <bluestein+0x70>
jmp    1259 <bluestein+0x129>
test   %r13,%r13
je     1259 <bluestein+0x129>
lea    (%r8,%r13,1),%rcx
lea    (%r14,%rcx,8),%rcx
add    $0x98,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  0x8(%r12,%rdx,8),%xmm1
movsd  0x8(%rbx,%rdx,8),%xmm2
mulsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
mulsd  (%r12,%rdx,8),%xmm0
mulsd  (%rbx,%rdx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %r13,%rdx
jb     1210 <bluestein+0xe0>
lea    (%r14,%rax,1),%rdx
add    $0x10,%rdx
mov    %r8,0x8(%rsp)
mov    %r9,0x28(%rsp)
lea    (%r9,%r8,8),%r15
add    $0x80,%r15
cmp    %rbp,%r13
mov    %rsi,0x10(%rsp)
jae    12bc <bluestein+0x18c>
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,4),%rax
lea    (%r14,%rax,8),%rax
add    $0x90,%rax
mov    %r15,0x18(%rsp)
mov    %rdx,%r15
mov    %rsi,%rdx
sub    %rdi,%rdx
shl    $0x4,%rdx
mov    %rax,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r15,%rdx
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rsi
mov    %rsi,%rdi
mov    %r15,%rsi
mov    %rdx,0x18(%rsp)
call   1040 <cfftf@plt>
cmpl   $0x0,0x24(%rsp)
jle    12ee <bluestein+0x1be>
test   %rbp,%rbp
je     1311 <bluestein+0x1e1>
lea    -0x1(%rbp),%rdi
cmp    $0x1,%rdi
jne    1328 <bluestein+0x1f8>
xor    %edx,%edx
mov    0x8(%rsp),%r11
jmp    1775 <bluestein+0x645>
test   %rbp,%rbp
je     1546 <bluestein+0x416>
lea    -0x1(%rbp),%rdi
cmp    $0x1,%rdi
jne    155d <bluestein+0x42d>
xor    %edx,%edx
mov    0x8(%rsp),%r11
jmp    17db <bluestein+0x6ab>
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
mov    0x18(%rsp),%rdx
call   1050 <cfftb@plt>
jmp    1863 <bluestein+0x733>
mov    %rdi,%rcx
shr    %rcx
mov    $0x10,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r11b
mov    0x28(%rsp),%rsi
lea    (%rsi,%rax,1),%r8
xor    %edx,%edx
cmp    %rsi,%r8
mov    0x8(%rsp),%r9
jb     1772 <bluestein+0x642>
test   %r11b,%r11b
jne    1772 <bluestein+0x642>
lea    (%r9,%r13,1),%r8
lea    (%r14,%r8,8),%r10
add    $0x98,%r10
lea    (%r14,%r8,8),%rsi
add    %rax,%rsi
add    $0x98,%rsi
cmp    %r10,%rsi
jb     1772 <bluestein+0x642>
test   %r11b,%r11b
jne    1772 <bluestein+0x642>
lea    (%r15,%rax,1),%rsi
cmp    %r15,%rsi
jb     1772 <bluestein+0x642>
test   %r11b,%r11b
jne    1772 <bluestein+0x642>
mov    %rcx,0x30(%rsp)
lea    (%r14,%r13,8),%rcx
add    $0x18,%rcx
lea    (%r14,%r13,8),%rsi
add    %rsi,%rax
add    $0x18,%rax
cmp    %rcx,%rax
jb     1772 <bluestein+0x642>
test   %r11b,%r11b
mov    %r9,%r11
jne    1775 <bluestein+0x645>
and    $0xfffffffffffffffe,%rdi
add    %rdi,%r8
lea    (%r14,%r8,8),%rdx
add    $0x98,%rdx
lea    (%r14,%r8,8),%r11
add    $0xa0,%r11
add    %r13,%rdi
lea    (%r14,%rdi,8),%r8
add    $0x20,%r8
lea    (%r14,%rdi,8),%rdi
add    $0x18,%rdi
cmp    %r11,%r15
setb   0x7(%rsp)
cmp    %rdx,%r10
setb   0x6(%rsp)
cmp    %r8,%r15
setb   %r9b
cmp    %rdx,%rcx
setb   0x5(%rsp)
cmp    %rdi,%r15
setb   0x4(%rsp)
mov    %rcx,%rax
mov    0x28(%rsp),%rcx
cmp    %rdx,%rcx
setb   0x3(%rsp)
cmp    %r8,%r10
setb   %r8b
cmp    %r11,%rax
setb   0x2(%rsp)
cmp    %rdi,%r10
setb   %al
cmp    %r11,%rcx
setb   %r10b
xor    %edx,%edx
mov    0x6(%rsp),%cl
test   %cl,0x7(%rsp)
jne    12e4 <bluestein+0x1b4>
and    0x5(%rsp),%r9b
jne    12e4 <bluestein+0x1b4>
mov    0x3(%rsp),%cl
and    %cl,0x4(%rsp)
jne    12e4 <bluestein+0x1b4>
and    0x2(%rsp),%r8b
jne    12e4 <bluestein+0x1b4>
and    %r10b,%al
mov    0x8(%rsp),%r11
jne    1775 <bluestein+0x645>
mov    0x30(%rsp),%r9
add    $0x1,%r9
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rax,%rax,1),%rdx
mov    0x10(%rsp),%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,2),%rcx
mov    %rax,%rdi
nopw   0x0(%rax,%rax,1)
movupd 0x90(%rsi,%rcx,1),%xmm0
movupd 0xa0(%rsi,%rcx,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd 0x10(%rsi),%xmm1
movupd 0x20(%rsi),%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm1
movapd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm1
mulpd  %xmm4,%xmm0
subpd  %xmm3,%xmm0
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm0,%xmm1
unpcklpd %xmm0,%xmm4
movupd %xmm4,0x90(%rsi,%rcx,1)
movupd %xmm1,0xa0(%rsi,%rcx,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14c0 <bluestein+0x390>
cmp    %rax,%r9
jne    1775 <bluestein+0x645>
jmp    1846 <bluestein+0x716>
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
mov    0x18(%rsp),%rdx
call   1050 <cfftb@plt>
jmp    18e0 <bluestein+0x7b0>
mov    %rdi,%rcx
shr    %rcx
mov    $0x10,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r11b
mov    0x28(%rsp),%rsi
lea    (%rsi,%rax,1),%r8
xor    %edx,%edx
cmp    %rsi,%r8
mov    0x8(%rsp),%r9
jb     17d8 <bluestein+0x6a8>
test   %r11b,%r11b
jne    17d8 <bluestein+0x6a8>
lea    (%r9,%r13,1),%r8
lea    (%r14,%r8,8),%r10
add    $0x98,%r10
lea    (%r14,%r8,8),%rsi
add    %rax,%rsi
add    $0x98,%rsi
cmp    %r10,%rsi
jb     17d8 <bluestein+0x6a8>
test   %r11b,%r11b
jne    17d8 <bluestein+0x6a8>
lea    (%r15,%rax,1),%rsi
cmp    %r15,%rsi
jb     17d8 <bluestein+0x6a8>
test   %r11b,%r11b
jne    17d8 <bluestein+0x6a8>
mov    %rcx,0x30(%rsp)
lea    (%r14,%r13,8),%rcx
add    $0x18,%rcx
lea    (%r14,%r13,8),%rsi
add    %rsi,%rax
add    $0x18,%rax
cmp    %rcx,%rax
jb     17d8 <bluestein+0x6a8>
test   %r11b,%r11b
mov    %r9,%r11
jne    17db <bluestein+0x6ab>
and    $0xfffffffffffffffe,%rdi
add    %rdi,%r8
lea    (%r14,%r8,8),%rdx
add    $0x98,%rdx
lea    (%r14,%r8,8),%r11
add    $0xa0,%r11
add    %r13,%rdi
lea    (%r14,%rdi,8),%r8
add    $0x20,%r8
lea    (%r14,%rdi,8),%rdi
add    $0x18,%rdi
cmp    %r11,%r15
setb   0x7(%rsp)
cmp    %rdx,%r10
setb   0x6(%rsp)
cmp    %r8,%r15
setb   %r9b
cmp    %rdx,%rcx
setb   0x5(%rsp)
cmp    %rdi,%r15
setb   0x4(%rsp)
mov    %rcx,%rax
mov    0x28(%rsp),%rcx
cmp    %rdx,%rcx
setb   0x3(%rsp)
cmp    %r8,%r10
setb   %r8b
cmp    %r11,%rax
setb   0x2(%rsp)
cmp    %rdi,%r10
setb   %al
cmp    %r11,%rcx
setb   %r10b
xor    %edx,%edx
mov    0x6(%rsp),%cl
test   %cl,0x7(%rsp)
jne    1307 <bluestein+0x1d7>
and    0x5(%rsp),%r9b
jne    1307 <bluestein+0x1d7>
mov    0x3(%rsp),%cl
and    %cl,0x4(%rsp)
jne    1307 <bluestein+0x1d7>
and    0x2(%rsp),%r8b
jne    1307 <bluestein+0x1d7>
and    %r10b,%al
mov    0x8(%rsp),%r11
jne    17db <bluestein+0x6ab>
mov    0x30(%rsp),%r9
add    $0x1,%r9
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rax,%rax,1),%rdx
mov    0x10(%rsp),%rcx
shl    $0x4,%rcx
lea    (%rcx,%rcx,2),%rcx
mov    %rax,%rdi
nop
movupd 0x90(%rsi,%rcx,1),%xmm0
movupd 0xa0(%rsi,%rcx,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd 0x10(%rsi),%xmm1
movupd 0x20(%rsi),%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm1
movapd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm1
mulpd  %xmm4,%xmm0
addpd  %xmm0,%xmm3
mulpd  %xmm2,%xmm4
subpd  %xmm1,%xmm4
movapd %xmm4,%xmm0
unpckhpd %xmm3,%xmm0
unpcklpd %xmm3,%xmm4
movupd %xmm4,0x90(%rsi,%rcx,1)
movupd %xmm0,0xa0(%rsi,%rcx,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rdi
jne    16f0 <bluestein+0x5c0>
cmp    %rax,%r9
jne    17db <bluestein+0x6ab>
jmp    1846 <bluestein+0x716>
mov    %r9,%r11
lea    (%r14,%r13,8),%rax
add    $0x18,%rax
lea    (%r11,%r13,1),%rcx
lea    (%r14,%rcx,8),%rcx
add    $0x98,%rcx
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
movsd  -0x8(%rcx,%rdx,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm3
subsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rcx,%rdx,8)
movsd  %xmm3,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rbp,%rdx
jb     1790 <bluestein+0x660>
jmp    1846 <bluestein+0x716>
mov    %r9,%r11
lea    (%r14,%r13,8),%rax
add    $0x18,%rax
lea    (%r11,%r13,1),%rcx
lea    (%r14,%rcx,8),%rcx
add    $0x98,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
movsd  -0x8(%rcx,%rdx,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm3
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rcx,%rdx,8)
movsd  %xmm4,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rbp,%rdx
jb     1800 <bluestein+0x6d0>
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
mov    0x18(%rsp),%rdx
call   1050 <cfftb@plt>
cmpl   $0x0,0x24(%rsp)
jle    18e0 <bluestein+0x7b0>
test   %r13,%r13
mov    0x8(%rsp),%rbp
je     195e <bluestein+0x82e>
lea    -0x1(%r13),%rsi
cmp    $0x1,%rsi
jne    196d <bluestein+0x83d>
xor    %edx,%edx
add    %r13,%rbp
lea    (%r14,%rbp,8),%rax
add    $0x98,%rax
xchg   %ax,%ax
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
mulsd  0x18(%r14,%rdx,8),%xmm1
mulsd  -0x8(%rax,%rdx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  0x18(%r14,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm0
mulsd  -0x8(%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %r13,%rdx
jb     1890 <bluestein+0x760>
jmp    195e <bluestein+0x82e>
test   %r13,%r13
mov    0x8(%rsp),%rbp
je     195e <bluestein+0x82e>
lea    -0x1(%r13),%rsi
cmp    $0x1,%rsi
jne    1a9b <bluestein+0x96b>
xor    %edx,%edx
add    %r13,%rbp
lea    (%r14,%rbp,8),%rax
add    $0x98,%rax
nopw   0x0(%rax,%rax,1)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  0x18(%r14,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
mulsd  -0x8(%rax,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  0x18(%r14,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm0
mulsd  -0x8(%rax,%rdx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %r13,%rdx
jb     1910 <bluestein+0x7e0>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rsi,%r8
shr    %r8
mov    $0x10,%ecx
mov    %r8,%rax
mul    %rcx
seto   %cl
lea    (%rbx,%rax,1),%rdi
xor    %edx,%edx
cmp    %rbx,%rdi
jb     1881 <bluestein+0x751>
test   %cl,%cl
jne    1881 <bluestein+0x751>
lea    0x8(%rbx),%rdi
add    %rbx,%rax
add    $0x8,%rax
cmp    %rdi,%rax
jb     1881 <bluestein+0x751>
test   %cl,%cl
jne    1881 <bluestein+0x751>
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%rsi,8),%rcx
add    $0x10,%rcx
mov    %rbp,%rax
add    %r13,%rax
add    %rsi,%rax
lea    (%r14,%rax,8),%rax
add    $0xa0,%rax
lea    (%r14,%rsi,8),%rdx
add    $0x20,%rdx
cmp    %rbx,%rax
seta   %sil
cmp    %rcx,%r15
setb   %dil
cmp    %rbx,%rdx
seta   %al
cmp    %rcx,%r12
setb   %cl
xor    %edx,%edx
test   %dil,%sil
jne    1881 <bluestein+0x751>
and    %cl,%al
jne    1881 <bluestein+0x751>
add    $0x1,%r8
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rax,%rax,1),%rdx
xor    %esi,%esi
mov    %rax,%rdi
nopl   0x0(%rax)
movupd (%r12,%rsi,1),%xmm0
movupd 0x10(%r12,%rsi,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd (%r15,%rsi,1),%xmm1
movupd 0x10(%r15,%rsi,1),%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm1
movapd %xmm1,%xmm3
mulpd  %xmm0,%xmm3
mulpd  %xmm2,%xmm1
mulpd  %xmm4,%xmm2
subpd  %xmm3,%xmm2
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm2,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm2,%xmm4
movups %xmm4,0x10(%rbx,%rsi,1)
movupd %xmm0,(%rbx,%rsi,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a20 <bluestein+0x8f0>
cmp    %rax,%r8
jne    1881 <bluestein+0x751>
jmp    195e <bluestein+0x82e>
mov    %rsi,%r8
shr    %r8
mov    $0x10,%ecx
mov    %r8,%rax
mul    %rcx
seto   %cl
lea    (%rbx,%rax,1),%rdi
xor    %edx,%edx
cmp    %rbx,%rdi
jb     18fa <bluestein+0x7ca>
test   %cl,%cl
jne    18fa <bluestein+0x7ca>
lea    0x8(%rbx),%rdi
add    %rbx,%rax
add    $0x8,%rax
cmp    %rdi,%rax
jb     18fa <bluestein+0x7ca>
test   %cl,%cl
jne    18fa <bluestein+0x7ca>
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%rsi,8),%rcx
add    $0x10,%rcx
mov    %rbp,%rax
add    %r13,%rax
add    %rsi,%rax
lea    (%r14,%rax,8),%rax
add    $0xa0,%rax
lea    (%r14,%rsi,8),%rdx
add    $0x20,%rdx
cmp    %rbx,%rax
seta   %sil
cmp    %rcx,%r15
setb   %dil
cmp    %rbx,%rdx
seta   %al
cmp    %rcx,%r12
setb   %cl
xor    %edx,%edx
test   %dil,%sil
jne    18fa <bluestein+0x7ca>
and    %cl,%al
jne    18fa <bluestein+0x7ca>
add    $0x1,%r8
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rax,%rax,1),%rdx
xor    %esi,%esi
mov    %rax,%rdi
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rsi,1),%xmm0
movupd 0x10(%r12,%rsi,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movupd (%r15,%rsi,1),%xmm3
movupd 0x10(%r15,%rsi,1),%xmm4
movapd %xmm3,%xmm5
unpcklpd %xmm4,%xmm5
unpckhpd %xmm1,%xmm0
unpckhpd %xmm4,%xmm3
movapd %xmm0,%xmm1
mulpd  %xmm3,%xmm1
mulpd  %xmm2,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm5,%xmm0
subpd  %xmm0,%xmm3
movapd %xmm2,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm2,%xmm3
movups %xmm3,0x10(%rbx,%rsi,1)
movupd %xmm0,(%rbx,%rsi,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b50 <bluestein+0xa20>
cmp    %rax,%r8
jne    18fa <bluestein+0x7ca>
jmp    195e <bluestein+0x82e>

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

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