#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*/ Naive_AnalysisX(double *, int, int, double *, double *,
                                   double *);
int /*<<< orphan*/ SemiNaiveReduced(double *, int, int, double *, double *,
                                    double *, double *);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ grid_fourier(double *, double *, double *, double *, int,
                                double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(double *, double *, int);
int /*<<< orphan*/ seanindex2(int, int, int, int *);
double sqrt(int);
void FST_semi_memo(double *rdata, double *idata, double *rcoeffs,
                   double *icoeffs, int size, double **seminaive_naive_table,
                   double *workspace, int isReal, int cutoff) {
  int bw, m, i, j;
  double *rres, *ires;
  double *rdataptr, *idataptr;
  double *fltres, *scratchpad;
  double *eval_pts;
  int tmpindex[2];
  double pow_one;
  double *cos_even;
  double tmpA;
  bw = size / 2;
  cos_even = (double *)malloc(sizeof(double) * bw);
  rres = workspace;
  ires = rres + (size * size);
  fltres = ires + (size * size);
  eval_pts = fltres + bw;
  scratchpad = eval_pts + (2 * bw);
  grid_fourier(rdata, idata, rres, ires, size, scratchpad);
  tmpA = sqrt(2. * 3.141592653589793);
  for (i = 0; i < size * size; i++) {
    rres[i] *= tmpA;
    ires[i] *= tmpA;
  }
  rdataptr = rcoeffs;
  idataptr = icoeffs;
  for (m = 0; m < bw; m++) {
    if (m < cutoff) {
      SemiNaiveReduced(rres + (m * size), bw, m, fltres,
                       seminaive_naive_table[m], scratchpad, cos_even);
      memcpy(rdataptr, fltres, sizeof(double) * (bw - m));
      rdataptr += bw - m;
      SemiNaiveReduced(ires + (m * size), bw, m, fltres,
                       seminaive_naive_table[m], scratchpad, cos_even);
      memcpy(idataptr, fltres, sizeof(double) * (bw - m));
      idataptr += bw - m;
    } else {
      Naive_AnalysisX(rres + (m * size), bw, m, fltres,
                      seminaive_naive_table[m], workspace);
      memcpy(rdataptr, fltres, sizeof(double) * (bw - m));
      rdataptr += bw - m;
      Naive_AnalysisX(ires + (m * size), bw, m, fltres,
                      seminaive_naive_table[m], workspace);
      memcpy(idataptr, fltres, sizeof(double) * (bw - m));
      idataptr += bw - m;
    }
  }
  if (isReal == 0) {
    for (m = bw + 1; m < size; m++) {
      if (size - m < cutoff) {
        SemiNaiveReduced(rres + (m * size), bw, size - m, fltres,
                         seminaive_naive_table[size - m], scratchpad, cos_even);
        if ((m % 2) != 0) {
          for (i = 0; i < m - bw; i++)
            rdataptr[i] = -fltres[i];
        } else {
          memcpy(rdataptr, fltres, sizeof(double) * (m - bw));
        }
        rdataptr += m - bw;
        SemiNaiveReduced(ires + (m * size), bw, size - m, fltres,
                         seminaive_naive_table[size - m], scratchpad, cos_even);
        if ((m % 2) != 0) {
          for (i = 0; i < m - bw; i++)
            idataptr[i] = -fltres[i];
        } else {
          memcpy(idataptr, fltres, sizeof(double) * (m - bw));
        }
        idataptr += m - bw;
      } else {
        Naive_AnalysisX(rres + (m * size), bw, size - m, fltres,
                        seminaive_naive_table[size - m], workspace);
        if ((m % 2) != 0) {
          for (i = 0; i < m - bw; i++)
            rdataptr[i] = -fltres[i];
        } else {
          memcpy(rdataptr, fltres, sizeof(double) * (m - bw));
        }
        rdataptr += m - bw;
        Naive_AnalysisX(ires + (m * size), bw, size - m, fltres,
                        seminaive_naive_table[size - m], workspace);
        if ((m % 2) != 0) {
          for (i = 0; i < m - bw; i++)
            idataptr[i] = -fltres[i];
        } else {
          memcpy(idataptr, fltres, sizeof(double) * (m - bw));
        }
        idataptr += m - bw;
      }
    }
  } else {
    pow_one = 1.0;
    for (i = 1; i < bw; i++) {
      pow_one *= -1.0;
      for (j = i; j < bw; j++) {
        seanindex2(i, j, bw, tmpindex);
        rcoeffs[tmpindex[1]] = pow_one * rcoeffs[tmpindex[0]];
        icoeffs[tmpindex[1]] = -1.0 * pow_one * icoeffs[tmpindex[0]];
      }
    }
  }
  free(cos_even);
}


x86 assembly (clang, -O0):
<FST_semi_memo>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x70(%rbp),%r9
call   1040 <grid_fourier@plt>
mov    $0x6,%edi
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    12c0 <FST_semi_memo+0x140>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    126c <FST_semi_memo+0xec>
mov    -0x18(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    14b5 <FST_semi_memo+0x335>
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    13d6 <FST_semi_memo+0x256>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0x70(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1090 <SemiNaiveReduced@plt>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0x70(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1090 <SemiNaiveReduced@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    14a2 <FST_semi_memo+0x322>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    0x10(%rbp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    0x10(%rbp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    14a7 <FST_semi_memo+0x327>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d7 <FST_semi_memo+0x157>
cmpl   $0x0,0x18(%rbp)
jne    1896 <FST_semi_memo+0x716>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1891 <FST_semi_memo+0x711>
mov    -0x24(%rbp),%eax
sub    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    16be <FST_semi_memo+0x53e>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x24(%rbp),%edx
sub    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%r8d
sub    -0x38(%rbp),%r8d
movslq %r8d,%r8
mov    (%rax,%r8,8),%r8
mov    -0x70(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1090 <SemiNaiveReduced@plt>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     159b <FST_semi_memo+0x41b>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1596 <FST_semi_memo+0x416>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1546 <FST_semi_memo+0x3c6>
jmp    15b6 <FST_semi_memo+0x436>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x24(%rbp),%edx
sub    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%r8d
sub    -0x38(%rbp),%r8d
movslq %r8d,%r8
mov    (%rax,%r8,8),%r8
mov    -0x70(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1090 <SemiNaiveReduced@plt>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1686 <FST_semi_memo+0x506>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1681 <FST_semi_memo+0x501>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1631 <FST_semi_memo+0x4b1>
jmp    16a1 <FST_semi_memo+0x521>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    187e <FST_semi_memo+0x6fe>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x24(%rbp),%edx
sub    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%r8d
sub    -0x38(%rbp),%r8d
movslq %r8d,%r8
mov    (%rax,%r8,8),%r8
mov    0x10(%rbp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     176b <FST_semi_memo+0x5eb>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1766 <FST_semi_memo+0x5e6>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1716 <FST_semi_memo+0x596>
jmp    1786 <FST_semi_memo+0x606>
mov    -0x58(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x24(%rbp),%edx
sub    -0x38(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%r8d
sub    -0x38(%rbp),%r8d
movslq %r8d,%r8
mov    (%rax,%r8,8),%r8
mov    0x10(%rbp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     184b <FST_semi_memo+0x6cb>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1846 <FST_semi_memo+0x6c6>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17f6 <FST_semi_memo+0x676>
jmp    1866 <FST_semi_memo+0x6e6>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1883 <FST_semi_memo+0x703>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14c8 <FST_semi_memo+0x348>
jmp    1967 <FST_semi_memo+0x7e7>
movsd  0x762(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1962 <FST_semi_memo+0x7e2>
movsd  0x747(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    194f <FST_semi_memo+0x7cf>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x34(%rbp),%edx
lea    -0x80(%rbp),%rcx
call   1060 <seanindex2@plt>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x6e9(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18d7 <FST_semi_memo+0x757>
jmp    1954 <FST_semi_memo+0x7d4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18ad <FST_semi_memo+0x72d>
jmp    1967 <FST_semi_memo+0x7e7>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FST_semi_memo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x10(%rsp)
mov    %r8d,%r15d
mov    %rcx,0x38(%rsp)
mov    %rdx,0xb0(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0xa0(%rsp)
mov    0x110(%rsp),%r12
mov    %r8d,%ebx
shr    $0x1f,%ebx
add    %r8d,%ebx
mov    %ebx,%eax
sar    %eax
mov    %rax,0x30(%rsp)
movslq %eax,%rbp
lea    0x0(,%rbp,8),%edi
mov    %edi,0x28(%rsp)
call   1080 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %r15d,%r14d
imul   %r14d,%r14d
lea    (%r12,%r14,8),%r13
lea    0x0(,%r14,8),%rax
add    %r13,%rax
mov    %rbp,0x50(%rsp)
mov    %rax,0x20(%rsp)
lea    (%rax,%rbp,8),%rax
and    $0xfffffffe,%ebx
movslq %ebx,%rcx
lea    (%rax,%rcx,8),%r9
mov    0xa0(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %r15d,0x1c(%rsp)
mov    %r15d,%r8d
mov    %r9,0x98(%rsp)
call   1040 <grid_fourier@plt>
mov    $0x6,%edi
call   10a0 <sqrt@plt>
test   %r14d,%r14d
je     13bb <FST_semi_memo+0x23b>
cmp    $0x4,%r14d
jae    125b <FST_semi_memo+0xdb>
xor    %eax,%eax
jmp    1390 <FST_semi_memo+0x210>
mov    %r14d,%eax
and    $0x7ffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     2126 <FST_semi_memo+0xfa6>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
or     $0x2,%rsi
and    %r8,%rsi
lea    0x30(%r12),%rdi
lea    (%r12,%r14,8),%rbp
add    $0x30,%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rdi,%rcx,8),%xmm2
movupd -0x20(%rdi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rdi,%rcx,8)
movupd %xmm3,-0x20(%rdi,%rcx,8)
movupd -0x30(%rbp,%rcx,8),%xmm2
movupd -0x20(%rbp,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbp,%rcx,8)
movupd %xmm3,-0x20(%rbp,%rcx,8)
movupd -0x10(%rdi,%rcx,8),%xmm2
movupd (%rdi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdi,%rcx,8)
movupd %xmm3,(%rdi,%rcx,8)
movupd -0x10(%rbp,%rcx,8),%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbp,%rcx,8)
movupd %xmm3,0x0(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12b0 <FST_semi_memo+0x130>
test   $0x1,%r8b
je     1388 <FST_semi_memo+0x208>
movupd (%r12,%rcx,8),%xmm2
movupd 0x10(%r12,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
movupd 0x0(%r13,%rcx,8),%xmm2
movupd 0x10(%r13,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm3,0x10(%r13,%rcx,8)
cmp    %r14,%rax
je     13bb <FST_semi_memo+0x23b>
nopl   (%rax)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1390 <FST_semi_memo+0x210>
mov    %r14,0x58(%rsp)
mov    %r13,0xb8(%rsp)
mov    0x38(%rsp),%r14
mov    0xb0(%rsp),%rsi
cmpl   $0x2,0x1c(%rsp)
mov    0x78(%rsp),%rbp
jl     15ba <FST_semi_memo+0x43a>
mov    0x1c(%rsp),%edx
movslq 0x120(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x80(%rsp)
mov    0x58(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
shl    $0x3,%rdx
mov    %rdx,0x90(%rsp)
xor    %ebx,%ebx
mov    0x110(%rsp),%r15
mov    %eax,%r12d
mov    0xb0(%rsp),%rsi
mov    0x38(%rsp),%r14
jmp    1511 <FST_semi_memo+0x391>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rdi
mov    0x30(%rsp),%rbp
mov    %ebp,%esi
mov    %ebx,%edx
mov    0x20(%rsp),%r14
mov    %r14,%rcx
mov    0x110(%rsp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    %ebp,%r13d
sub    %ebx,%r13d
shl    $0x3,%r13d
mov    %r12,%rdi
mov    %r14,%rsi
mov    0x28(%rsp),%ebp
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    0x60(%rsp),%rax
lea    (%r15,%rax,1),%rdi
mov    0x10(%rsp),%rax
mov    (%rax,%rbx,8),%r8
mov    0x30(%rsp),%rsi
mov    %ebx,%edx
mov    %r14,%rcx
mov    0x110(%rsp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    0x70(%rsp),%r12d
mov    %r12d,0x68(%rsp)
mov    0xa0(%rsp),%rdi
mov    %r14,%rsi
mov    %rdi,%r14
mov    %r13d,%edx
call   1070 <memcpy@plt>
movslq 0x68(%rsp),%rax
mov    0x40(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
lea    (%r14,%rax,8),%r14
add    $0x1,%rbx
add    $0xfffffff8,%ebp
mov    %ebp,0x28(%rsp)
add    $0xffffffff,%r12d
add    0x90(%rsp),%r15
cmp    %rbx,0x80(%rsp)
mov    0x78(%rsp),%rbp
je     15ba <FST_semi_memo+0x43a>
mov    %r12d,0x70(%rsp)
mov    %rsi,%r12
mov    %r14,0xa0(%rsp)
mov    0x10(%rsp),%rax
mov    (%rax,%rbx,8),%r8
cmp    0x88(%rsp),%rbx
mov    %rsi,0x40(%rsp)
jge    1450 <FST_semi_memo+0x2d0>
mov    %rbp,(%rsp)
mov    %r15,%rdi
mov    0x30(%rsp),%r13
mov    %r13d,%esi
mov    %ebx,%edx
mov    0x20(%rsp),%r14
mov    %r14,%rcx
mov    0x98(%rsp),%r9
call   1090 <SemiNaiveReduced@plt>
mov    %r13d,%eax
sub    %ebx,%eax
mov    %eax,0x68(%rsp)
mov    %r12,%rdi
mov    %r14,%rsi
mov    0x28(%rsp),%ebp
mov    %ebp,%edx
call   1070 <memcpy@plt>
mov    0x60(%rsp),%rax
lea    (%r15,%rax,1),%rdi
mov    0x10(%rsp),%rax
mov    (%rax,%rbx,8),%r8
mov    0x78(%rsp),%rax
mov    %rax,(%rsp)
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r14,%rcx
mov    0x98(%rsp),%r9
call   1090 <SemiNaiveReduced@plt>
mov    %ebp,%r13d
mov    0x70(%rsp),%r12d
jmp    14bf <FST_semi_memo+0x33f>
cmpl   $0x0,0x118(%rsp)
je     16bc <FST_semi_memo+0x53c>
cmpl   $0x4,0x1c(%rsp)
mov    0x38(%rsp),%r12
mov    0xb0(%rsp),%rbp
jl     210a <FST_semi_memo+0xf8a>
mov    0x30(%rsp),%rax
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %ecx,0x10(%rsp)
movsd  0x1a04(%rip),%xmm2
mov    $0x1,%r14d
lea    0xc0(%rsp),%r15
movapd %xmm2,%xmm1
mov    0x30(%rsp),%r13
jmp    1633 <FST_semi_memo+0x4b3>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14d
movapd %xmm1,%xmm2
cmp    0x10(%rsp),%r14d
je     210a <FST_semi_memo+0xf8a>
xorpd  0x19d5(%rip),%xmm1
cmp    %r13d,%r14d
jge    1620 <FST_semi_memo+0x4a0>
mov    %r14d,%ebx
movapd %xmm1,0x40(%rsp)
movapd %xmm2,0xa0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r15,%rcx
call   1060 <seanindex2@plt>
movapd 0xa0(%rsp),%xmm2
movapd 0x40(%rsp),%xmm1
movslq 0xc0(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movslq 0xc4(%rsp),%rcx
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%ebx
cmp    %ebx,%r13d
jne    1660 <FST_semi_memo+0x4e0>
jmp    1620 <FST_semi_memo+0x4a0>
mov    0x30(%rsp),%rax
add    $0x1,%eax
cmp    0x1c(%rsp),%eax
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%r10
jge    210a <FST_semi_memo+0xf8a>
add    $0x1,%r10
movslq 0x1c(%rsp),%rax
mov    %rax,0xb0(%rsp)
movslq 0x120(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x58(%rsp),%rdx
lea    (%rdx,%rdx,1),%rax
add    $0x1,%rax
mov    %rax,0xc8(%rsp)
shl    $0x4,%rdx
mov    0x110(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
add    $0x30,%rcx
mov    %rcx,0x58(%rsp)
lea    (%rdx,%rax,1),%r12
add    $0x18,%r12
mov    $0x1,%r15d
xor    %r8d,%r8d
jmp    17eb <FST_semi_memo+0x66b>
nopl   (%rax)
mov    0x50(%rsp),%rax
mov    %eax,%ebx
mov    0x30(%rsp),%rbp
sub    %ebp,%ebx
lea    0x0(,%rbx,8),%edx
mov    0x40(%rsp),%rdi
mov    %r13,%rsi
call   1070 <memcpy@plt>
mov    0xb8(%rsp),%rax
mov    0x68(%rsp),%rcx
lea    (%rax,%rcx,8),%rdi
mov    0x10(%rsp),%rax
mov    0x90(%rsp),%rdx
mov    (%rax,%rdx,8),%r8
mov    %ebp,%esi
mov    %r13,%rcx
mov    0x110(%rsp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    0x70(%rsp),%r15
lea    0x0(,%rbx,8),%edx
mov    0xa0(%rsp),%r14
mov    %r14,%rdi
mov    %r13,%rsi
call   1070 <memcpy@plt>
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%r10
mov    0x40(%rsp),%rsi
mov    0x28(%rsp),%r8
movslq %ebx,%rax
lea    (%rsi,%rax,8),%rsi
lea    (%r14,%rax,8),%r14
add    $0x1,%r10
add    $0x1,%r15
add    $0x1,%r8
cmp    0x1c(%rsp),%r10d
je     210a <FST_semi_memo+0xf8a>
mov    %r14,0xa0(%rsp)
mov    %r15d,%ebx
and    $0x3,%ebx
mov    %r15,%rbp
and    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffc,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r15,0x70(%rsp)
mov    %r15,%r14
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%r14
lea    -0x4(%r14),%rax
mov    %rax,0x60(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x80(%rsp)
mov    0xc8(%rsp),%rax
mov    %r8,0x28(%rsp)
add    %r8,%rax
mov    0x110(%rsp),%r9
lea    (%r9,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    %r10d,%r15d
mov    0xb0(%rsp),%rax
mov    %rax,%rdx
sub    %r10,%rdx
mov    %r10,0x50(%rsp)
imul   %rax,%r10
lea    (%r9,%r10,8),%rdi
mov    0x0(%r13,%rdx,8),%r8
cmp    0xd0(%rsp),%rdx
mov    %rsi,0x40(%rsp)
mov    %r10,0x68(%rsp)
mov    %rdx,0x90(%rsp)
jge    1940 <FST_semi_memo+0x7c0>
mov    0x78(%rsp),%rax
mov    %rax,(%rsp)
mov    0x30(%rsp),%r14
mov    %r14d,%esi
mov    0x20(%rsp),%r13
mov    %r13,%rcx
mov    0x98(%rsp),%r9
call   1090 <SemiNaiveReduced@plt>
mov    %r15,0x38(%rsp)
test   $0x1,%r15b
jne    19a0 <FST_semi_memo+0x820>
mov    0x50(%rsp),%rax
mov    %eax,%ebx
sub    %r14d,%ebx
lea    0x0(,%rbx,8),%edx
mov    0x40(%rsp),%rdi
mov    %r13,%rsi
call   1070 <memcpy@plt>
mov    0xb8(%rsp),%rax
mov    0x68(%rsp),%rcx
lea    (%rax,%rcx,8),%rdi
mov    0x10(%rsp),%rax
mov    0x90(%rsp),%rdx
mov    (%rax,%rdx,8),%r8
mov    0x78(%rsp),%rax
mov    %rax,(%rsp)
mov    %r14d,%esi
mov    %r13,%rcx
mov    0x98(%rsp),%r9
call   1090 <SemiNaiveReduced@plt>
jmp    1796 <FST_semi_memo+0x616>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rcx
call   1050 <Naive_AnalysisX@plt>
test   $0x1,%r15b
je     1740 <FST_semi_memo+0x5c0>
mov    0x90(%rsp),%r9
mov    0x70(%rsp),%r15
cmp    $0x4,%r15
mov    0xb8(%rsp),%r8
mov    0x40(%rsp),%rdi
jae    19f4 <FST_semi_memo+0x874>
xor    %r14d,%r14d
mov    0x10(%rsp),%r13
mov    0x20(%rsp),%rsi
movapd 0x167f(%rip),%xmm2
movapd 0x1677(%rip),%xmm3
jmp    1b10 <FST_semi_memo+0x990>
xchg   %ax,%ax
mov    0x78(%rsp),%r13
mov    %r14,%rsi
mov    0x90(%rsp),%r10
mov    0x70(%rsp),%r15
cmp    $0x4,%r15
mov    0xb8(%rsp),%r8
mov    0x40(%rsp),%rdi
jae    1a29 <FST_semi_memo+0x8a9>
xor    %eax,%eax
mov    0x20(%rsp),%r11
mov    0x98(%rsp),%r9
mov    0xa0(%rsp),%r14
movapd 0x1629(%rip),%xmm2
movapd 0x1621(%rip),%xmm3
jmp    1e10 <FST_semi_memo+0xc90>
cmp    0x88(%rsp),%rdi
mov    0x10(%rsp),%r13
mov    0x20(%rsp),%rsi
movapd 0x1602(%rip),%xmm2
movapd 0x15fa(%rip),%xmm3
jae    1a70 <FST_semi_memo+0x8f0>
lea    (%rdi,%r15,8),%rax
cmp    %rax,%rsi
jae    1a70 <FST_semi_memo+0x8f0>
xor    %r14d,%r14d
jmp    1b10 <FST_semi_memo+0x990>
cmp    0x88(%rsp),%rdi
mov    0x20(%rsp),%r11
mov    0x98(%rsp),%r9
mov    0xa0(%rsp),%r14
movapd 0x15c2(%rip),%xmm2
movapd 0x15ba(%rip),%xmm3
jae    1cd4 <FST_semi_memo+0xb54>
lea    (%rdi,%r15,8),%rax
cmp    %rax,%r11
jae    1cd4 <FST_semi_memo+0xb54>
xor    %eax,%eax
jmp    1e10 <FST_semi_memo+0xc90>
cmpq   $0x0,0x60(%rsp)
je     1db1 <FST_semi_memo+0xc31>
mov    %rbp,%rcx
xor    %eax,%eax
mov    0x58(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rax,8),%xmm0
movupd -0x20(%rdx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
movupd -0x10(%rdx,%rax,8),%xmm0
movupd (%rdx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rdi,%rax,8)
movupd %xmm1,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1a90 <FST_semi_memo+0x910>
testb  $0x1,0x80(%rsp)
01
je     1b00 <FST_semi_memo+0x980>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
cmp    %r14,%r15
je     1b9f <FST_semi_memo+0xa1f>
nopl   0x0(%rax)
mov    0x28(%rsp),%rax
sub    %r14,%rax
test   $0x3,%r15b
je     1b4a <FST_semi_memo+0x9ca>
mov    %rbx,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%r14,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rdi,%r14,8)
add    $0x1,%r14
add    $0xffffffffffffffff,%rcx
jne    1b30 <FST_semi_memo+0x9b0>
cmp    $0x3,%rax
jb     1b9f <FST_semi_memo+0xa1f>
movsd  -0x18(%r12,%r14,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdi,%r14,8)
movsd  -0x10(%r12,%r14,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%rdi,%r14,8)
movsd  -0x8(%r12,%r14,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x10(%rdi,%r14,8)
movsd  (%r12,%r14,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x18(%rdi,%r14,8)
add    $0x4,%r14
cmp    %r14,%r15
jne    1b50 <FST_semi_memo+0x9d0>
mov    %rsi,%rcx
mov    0x68(%rsp),%rax
lea    (%r8,%rax,8),%rdi
mov    %r9,%rdx
mov    0x0(%r13,%r9,8),%r8
mov    0x30(%rsp),%r14
mov    %r14d,%esi
mov    0x110(%rsp),%r9
call   1050 <Naive_AnalysisX@plt>
mov    0x50(%rsp),%r10
mov    %r10d,%eax
sub    %r14d,%eax
mov    %rax,%r9
cmp    $0x4,%r15
jae    1bf7 <FST_semi_memo+0xa77>
xor    %eax,%eax
mov    0x20(%rsp),%rdi
mov    0xa0(%rsp),%r14
mov    0x40(%rsp),%rsi
mov    0x28(%rsp),%r8
jmp    1c2b <FST_semi_memo+0xaab>
mov    0xa0(%rsp),%r14
cmp    0x88(%rsp),%r14
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%r8
jae    1d3d <FST_semi_memo+0xbbd>
lea    (%r14,%r15,8),%rax
cmp    %rax,%rdi
jae    1d3d <FST_semi_memo+0xbbd>
xor    %eax,%eax
mov    0x40(%rsp),%rsi
movapd 0x13dd(%rip),%xmm2
movapd 0x13d5(%rip),%xmm3
mov    %r8,%rcx
sub    %rax,%rcx
test   $0x3,%r15b
je     1c69 <FST_semi_memo+0xae9>
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1c50 <FST_semi_memo+0xad0>
cmp    $0x3,%rcx
jb     2090 <FST_semi_memo+0xf10>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r14,%rax,8)
movsd  -0x10(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%r14,%rax,8)
movsd  -0x8(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x10(%r14,%rax,8)
movsd  (%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r15
jne    1c80 <FST_semi_memo+0xb00>
jmp    2090 <FST_semi_memo+0xf10>
cmpq   $0x0,0x60(%rsp)
je     1dc6 <FST_semi_memo+0xc46>
mov    %rbp,%rax
xor    %ecx,%ecx
mov    0x58(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rcx,8),%xmm0
movupd -0x20(%rdx,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rdi,%rcx,8)
movupd %xmm1,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    1cf0 <FST_semi_memo+0xb70>
jmp    1dc8 <FST_semi_memo+0xc48>
cmpq   $0x0,0x60(%rsp)
je     202e <FST_semi_memo+0xeae>
xor    %ecx,%ecx
mov    0x58(%rsp),%rax
movapd 0x12b8(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rax,%rcx,8),%xmm0
movupd -0x20(%rax,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rcx,8)
movupd %xmm1,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1d60 <FST_semi_memo+0xbe0>
jmp    2038 <FST_semi_memo+0xeb8>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1ae2 <FST_semi_memo+0x962>
jmp    1b00 <FST_semi_memo+0x980>
xor    %ecx,%ecx
mov    %r15,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
and    %rdx,%rax
testb  $0x1,0x80(%rsp)
01
je     1e02 <FST_semi_memo+0xc82>
movupd (%r11,%rcx,8),%xmm0
movupd 0x10(%r11,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
cmp    %rax,%r15
je     1e9b <FST_semi_memo+0xd1b>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
sub    %rax,%rcx
test   $0x3,%r15b
je     1e49 <FST_semi_memo+0xcc9>
mov    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r11,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e30 <FST_semi_memo+0xcb0>
cmp    $0x3,%rcx
jb     1e9b <FST_semi_memo+0xd1b>
nop
movsd  -0x18(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdi,%rax,8)
movsd  -0x10(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%rdi,%rax,8)
movsd  -0x8(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x10(%rdi,%rax,8)
movsd  (%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r15
jne    1e50 <FST_semi_memo+0xcd0>
mov    0x38(%rsp),%rax
sub    %esi,%eax
mov    %rax,0x38(%rsp)
mov    %r11,%rcx
mov    0x68(%rsp),%rax
lea    (%r8,%rax,8),%rdi
mov    0x10(%rsp),%rax
mov    %r10,%rdx
mov    (%rax,%r10,8),%r8
mov    %r13,(%rsp)
call   1090 <SemiNaiveReduced@plt>
cmp    $0x4,%r15
jae    1eeb <FST_semi_memo+0xd6b>
xor    %eax,%eax
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0x28(%rsp),%r8
jmp    1f21 <FST_semi_memo+0xda1>
cmp    0x88(%rsp),%r14
mov    0x50(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%r8
jae    1fc4 <FST_semi_memo+0xe44>
lea    (%r14,%r15,8),%rax
cmp    %rax,%rdi
jae    1fc4 <FST_semi_memo+0xe44>
xor    %eax,%eax
mov    0x10(%rsp),%r13
mov    0x40(%rsp),%rsi
movapd 0x10e7(%rip),%xmm2
movapd 0x10df(%rip),%xmm3
mov    %r8,%rcx
sub    %rax,%rcx
test   $0x3,%r15b
je     1f59 <FST_semi_memo+0xdd9>
nopl   (%rax)
movsd  (%rdi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1f40 <FST_semi_memo+0xdc0>
cmp    $0x3,%rcx
jb     2100 <FST_semi_memo+0xf80>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r14,%rax,8)
movsd  -0x10(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%r14,%rax,8)
movsd  -0x8(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x10(%r14,%rax,8)
movsd  (%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r15
jne    1f70 <FST_semi_memo+0xdf0>
jmp    2100 <FST_semi_memo+0xf80>
cmpq   $0x0,0x60(%rsp)
je     2098 <FST_semi_memo+0xf18>
xor    %ecx,%ecx
mov    0x58(%rsp),%rax
movapd 0x1031(%rip),%xmm3
nop
movupd -0x30(%rax,%rcx,8),%xmm0
movupd -0x20(%rax,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rcx,8)
movupd %xmm1,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1fe0 <FST_semi_memo+0xe60>
jmp    20a2 <FST_semi_memo+0xf22>
xor    %ecx,%ecx
movapd 0xfd8(%rip),%xmm3
mov    %r15,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
and    %rdx,%rax
testb  $0x1,0x80(%rsp)
01
mov    0x40(%rsp),%rsi
movapd 0xfb3(%rip),%xmm2
je     207f <FST_semi_memo+0xeff>
movupd (%rdi,%rcx,8),%xmm0
movupd 0x10(%rdi,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
cmp    %rax,%r15
jne    1c3b <FST_semi_memo+0xabb>
nopl   0x0(%rax,%rax,1)
mov    %r9,%rbx
jmp    17c9 <FST_semi_memo+0x649>
xor    %ecx,%ecx
movapd 0xf6e(%rip),%xmm3
mov    %r15,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
and    %rdx,%rax
testb  $0x1,0x80(%rsp)
01
mov    0x10(%rsp),%r13
mov    0x40(%rsp),%rsi
movapd 0xf44(%rip),%xmm2
je     20ee <FST_semi_memo+0xf6e>
movupd (%rdi,%rcx,8),%xmm0
movupd 0x10(%rdi,%rcx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
cmp    %rax,%r15
jne    1f31 <FST_semi_memo+0xdb1>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rbx
jmp    17c9 <FST_semi_memo+0x649>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1342 <FST_semi_memo+0x1c2>
jmp    1388 <FST_semi_memo+0x208>

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

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