#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*/ fft1(double *, double *, int, int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void fft2(double ar[], double ai[], int n, int nmax, int flag) {
  int i, iter, j, k;
  double *p, *q, *wr, *wi;
  if (n < 2) {
    fprintf(stderr, "Error : Illegal parameter in fft2()\n");
    return;
  }
  iter = 0;
  i = n;
  while ((i /= 2) != 0)
    iter++;
  j = 1;
  for (i = 1; i <= iter; i++)
    j *= 2;
  if (n != j) {
    fprintf(stderr, "Error : n != 2 ^ k  in fft2()\n");
    return;
  }
  wr = (double *)malloc(n * sizeof(double));
  if (wr == NULL) {
    fprintf(stderr, "Error : Out of memory  in fft2()\n");
    return;
  }
  wi = (double *)malloc(n * sizeof(double));
  if (wi == NULL) {
    fprintf(stderr, "Error : Out of memory  in fft2()\n");
    free((char *)wr);
    return;
  }
  for (j = 0; j < n; j++, k += nmax) {
    for (i = 0, p = ar + j, q = ai + j; i < n; i++, p += nmax, q += nmax) {
      *(wr + i) = *p;
      *(wi + i) = *q;
    }
    fft1(wr, wi, n, iter, flag);
    for (i = 0, p = ar + j, q = ai + j; i < n; i++, p += nmax, q += nmax) {
      *p = *(wr + i);
      *q = *(wi + i);
    }
  }
  for (i = k = 0; i < n; i++, k += nmax) {
    for (j = 0, p = ar + k, q = ai + k; j < n; j++) {
      *(wr + j) = *p++;
      *(wi + j) = *q++;
    }
    fft1(wr, wi, n, iter, flag);
    for (j = 0, p = ar + k, q = ai + k; j < n; j++) {
      *p++ = *(wr + j);
      *q++ = *(wi + j);
    }
  }
  free((char *)wr);
  free((char *)wi);
  return;
}


x86 assembly (clang, -O0):
<fft2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
cmpl   $0x2,-0x14(%rbp)
jge    117e <fft2+0x3e>
mov    0x2e75(%rip),%rax
mov    (%rax),%edi
lea    0xe8c(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1569 <fft2+0x429>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
je     11b0 <fft2+0x70>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    118b <fft2+0x4b>
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11e1 <fft2+0xa1>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11be <fft2+0x7e>
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1207 <fft2+0xc7>
mov    0x2dec(%rip),%rax
mov    (%rax),%edi
lea    0xe28(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1569 <fft2+0x429>
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    123f <fft2+0xff>
mov    0x2db4(%rip),%rax
mov    (%rax),%edi
lea    0xe0f(%rip),%rsi
call   1040 <fprintf@plt>
jmp    1569 <fft2+0x429>
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    1280 <fft2+0x140>
mov    0x2d7c(%rip),%rax
mov    (%rax),%edi
lea    0xdd7(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
jmp    1569 <fft2+0x429>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13fc <fft2+0x2bc>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    132e <fft2+0x1ee>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    12c0 <fft2+0x180>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
call   1060 <fft1@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e0 <fft2+0x2a0>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1372 <fft2+0x232>
jmp    13e5 <fft2+0x2a5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1287 <fft2+0x147>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1557 <fft2+0x417>
movl   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    149d <fft2+0x35d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1443 <fft2+0x303>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
call   1060 <fft1@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    153b <fft2+0x3fb>
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14e1 <fft2+0x3a1>
jmp    1540 <fft2+0x400>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    140a <fft2+0x2ca>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fft2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
cmp    $0x2,%edx
jge    116b <fft2+0x2b>
mov    0x2e83(%rip),%rax
mov    (%rax),%edi
lea    0xe9a(%rip),%rsi
jmp    1539 <fft2+0x3f9>
mov    %r8d,%r15d
mov    %ecx,%r13d
xor    %r12d,%r12d
mov    $0x1,%cl
mov    %edx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %ecx,%r8d
mov    %ebx,%ebp
shr    $0x1f,%ebp
add    %ebx,%ebp
sar    %ebp
add    $0x1,%r12d
lea    0x1(%rbp),%eax
lea    0x1(%r8),%ecx
mov    %ebp,%ebx
cmp    $0x2,%eax
ja     1180 <fft2+0x40>
lea    -0x1(%r12),%ecx
cmp    $0x7,%ecx
jae    11af <fft2+0x6f>
mov    $0x1,%ecx
jmp    11c8 <fft2+0x88>
mov    %r12d,%ebp
and    $0x7ffffff8,%ebp
mov    $0x1,%ecx
nopl   (%rax)
shl    $0x8,%ecx
add    $0xfffffff8,%ebp
jne    11c0 <fft2+0x80>
test   $0x7,%r12b
je     11e7 <fft2+0xa7>
movzbl %r8b,%eax
and    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nop
add    %ecx,%ecx
add    $0xffffffff,%eax
jne    11e0 <fft2+0xa0>
cmp    %edx,%ecx
jne    1517 <fft2+0x3d7>
mov    %rdi,0x40(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdx,0x10(%rsp)
lea    0x0(,%rdx,8),%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1529 <fft2+0x3e9>
mov    %rax,%rbx
mov    %r14d,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     1b8c <fft2+0xa4c>
mov    %rax,%r14
mov    %r12,0xa0(%rsp)
mov    %r15d,0x54(%rsp)
mov    0x10(%rsp),%rdx
test   %edx,%edx
mov    0x30(%rsp),%r8
mov    0x40(%rsp),%r11
jle    1b7f <fft2+0xa3f>
movslq %r13d,%r10
mov    %edx,%r9d
lea    -0x1(%r9),%rax
mov    %rax,0x48(%rsp)
mov    %r9d,%esi
and    $0xfffffffe,%esi
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x18(%rsp)
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x60(%rsp)
mov    %r10,%rdi
shl    $0x4,%rdi
lea    (%r8,%r10,8),%rbp
lea    (%r11,%r10,8),%rax
mov    %rax,0x38(%rsp)
mov    %r10,%rax
shl    $0x5,%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%r10,8),%r12
xor    %ecx,%ecx
mov    %r11,0x80(%rsp)
mov    %r8,0x78(%rsp)
xor    %eax,%eax
mov    %rsi,0x70(%rsp)
mov    %r10,0x28(%rsp)
mov    %r9,0x8(%rsp)
mov    %rdi,0x68(%rsp)
mov    %rbp,0x88(%rsp)
jmp    1322 <fft2+0x1e2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x90(%rsp),%rax
add    $0x1,%rax
mov    0x20(%rsp),%rcx
add    $0x8,%rcx
addq   $0x8,0x78(%rsp)
addq   $0x8,0x80(%rsp)
mov    %rbp,%r9
cmp    %rbp,%rax
mov    0x70(%rsp),%rsi
mov    0x68(%rsp),%rdi
mov    0x88(%rsp),%rbp
je     154f <fft2+0x40f>
lea    (%r11,%rax,8),%r13
mov    %rax,0x90(%rsp)
lea    (%r8,%rax,8),%r15
cmpq   $0x0,0x48(%rsp)
mov    %rcx,0x20(%rsp)
je     1500 <fft2+0x3c0>
mov    %r9,%rdx
xor    %eax,%eax
mov    0x38(%rsp),%r9
nopl   (%rax)
movsd  (%r11,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%r8,%rcx,1),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  (%r9,%rcx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x0(%rbp,%rcx,1),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
add    $0x2,%rax
add    %rdi,%rcx
cmp    %rax,%rsi
jne    1350 <fft2+0x210>
lea    (%r8,%rcx,1),%rsi
add    %r11,%rcx
mov    %rdx,%r9
mov    0x10(%rsp),%rdx
test   $0x1,%r9b
je     13b4 <fft2+0x274>
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rsi),%xmm0
movsd  %xmm0,(%r14,%rax,8)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    0xa0(%rsp),%rcx
mov    0x54(%rsp),%r8d
call   1060 <fft1@plt>
cmpq   $0x3,0x48(%rsp)
jae    13e0 <fft2+0x2a0>
xor    %eax,%eax
jmp    1495 <fft2+0x355>
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rcx
mov    0x78(%rsp),%rdx
xor    %eax,%eax
mov    0x60(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%r15
mov    %rcx,%r13
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rdx)
movsd  0x8(%rbx,%rax,8),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x0(%r13,%r12,1)
movsd  0x8(%r14,%rax,8),%xmm0
add    %r12,%rdx
movsd  %xmm0,(%r15,%r12,1)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,1)
add    %r12,%rcx
movsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rdx,1)
add    %r12,%rdx
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,1)
add    %r12,%rcx
movsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rdx,1)
add    %r12,%rdx
add    $0x4,%rax
add    %r12,%rcx
add    %r12,%rdx
cmp    %rax,%rsi
jne    1400 <fft2+0x2c0>
mov    0x58(%rsp),%rcx
add    %rcx,%r15
add    %rcx,%r13
mov    0x10(%rsp),%rdx
mov    0x30(%rsp),%r8
mov    0x40(%rsp),%r11
mov    0x28(%rsp),%r10
mov    0x8(%rsp),%rbp
mov    0x18(%rsp),%r9
test   %r9,%r9
je     12e0 <fft2+0x1a0>
lea    (%r14,%rax,8),%rcx
lea    (%rbx,%rax,8),%rax
xor    %edi,%edi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rdi,8)
add    $0x1,%rsi
add    %r10,%rdi
cmp    %rsi,%r9
jne    14d0 <fft2+0x390>
jmp    12e0 <fft2+0x1a0>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    %r15,%rsi
mov    %r13,%rcx
test   $0x1,%r9b
jne    13a1 <fft2+0x261>
jmp    13b4 <fft2+0x274>
mov    0x2ac2(%rip),%rax
mov    (%rax),%edi
lea    0xafe(%rip),%rsi
jmp    1539 <fft2+0x3f9>
mov    0x2ab0(%rip),%rax
mov    (%rax),%edi
lea    0xb0b(%rip),%rsi
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fprintf@plt>
test   %edx,%edx
jle    1b7f <fft2+0xa3f>
lea    (%rbx,%r9,8),%rcx
lea    (%r14,%r9,8),%rax
mov    %r9d,%esi
and    $0xfffffffc,%esi
mov    %rsi,0x38(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x60(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rax,0x68(%rsp)
cmp    %rax,%rbx
setb   %al
mov    %rcx,0x70(%rsp)
cmp    %rcx,%r14
setb   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %rsi,%rax
mov    %rsi,0x58(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x98(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x88(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x18(%rsp)
lea    0x30(%r8),%rbp
lea    0x30(%r11),%rax
lea    0x8(%r14),%rcx
mov    %rcx,0xc0(%rsp)
lea    0x8(%rbx),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x18(%r14),%rcx
mov    %rcx,0xb0(%rsp)
lea    0x18(%rbx),%rcx
mov    %rcx,0xa8(%rsp)
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1638 <fft2+0x4f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x80(%rsp),%esi
add    $0x1,%esi
mov    0x90(%rsp),%rcx
add    %r10,%rcx
add    %r12,%rbp
mov    0x48(%rsp),%rax
add    %r12,%rax
cmp    %edx,%esi
je     1b7f <fft2+0xa3f>
mov    %esi,0x80(%rsp)
mov    %rax,0x48(%rsp)
mov    %rbp,0x20(%rsp)
lea    (%rcx,%r9,1),%rax
lea    (%r11,%rcx,8),%r13
lea    (%r11,%rax,8),%rdi
mov    %rcx,0x90(%rsp)
lea    (%r8,%rcx,8),%r15
lea    (%r8,%rax,8),%r11
cmp    $0x4,%edx
mov    %rdi,0x78(%rsp)
jae    1690 <fft2+0x550>
xor    %esi,%esi
mov    %r15,%r8
mov    %r13,%rcx
test   $0x1,%r9b
je     17e6 <fft2+0x6a6>
jmp    1800 <fft2+0x6c0>
cs nopw 0x0(%rax,%rax,1)
cmp    %rdi,%rbx
setb   %al
mov    0x70(%rsp),%rsi
cmp    %rsi,%r13
setb   %cl
and    %al,%cl
or     0x7(%rsp),%cl
cmp    %r11,%rbx
setb   %al
cmp    %rsi,%r15
setb   %r9b
cmp    %rdi,%r14
setb   %sil
mov    0x68(%rsp),%rdi
cmp    %rdi,%r13
setb   %r8b
cmp    %r11,%r14
setb   %r10b
cmp    %rdi,%r15
setb   %dil
test   %cl,%cl
jne    17eb <fft2+0x6ab>
and    %r9b,%al
jne    17eb <fft2+0x6ab>
and    %r8b,%sil
jne    17eb <fft2+0x6ab>
mov    $0x0,%esi
mov    %r15,%r8
mov    %r13,%rcx
and    %dil,%r10b
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%rdi
jne    17e0 <fft2+0x6a0>
cmpq   $0x0,0x60(%rsp)
mov    0x48(%rsp),%rsi
je     1a36 <fft2+0x8f6>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups -0x30(%rdi,%rax,8),%xmm0
movups -0x20(%rdi,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups -0x10(%rsi,%rax,8),%xmm0
movups (%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups -0x10(%rdi,%rax,8),%xmm0
movups (%rdi,%rax,8),%xmm1
movups %xmm0,0x20(%r14,%rax,8)
movups %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1730 <fft2+0x5f0>
testb  $0x1,0x58(%rsp)
je     17bc <fft2+0x67c>
movups 0x0(%r13,%rax,8),%xmm0
movups 0x10(%r13,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
cmp    %r9,0x38(%rsp)
je     1887 <fft2+0x747>
mov    0x38(%rsp),%rsi
lea    (%r15,%rsi,8),%r8
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
nopl   0x0(%rax,%rax,1)
test   $0x1,%r9b
jne    1800 <fft2+0x6c0>
mov    %rsi,%rbp
jmp    1823 <fft2+0x6e3>
xor    %esi,%esi
mov    %r15,%r8
mov    %r13,%rcx
mov    0x8(%rsp),%r9
test   $0x1,%r9b
je     17e6 <fft2+0x6a6>
xchg   %ax,%ax
movsd  (%rcx),%xmm0
add    $0x8,%rcx
movsd  %xmm0,(%rbx,%rsi,8)
movsd  (%r8),%xmm0
add    $0x8,%r8
movsd  %xmm0,(%r14,%rsi,8)
mov    %rsi,%rbp
or     $0x1,%rbp
not    %rsi
cmp    0x88(%rsp),%rsi
je     1887 <fft2+0x747>
mov    %r9,%rax
sub    %rbp,%rax
mov    0xc0(%rsp),%rsi
lea    (%rsi,%rbp,8),%rdi
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rbp,8),%rsi
xor    %ebp,%ebp
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rbp,8)
movsd  (%r8,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rbp,8)
movsd  0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
movsd  0x8(%r8,%rbp,8),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1850 <fft2+0x710>
mov    %r11,%rbp
mov    %rbx,%rdi
mov    %r14,%rsi
mov    0xa0(%rsp),%rcx
mov    0x54(%rsp),%r8d
call   1060 <fft1@plt>
mov    0x10(%rsp),%rdx
cmp    $0x4,%edx
jae    18c0 <fft2+0x780>
xor    %eax,%eax
mov    0x30(%rsp),%r8
mov    0x40(%rsp),%r11
jmp    1a70 <fft2+0x930>
nopl   (%rax)
mov    %rbp,%rdi
cmp    %rbp,%r13
setb   %r11b
mov    0x78(%rsp),%rcx
cmp    %rcx,%r15
setb   %bpl
mov    0x70(%rsp),%rdx
cmp    %rdx,%r13
setb   %al
cmp    %rcx,%rbx
setb   %r10b
mov    0x68(%rsp),%rsi
cmp    %rsi,%r13
setb   %r9b
cmp    %rcx,%r14
setb   %r8b
cmp    %rdx,%r15
setb   %dl
cmp    %rdi,%rbx
setb   %cl
cmp    %rsi,%r15
setb   %sil
cmp    %rdi,%r14
setb   %dil
test   %bpl,%r11b
jne    1b73 <fft2+0xa33>
and    %r10b,%al
mov    0x40(%rsp),%r11
jne    1a58 <fft2+0x918>
and    %r8b,%r9b
jne    1a58 <fft2+0x918>
and    %cl,%dl
mov    0x30(%rsp),%r8
jne    1a2d <fft2+0x8ed>
and    %dil,%sil
jne    1a2d <fft2+0x8ed>
cmpq   $0x0,0x60(%rsp)
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%rbp
je     1a48 <fft2+0x908>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x8(%rsp),%r9
mov    0x48(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,-0x30(%rsi,%rax,8)
movups %xmm1,-0x20(%rsi,%rax,8)
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,-0x30(%rbp,%rax,8)
movups %xmm1,-0x20(%rbp,%rax,8)
movups 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movups %xmm0,-0x10(%rsi,%rax,8)
movups %xmm1,(%rsi,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,-0x10(%rbp,%rax,8)
movups %xmm1,0x0(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1980 <fft2+0x840>
testb  $0x1,0x58(%rsp)
je     1a0d <fft2+0x8cd>
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
cmp    %r9,0x38(%rsp)
je     1610 <fft2+0x4d0>
mov    0x38(%rsp),%rax
lea    (%r15,%rax,8),%r15
lea    0x0(%r13,%rax,8),%r13
mov    0x18(%rsp),%rsi
jmp    1a84 <fft2+0x944>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
jmp    1a70 <fft2+0x930>
xor    %eax,%eax
testb  $0x1,0x58(%rsp)
jne    1791 <fft2+0x651>
jmp    17bc <fft2+0x67c>
xor    %eax,%eax
mov    0x8(%rsp),%r9
testb  $0x1,0x58(%rsp)
jne    19e2 <fft2+0x8a2>
jmp    1a0d <fft2+0x8cd>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
mov    0x30(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%r10
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rbp
mov    %rax,%rcx
not    %rcx
add    %r9,%rcx
test   %rsi,%rsi
je     1ac8 <fft2+0x988>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x8,%r13
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r15)
add    $0x8,%r15
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1aa0 <fft2+0x960>
cmp    $0x3,%rcx
jb     1610 <fft2+0x4d0>
mov    %r9,%rcx
sub    %rax,%rcx
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rax,8),%rdi
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x18(%rax,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
movsd  -0x18(%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
movsd  -0x10(%rax,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
movsd  -0x10(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r15,%rsi,8)
movsd  -0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r13,%rsi,8)
movsd  -0x8(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r15,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,0x18(%r13,%rsi,8)
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x18(%r15,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1b00 <fft2+0x9c0>
jmp    1610 <fft2+0x4d0>
xor    %eax,%eax
mov    0x10(%rsp),%rdx
jmp    18ae <fft2+0x76e>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
jmp    1ba4 <fft2+0xa64>
mov    0x244d(%rip),%rax
mov    (%rax),%edi
lea    0x4a8(%rip),%rsi
call   1040 <fprintf@plt>
mov    %rbx,%rdi
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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