void fftmx(double *a, double *b, int ntot, int n, int nspan, int isn, int m,
           int *kt, double *at, double *ck, double *bt, double *sk, int *np,
           int nfac[]) {
  int i, inc, j, jc, jf, jj, k, k1, k2, k3, k4, kk, klim, ks, kspan, kspnn, lim,
      maxf, mm, nn, nt;
  double aa, aj, ajm, ajp, ak, akm, akp, bb, bj, bjm, bjp, bk, bkm, bkp, c1, c2,
      c3, c72, cd, dr, rad, sd, s1, s2, s3, s72, s120;
  double xx;
  c2 = c3 = s2 = s3 = k3 = 0;
  inc = abs(isn);
  nt = inc * ntot;
  ks = inc * nspan;
  rad = 0.785398163397448278900;
  c72 = 0.309016994374947451270;
  s72 = 0.951056516295153531190;
  s120 = 0.866025403784438707600;
  if (isn < 0) {
    s72 = -s72;
    s120 = -s120;
    rad = -rad;
  } else {
    ak = 1.0 / (double)n;
    for (j = 1; j <= nt; j += inc) {
      a[j] *= (double)ak;
      b[j] *= (double)ak;
    }
  }
  kspan = ks;
  nn = nt - inc;
  jc = ks / n;
  lim = 32;
  klim = lim * jc;
  i = 0;
  jf = 0;
  maxf = m - (*kt);
  maxf = nfac[maxf];
  if ((*kt) > 0 && maxf < nfac[*kt])
    maxf = nfac[*kt];
lbl40:
  dr = (8.0 * (double)jc) / ((double)kspan);
  xx = sin((double)0.5 * dr * rad);
  cd = 2.0 * xx * xx;
  sd = sin(dr * rad);
  kk = 1;
  if (nfac[++i] != 2)
    goto lbl110;
  kspan /= 2;
  k1 = kspan + 2;
  do {
    do {
      k2 = kk + kspan;
      ak = a[k2];
      bk = b[k2];
      a[k2] = (a[kk]) - (double)ak;
      b[k2] = (b[kk]) - (double)bk;
      a[kk] = (a[kk]) + (double)ak;
      b[kk] = (b[kk]) + (double)bk;
      kk = k2 + kspan;
    } while (kk <= nn);
    kk -= nn;
  } while (kk <= jc);
  if (kk > kspan)
    goto lbl350;
lbl60:
  c1 = 1.0 - cd;
  s1 = sd;
  mm = (k1 / 2 < klim ? k1 / 2 : klim);
  goto lbl80;
lbl70:
  ak = c1 - ((cd * c1) + (sd * s1));
  s1 = ((sd * c1) - (cd * s1)) + s1;
  c1 = ak;
lbl80:
  do {
    do {
      k2 = kk + kspan;
      ak = a[kk] - a[k2];
      bk = b[kk] - b[k2];
      a[kk] = a[kk] + a[k2];
      b[kk] = b[kk] + b[k2];
      a[k2] = (double)((c1 * ak) - (s1 * bk));
      b[k2] = (double)((s1 * ak) + (c1 * bk));
      kk = k2 + kspan;
    } while (kk < nt);
    k2 = kk - nt;
    c1 = -c1;
    kk = k1 - k2;
  } while (kk > k2);
  kk += jc;
  if (kk <= mm)
    goto lbl70;
  if (kk < k2)
    goto lbl90;
  k1 += (inc + inc);
  kk = ((k1 - kspan) / 2) + jc;
  if (kk <= (jc + jc))
    goto lbl60;
  goto lbl40;
lbl90:
  s1 = ((double)((kk - 1) / jc)) * dr * rad;
  c1 = cos(s1);
  s1 = sin(s1);
  mm = (k1 / 2 < mm + klim ? k1 / 2 : mm + klim);
  goto lbl80;
lbl100:
  k1 = kk + kspan;
  k2 = k1 + kspan;
  ak = a[kk];
  bk = b[kk];
  aj = a[k1] + a[k2];
  bj = b[k1] + b[k2];
  a[kk] = (double)(ak + aj);
  b[kk] = (double)(bk + bj);
  ak += (-0.5 * aj);
  bk += (-0.5 * bj);
  aj = (a[k1] - a[k2]) * s120;
  bj = (b[k1] - b[k2]) * s120;
  a[k1] = (double)(ak - bj);
  b[k1] = (double)(bk + aj);
  a[k2] = (double)(ak + bj);
  b[k2] = (double)(bk - aj);
  kk = k2 + kspan;
  if (kk < nn)
    goto lbl100;
  kk -= nn;
  if (kk <= kspan)
    goto lbl100;
  goto lbl290;
lbl110:
  if (nfac[i] != 4)
    goto lbl230;
  kspnn = kspan;
  kspan = kspan / 4;
lbl120:
  c1 = 1.0;
  s1 = 0;
  mm = (kspan < klim ? kspan : klim);
  goto lbl150;
lbl130:
  c2 = c1 - ((cd * c1) + (sd * s1));
  s1 = ((sd * c1) - (cd * s1)) + s1;
  c1 = c2;
lbl140:
  c2 = (c1 * c1) - (s1 * s1);
  s2 = c1 * s1 * 2.0;
  c3 = (c2 * c1) - (s2 * s1);
  s3 = (c2 * s1) + (s2 * c1);
lbl150:
  k1 = kk + kspan;
  k2 = k1 + kspan;
  k3 = k2 + kspan;
  akp = a[kk] + a[k2];
  akm = a[kk] - a[k2];
  ajp = a[k1] + a[k3];
  ajm = a[k1] - a[k3];
  a[kk] = (double)(akp + ajp);
  ajp = akp - ajp;
  bkp = b[kk] + b[k2];
  bkm = b[kk] - b[k2];
  bjp = b[k1] + b[k3];
  bjm = b[k1] - b[k3];
  b[kk] = (double)(bkp + bjp);
  bjp = bkp - bjp;
  if (isn < 0)
    goto lbl180;
  akp = akm - bjm;
  akm = akm + bjm;
  bkp = bkm + ajm;
  bkm = bkm - ajm;
  if (s1 == 0.0)
    goto lbl190;
lbl160:
  a[k1] = (double)((akp * c1) - (bkp * s1));
  b[k1] = (double)((akp * s1) + (bkp * c1));
  a[k2] = (double)((ajp * c2) - (bjp * s2));
  b[k2] = (double)((ajp * s2) + (bjp * c2));
  a[k3] = (double)((akm * c3) - (bkm * s3));
  b[k3] = (double)((akm * s3) + (bkm * c3));
  kk = k3 + kspan;
  if (kk <= nt)
    goto lbl150;
lbl170:
  kk -= (nt - jc);
  if (kk <= mm)
    goto lbl130;
  if (kk < kspan)
    goto lbl200;
  kk -= (kspan - inc);
  if (kk <= jc)
    goto lbl120;
  if (kspan == jc)
    goto lbl350;
  goto lbl40;
lbl180:
  akp = akm + bjm;
  akm = akm - bjm;
  bkp = bkm - ajm;
  bkm = bkm + ajm;
  if (s1 != 0.0)
    goto lbl160;
lbl190:
  a[k1] = (double)akp;
  b[k1] = (double)bkp;
  a[k2] = (double)ajp;
  b[k2] = (double)bjp;
  a[k3] = (double)akm;
  b[k3] = (double)bkm;
  kk = k3 + kspan;
  if (kk <= nt)
    goto lbl150;
  goto lbl170;
lbl200:
  s1 = ((double)((kk - 1) / jc)) * dr * rad;
  c1 = cos(s1);
  s1 = sin(s1);
  mm = (kspan < mm + klim ? kspan : mm + klim);
  goto lbl140;
lbl210:
  c2 = (c72 * c72) - (s72 * s72);
  s2 = 2.0 * c72 * s72;
lbl220:
  k1 = kk + kspan;
  k2 = k1 + kspan;
  k3 = k2 + kspan;
  k4 = k3 + kspan;
  akp = a[k1] + a[k4];
  akm = a[k1] - a[k4];
  bkp = b[k1] + b[k4];
  bkm = b[k1] - b[k4];
  ajp = a[k2] + a[k3];
  ajm = a[k2] - a[k3];
  bjp = b[k2] + b[k3];
  bjm = b[k2] - b[k3];
  aa = a[kk];
  bb = b[kk];
  a[kk] = (double)(aa + akp + ajp);
  b[kk] = (double)(bb + bkp + bjp);
  ak = (akp * c72) + (ajp * c2) + aa;
  bk = (bkp * c72) + (bjp * c2) + bb;
  aj = (akm * s72) + (ajm * s2);
  bj = (bkm * s72) + (bjm * s2);
  a[k1] = (double)(ak - bj);
  a[k4] = (double)(ak + bj);
  b[k1] = (double)(bk + aj);
  b[k4] = (double)(bk - aj);
  ak = (akp * c2) + (ajp * c72) + aa;
  bk = (bkp * c2) + (bjp * c72) + bb;
  aj = (akm * s2) - (ajm * s72);
  bj = (bkm * s2) - (bjm * s72);
  a[k2] = (double)(ak - bj);
  a[k3] = (double)(ak + bj);
  b[k2] = (double)(bk + aj);
  b[k3] = (double)(bk - aj);
  kk = k4 + kspan;
  if (kk < nn)
    goto lbl220;
  kk -= nn;
  if (kk <= kspan)
    goto lbl220;
  goto lbl290;
lbl230:
  k = nfac[i];
  kspnn = kspan;
  kspan /= k;
  if (k == 3)
    goto lbl100;
  if (k == 5)
    goto lbl210;
  if (k == jf)
    goto lbl250;
  jf = k;
  s1 = rad / (((double)(k)) / 8.0);
  c1 = cos(s1);
  s1 = sin(s1);
  ck[jf] = 1.0;
  sk[jf] = 0.0;
  for (j = 1; j < k; j++) {
    ck[j] = (double)((ck[k]) * c1 + (sk[k]) * s1);
    sk[j] = (double)((ck[k]) * s1 - (sk[k]) * c1);
    k--;
    ck[k] = ck[j];
    sk[k] = -(sk[j]);
  }
lbl250:
  k1 = kk;
  k2 = kk + kspnn;
  aa = a[kk];
  bb = b[kk];
  ak = aa;
  bk = bb;
  j = 1;
  k1 += kspan;
  do {
    k2 -= kspan;
    j++;
    at[j] = a[k1] + a[k2];
    ak = at[j] + ak;
    bt[j] = b[k1] + b[k2];
    bk = bt[j] + bk;
    j++;
    at[j] = a[k1] - a[k2];
    bt[j] = b[k1] - b[k2];
    k1 += kspan;
  } while (k1 < k2);
  a[kk] = (double)ak;
  b[kk] = (double)bk;
  k1 = kk;
  k2 = kk + kspnn;
  j = 1;
lbl270:
  k1 += kspan;
  k2 -= kspan;
  jj = j;
  ak = aa;
  bk = bb;
  aj = 0.0;
  bj = 0.0;
  k = 1;
  do {
    k++;
    ak = (at[k] * ck[jj]) + ak;
    bk = (bt[k] * ck[jj]) + bk;
    k++;
    aj = (at[k] * sk[jj]) + aj;
    bj = (bt[k] * sk[jj]) + bj;
    jj += j;
    if (jj > jf)
      jj -= jf;
  } while (k < jf);
  k = jf - j;
  a[k1] = (double)(ak - bj);
  b[k1] = (double)(bk + aj);
  a[k2] = (double)(ak + bj);
  b[k2] = (double)(bk - aj);
  j++;
  if (j < k)
    goto lbl270;
  kk += kspnn;
  if (kk <= nn)
    goto lbl250;
  kk -= nn;
  if (kk <= kspan)
    goto lbl250;
lbl290:
  if (i == m)
    goto lbl350;
  kk = jc + 1;
lbl300:
  c2 = 1.0 - cd;
  s1 = sd;
  mm = (kspan < klim ? kspan : klim);
  goto lbl320;
lbl310:
  c2 = c1 - ((cd * c1) + (sd * s1));
  s1 = s1 + ((sd * c1) - (cd * s1));
lbl320:
  c1 = c2;
  s2 = s1;
  kk += kspan;
lbl330:
  ak = a[kk];
  a[kk] = (double)((c2 * ak) - (s2 * b[kk]));
  b[kk] = (double)((s2 * ak) + (c2 * b[kk]));
  kk += kspnn;
  if (kk <= nt)
    goto lbl330;
  ak = s1 * s2;
  s2 = (s1 * c2) + (c1 * s2);
  c2 = (c1 * c2) - ak;
  kk -= (nt - kspan);
  if (kk <= kspnn)
    goto lbl330;
  kk -= (kspnn - jc);
  if (kk <= mm)
    goto lbl310;
  if (kk < kspan)
    goto lbl340;
  kk -= (kspan - jc - inc);
  if (kk <= (jc + jc))
    goto lbl300;
  goto lbl40;
lbl340:
  s1 = ((double)((kk - 1) / jc)) * dr * rad;
  c2 = cos(s1);
  s1 = sin(s1);
  mm = (kspan < mm + klim ? kspan : mm + klim);
  goto lbl320;
lbl350:
  np[1] = ks;
  if (!(*kt))
    goto lbl440;
  k = *kt + *kt + 1;
  if (m < k)
    k--;
  np[k + 1] = jc;
  for (j = 1; j < k; j++, k--) {
    np[j + 1] = np[j] / nfac[j];
    np[k] = np[k + 1] * nfac[j];
  }
  k3 = np[k + 1];
  kspan = np[2];
  kk = jc + 1;
  k2 = kspan + 1;
  j = 1;
  if (n != ntot)
    goto lbl400;
lbl370:
  do {
    ak = a[kk];
    a[kk] = a[k2];
    a[k2] = (double)ak;
    bk = b[kk];
    b[kk] = b[k2];
    b[k2] = (double)bk;
    kk += inc;
    k2 += kspan;
  } while (k2 < ks);
lbl380:
  do {
    k2 -= np[j++];
    k2 += np[j + 1];
  } while (k2 > np[j]);
  j = 1;
lbl390:
  if (kk < k2) {
    goto lbl370;
  }
  kk += inc;
  k2 += kspan;
  if (k2 < ks)
    goto lbl390;
  if (kk < ks)
    goto lbl380;
  jc = k3;
  goto lbl440;
lbl400:
  do {
    do {
      k = kk + jc;
      do {
        ak = a[kk];
        a[kk] = a[k2];
        a[k2] = (double)ak;
        bk = b[kk];
        b[kk] = b[k2];
        b[k2] = (double)bk;
        kk += inc;
        k2 += inc;
      } while (kk < k);
      kk += (ks - jc);
      k2 += (ks - jc);
    } while (kk < nt);
    k2 -= (nt - kspan);
    kk -= (nt - jc);
  } while (k2 < ks);
lbl420:
  do {
    k2 -= np[j++];
    k2 += np[j + 1];
  } while (k2 > np[j]);
  j = 1;
lbl430:
  if (kk < k2)
    goto lbl400;
  kk += jc;
  k2 += kspan;
  if (k2 < ks)
    goto lbl430;
  if (kk < ks)
    goto lbl420;
  jc = k3;
lbl440:
  if ((2 * (*kt)) + 1 >= m)
    return;
  kspnn = *(np + *(kt) + 1);
  j = m - *kt;
  nfac[j + 1] = 1;
lbl450:
  nfac[j] = nfac[j] * nfac[j + 1];
  j--;
  if (j != *kt)
    goto lbl450;
  *kt = *(kt) + 1;
  nn = nfac[*kt] - 1;
  jj = 0;
  j = 0;
  goto lbl480;
lbl460:
  jj -= k2;
  k2 = kk;
  kk = nfac[++k];
lbl470:
  jj += kk;
  if (jj >= k2)
    goto lbl460;
  np[j] = jj;
lbl480:
  k2 = nfac[*kt];
  k = *kt + 1;
  kk = nfac[k];
  j++;
  if (j <= nn)
    goto lbl470;
  j = 0;
  goto lbl500;
lbl490:
  k = kk;
  kk = np[k];
  np[k] = -kk;
  if (kk != j)
    goto lbl490;
  k3 = kk;
lbl500:
  kk = np[++j];
  if (kk < 0)
    goto lbl500;
  if (kk != j)
    goto lbl490;
  np[j] = -j;
  if (j != nn)
    goto lbl500;
  maxf *= inc;
  goto lbl570;
lbl510:
  j--;
  if (np[j] < 0)
    goto lbl510;
  jj = jc;
lbl520:
  kspan = jj;
  if (jj > maxf)
    kspan = maxf;
  jj -= kspan;
  k = np[j];
  kk = (jc * k) + i + jj;
  k1 = kk + kspan;
  k2 = 0;
lbl530:
  k2++;
  at[k2] = a[k1];
  bt[k2] = b[k1];
  k1 -= inc;
  if (k1 != kk)
    goto lbl530;
lbl540:
  k1 = kk + kspan;
  k2 = k1 - (jc * (k + np[k]));
  k = -(np[k]);
lbl550:
  a[k1] = a[k2];
  b[k1] = b[k2];
  k1 -= inc;
  k2 -= inc;
  if (k1 != kk)
    goto lbl550;
  kk = k2;
  if (k != j)
    goto lbl540;
  k1 = kk + kspan;
  k2 = 0;
lbl560:
  k2++;
  a[k1] = at[k2];
  b[k1] = bt[k2];
  k1 -= inc;
  if (k1 != kk)
    goto lbl560;
  if (jj)
    goto lbl520;
  if (j != 1)
    goto lbl510;
lbl570:
  j = k3 + 1;
  nt -= kspnn;
  i = nt - inc + 1;
  if (nt >= 0)
    goto lbl510;
  return;
}


x86 assembly (clang, -O0):
<fftmx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x20(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x58(%rbp)
movsd  0x2e4e(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  0x2e36(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0x2e1e(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0x2e06(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
cmpl   $0x0,-0x20(%rbp)
jge    1286 <fftmx+0x156>
movsd  -0x148(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    12f9 <fftmx+0x1c9>
cvtsi2sdl -0x18(%rbp),%xmm1
movsd  0x2d8d(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     12f4 <fftmx+0x1c4>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    12a6 <fftmx+0x176>
jmp    12f9 <fftmx+0x1c9>
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x74(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x58(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,-0x30(%rbp)
movl   $0x20,-0x64(%rbp)
mov    -0x64(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x68(%rbp)
mov    0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1380 <fftmx+0x250>
mov    -0x68(%rbp),%eax
mov    0x48(%rbp),%rcx
mov    0x18(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1380 <fftmx+0x250>
mov    0x48(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    1385 <fftmx+0x255>
cvtsi2sdl -0x30(%rbp),%xmm1
movsd  0x2ca6(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x5c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x2c81(%rip),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x2c54(%rip),%xmm0
mulsd  -0x158(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x1,-0x50(%rbp)
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
cmpl   $0x2,(%rax,%rcx,4)
je     142f <fftmx+0x2ff>
jmp    1ad8 <fftmx+0x9a8>
mov    -0x5c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x40(%rbp)
jmp    144b <fftmx+0x31b>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    144b <fftmx+0x31b>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    1446 <fftmx+0x316>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    1543 <fftmx+0x413>
jmp    30c4 <fftmx+0x1f94>
jmp    1548 <fftmx+0x418>
movsd  0x2ad0(%rip),%xmm0
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    -0x54(%rbp),%eax
jge    159a <fftmx+0x46a>
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x15c(%rbp)
jmp    15a3 <fftmx+0x473>
mov    -0x54(%rbp),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    164c <fftmx+0x51c>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0x128(%rbp),%xmm2
ff
mulsd  -0x130(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1651 <fftmx+0x521>
jmp    1656 <fftmx+0x526>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jl     1656 <fftmx+0x526>
mov    -0x50(%rbp),%eax
sub    -0x74(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0xf0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x40(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1651 <fftmx+0x521>
mov    -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     17e6 <fftmx+0x6b6>
jmp    15b1 <fftmx+0x481>
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    17f7 <fftmx+0x6c7>
jmp    1832 <fftmx+0x702>
mov    -0x28(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x30(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jg     182d <fftmx+0x6fd>
jmp    1548 <fftmx+0x418>
jmp    1385 <fftmx+0x255>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x30(%rbp)
cvtsi2sd %eax,%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    18b1 <fftmx+0x781>
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x160(%rbp)
jmp    18bd <fftmx+0x78d>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    164c <fftmx+0x51c>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0x26a3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  0x267b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1ab7 <fftmx+0x987>
jmp    18cb <fftmx+0x79b>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1ad3 <fftmx+0x9a3>
jmp    18cb <fftmx+0x79b>
jmp    2d54 <fftmx+0x1c24>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
je     1aef <fftmx+0x9bf>
jmp    27a0 <fftmx+0x1670>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
movsd  0x2515(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1b38 <fftmx+0xa08>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x164(%rbp)
jmp    1b41 <fftmx+0xa11>
mov    -0x54(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x164(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1ccc <fftmx+0xb9c>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0x128(%rbp),%xmm2
ff
mulsd  -0x130(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0x130(%rbp),%xmm0
ff
movsd  0x23df(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
cmpl   $0x0,-0x20(%rbp)
jge    1e70 <fftmx+0xd40>
jmp    20fc <fftmx+0xfcc>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ef0 <fftmx+0xdc0>
jp     1ef0 <fftmx+0xdc0>
jmp    2186 <fftmx+0x1056>
jmp    1ef5 <fftmx+0xdc5>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
movsd  -0xe0(%rbp),%xmm1
mulsd  -0x140(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2092 <fftmx+0xf62>
jmp    1ccc <fftmx+0xb9c>
jmp    2097 <fftmx+0xf67>
mov    -0x74(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     20b6 <fftmx+0xf86>
jmp    1b4f <fftmx+0xa1f>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    20c7 <fftmx+0xf97>
jmp    2223 <fftmx+0x10f3>
mov    -0x5c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     20e6 <fftmx+0xfb6>
jmp    1b03 <fftmx+0x9d3>
mov    -0x5c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    20f7 <fftmx+0xfc7>
jmp    30c4 <fftmx+0x1f94>
jmp    1385 <fftmx+0x255>
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    217c <fftmx+0x104c>
jp     217c <fftmx+0x104c>
jmp    2181 <fftmx+0x1051>
jmp    1ef5 <fftmx+0xdc5>
jmp    2186 <fftmx+0x1056>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     221e <fftmx+0x10ee>
jmp    1ccc <fftmx+0xb9c>
jmp    2097 <fftmx+0xf67>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x30(%rbp)
cvtsi2sd %eax,%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x5c(%rbp),%eax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    2292 <fftmx+0x1162>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x168(%rbp)
jmp    229e <fftmx+0x116e>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1bea <fftmx+0xaba>
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x148(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0x1d2d(%rip),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    277f <fftmx+0x164f>
jmp    2313 <fftmx+0x11e3>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     279b <fftmx+0x166b>
jmp    2313 <fftmx+0x11e3>
jmp    2d54 <fftmx+0x1c24>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x5c(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jne    27cf <fftmx+0x169f>
jmp    18cb <fftmx+0x79b>
cmpl   $0x5,-0x3c(%rbp)
jne    27de <fftmx+0x16ae>
jmp    22ac <fftmx+0x117c>
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    27ef <fftmx+0x16bf>
jmp    2978 <fftmx+0x1848>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  0x182e(%rip),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x17cc(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2973 <fftmx+0x1843>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x130(%rbp),%xmm2
ff
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2870 <fftmx+0x1740>
jmp    2978 <fftmx+0x1848>
mov    -0x50(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x50(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x1,-0x2c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jl     29db <fftmx+0x18ab>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x50(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    2c71 <fftmx+0x1b41>
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
jmp    2c76 <fftmx+0x1b46>
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     2b77 <fftmx+0x1a47>
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2d19 <fftmx+0x1be9>
jmp    2b23 <fftmx+0x19f3>
mov    -0x60(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jg     2d33 <fftmx+0x1c03>
jmp    2978 <fftmx+0x1848>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     2d4f <fftmx+0x1c1f>
jmp    2978 <fftmx+0x1848>
jmp    2d54 <fftmx+0x1c24>
mov    -0x24(%rbp),%eax
cmp    0x10(%rbp),%eax
jne    2d65 <fftmx+0x1c35>
jmp    30c4 <fftmx+0x1f94>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movsd  0x12aa(%rip),%xmm0
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    2db0 <fftmx+0x1c80>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    2db9 <fftmx+0x1c89>
mov    -0x54(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    2e56 <fftmx+0x1d26>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0x128(%rbp),%xmm2
ff
mulsd  -0x130(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  -0x130(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2f39 <fftmx+0x1e09>
jmp    2e7f <fftmx+0x1d4f>
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x74(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     2fdf <fftmx+0x1eaf>
jmp    2e7f <fftmx+0x1d4f>
mov    -0x60(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     2ffe <fftmx+0x1ece>
jmp    2dc7 <fftmx+0x1c97>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    300f <fftmx+0x1edf>
jmp    303b <fftmx+0x1f0b>
mov    -0x5c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    -0x28(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jg     3036 <fftmx+0x1f06>
jmp    2d6e <fftmx+0x1c3e>
jmp    1385 <fftmx+0x255>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x30(%rbp)
cvtsi2sd %eax,%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x5c(%rbp),%eax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    30aa <fftmx+0x1f7a>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x170(%rbp)
jmp    30b6 <fftmx+0x1f86>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    2e56 <fftmx+0x1d26>
mov    -0x58(%rbp),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    30e0 <fftmx+0x1fb0>
jmp    34db <fftmx+0x23ab>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    0x18(%rbp),%rcx
add    (%rcx),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    3107 <fftmx+0x1fd7>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%edx
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    3194 <fftmx+0x2064>
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rsi
cltd
idivl  (%rcx,%rsi,4)
mov    %eax,%edx
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    3121 <fftmx+0x1ff1>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0x40(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     31db <fftmx+0x20ab>
jmp    3333 <fftmx+0x2203>
jmp    31e0 <fftmx+0x20b0>
jmp    31e5 <fftmx+0x20b5>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jl     31e5 <fftmx+0x20b5>
jmp    3290 <fftmx+0x2160>
jmp    3295 <fftmx+0x2165>
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x40(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     3295 <fftmx+0x2165>
movl   $0x1,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    32f4 <fftmx+0x21c4>
jmp    31e0 <fftmx+0x20b0>
mov    -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    3317 <fftmx+0x21e7>
jmp    32e3 <fftmx+0x21b3>
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    3328 <fftmx+0x21f8>
jmp    3290 <fftmx+0x2160>
mov    -0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    34db <fftmx+0x23ab>
jmp    3338 <fftmx+0x2208>
jmp    333d <fftmx+0x220d>
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jl     3346 <fftmx+0x2216>
mov    -0x58(%rbp),%eax
sub    -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x58(%rbp),%eax
sub    -0x30(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jl     333d <fftmx+0x220d>
mov    -0x74(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x74(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jl     3338 <fftmx+0x2208>
jmp    343d <fftmx+0x230d>
jmp    3442 <fftmx+0x2312>
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x40(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     3442 <fftmx+0x2312>
movl   $0x1,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    34a1 <fftmx+0x2371>
jmp    3333 <fftmx+0x2203>
mov    -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    34c4 <fftmx+0x2394>
jmp    3490 <fftmx+0x2360>
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    34d5 <fftmx+0x23a5>
jmp    343d <fftmx+0x230d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
cmp    0x10(%rbp),%eax
jl     34f5 <fftmx+0x23c5>
jmp    391e <fftmx+0x27ee>
mov    0x40(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    0x4(%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x2c(%rbp)
mov    0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   (%rax,%rcx,4),%edx
mov    0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
je     356b <fftmx+0x243b>
jmp    3527 <fftmx+0x23f7>
mov    0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    0x48(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
jmp    35f0 <fftmx+0x24c0>
mov    -0x44(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jl     35e2 <fftmx+0x24b2>
jmp    35a1 <fftmx+0x2471>
mov    -0x38(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x48(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jg     3635 <fftmx+0x2505>
jmp    35c8 <fftmx+0x2498>
movl   $0x0,-0x2c(%rbp)
jmp    367c <fftmx+0x254c>
mov    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
xor    %edx,%edx
sub    -0x50(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     3676 <fftmx+0x2546>
jmp    3641 <fftmx+0x2511>
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jge    36a1 <fftmx+0x2571>
jmp    367c <fftmx+0x254c>
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     36b2 <fftmx+0x2582>
jmp    3641 <fftmx+0x2511>
xor    %edx,%edx
sub    -0x2c(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
cmp    -0x70(%rbp),%eax
je     36d3 <fftmx+0x25a3>
jmp    367c <fftmx+0x254c>
mov    -0x28(%rbp),%eax
imul   -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    38ea <fftmx+0x27ba>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    3702 <fftmx+0x25d2>
jmp    36e2 <fftmx+0x25b2>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x68(%rbp),%eax
jle    3720 <fftmx+0x25f0>
mov    -0x68(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x3c(%rbp),%eax
add    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     37b2 <fftmx+0x2682>
jmp    3759 <fftmx+0x2629>
jmp    37b7 <fftmx+0x2687>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x30(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    0x40(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
add    (%rsi,%rdi,4),%edx
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x40(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     3847 <fftmx+0x2717>
jmp    37ec <fftmx+0x26bc>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     385e <fftmx+0x272e>
jmp    37b7 <fftmx+0x2687>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     38c7 <fftmx+0x2797>
jmp    386e <fftmx+0x273e>
cmpl   $0x0,-0x38(%rbp)
je     38d6 <fftmx+0x27a6>
jmp    3708 <fftmx+0x25d8>
cmpl   $0x1,-0x2c(%rbp)
je     38e5 <fftmx+0x27b5>
jmp    36e2 <fftmx+0x25b2>
jmp    38ea <fftmx+0x27ba>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%ecx
mov    -0x74(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
sub    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x74(%rbp)
jl     3919 <fftmx+0x27e9>
jmp    36e2 <fftmx+0x25b2>
jmp    391e <fftmx+0x27ee>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fftmx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9d,%r10d
mov    %ecx,%r14d
mov    %edx,0x14(%rsp)
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    0x218(%rsp),%r11
mov    0x1e8(%rsp),%r15
mov    %r9d,%edi
neg    %edi
cmovs  %r9d,%edi
mov    %edi,%r13d
imul   %edx,%r13d
mov    %edi,%esi
mov    %r8,0x108(%rsp)
imul   %r8d,%esi
test   %r9d,%r9d
js     11fa <fftmx+0xda>
movsd  0x1ea0(%rip),%xmm2
movsd  0x1ea0(%rip),%xmm0
movsd  %xmm0,0x100(%rsp)
movsd  0x1e97(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
test   %r13d,%r13d
jle    1221 <fftmx+0x101>
cvtsi2sd %r14d,%xmm1
movsd  0x1e63(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %edi,%eax
shl    $0x3,%rax
mov    $0x8,%ecx
mov    $0x1,%edx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,1)
movsd  (%rbx,%rcx,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,1)
add    %rax,%rcx
add    %edi,%edx
cmp    %edx,%r13d
jge    11d0 <fftmx+0xb0>
jmp    1221 <fftmx+0x101>
movsd  0x1dfe(%rip),%xmm2
movsd  0x1dfe(%rip),%xmm0
movsd  %xmm0,0x100(%rsp)
movsd  0x1df5(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %esi,%eax
cltd
idiv   %r14d
mov    %eax,%r9d
mov    (%r15),%eax
mov    0x1e0(%rsp),%ecx
sub    %eax,%ecx
movslq %ecx,%rcx
mov    (%r11,%rcx,4),%ecx
test   %eax,%eax
mov    %r14d,0xd0(%rsp)
jle    1252 <fftmx+0x132>
mov    (%r11,%rax,4),%eax
cmp    %eax,%ecx
cmovl  %eax,%ecx
mov    %ecx,0x54(%rsp)
mov    0x200(%rsp),%r15
mov    %r13d,%eax
sub    %edi,%eax
mov    %eax,0x4c(%rsp)
mov    %r9d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %r9d,%xmm0
mulsd  0x1dbe(%rip),%xmm0
movsd  %xmm0,0x178(%rsp)
shl    $0x5,%eax
mov    %eax,0x58(%rsp)
lea    (%rdi,%rdi,1),%eax
mov    %eax,0x11c(%rsp)
lea    (%r9,%r9,1),%eax
mov    %eax,0xdc(%rsp)
movsd  0x100(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d88(%rip),%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,0x168(%rsp)
movsd  0x1d7b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x160(%rsp)
lea    0x1(%r9),%eax
mov    %rax,0xf8(%rsp)
mov    %r9d,%r8d
sub    %r13d,%r8d
movslq %r13d,%rax
mov    %rax,0x120(%rsp)
mov    %r13d,%eax
neg    %eax
mov    %rax,0xc8(%rsp)
mov    $0x1,%eax
sub    0x14(%rsp),%eax
imul   %edi,%eax
lea    (%rax,%r9,2),%eax
mov    %eax,0x114(%rsp)
lea    -0x1(%r8),%eax
mov    %rax,0x148(%rsp)
xorpd  %xmm14,%xmm14
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x128(%rsp)
xorpd  %xmm4,%xmm4
xorpd  %xmm12,%xmm12
xor    %eax,%eax
mov    %rax,0x70(%rsp)
mov    %esi,%r12d
movl   $0x0,0x50(%rsp)
xor    %eax,%eax
mov    %esi,0x3c(%rsp)
mov    %rdi,0x40(%rsp)
mov    %r9,0x18(%rsp)
mov    %r10d,0xd4(%rsp)
movsd  %xmm2,0x150(%rsp)
mov    %r8,0xb8(%rsp)
movsd  %xmm12,0x158(%rsp)
movapd %xmm4,0x130(%rsp)
movsd  %xmm14,0x78(%rsp)
cltq
mov    %rax,0xc0(%rsp)
mov    %esi,%r14d
jmp    13b8 <fftmx+0x298>
cs nopw 0x0(%rax,%rax,1)
mov    0x200(%rsp),%r15
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0x178(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%rsp)
movapd %xmm1,%xmm0
mulsd  0x1c6e(%rip),%xmm0
mulsd  0x28(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0xa0(%rsp)
movsd  0x28(%rsp),%xmm0
mulsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm13
mov    0x218(%rsp),%rax
mov    0xc0(%rsp),%rcx
movslq 0x4(%rax,%rcx,4),%r12
add    $0x1,%rcx
cmp    $0x2,%r12
mov    %rcx,0xc0(%rsp)
movsd  %xmm0,0x80(%rsp)
jne    1720 <fftmx+0x600>
mov    %r14d,%eax
shr    $0x1f,%eax
add    %r14d,%eax
mov    %eax,%r14d
sar    %r14d
mov    $0x1,%eax
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%r9
mov    0x4c(%rsp),%edx
movapd 0x1bf7(%rip),%xmm6
nopl   0x0(%rax)
lea    (%rax,%r14,1),%ecx
movslq %ecx,%r15
movsd  0x0(%rbp,%r15,8),%xmm0
movsd  (%rbx,%r15,8),%xmm1
cltq
movsd  0x0(%rbp,%rax,8),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp,%r15,8)
movsd  (%rbx,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%r15,8)
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    %r14d,%r15d
mov    %r15d,%eax
sub    %edx,%r15d
jle    1480 <fftmx+0x360>
mov    %r15d,%eax
cmp    %r9d,%r15d
jle    1480 <fftmx+0x360>
cmp    %r14d,%r15d
mov    0xc8(%rsp),%rdx
movapd 0xa0(%rsp),%xmm9
jg     251d <fftmx+0x13fd>
lea    0x2(%r14),%r12d
movsd  0x1b12(%rip),%xmm0
subsd  %xmm9,%xmm0
movsd  %xmm0,0x20(%rsp)
movapd %xmm9,%xmm8
xorpd  %xmm6,%xmm8
movapd %xmm8,0xe0(%rsp)
jmp    155c <fftmx+0x43c>
nopw   0x0(%rax,%rax,1)
add    0x11c(%rsp),%r12d
mov    %r12d,%eax
sub    %r14d,%eax
mov    %eax,%r15d
shr    $0x1f,%r15d
add    %eax,%r15d
sar    %r15d
add    %r9d,%r15d
cmp    0xdc(%rsp),%r15d
jg     13b0 <fftmx+0x290>
mov    %r12d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
sar    %eax
mov    %eax,0x30(%rsp)
mov    0x58(%rsp),%esi
movsd  0x20(%rsp),%xmm7
movapd %xmm13,%xmm0
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%eax
cmp    %esi,%eax
cmovl  %eax,%esi
nopl   0x0(%rax)
movapd %xmm0,%xmm1
xorpd  %xmm6,%xmm1
nopl   0x0(%rax,%rax,1)
mov    %r15d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rcx
add    %r14d,%eax
movsd  0x0(%rbp,%rcx,8),%xmm2
cltq
movsd  0x0(%rbp,%rax,8),%xmm3
movapd %xmm2,%xmm4
movsd  (%rbx,%rcx,8),%xmm5
subsd  (%rbx,%rax,8),%xmm5
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm2
addsd  (%rbx,%rax,8),%xmm2
subsd  %xmm3,%xmm4
movsd  %xmm2,(%rbx,%rcx,8)
movapd %xmm7,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm5
movapd %xmm7,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm5,%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
add    %r14d,%eax
cmp    %r13d,%eax
jl     15b0 <fftmx+0x490>
add    %edx,%eax
xorpd  %xmm6,%xmm7
mov    %r12d,%r15d
sub    %eax,%r15d
cmp    %eax,%r15d
jg     15a0 <fftmx+0x480>
add    %r9d,%r15d
cmp    %esi,%r15d
jg     1680 <fftmx+0x560>
movapd %xmm13,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm13,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm2,%xmm7
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
jmp    1590 <fftmx+0x470>
nopl   0x0(%rax,%rax,1)
cmp    %eax,%r15d
jge    1530 <fftmx+0x410>
lea    -0x1(%r15),%eax
cltd
idiv   %r9d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
mov    %esi,0x8(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x90(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0x90(%rsp),%xmm7
mov    0x8(%rsp),%esi
movapd 0xe0(%rsp),%xmm8
movsd  0x80(%rsp),%xmm13
movapd 0xa0(%rsp),%xmm9
movapd 0x1973(%rip),%xmm6
mov    0xc8(%rsp),%rdx
mov    0x18(%rsp),%r9
add    0x58(%rsp),%esi
jmp    1580 <fftmx+0x460>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x4,%r12d
mov    0x40(%rsp),%rax
mov    0xd4(%rsp),%r10d
movapd 0x1937(%rip),%xmm7
movsd  0x158(%rsp),%xmm12
movsd  0x78(%rsp),%xmm14
movapd 0x130(%rsp),%xmm4
je     2160 <fftmx+0x1040>
mov    %r14d,%eax
cltd
idiv   %r12d
mov    %eax,%r10d
cmp    $0x3,%r12d
movsd  0x150(%rsp),%xmm5
mov    0xb8(%rsp),%r8
movapd 0xa0(%rsp),%xmm8
mov    %r10,0x20(%rsp)
je     1a06 <fftmx+0x8e6>
cmp    $0x5,%r12d
jne    1ae9 <fftmx+0x9c9>
mov    $0x1,%edi
mov    0x18(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%r10,1),%eax
lea    (%rax,%r10,1),%ecx
lea    (%rcx,%r10,1),%r8d
lea    (%r8,%r10,1),%edx
movslq %eax,%rsi
movsd  0x0(%rbp,%rsi,8),%xmm11
movslq %edx,%rax
movsd  0x0(%rbp,%rax,8),%xmm1
movapd %xmm11,%xmm0
addsd  %xmm1,%xmm0
subsd  %xmm1,%xmm11
movsd  (%rbx,%rsi,8),%xmm7
movsd  (%rbx,%rax,8),%xmm4
movapd %xmm7,%xmm3
addsd  %xmm4,%xmm3
subsd  %xmm4,%xmm7
movslq %ecx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm10
movslq %r8d,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm5
movapd %xmm10,%xmm14
addsd  %xmm5,%xmm14
subsd  %xmm5,%xmm10
movsd  (%rbx,%rdx,8),%xmm12
movsd  (%rbx,%rcx,8),%xmm4
movapd %xmm12,%xmm13
addsd  %xmm4,%xmm13
subsd  %xmm4,%xmm12
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm2
movsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,0x60(%rsp)
movapd %xmm0,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm2,%xmm5
movsd  %xmm2,0x8(%rsp)
addsd  %xmm14,%xmm4
movsd  %xmm4,0x0(%rbp,%rdi,8)
movapd %xmm3,%xmm4
addsd  %xmm1,%xmm4
addsd  %xmm13,%xmm4
movsd  %xmm4,(%rbx,%rdi,8)
movsd  0x168(%rsp),%xmm9
movapd %xmm9,%xmm4
mulsd  %xmm14,%xmm4
movapd %xmm0,%xmm2
movsd  0x17c2(%rip),%xmm6
mulsd  %xmm6,%xmm2
addsd  %xmm4,%xmm2
addsd  %xmm5,%xmm2
movapd %xmm9,%xmm4
mulsd  %xmm13,%xmm4
movapd %xmm3,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm4,%xmm1
movsd  0x160(%rsp),%xmm8
movapd %xmm8,%xmm4
mulsd  %xmm10,%xmm4
movapd %xmm11,%xmm5
movsd  0x100(%rsp),%xmm15
mulsd  %xmm15,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm8,%xmm4
mulsd  %xmm12,%xmm4
movapd %xmm7,%xmm6
mulsd  %xmm15,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm2,%xmm4
subsd  %xmm6,%xmm4
movsd  %xmm4,0x0(%rbp,%rsi,8)
addsd  %xmm2,%xmm6
movsd  0x60(%rsp),%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm6,0x0(%rbp,%rax,8)
movapd %xmm5,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rsi,8)
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x171d(%rip),%xmm1
mulsd  %xmm1,%xmm14
mulsd  %xmm9,%xmm0
addsd  %xmm14,%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  %xmm1,%xmm13
mulsd  %xmm9,%xmm3
addsd  %xmm13,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm15,%xmm10
mulsd  %xmm8,%xmm11
subsd  %xmm10,%xmm11
mulsd  %xmm15,%xmm12
mulsd  %xmm8,%xmm7
subsd  %xmm12,%xmm7
movapd %xmm0,%xmm1
subsd  %xmm7,%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
addsd  %xmm0,%xmm7
movsd  %xmm7,0x0(%rbp,%rcx,8)
movapd %xmm11,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
subsd  %xmm11,%xmm3
movsd  %xmm3,(%rbx,%rcx,8)
add    %r10d,%eax
mov    %eax,%edi
sub    0x4c(%rsp),%eax
jl     17b0 <fftmx+0x690>
mov    %eax,%edi
cmp    %r10d,%eax
jle    17b0 <fftmx+0x690>
mov    %r8,0x70(%rsp)
mov    0x40(%rsp),%rdi
mov    0xb8(%rsp),%r8
mov    0xc8(%rsp),%rcx
movapd 0x1683(%rip),%xmm7
movapd 0xa0(%rsp),%xmm8
movsd  0x80(%rsp),%xmm13
jmp    1e53 <fftmx+0xd33>
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
lea    (%rax,%r10,1),%edx
movslq %eax,%rsi
movsd  0x0(%rbp,%rsi,8),%xmm2
movsd  (%rbx,%rsi,8),%xmm3
movslq %edx,%rcx
add    %r10d,%edx
movsd  0x0(%rbp,%rcx,8),%xmm0
movslq %edx,%rax
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
addsd  (%rbx,%rax,8),%xmm1
movapd %xmm2,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x0(%rbp,%rsi,8)
movapd %xmm3,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rbx,%rsi,8)
movsd  0x15fc(%rip),%xmm4
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm4,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
subsd  0x0(%rbp,%rax,8),%xmm2
addsd  %xmm3,%xmm1
movsd  (%rbx,%rcx,8),%xmm3
subsd  (%rbx,%rax,8),%xmm3
mulsd  %xmm5,%xmm2
mulsd  %xmm5,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,0x0(%rbp,%rcx,8)
movapd %xmm1,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%rbx,%rcx,8)
addsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%rbp,%rax,8)
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    %r10d,%eax
mov    %eax,%ecx
sub    0x4c(%rsp),%ecx
jl     1a10 <fftmx+0x8f0>
mov    %ecx,%eax
cmp    %r10d,%ecx
jle    1a10 <fftmx+0x8f0>
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%r9
jmp    1e4b <fftmx+0xd2b>
mov    0x50(%rsp),%eax
cmp    %eax,%r12d
jne    1b01 <fftmx+0x9e1>
cltq
mov    %rax,0x90(%rsp)
jmp    1c3c <fftmx+0xb1c>
xorps  %xmm1,%xmm1
cvtsi2sd %r12d,%xmm1
mulsd  0x1557(%rip),%xmm1
movsd  0x28(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mov    0x1f8(%rsp),%rdi
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rdi,%r12,8)
mov    0x208(%rsp),%rsi
movq   $0x0,(%rsi,%r12,8)
cmp    $0x2,%r12d
mov    %r12,0x90(%rsp)
jl     1c13 <fftmx+0xaf3>
xorpd  %xmm1,%xmm1
mov    $0x2,%eax
mov    %r12,%rcx
movapd 0x14ed(%rip),%xmm7
movsd  0x80(%rsp),%xmm13
mov    0x20(%rsp),%r10
movsd  0x60(%rsp),%xmm3
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rdi,%rax,8)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rsi,%rax,8)
movsd  -0x8(%rdi,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%rcx,8)
movsd  -0x8(%rsi,%rax,8),%xmm1
xorpd  %xmm7,%xmm1
movlpd %xmm1,-0x8(%rsi,%rcx,8)
add    $0xffffffffffffffff,%rcx
lea    0x1(%rax),%rdx
cmp    %rcx,%rax
mov    %rdx,%rax
jl     1ba0 <fftmx+0xa80>
mov    %r12d,%eax
mov    %r12d,0x50(%rsp)
movapd 0xa0(%rsp),%xmm8
jmp    1c3c <fftmx+0xb1c>
mov    %r12d,%eax
mov    %r12d,0x50(%rsp)
movapd 0x144d(%rip),%xmm7
movapd 0xa0(%rsp),%xmm8
movsd  0x80(%rsp),%xmm13
mov    0x20(%rsp),%r10
movslq %r10d,%r8
mov    %r14d,%eax
sub    %r10d,%eax
mov    %rax,0xe0(%rsp)
mov    $0x1,%r9d
mov    %r8,0x60(%rsp)
nopl   0x0(%rax,%rax,1)
movslq %r9d,%r11
add    %r14d,%r9d
movsd  0x0(%rbp,%r11,8),%xmm0
movsd  (%rbx,%r11,8),%xmm1
lea    (%r11,%r10,1),%eax
movslq %eax,%rdx
mov    0xe0(%rsp),%rax
add    %r11d,%eax
mov    $0x3,%edi
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
mov    0x1f0(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm4
movslq %eax,%rcx
addsd  0x0(%rbp,%rcx,8),%xmm4
movsd  %xmm4,-0x8(%rsi,%rdi,8)
addsd  %xmm4,%xmm2
movsd  (%rbx,%rdx,8),%xmm4
addsd  (%rbx,%rcx,8),%xmm4
movsd  %xmm4,-0x8(%r15,%rdi,8)
addsd  %xmm4,%xmm3
movsd  0x0(%rbp,%rdx,8),%xmm4
subsd  0x0(%rbp,%rcx,8),%xmm4
movsd  %xmm4,(%rsi,%rdi,8)
movsd  (%rbx,%rdx,8),%xmm4
subsd  (%rbx,%rcx,8),%xmm4
movsd  %xmm4,(%r15,%rdi,8)
add    %r8,%rdx
add    $0x2,%rdi
mov    %ecx,%eax
sub    %r10d,%eax
cmp    %rcx,%rdx
jl     1ca0 <fftmx+0xb80>
movsd  %xmm2,0x0(%rbp,%r11,8)
movsd  %xmm3,(%rbx,%r11,8)
mov    $0x1,%edi
mov    %r9d,0x30(%rsp)
mov    %r9d,%r12d
nopw   0x0(%rax,%rax,1)
add    %r8,%r11
mov    %r11,0x8(%rsp)
xorpd  %xmm2,%xmm2
mov    $0x1,%eax
movapd %xmm0,%xmm4
movapd %xmm1,%xmm3
mov    %edi,%ecx
mov    0x1f0(%rsp),%rdx
mov    0x208(%rsp),%r8
mov    0x1f8(%rsp),%r9
mov    0x50(%rsp),%r10d
mov    0x90(%rsp),%r11
movslq %ecx,%rcx
movsd  (%r9,%rcx,8),%xmm5
movsd  0x8(%rdx,%rax,8),%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm6,%xmm4
mulsd  0x8(%r15,%rax,8),%xmm5
addsd  %xmm5,%xmm3
movsd  0x10(%rdx,%rax,8),%xmm5
movhpd 0x10(%r15,%rax,8),%xmm5
lea    0x2(%rax),%rsi
movsd  (%r8,%rcx,8),%xmm6
unpcklpd %xmm6,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm6,%xmm2
add    %edi,%ecx
cmp    %r10d,%ecx
mov    $0x0,%eax
cmovg  %r10d,%eax
sub    %eax,%ecx
mov    %rsi,%rax
cmp    %r11,%rsi
jl     1d60 <fftmx+0xc40>
sub    0x20(%rsp),%r12d
sub    %edi,%r10d
movapd %xmm2,%xmm5
unpckhpd %xmm2,%xmm5
movapd %xmm4,%xmm6
subsd  %xmm5,%xmm6
mov    0x8(%rsp),%r11
movsd  %xmm6,0x0(%rbp,%r11,8)
movapd %xmm3,%xmm6
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rbx,%r11,8)
addsd  %xmm4,%xmm5
movslq %r12d,%rcx
movsd  %xmm5,0x0(%rbp,%rcx,8)
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rbx,%rcx,8)
add    $0x1,%edi
cmp    %r10d,%edi
mov    0x60(%rsp),%r8
jl     1d20 <fftmx+0xc00>
mov    0x30(%rsp),%r9d
mov    %r9d,%eax
sub    0x4c(%rsp),%eax
mov    0x20(%rsp),%r10
jle    1c60 <fftmx+0xb40>
mov    %eax,%r9d
cmp    %r10d,%eax
jle    1c60 <fftmx+0xb40>
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%r9
mov    0xb8(%rsp),%r8
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rax
cmp    0x1e0(%rsp),%eax
je     251d <fftmx+0x13fd>
movsd  0x11a8(%rip),%xmm0
subsd  %xmm8,%xmm0
mov    0x58(%rsp),%eax
cmp    %eax,%r10d
mov    %eax,%edx
cmovl  %r10d,%edx
mov    %r9d,%eax
sub    %r14d,%eax
mov    %eax,0x130(%rsp)
mov    %r10d,%r12d
sub    %r13d,%r12d
movapd %xmm8,%xmm9
xorpd  %xmm7,%xmm9
movslq %r14d,%rax
mov    %rax,0x8(%rsp)
lea    (%r8,%r10,1),%eax
sub    %r14d,%eax
mov    %eax,0x60(%rsp)
mov    0x114(%rsp),%eax
sub    %r14d,%eax
mov    %eax,0x90(%rsp)
mov    0x148(%rsp),%rax
add    %r10d,%eax
sub    %r14d,%eax
mov    %eax,0x30(%rsp)
lea    (%rcx,%r10,1),%eax
mov    %eax,0xe0(%rsp)
mov    0xf8(%rsp),%rax
mov    %eax,%ecx
mov    %edx,0x118(%rsp)
mov    %edx,0x78(%rsp)
movsd  %xmm0,0x170(%rsp)
movapd %xmm0,%xmm1
movapd %xmm13,%xmm0
mov    0x120(%rsp),%r10
mov    %r12d,0xd8(%rsp)
movapd %xmm9,0x190(%rsp)
jmp    1f64 <fftmx+0xe44>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm13,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm8,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm0,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm13,%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm2,%xmm1
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm0
add    0x20(%rsp),%ecx
movapd %xmm0,%xmm10
xorpd  %xmm7,%xmm10
movapd %xmm1,%xmm14
movapd %xmm0,%xmm2
nopl   0x0(%rax,%rax,1)
mov    %ecx,%r8d
movapd %xmm2,%xmm3
xorpd  %xmm7,%xmm3
movslq %ecx,%rcx
xor    %edi,%edi
mov    0xe0(%rsp),%eax
mov    %eax,%esi
mov    0x30(%rsp),%eax
mov    0x90(%rsp),%edx
mov    0x60(%rsp),%r15d
mov    0x8(%rsp),%r11
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm4
movsd  (%rbx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm14,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm5
mulsd  %xmm14,%xmm5
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,(%rbx,%rcx,8)
add    %r11,%rcx
add    %r14d,%r15d
add    %r14d,%edx
add    %r14d,%eax
add    %r14d,%esi
add    %r14d,%edi
cmp    %r10,%rcx
jle    1fb0 <fftmx+0xe90>
add    %r8d,%edi
add    %r12d,%edi
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm10,%xmm2
mulsd  %xmm1,%xmm14
addsd  %xmm2,%xmm14
lea    (%r8,%rsi,1),%ecx
movapd %xmm4,%xmm2
cmp    %r14d,%edi
jle    1f80 <fftmx+0xe60>
add    %r8d,%esi
mov    %esi,%ecx
add    0x130(%rsp),%ecx
cmp    0x78(%rsp),%ecx
jle    1f30 <fftmx+0xe10>
mov    0x20(%rsp),%r12
cmp    %r12d,%ecx
jge    2103 <fftmx+0xfe3>
add    %r8d,%r15d
add    %r8d,%eax
cltd
idiv   %r9d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x188(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x180(%rsp)
movsd  0x188(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x180(%rsp),%xmm1
movapd 0x190(%rsp),%xmm9
movsd  0x80(%rsp),%xmm13
movapd 0xa0(%rsp),%xmm8
movapd 0xf9d(%rip),%xmm7
mov    0x120(%rsp),%r10
mov    0x18(%rsp),%r9
mov    0x78(%rsp),%eax
add    0x58(%rsp),%eax
cmp    %eax,%r12d
cmovl  %r12d,%eax
mov    %eax,0x78(%rsp)
mov    %r15d,%ecx
mov    0xd8(%rsp),%r12d
jmp    1f64 <fftmx+0xe44>
add    %edx,%r8d
mov    %r8d,%ecx
mov    0x118(%rsp),%eax
mov    %eax,0x78(%rsp)
movsd  0x170(%rsp),%xmm1
movapd %xmm13,%xmm0
cmp    0xdc(%rsp),%r8d
mov    0xd8(%rsp),%r12d
jle    1f64 <fftmx+0xe44>
mov    0x200(%rsp),%r15
mov    0xc0(%rsp),%rax
mov    0x20(%rsp),%rsi
jmp    1387 <fftmx+0x267>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x3(%r14),%esi
test   %r14d,%r14d
cmovns %r14d,%esi
sar    $0x2,%esi
mov    %eax,%r11d
sub    %esi,%r11d
mov    0x58(%rsp),%r12d
cmp    %r12d,%esi
cmovl  %esi,%r12d
movapd 0xa0(%rsp),%xmm0
xorpd  %xmm7,%xmm0
movapd %xmm0,0x60(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%r14d
mov    %r12d,0x8(%rsp)
movsd  0xe6d(%rip),%xmm10
mov    0x18(%rsp),%r9
mov    0xb8(%rsp),%r8
xorpd  %xmm9,%xmm9
mov    %r11d,0xe0(%rsp)
mov    %rsi,0x20(%rsp)
jmp    22a0 <fftmx+0x1180>
nop
ucomisd %xmm9,%xmm0
movapd %xmm8,%xmm5
addsd  %xmm1,%xmm5
subsd  %xmm1,%xmm8
movapd %xmm15,%xmm7
subsd  %xmm6,%xmm7
addsd  %xmm6,%xmm15
jne    21f9 <fftmx+0x10d9>
jnp    2377 <fftmx+0x1257>
movapd %xmm0,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm5,%xmm6
movapd %xmm10,%xmm11
mulsd  %xmm10,%xmm6
subsd  %xmm1,%xmm6
movsd  %xmm6,0x0(%rbp,%rcx,8)
mulsd  %xmm10,%xmm7
mulsd  %xmm0,%xmm5
addsd  %xmm7,%xmm5
movsd  %xmm5,(%rbx,%rcx,8)
movapd %xmm4,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm5
mulsd  %xmm14,%xmm5
subsd  %xmm1,%xmm5
movsd  %xmm5,0x0(%rbp,%rax,8)
mulsd  %xmm14,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movapd %xmm12,%xmm1
mulsd  %xmm15,%xmm1
movapd %xmm8,%xmm2
movsd  0x128(%rsp),%xmm3
mulsd  %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%r14,8)
mulsd  %xmm3,%xmm15
mulsd  %xmm12,%xmm8
addsd  %xmm15,%xmm8
movsd  %xmm8,(%rbx,%r14,8)
add    %esi,%r14d
cmp    %r13d,%r14d
jg     239f <fftmx+0x127f>
lea    (%r14,%rsi,1),%ecx
lea    (%rcx,%rsi,1),%eax
lea    (%rax,%rsi,1),%edi
movslq %r14d,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm8
cltq
movsd  0x0(%rbp,%rax,8),%xmm3
movapd %xmm8,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm3,%xmm8
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm6
mov    %rdi,0x70(%rsp)
movslq %edi,%r14
movsd  0x0(%rbp,%r14,8),%xmm3
movapd %xmm6,%xmm1
addsd  %xmm3,%xmm1
subsd  %xmm3,%xmm6
movapd %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,8)
subsd  %xmm1,%xmm2
movsd  (%rbx,%rdx,8),%xmm15
movsd  (%rbx,%rax,8),%xmm5
movapd %xmm15,%xmm3
addsd  %xmm5,%xmm3
subsd  %xmm5,%xmm15
movsd  (%rbx,%rcx,8),%xmm1
movsd  (%rbx,%r14,8),%xmm5
movapd %xmm1,%xmm7
addsd  %xmm5,%xmm7
subsd  %xmm5,%xmm1
movapd %xmm3,%xmm5
addsd  %xmm7,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
subsd  %xmm7,%xmm3
test   %r10d,%r10d
js     21d0 <fftmx+0x10b0>
ucomisd %xmm9,%xmm0
movapd %xmm8,%xmm5
subsd  %xmm1,%xmm5
addsd  %xmm1,%xmm8
movapd %xmm6,%xmm7
addsd  %xmm15,%xmm7
subsd  %xmm6,%xmm15
jne    21f9 <fftmx+0x10d9>
jp     21f9 <fftmx+0x10d9>
movsd  %xmm5,0x0(%rbp,%rcx,8)
movsd  %xmm7,(%rbx,%rcx,8)
movsd  %xmm2,0x0(%rbp,%rax,8)
movsd  %xmm3,(%rbx,%rax,8)
movsd  %xmm8,0x0(%rbp,%r14,8)
movsd  %xmm15,(%rbx,%r14,8)
jmp    2294 <fftmx+0x1174>
add    %r8d,%r14d
cmp    %r12d,%r14d
jle    23cf <fftmx+0x12af>
cmp    %esi,%r14d
jl     2410 <fftmx+0x12f0>
add    %r11d,%r14d
xorpd  %xmm0,%xmm0
mov    0x8(%rsp),%r12d
movsd  0xc57(%rip),%xmm10
cmp    %r9d,%r14d
jle    22a0 <fftmx+0x1180>
jmp    2500 <fftmx+0x13e0>
movapd %xmm13,%xmm1
mulsd  %xmm0,%xmm1
movapd 0xa0(%rsp),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm1
mulsd  0x60(%rsp),%xmm1
movapd %xmm13,%xmm3
mulsd  %xmm10,%xmm3
subsd  %xmm2,%xmm10
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
jmp    2491 <fftmx+0x1371>
lea    -0x1(%r14),%eax
cltd
idiv   %r9d
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x90(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x90(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x30(%rsp),%xmm10
mov    0x20(%rsp),%rsi
mov    0xe0(%rsp),%r11d
movsd  0x80(%rsp),%xmm13
xorpd  %xmm9,%xmm9
mov    0xb8(%rsp),%r8
mov    0xd4(%rsp),%r10d
mov    0x18(%rsp),%r9
add    0x58(%rsp),%r12d
cmp    %r12d,%esi
cmovl  %esi,%r12d
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm10,%xmm14
mulsd  %xmm10,%xmm14
subsd  %xmm1,%xmm14
movapd %xmm10,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm4
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm14,%xmm2
mulsd  %xmm10,%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x128(%rsp)
movapd %xmm10,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm14,%xmm12
mulsd  %xmm0,%xmm12
addsd  %xmm1,%xmm12
jmp    22a0 <fftmx+0x1180>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r9d,%esi
mov    0xc0(%rsp),%rax
mov    0x3c(%rsp),%r12d
mov    0x40(%rsp),%rdi
jne    137d <fftmx+0x25d>
jmp    2522 <fftmx+0x1402>
mov    0x3c(%rsp),%r12d
mov    0x210(%rsp),%rdx
mov    %r12d,0x4(%rdx)
mov    0x1e8(%rsp),%r15
mov    (%r15),%ecx
test   %ecx,%ecx
je     25e5 <fftmx+0x14c5>
mov    %ecx,%eax
add    %ecx,%eax
add    %ecx,%ecx
add    $0x1,%ecx
cmp    0x1e0(%rsp),%ecx
cmovle %ecx,%eax
movslq %eax,%rcx
mov    %r9d,0x4(%rdx,%rcx,4)
cmp    $0x2,%ecx
jl     25f5 <fftmx+0x14d5>
mov    %eax,%esi
mov    %rsi,%rax
shl    $0x20,%rax
movabs $0x100000000,%rcx
add    %rax,%rcx
mov    $0x2,%edi
movabs $0xffffffff00000000,%r8
ff ff ff
mov    0x210(%rsp),%r9
mov    0x218(%rsp),%r10
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r9,%rdi,4),%eax
cltd
idivl  -0x4(%r10,%rdi,4)
mov    %eax,(%r9,%rdi,4)
mov    -0x4(%r10,%rdi,4),%eax
imul   0x4(%r9,%rsi,4),%eax
mov    %eax,(%r9,%rsi,4)
add    $0xffffffffffffffff,%rsi
add    %r8,%rcx
lea    0x1(%rdi),%rax
cmp    %rsi,%rdi
mov    %rax,%rdi
jl     25a0 <fftmx+0x1480>
sar    $0x20,%rcx
mov    0x14(%rsp),%eax
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%r9
jmp    25fd <fftmx+0x14dd>
mov    %rdx,%rsi
mov    0x218(%rsp),%r14
jmp    2865 <fftmx+0x1745>
add    $0x1,%rcx
mov    0x14(%rsp),%eax
mov    0xd0(%rsp),%esi
mov    0x210(%rsp),%rdx
mov    (%rdx,%rcx,4),%ecx
mov    %rcx,0x70(%rsp)
mov    0x8(%rdx),%r15d
lea    0x1(%r15),%ecx
cmp    %eax,%esi
jne    2704 <fftmx+0x15e4>
movslq %r15d,%r10
mov    %edi,%r11d
movslq %r12d,%r14
mov    0x4(%rdx),%eax
mov    %eax,0x8(%rsp)
lea    0xc(%rdx),%r9
jmp    2648 <fftmx+0x1528>
nopw   0x0(%rax,%rax,1)
mov    %rdx,0xf8(%rsp)
mov    0xf8(%rsp),%r8
movslq %r8d,%r8
movslq %ecx,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r8,8),%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%r8,8)
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  (%rbx,%r8,8),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%r8,8)
movsd  %xmm0,(%rbx,%rcx,8)
add    %r11,%r8
add    %r10,%rcx
cmp    %r14,%rcx
jl     2660 <fftmx+0x1540>
mov    %r9,%rax
mov    %r15d,%edx
mov    0x8(%rsp),%esi
cs nopw 0x0(%rax,%rax,1)
nop
sub    %esi,%ecx
mov    %edx,%edi
mov    (%rax),%edx
add    %edx,%ecx
add    $0x4,%rax
mov    %edi,%esi
cmp    %edi,%ecx
jg     26b0 <fftmx+0x1590>
mov    0x40(%rsp),%rax
mov    0x210(%rsp),%rsi
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %ecx,%edx
jl     2640 <fftmx+0x1520>
add    %eax,%edx
add    %r15d,%ecx
cmp    %r12d,%ecx
jl     26e0 <fftmx+0x15c0>
mov    %rdx,%r8
cmp    %r12d,%edx
jl     269b <fftmx+0x157b>
mov    0x70(%rsp),%r9
jmp    2855 <fftmx+0x1735>
mov    %edi,%r14d
mov    0x4(%rdx),%esi
mov    %esi,0x90(%rsp)
mov    %r12d,%esi
sub    %r9d,%esi
mov    %rsi,0x8(%rsp)
mov    0x108(%rsp),%rsi
sub    %eax,%esi
imul   %edi,%esi
mov    %rsi,0x108(%rsp)
lea    (%r15,%rsi,1),%eax
sub    %r9d,%eax
mov    %eax,0x60(%rsp)
lea    0xc(%rdx),%rax
mov    %rax,0x30(%rsp)
mov    0xf8(%rsp),%rax
nopl   (%rax)
mov    %ecx,%edx
mov    %eax,%r12d
lea    (%r12,%r9,1),%eax
movslq %r12d,%rcx
cltq
movslq %edx,%rdi
lea    0x0(%rbp,%rdi,8),%rsi
lea    (%rbx,%rdi,8),%r8
lea    0x0(,%rcx,8),%r9
add    %rbp,%r9
lea    (%rbx,%rcx,8),%r10
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rdi,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%r9,%rdi,8)
movsd  %xmm0,(%rsi,%rdi,8)
movsd  (%r10,%rdi,8),%xmm0
movsd  (%r8,%rdi,8),%xmm1
movsd  %xmm1,(%r10,%rdi,8)
movsd  %xmm0,(%r8,%rdi,8)
add    %r14,%rdi
lea    (%rcx,%rdi,1),%r11
cmp    %rax,%r11
jl     2780 <fftmx+0x1660>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r12,1),%eax
add    %edi,%eax
add    %edx,%ecx
add    %edi,%ecx
cmp    %r13d,%eax
mov    0x18(%rsp),%r9
jl     2750 <fftmx+0x1630>
add    0x60(%rsp),%edx
mov    %edx,%ecx
add    %edi,%ecx
add    0x108(%rsp),%r12d
mov    %r12d,%eax
add    %edi,%eax
cmp    0x3c(%rsp),%ecx
jl     2750 <fftmx+0x1630>
mov    0x3c(%rsp),%r8d
mov    %rax,%r10
mov    0x30(%rsp),%rax
mov    %r15d,%esi
mov    0x90(%rsp),%edi
nopl   (%rax)
sub    %edi,%ecx
mov    %esi,%edx
mov    (%rax),%esi
add    %esi,%ecx
add    $0x4,%rax
mov    %edx,%edi
cmp    %edx,%ecx
jg     2810 <fftmx+0x16f0>
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %ecx,%eax
jl     2750 <fftmx+0x1630>
add    %r9d,%eax
add    %r15d,%ecx
cmp    %r8d,%ecx
jl     2830 <fftmx+0x1710>
cmp    %r8d,%eax
jl     27fb <fftmx+0x16db>
mov    0x70(%rsp),%r9
mov    0x210(%rsp),%rsi
mov    0x218(%rsp),%r14
mov    0x1e8(%rsp),%r15
movslq (%r15),%rax
lea    (%rax,%rax,1),%ecx
add    $0x1,%ecx
mov    0x1e0(%rsp),%edi
cmp    %edi,%ecx
jge    2c19 <fftmx+0x1af9>
mov    %r9,0x18(%rsp)
mov    0x4(%rsi,%rax,4),%ecx
mov    %ecx,0x28(%rsp)
sub    %eax,%edi
movslq %edi,%rax
movl   $0x1,0x4(%r14,%rax,4)
lea    (%r14,%rax,4),%rax
nopl   0x0(%rax)
mov    0x4(%rax),%ecx
imul   (%rax),%ecx
mov    %ecx,(%rax)
movslq (%r15),%rdx
add    $0xfffffffffffffffc,%rax
add    $0xffffffff,%edi
cmp    %edx,%edi
jne    28a0 <fftmx+0x1780>
lea    0x1(%rdx),%rcx
mov    %ecx,(%r15)
movslq 0x4(%r14,%rdx,4),%rdi
lea    -0x1(%rdi),%r8
cmp    $0x2,%rdi
jl     2923 <fftmx+0x1803>
mov    %edi,%r9d
lea    0x4(%r14),%r10
xor    %edx,%edx
mov    $0x1,%r11d
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rax
lea    (%r10,%rax,4),%rcx
mov    %edx,%eax
nopl   0x0(%rax)
mov    (%rcx),%esi
mov    %eax,%edx
add    %esi,%edx
add    $0x4,%rcx
mov    %edx,%eax
sub    %edi,%eax
mov    %esi,%edi
jge    28f0 <fftmx+0x17d0>
mov    0x210(%rsp),%rsi
mov    %edx,(%rsi,%r11,4)
add    $0x1,%r11
cmp    %r9,%r11
je     2923 <fftmx+0x1803>
mov    (%r15),%ecx
movslq %ecx,%rax
mov    (%r14,%rax,4),%edi
jmp    28e0 <fftmx+0x17c0>
neg    %r8
lea    0x4(%rsi),%r9
xor    %ecx,%ecx
movslq %ecx,%r10
mov    %r10d,%esi
not    %esi
lea    0x1(%r10),%r11d
lea    (%r10,%r8,1),%r14
add    $0x1,%r14
lea    (%r9,%r10,4),%r15
xor    %edi,%edi
jmp    2957 <fftmx+0x1837>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%esi
add    $0x1,%rdi
mov    (%r15,%rdi,4),%eax
test   %eax,%eax
js     2950 <fftmx+0x1830>
lea    (%r14,%rdi,1),%rcx
lea    (%r11,%rdi,1),%edx
cmp    %eax,%edx
jne    2980 <fftmx+0x1860>
mov    %esi,(%r15,%rdi,4)
test   %rcx,%rcx
jne    2950 <fftmx+0x1830>
jmp    29cc <fftmx+0x18ac>
cs nopw 0x0(%rax,%rax,1)
lea    (%r10,%rdi,1),%rcx
add    $0x1,%rcx
add    %rdi,%r11
mov    0x210(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rdx
mov    (%rsi,%rdx,4),%eax
mov    %eax,%esi
neg    %esi
mov    0x210(%rsp),%rdi
mov    %esi,(%rdi,%rdx,4)
mov    0x210(%rsp),%rsi
cmp    %eax,%r11d
jne    29a0 <fftmx+0x1880>
mov    %r11,0x70(%rsp)
jmp    292c <fftmx+0x180c>
sub    0x28(%rsp),%r13d
mov    0x40(%rsp),%rdx
mov    0x54(%rsp),%r10d
mov    0x210(%rsp),%rsi
mov    0x200(%rsp),%r11
mov    0x1f0(%rsp),%r14
mov    0x18(%rsp),%r9
js     2c19 <fftmx+0x1af9>
imul   %edx,%r10d
mov    0x70(%rsp),%rax
add    $0x1,%eax
mov    $0x1,%edi
sub    %edx,%edi
mov    %rdi,0xa0(%rsp)
cltq
mov    %rax,0x88(%rsp)
mov    0x14(%rsp),%eax
add    $0xffffffff,%eax
imul   %edx,%eax
sub    0x28(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x14(%rsp)
mov    %r9d,%eax
neg    %eax
mov    %eax,0x8(%rsp)
mov    %r10d,0x54(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rax
add    %r13d,%eax
mov    %rax,0x58(%rsp)
mov    0x88(%rsp),%r12
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rsi,%r12,4),%r15d
add    $0xffffffffffffffff,%r12
test   %r15d,%r15d
js     2a70 <fftmx+0x1950>
mov    %r15d,%esi
imul   %r9d,%esi
mov    0x58(%rsp),%rax
add    %esi,%eax
mov    %rax,0xe0(%rsp)
add    0x14(%rsp),%esi
mov    %rsi,0x30(%rsp)
mov    %r9d,%ecx
mov    %r15d,0x90(%rsp)
nopl   0x0(%rax,%rax,1)
cmp    %r10d,%ecx
mov    %ecx,%edi
cmovg  %r10d,%edi
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,1),%r8d
sub    %edi,%ecx
mov    0xe0(%rsp),%rax
mov    %rcx,0x60(%rsp)
lea    (%rcx,%rax,1),%r9d
mov    %edi,%ecx
neg    %ecx
mov    %rdx,%r10
mov    $0x8,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r8,%rdx,1),%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rsi,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rsi,1)
add    $0x8,%rsi
sub    %r10d,%edx
cmp    %edx,%ecx
jne    2af0 <fftmx+0x19d0>
mov    %r15d,%eax
mov    %r10,%rdx
mov    0x210(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %r9d,%r11d
lea    (%r11,%rdi,1),%r15d
movslq %eax,%r10
mov    (%rsi,%r10,4),%r8d
add    %r8d,%r10d
mov    0x8(%rsp),%eax
mov    %eax,%r9d
imul   %r10d,%r9d
xor    %r14d,%r14d
nop
lea    (%r9,%r15,1),%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm0
movslq %r15d,%r15
movsd  %xmm0,0x0(%rbp,%r15,8)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%r15,8)
sub    %edx,%r15d
add    %edx,%r14d
cmp    %r14d,%edi
jne    2b50 <fftmx+0x1a30>
mov    %r8d,%eax
neg    %eax
add    %r15d,%r9d
cmp    %eax,%r12d
jne    2b30 <fftmx+0x1a10>
lea    (%r11,%rdi,2),%edi
mov    0x18(%rsp),%r9
imul   %r9d,%r10d
sub    %r10d,%edi
sub    %r14d,%edi
mov    $0x8,%eax
mov    0x200(%rsp),%r11
mov    0x1f0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,1),%xmm0
movslq %edi,%rdi
movsd  %xmm0,0x0(%rbp,%rdi,8)
movsd  (%r11,%rax,1),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
sub    %edx,%edi
add    $0x8,%rax
add    %edx,%ecx
jne    2bc0 <fftmx+0x1aa0>
mov    0x60(%rsp),%rcx
test   %ecx,%ecx
mov    0x54(%rsp),%r10d
mov    0x90(%rsp),%r15d
jne    2ab0 <fftmx+0x1990>
cmp    $0xffffffff,%r8d
jne    2a70 <fftmx+0x1950>
mov    0x28(%rsp),%eax
sub    %eax,0x14(%rsp)
sub    %eax,%r13d
jns    2a50 <fftmx+0x1930>
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @fftmx(double* %0, double* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* %7, double* %8, double* %9, double* %10, double* %11, i32* %12, i32* %13) {
%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 i32*
%28 = alloca i32*
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
store double* %0, double** %15
store double* %1, double** %16
store i32 %2, i32* %17
store i32 %3, i32* %18
store i32 %4, i32* %19
store i32 %5, i32* %20
store i32 %6, i32* %21
store i32* %7, i32** %22
store double* %8, double** %23
store double* %9, double** %24
store double* %10, double** %25
store double* %11, double** %26
store i32* %12, i32** %27
store i32* %13, i32** %28
store i32 0, i32* %38
store double 0.000000e+00, double* %74
store double 0.000000e+00, double* %73
store double 0.000000e+00, double* %66
store double 0.000000e+00, double* %65
%78 = load i32, i32* %20
%79 = call i32 @abs(i32 %78)
store i32 %79, i32* %30
%80 = load i32, i32* %30
%81 = load i32, i32* %17
%82 = mul nsw i32 %80, %81
store i32 %82, i32* %49
%83 = load i32, i32* %30
%84 = load i32, i32* %19
%85 = mul nsw i32 %83, %84
store i32 %85, i32* %42
store double 0x3FE921FB54442D18, double* %70
store double 0x3FD3C6EF372FE950, double* %67
store double 0x3FEE6F0E134454FF, double* %75
store double 0x3FEBB67AE8584CAB, double* %76
%86 = load i32, i32* %20
%87 = icmp slt i32 %86, 0
br i1 %87, label %88, label %95
88: ; preds = %14
%89 = load double, double* %75
%90 = fneg double %89
store double %90, double* %75
%91 = load double, double* %76
%92 = fneg double %91
store double %92, double* %76
%93 = load double, double* %70
%94 = fneg double %93
store double %94, double* %70
br label %123
95: ; preds = %14
%96 = load i32, i32* %18
%97 = sitofp i32 %96 to double
%98 = fdiv double 1.000000e+00, %97
store double %98, double* %54
store i32 1, i32* %31
br label %99
99: ; preds = %118, %95
%100 = load i32, i32* %31
%101 = load i32, i32* %49
%102 = icmp sle i32 %100, %101
br i1 %102, label %103, label %122
103: ; preds = %99
%104 = load double, double* %54
%105 = load double*, double** %15
%106 = load i32, i32* %31
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = fmul double %109, %104
store double %110, double* %108
%111 = load double, double* %54
%112 = load double*, double** %16
%113 = load i32, i32* %31
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
%116 = load double, double* %115
%117 = fmul double %116, %111
store double %117, double* %115
br label %118
118: ; preds = %103
%119 = load i32, i32* %30
%120 = load i32, i32* %31
%121 = add nsw i32 %120, %119
store i32 %121, i32* %31
br label %99
122: ; preds = %99
br label %123
123: ; preds = %122, %88
%124 = load i32, i32* %42
store i32 %124, i32* %43
%125 = load i32, i32* %49
%126 = load i32, i32* %30
%127 = sub nsw i32 %125, %126
store i32 %127, i32* %48
%128 = load i32, i32* %42
%129 = load i32, i32* %18
%130 = sdiv i32 %128, %129
store i32 %130, i32* %32
store i32 32, i32* %45
%131 = load i32, i32* %45
%132 = load i32, i32* %32
%133 = mul nsw i32 %131, %132
store i32 %133, i32* %41
store i32 0, i32* %29
store i32 0, i32* %33
%134 = load i32, i32* %21
%135 = load i32*, i32** %22
%136 = load i32, i32* %135
%137 = sub nsw i32 %134, %136
store i32 %137, i32* %46
%138 = load i32*, i32** %28
%139 = load i32, i32* %46
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %138, i64 %140
%142 = load i32, i32* %141
store i32 %142, i32* %46
%143 = load i32*, i32** %22
%144 = load i32, i32* %143
%145 = icmp sgt i32 %144, 0
br i1 %145, label %146, label %162
146: ; preds = %123
%147 = load i32, i32* %46
%148 = load i32*, i32** %28
%149 = load i32*, i32** %22
%150 = load i32, i32* %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %148, i64 %151
%153 = load i32, i32* %152
%154 = icmp slt i32 %147, %153
br i1 %154, label %155, label %162
155: ; preds = %146
%156 = load i32*, i32** %28
%157 = load i32*, i32** %22
%158 = load i32, i32* %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %156, i64 %159
%161 = load i32, i32* %160
store i32 %161, i32* %46
br label %162
162: ; preds = %155, %146, %123
br label %163
163: ; preds = %1765, %905, %440, %162
%164 = load i32, i32* %32
%165 = sitofp i32 %164 to double
%166 = fmul double 8.000000e+00, %165
%167 = load i32, i32* %43
%168 = sitofp i32 %167 to double
%169 = fdiv double %166, %168
store double %169, double* %69
%170 = load double, double* %69
%171 = fmul double 5.000000e-01, %170
%172 = load double, double* %70
%173 = fmul double %171, %172
%174 = call double @sin(double %173)
store double %174, double* %77
%175 = load double, double* %77
%176 = fmul double 2.000000e+00, %175
%177 = load double, double* %77
%178 = fmul double %176, %177
store double %178, double* %68
%179 = load double, double* %69
%180 = load double, double* %70
%181 = fmul double %179, %180
%182 = call double @sin(double %181)
store double %182, double* %71
store i32 1, i32* %40
%183 = load i32*, i32** %28
%184 = load i32, i32* %29
%185 = add nsw i32 %184, 1
store i32 %185, i32* %29
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %183, i64 %186
%188 = load i32, i32* %187
%189 = icmp ne i32 %188, 2
br i1 %189, label %190, label %191
190: ; preds = %163
br label %599
191: ; preds = %163
%192 = load i32, i32* %43
%193 = sdiv i32 %192, 2
store i32 %193, i32* %43
%194 = load i32, i32* %43
%195 = add nsw i32 %194, 2
store i32 %195, i32* %36
br label %196
196: ; preds = %266, %191
br label %197
197: ; preds = %258, %196
%198 = load i32, i32* %40
%199 = load i32, i32* %43
%200 = add nsw i32 %198, %199
store i32 %200, i32* %37
%201 = load double*, double** %15
%202 = load i32, i32* %37
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
%205 = load double, double* %204
store double %205, double* %54
%206 = load double*, double** %16
%207 = load i32, i32* %37
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %206, i64 %208
%210 = load double, double* %209
store double %210, double* %61
%211 = load double*, double** %15
%212 = load i32, i32* %40
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = load double, double* %54
%217 = fsub double %215, %216
%218 = load double*, double** %15
%219 = load i32, i32* %37
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
store double %217, double* %221
%222 = load double*, double** %16
%223 = load i32, i32* %40
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %222, i64 %224
%226 = load double, double* %225
%227 = load double, double* %61
%228 = fsub double %226, %227
%229 = load double*, double** %16
%230 = load i32, i32* %37
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
store double %228, double* %232
%233 = load double*, double** %15
%234 = load i32, i32* %40
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = load double, double* %54
%239 = fadd double %237, %238
%240 = load double*, double** %15
%241 = load i32, i32* %40
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %240, i64 %242
store double %239, double* %243
%244 = load double*, double** %16
%245 = load i32, i32* %40
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %244, i64 %246
%248 = load double, double* %247
%249 = load double, double* %61
%250 = fadd double %248, %249
%251 = load double*, double** %16
%252 = load i32, i32* %40
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
store double %250, double* %254
%255 = load i32, i32* %37
%256 = load i32, i32* %43
%257 = add nsw i32 %255, %256
store i32 %257, i32* %40
br label %258
258: ; preds = %197
%259 = load i32, i32* %40
%260 = load i32, i32* %48
%261 = icmp sle i32 %259, %260
br i1 %261, label %197, label %262
262: ; preds = %258
%263 = load i32, i32* %48
%264 = load i32, i32* %40
%265 = sub nsw i32 %264, %263
store i32 %265, i32* %40
br label %266
266: ; preds = %262
%267 = load i32, i32* %40
%268 = load i32, i32* %32
%269 = icmp sle i32 %267, %268
br i1 %269, label %196, label %270
270: ; preds = %266
%271 = load i32, i32* %40
%272 = load i32, i32* %43
%273 = icmp sgt i32 %271, %272
br i1 %273, label %274, label %275
274: ; preds = %270
br label %1793
275: ; preds = %270
br label %276
276: ; preds = %439, %275
%277 = load double, double* %68
%278 = fsub double 1.000000e+00, %277
store double %278, double* %64
%279 = load double, double* %71
store double %279, double* %72
%280 = load i32, i32* %36
%281 = sdiv i32 %280, 2
%282 = load i32, i32* %41
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %287
284: ; preds = %276
%285 = load i32, i32* %36
%286 = sdiv i32 %285, 2
br label %289
287: ; preds = %276
%288 = load i32, i32* %41
br label %289
289: ; preds = %287, %284
%290 = phi i32 [ %286, %284 ], [ %288, %287 ]
store i32 %290, i32* %47
br label %310
291: ; preds = %416
%292 = load double, double* %64
%293 = load double, double* %68
%294 = load double, double* %64
%295 = load double, double* %71
%296 = load double, double* %72
%297 = fmul double %295, %296
%298 = call double @llvm.fmuladd.f64(double %293, double %294, double %297)
%299 = fsub double %292, %298
store double %299, double* %54
%300 = load double, double* %71
%301 = load double, double* %64
%302 = load double, double* %68
%303 = load double, double* %72
%304 = fmul double %302, %303
%305 = fneg double %304
%306 = call double @llvm.fmuladd.f64(double %300, double %301, double %305)
%307 = load double, double* %72
%308 = fadd double %306, %307
store double %308, double* %72
%309 = load double, double* %54
store double %309, double* %64
br label %310
310: ; preds = %468, %291, %289
br label %311
311: ; preds = %405, %310
br label %312
312: ; preds = %392, %311
%313 = load i32, i32* %40
%314 = load i32, i32* %43
%315 = add nsw i32 %313, %314
store i32 %315, i32* %37
%316 = load double*, double** %15
%317 = load i32, i32* %40
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = load double*, double** %15
%322 = load i32, i32* %37
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %321, i64 %323
%325 = load double, double* %324
%326 = fsub double %320, %325
store double %326, double* %54
%327 = load double*, double** %16
%328 = load i32, i32* %40
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %327, i64 %329
%331 = load double, double* %330
%332 = load double*, double** %16
%333 = load i32, i32* %37
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %332, i64 %334
%336 = load double, double* %335
%337 = fsub double %331, %336
store double %337, double* %61
%338 = load double*, double** %15
%339 = load i32, i32* %40
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %338, i64 %340
%342 = load double, double* %341
%343 = load double*, double** %15
%344 = load i32, i32* %37
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
%347 = load double, double* %346
%348 = fadd double %342, %347
%349 = load double*, double** %15
%350 = load i32, i32* %40
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %349, i64 %351
store double %348, double* %352
%353 = load double*, double** %16
%354 = load i32, i32* %40
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %353, i64 %355
%357 = load double, double* %356
%358 = load double*, double** %16
%359 = load i32, i32* %37
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %358, i64 %360
%362 = load double, double* %361
%363 = fadd double %357, %362
%364 = load double*, double** %16
%365 = load i32, i32* %40
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
store double %363, double* %367
%368 = load double, double* %64
%369 = load double, double* %54
%370 = load double, double* %72
%371 = load double, double* %61
%372 = fmul double %370, %371
%373 = fneg double %372
%374 = call double @llvm.fmuladd.f64(double %368, double %369, double %373)
%375 = load double*, double** %15
%376 = load i32, i32* %37
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %375, i64 %377
store double %374, double* %378
%379 = load double, double* %72
%380 = load double, double* %54
%381 = load double, double* %64
%382 = load double, double* %61
%383 = fmul double %381, %382
%384 = call double @llvm.fmuladd.f64(double %379, double %380, double %383)
%385 = load double*, double** %16
%386 = load i32, i32* %37
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %385, i64 %387
store double %384, double* %388
%389 = load i32, i32* %37
%390 = load i32, i32* %43
%391 = add nsw i32 %389, %390
store i32 %391, i32* %40
br label %392
392: ; preds = %312
%393 = load i32, i32* %40
%394 = load i32, i32* %49
%395 = icmp slt i32 %393, %394
br i1 %395, label %312, label %396
396: ; preds = %392
%397 = load i32, i32* %40
%398 = load i32, i32* %49
%399 = sub nsw i32 %397, %398
store i32 %399, i32* %37
%400 = load double, double* %64
%401 = fneg double %400
store double %401, double* %64
%402 = load i32, i32* %36
%403 = load i32, i32* %37
%404 = sub nsw i32 %402, %403
store i32 %404, i32* %40
br label %405
405: ; preds = %396
%406 = load i32, i32* %40
%407 = load i32, i32* %37
%408 = icmp sgt i32 %406, %407
br i1 %408, label %311, label %409
409: ; preds = %405
%410 = load i32, i32* %32
%411 = load i32, i32* %40
%412 = add nsw i32 %411, %410
store i32 %412, i32* %40
%413 = load i32, i32* %40
%414 = load i32, i32* %47
%415 = icmp sle i32 %413, %414
br i1 %415, label %416, label %417
416: ; preds = %409
br label %291
417: ; preds = %409
%418 = load i32, i32* %40
%419 = load i32, i32* %37
%420 = icmp slt i32 %418, %419
br i1 %420, label %421, label %422
421: ; preds = %417
br label %441
422: ; preds = %417
%423 = load i32, i32* %30
%424 = load i32, i32* %30
%425 = add nsw i32 %423, %424
%426 = load i32, i32* %36
%427 = add nsw i32 %426, %425
store i32 %427, i32* %36
%428 = load i32, i32* %36
%429 = load i32, i32* %43
%430 = sub nsw i32 %428, %429
%431 = sdiv i32 %430, 2
%432 = load i32, i32* %32
%433 = add nsw i32 %431, %432
store i32 %433, i32* %40
%434 = load i32, i32* %40
%435 = load i32, i32* %32
%436 = load i32, i32* %32
%437 = add nsw i32 %435, %436
%438 = icmp sle i32 %434, %437
br i1 %438, label %439, label %440
439: ; preds = %422
br label %276
440: ; preds = %422
br label %163
441: ; preds = %421
%442 = load i32, i32* %40
%443 = sub nsw i32 %442, 1
%444 = load i32, i32* %32
%445 = sdiv i32 %443, %444
%446 = sitofp i32 %445 to double
%447 = load double, double* %69
%448 = fmul double %446, %447
%449 = load double, double* %70
%450 = fmul double %448, %449
store double %450, double* %72
%451 = load double, double* %72
%452 = call double @cos(double %451)
store double %452, double* %64
%453 = load double, double* %72
%454 = call double @sin(double %453)
store double %454, double* %72
%455 = load i32, i32* %36
%456 = sdiv i32 %455, 2
%457 = load i32, i32* %47
%458 = load i32, i32* %41
%459 = add nsw i32 %457, %458
%460 = icmp slt i32 %456, %459
br i1 %460, label %461, label %464
461: ; preds = %441
%462 = load i32, i32* %36
%463 = sdiv i32 %462, 2
br label %468
464: ; preds = %441
%465 = load i32, i32* %47
%466 = load i32, i32* %41
%467 = add nsw i32 %465, %466
br label %468
468: ; preds = %464, %461
%469 = phi i32 [ %463, %461 ], [ %467, %464 ]
store i32 %469, i32* %47
br label %310
470: ; preds = %1272, %597, %589
%471 = load i32, i32* %40
%472 = load i32, i32* %43
%473 = add nsw i32 %471, %472
store i32 %473, i32* %36
%474 = load i32, i32* %36
%475 = load i32, i32* %43
%476 = add nsw i32 %474, %475
store i32 %476, i32* %37
%477 = load double*, double** %15
%478 = load i32, i32* %40
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %477, i64 %479
%481 = load double, double* %480
store double %481, double* %54
%482 = load double*, double** %16
%483 = load i32, i32* %40
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %482, i64 %484
%486 = load double, double* %485
store double %486, double* %61
%487 = load double*, double** %15
%488 = load i32, i32* %36
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %487, i64 %489
%491 = load double, double* %490
%492 = load double*, double** %15
%493 = load i32, i32* %37
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %492, i64 %494
%496 = load double, double* %495
%497 = fadd double %491, %496
store double %497, double* %51
%498 = load double*, double** %16
%499 = load i32, i32* %36
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
%502 = load double, double* %501
%503 = load double*, double** %16
%504 = load i32, i32* %37
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %503, i64 %505
%507 = load double, double* %506
%508 = fadd double %502, %507
store double %508, double* %58
%509 = load double, double* %54
%510 = load double, double* %51
%511 = fadd double %509, %510
%512 = load double*, double** %15
%513 = load i32, i32* %40
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %512, i64 %514
store double %511, double* %515
%516 = load double, double* %61
%517 = load double, double* %58
%518 = fadd double %516, %517
%519 = load double*, double** %16
%520 = load i32, i32* %40
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
store double %518, double* %522
%523 = load double, double* %51
%524 = load double, double* %54
%525 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %523, double %524)
store double %525, double* %54
%526 = load double, double* %58
%527 = load double, double* %61
%528 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %526, double %527)
store double %528, double* %61
%529 = load double*, double** %15
%530 = load i32, i32* %36
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %529, i64 %531
%533 = load double, double* %532
%534 = load double*, double** %15
%535 = load i32, i32* %37
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double, double* %534, i64 %536
%538 = load double, double* %537
%539 = fsub double %533, %538
%540 = load double, double* %76
%541 = fmul double %539, %540
store double %541, double* %51
%542 = load double*, double** %16
%543 = load i32, i32* %36
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds double, double* %542, i64 %544
%546 = load double, double* %545
%547 = load double*, double** %16
%548 = load i32, i32* %37
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double, double* %547, i64 %549
%551 = load double, double* %550
%552 = fsub double %546, %551
%553 = load double, double* %76
%554 = fmul double %552, %553
store double %554, double* %58
%555 = load double, double* %54
%556 = load double, double* %58
%557 = fsub double %555, %556
%558 = load double*, double** %15
%559 = load i32, i32* %36
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
store double %557, double* %561
%562 = load double, double* %61
%563 = load double, double* %51
%564 = fadd double %562, %563
%565 = load double*, double** %16
%566 = load i32, i32* %36
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %565, i64 %567
store double %564, double* %568
%569 = load double, double* %54
%570 = load double, double* %58
%571 = fadd double %569, %570
%572 = load double*, double** %15
%573 = load i32, i32* %37
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %572, i64 %574
store double %571, double* %575
%576 = load double, double* %61
%577 = load double, double* %51
%578 = fsub double %576, %577
%579 = load double*, double** %16
%580 = load i32, i32* %37
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %579, i64 %581
store double %578, double* %582
%583 = load i32, i32* %37
%584 = load i32, i32* %43
%585 = add nsw i32 %583, %584
store i32 %585, i32* %40
%586 = load i32, i32* %40
%587 = load i32, i32* %48
%588 = icmp slt i32 %586, %587
br i1 %588, label %589, label %590
589: ; preds = %470
br label %470
590: ; preds = %470
%591 = load i32, i32* %48
%592 = load i32, i32* %40
%593 = sub nsw i32 %592, %591
store i32 %593, i32* %40
%594 = load i32, i32* %40
%595 = load i32, i32* %43
%596 = icmp sle i32 %594, %595
br i1 %596, label %597, label %598
597: ; preds = %590
br label %470
598: ; preds = %590
br label %1625
599: ; preds = %190
%600 = load i32*, i32** %28
%601 = load i32, i32* %29
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds i32, i32* %600, i64 %602
%604 = load i32, i32* %603
%605 = icmp ne i32 %604, 4
br i1 %605, label %606, label %607
606: ; preds = %599
br label %1260
607: ; preds = %599
%608 = load i32, i32* %43
store i32 %608, i32* %44
%609 = load i32, i32* %43
%610 = sdiv i32 %609, 4
store i32 %610, i32* %43
br label %611
611: ; preds = %899, %607
store double 1.000000e+00, double* %64
store double 0.000000e+00, double* %72
%612 = load i32, i32* %43
%613 = load i32, i32* %41
%614 = icmp slt i32 %612, %613
br i1 %614, label %615, label %617
615: ; preds = %611
%616 = load i32, i32* %43
br label %619
617: ; preds = %611
%618 = load i32, i32* %41
br label %619
619: ; preds = %617, %615
%620 = phi i32 [ %616, %615 ], [ %618, %617 ]
store i32 %620, i32* %47
br label %665
621: ; preds = %884
%622 = load double, double* %64
%623 = load double, double* %68
%624 = load double, double* %64
%625 = load double, double* %71
%626 = load double, double* %72
%627 = fmul double %625, %626
%628 = call double @llvm.fmuladd.f64(double %623, double %624, double %627)
%629 = fsub double %622, %628
store double %629, double* %65
%630 = load double, double* %71
%631 = load double, double* %64
%632 = load double, double* %68
%633 = load double, double* %72
%634 = fmul double %632, %633
%635 = fneg double %634
%636 = call double @llvm.fmuladd.f64(double %630, double %631, double %635)
%637 = load double, double* %72
%638 = fadd double %636, %637
store double %638, double* %72
%639 = load double, double* %65
store double %639, double* %64
br label %640
640: ; preds = %987, %621
%641 = load double, double* %64
%642 = load double, double* %64
%643 = load double, double* %72
%644 = load double, double* %72
%645 = fmul double %643, %644
%646 = fneg double %645
%647 = call double @llvm.fmuladd.f64(double %641, double %642, double %646)
store double %647, double* %65
%648 = load double, double* %64
%649 = load double, double* %72
%650 = fmul double %648, %649
%651 = fmul double %650, 2.000000e+00
store double %651, double* %73
%652 = load double, double* %65
%653 = load double, double* %64
%654 = load double, double* %73
%655 = load double, double* %72
%656 = fmul double %654, %655
%657 = fneg double %656
%658 = call double @llvm.fmuladd.f64(double %652, double %653, double %657)
store double %658, double* %66
%659 = load double, double* %65
%660 = load double, double* %72
%661 = load double, double* %73
%662 = load double, double* %64
%663 = fmul double %661, %662
%664 = call double @llvm.fmuladd.f64(double %659, double %660, double %663)
store double %664, double* %74
br label %665
665: ; preds = %960, %873, %640, %619
%666 = load i32, i32* %40
%667 = load i32, i32* %43
%668 = add nsw i32 %666, %667
store i32 %668, i32* %36
%669 = load i32, i32* %36
%670 = load i32, i32* %43
%671 = add nsw i32 %669, %670
store i32 %671, i32* %37
%672 = load i32, i32* %37
%673 = load i32, i32* %43
%674 = add nsw i32 %672, %673
store i32 %674, i32* %38
%675 = load double*, double** %15
%676 = load i32, i32* %40
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds double, double* %675, i64 %677
%679 = load double, double* %678
%680 = load double*, double** %15
%681 = load i32, i32* %37
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %680, i64 %682
%684 = load double, double* %683
%685 = fadd double %679, %684
store double %685, double* %56
%686 = load double*, double** %15
%687 = load i32, i32* %40
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %686, i64 %688
%690 = load double, double* %689
%691 = load double*, double** %15
%692 = load i32, i32* %37
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds double, double* %691, i64 %693
%695 = load double, double* %694
%696 = fsub double %690, %695
store double %696, double* %55
%697 = load double*, double** %15
%698 = load i32, i32* %36
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds double, double* %697, i64 %699
%701 = load double, double* %700
%702 = load double*, double** %15
%703 = load i32, i32* %38
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds double, double* %702, i64 %704
%706 = load double, double* %705
%707 = fadd double %701, %706
store double %707, double* %53
%708 = load double*, double** %15
%709 = load i32, i32* %36
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %708, i64 %710
%712 = load double, double* %711
%713 = load double*, double** %15
%714 = load i32, i32* %38
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds double, double* %713, i64 %715
%717 = load double, double* %716
%718 = fsub double %712, %717
store double %718, double* %52
%719 = load double, double* %56
%720 = load double, double* %53
%721 = fadd double %719, %720
%722 = load double*, double** %15
%723 = load i32, i32* %40
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds double, double* %722, i64 %724
store double %721, double* %725
%726 = load double, double* %56
%727 = load double, double* %53
%728 = fsub double %726, %727
store double %728, double* %53
%729 = load double*, double** %16
%730 = load i32, i32* %40
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %729, i64 %731
%733 = load double, double* %732
%734 = load double*, double** %16
%735 = load i32, i32* %37
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds double, double* %734, i64 %736
%738 = load double, double* %737
%739 = fadd double %733, %738
store double %739, double* %63
%740 = load double*, double** %16
%741 = load i32, i32* %40
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds double, double* %740, i64 %742
%744 = load double, double* %743
%745 = load double*, double** %16
%746 = load i32, i32* %37
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds double, double* %745, i64 %747
%749 = load double, double* %748
%750 = fsub double %744, %749
store double %750, double* %62
%751 = load double*, double** %16
%752 = load i32, i32* %36
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds double, double* %751, i64 %753
%755 = load double, double* %754
%756 = load double*, double** %16
%757 = load i32, i32* %38
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %756, i64 %758
%760 = load double, double* %759
%761 = fadd double %755, %760
store double %761, double* %60
%762 = load double*, double** %16
%763 = load i32, i32* %36
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds double, double* %762, i64 %764
%766 = load double, double* %765
%767 = load double*, double** %16
%768 = load i32, i32* %38
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds double, double* %767, i64 %769
%771 = load double, double* %770
%772 = fsub double %766, %771
store double %772, double* %59
%773 = load double, double* %63
%774 = load double, double* %60
%775 = fadd double %773, %774
%776 = load double*, double** %16
%777 = load i32, i32* %40
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double, double* %776, i64 %778
store double %775, double* %779
%780 = load double, double* %63
%781 = load double, double* %60
%782 = fsub double %780, %781
store double %782, double* %60
%783 = load i32, i32* %20
%784 = icmp slt i32 %783, 0
br i1 %784, label %785, label %786
785: ; preds = %665
br label %906
786: ; preds = %665
%787 = load double, double* %55
%788 = load double, double* %59
%789 = fsub double %787, %788
store double %789, double* %56
%790 = load double, double* %55
%791 = load double, double* %59
%792 = fadd double %790, %791
store double %792, double* %55
%793 = load double, double* %62
%794 = load double, double* %52
%795 = fadd double %793, %794
store double %795, double* %63
%796 = load double, double* %62
%797 = load double, double* %52
%798 = fsub double %796, %797
store double %798, double* %62
%799 = load double, double* %72
%800 = fcmp oeq double %799, 0.000000e+00
br i1 %800, label %801, label %802
801: ; preds = %786
br label %923
802: ; preds = %786
br label %803
803: ; preds = %921, %802
%804 = load double, double* %56
%805 = load double, double* %64
%806 = load double, double* %63
%807 = load double, double* %72
%808 = fmul double %806, %807
%809 = fneg double %808
%810 = call double @llvm.fmuladd.f64(double %804, double %805, double %809)
%811 = load double*, double** %15
%812 = load i32, i32* %36
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds double, double* %811, i64 %813
store double %810, double* %814
%815 = load double, double* %56
%816 = load double, double* %72
%817 = load double, double* %63
%818 = load double, double* %64
%819 = fmul double %817, %818
%820 = call double @llvm.fmuladd.f64(double %815, double %816, double %819)
%821 = load double*, double** %16
%822 = load i32, i32* %36
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds double, double* %821, i64 %823
store double %820, double* %824
%825 = load double, double* %53
%826 = load double, double* %65
%827 = load double, double* %60
%828 = load double, double* %73
%829 = fmul double %827, %828
%830 = fneg double %829
%831 = call double @llvm.fmuladd.f64(double %825, double %826, double %830)
%832 = load double*, double** %15
%833 = load i32, i32* %37
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds double, double* %832, i64 %834
store double %831, double* %835
%836 = load double, double* %53
%837 = load double, double* %73
%838 = load double, double* %60
%839 = load double, double* %65
%840 = fmul double %838, %839
%841 = call double @llvm.fmuladd.f64(double %836, double %837, double %840)
%842 = load double*, double** %16
%843 = load i32, i32* %37
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double, double* %842, i64 %844
store double %841, double* %845
%846 = load double, double* %55
%847 = load double, double* %66
%848 = load double, double* %62
%849 = load double, double* %74
%850 = fmul double %848, %849
%851 = fneg double %850
%852 = call double @llvm.fmuladd.f64(double %846, double %847, double %851)
%853 = load double*, double** %15
%854 = load i32, i32* %38
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds double, double* %853, i64 %855
store double %852, double* %856
%857 = load double, double* %55
%858 = load double, double* %74
%859 = load double, double* %62
%860 = load double, double* %66
%861 = fmul double %859, %860
%862 = call double @llvm.fmuladd.f64(double %857, double %858, double %861)
%863 = load double*, double** %16
%864 = load i32, i32* %38
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %863, i64 %865
store double %862, double* %866
%867 = load i32, i32* %38
%868 = load i32, i32* %43
%869 = add nsw i32 %867, %868
store i32 %869, i32* %40
%870 = load i32, i32* %40
%871 = load i32, i32* %49
%872 = icmp sle i32 %870, %871
br i1 %872, label %873, label %874
873: ; preds = %803
br label %665
874: ; preds = %803
br label %875
875: ; preds = %961, %874
%876 = load i32, i32* %49
%877 = load i32, i32* %32
%878 = sub nsw i32 %876, %877
%879 = load i32, i32* %40
%880 = sub nsw i32 %879, %878
store i32 %880, i32* %40
%881 = load i32, i32* %40
%882 = load i32, i32* %47
%883 = icmp sle i32 %881, %882
br i1 %883, label %884, label %885
884: ; preds = %875
br label %621
885: ; preds = %875
%886 = load i32, i32* %40
%887 = load i32, i32* %43
%888 = icmp slt i32 %886, %887
br i1 %888, label %889, label %890
889: ; preds = %885
br label %962
890: ; preds = %885
%891 = load i32, i32* %43
%892 = load i32, i32* %30
%893 = sub nsw i32 %891, %892
%894 = load i32, i32* %40
%895 = sub nsw i32 %894, %893
store i32 %895, i32* %40
%896 = load i32, i32* %40
%897 = load i32, i32* %32
%898 = icmp sle i32 %896, %897
br i1 %898, label %899, label %900
899: ; preds = %890
br label %611
900: ; preds = %890
%901 = load i32, i32* %43
%902 = load i32, i32* %32
%903 = icmp eq i32 %901, %902
br i1 %903, label %904, label %905
904: ; preds = %900
br label %1793
905: ; preds = %900
br label %163
906: ; preds = %785
%907 = load double, double* %55
%908 = load double, double* %59
%909 = fadd double %907, %908
store double %909, double* %56
%910 = load double, double* %55
%911 = load double, double* %59
%912 = fsub double %910, %911
store double %912, double* %55
%913 = load double, double* %62
%914 = load double, double* %52
%915 = fsub double %913, %914
store double %915, double* %63
%916 = load double, double* %62
%917 = load double, double* %52
%918 = fadd double %916, %917
store double %918, double* %62
%919 = load double, double* %72
%920 = fcmp une double %919, 0.000000e+00
br i1 %920, label %921, label %922
921: ; preds = %906
br label %803
922: ; preds = %906
br label %923
923: ; preds = %922, %801
%924 = load double, double* %56
%925 = load double*, double** %15
%926 = load i32, i32* %36
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds double, double* %925, i64 %927
store double %924, double* %928
%929 = load double, double* %63
%930 = load double*, double** %16
%931 = load i32, i32* %36
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds double, double* %930, i64 %932
store double %929, double* %933
%934 = load double, double* %53
%935 = load double*, double** %15
%936 = load i32, i32* %37
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds double, double* %935, i64 %937
store double %934, double* %938
%939 = load double, double* %60
%940 = load double*, double** %16
%941 = load i32, i32* %37
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds double, double* %940, i64 %942
store double %939, double* %943
%944 = load double, double* %55
%945 = load double*, double** %15
%946 = load i32, i32* %38
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %945, i64 %947
store double %944, double* %948
%949 = load double, double* %62
%950 = load double*, double** %16
%951 = load i32, i32* %38
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds double, double* %950, i64 %952
store double %949, double* %953
%954 = load i32, i32* %38
%955 = load i32, i32* %43
%956 = add nsw i32 %954, %955
store i32 %956, i32* %40
%957 = load i32, i32* %40
%958 = load i32, i32* %49
%959 = icmp sle i32 %957, %958
br i1 %959, label %960, label %961
960: ; preds = %923
br label %665
961: ; preds = %923
br label %875
962: ; preds = %889
%963 = load i32, i32* %40
%964 = sub nsw i32 %963, 1
%965 = load i32, i32* %32
%966 = sdiv i32 %964, %965
%967 = sitofp i32 %966 to double
%968 = load double, double* %69
%969 = fmul double %967, %968
%970 = load double, double* %70
%971 = fmul double %969, %970
store double %971, double* %72
%972 = load double, double* %72
%973 = call double @cos(double %972)
store double %973, double* %64
%974 = load double, double* %72
%975 = call double @sin(double %974)
store double %975, double* %72
%976 = load i32, i32* %43
%977 = load i32, i32* %47
%978 = load i32, i32* %41
%979 = add nsw i32 %977, %978
%980 = icmp slt i32 %976, %979
br i1 %980, label %981, label %983
981: ; preds = %962
%982 = load i32, i32* %43
br label %987
983: ; preds = %962
%984 = load i32, i32* %47
%985 = load i32, i32* %41
%986 = add nsw i32 %984, %985
br label %987
987: ; preds = %983, %981
%988 = phi i32 [ %982, %981 ], [ %986, %983 ]
store i32 %988, i32* %47
br label %640
989: ; preds = %1276
%990 = load double, double* %67
%991 = load double, double* %67
%992 = load double, double* %75
%993 = load double, double* %75
%994 = fmul double %992, %993
%995 = fneg double %994
%996 = call double @llvm.fmuladd.f64(double %990, double %991, double %995)
store double %996, double* %65
%997 = load double, double* %67
%998 = fmul double 2.000000e+00, %997
%999 = load double, double* %75
%1000 = fmul double %998, %999
store double %1000, double* %73
br label %1001
1001: ; preds = %1258, %1250, %989
%1002 = load i32, i32* %40
%1003 = load i32, i32* %43
%1004 = add nsw i32 %1002, %1003
store i32 %1004, i32* %36
%1005 = load i32, i32* %36
%1006 = load i32, i32* %43
%1007 = add nsw i32 %1005, %1006
store i32 %1007, i32* %37
%1008 = load i32, i32* %37
%1009 = load i32, i32* %43
%1010 = add nsw i32 %1008, %1009
store i32 %1010, i32* %38
%1011 = load i32, i32* %38
%1012 = load i32, i32* %43
%1013 = add nsw i32 %1011, %1012
store i32 %1013, i32* %39
%1014 = load double*, double** %15
%1015 = load i32, i32* %36
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %1014, i64 %1016
%1018 = load double, double* %1017
%1019 = load double*, double** %15
%1020 = load i32, i32* %39
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds double, double* %1019, i64 %1021
%1023 = load double, double* %1022
%1024 = fadd double %1018, %1023
store double %1024, double* %56
%1025 = load double*, double** %15
%1026 = load i32, i32* %36
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds double, double* %1025, i64 %1027
%1029 = load double, double* %1028
%1030 = load double*, double** %15
%1031 = load i32, i32* %39
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds double, double* %1030, i64 %1032
%1034 = load double, double* %1033
%1035 = fsub double %1029, %1034
store double %1035, double* %55
%1036 = load double*, double** %16
%1037 = load i32, i32* %36
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds double, double* %1036, i64 %1038
%1040 = load double, double* %1039
%1041 = load double*, double** %16
%1042 = load i32, i32* %39
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds double, double* %1041, i64 %1043
%1045 = load double, double* %1044
%1046 = fadd double %1040, %1045
store double %1046, double* %63
%1047 = load double*, double** %16
%1048 = load i32, i32* %36
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds double, double* %1047, i64 %1049
%1051 = load double, double* %1050
%1052 = load double*, double** %16
%1053 = load i32, i32* %39
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds double, double* %1052, i64 %1054
%1056 = load double, double* %1055
%1057 = fsub double %1051, %1056
store double %1057, double* %62
%1058 = load double*, double** %15
%1059 = load i32, i32* %37
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds double, double* %1058, i64 %1060
%1062 = load double, double* %1061
%1063 = load double*, double** %15
%1064 = load i32, i32* %38
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds double, double* %1063, i64 %1065
%1067 = load double, double* %1066
%1068 = fadd double %1062, %1067
store double %1068, double* %53
%1069 = load double*, double** %15
%1070 = load i32, i32* %37
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds double, double* %1069, i64 %1071
%1073 = load double, double* %1072
%1074 = load double*, double** %15
%1075 = load i32, i32* %38
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1074, i64 %1076
%1078 = load double, double* %1077
%1079 = fsub double %1073, %1078
store double %1079, double* %52
%1080 = load double*, double** %16
%1081 = load i32, i32* %37
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds double, double* %1080, i64 %1082
%1084 = load double, double* %1083
%1085 = load double*, double** %16
%1086 = load i32, i32* %38
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds double, double* %1085, i64 %1087
%1089 = load double, double* %1088
%1090 = fadd double %1084, %1089
store double %1090, double* %60
%1091 = load double*, double** %16
%1092 = load i32, i32* %37
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds double, double* %1091, i64 %1093
%1095 = load double, double* %1094
%1096 = load double*, double** %16
%1097 = load i32, i32* %38
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds double, double* %1096, i64 %1098
%1100 = load double, double* %1099
%1101 = fsub double %1095, %1100
store double %1101, double* %59
%1102 = load double*, double** %15
%1103 = load i32, i32* %40
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds double, double* %1102, i64 %1104
%1106 = load double, double* %1105
store double %1106, double* %50
%1107 = load double*, double** %16
%1108 = load i32, i32* %40
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds double, double* %1107, i64 %1109
%1111 = load double, double* %1110
store double %1111, double* %57
%1112 = load double, double* %50
%1113 = load double, double* %56
%1114 = fadd double %1112, %1113
%1115 = load double, double* %53
%1116 = fadd double %1114, %1115
%1117 = load double*, double** %15
%1118 = load i32, i32* %40
%1119 = sext i32 %1118 to i64
%1120 = getelementptr inbounds double, double* %1117, i64 %1119
store double %1116, double* %1120
%1121 = load double, double* %57
%1122 = load double, double* %63
%1123 = fadd double %1121, %1122
%1124 = load double, double* %60
%1125 = fadd double %1123, %1124
%1126 = load double*, double** %16
%1127 = load i32, i32* %40
%1128 = sext i32 %1127 to i64
%1129 = getelementptr inbounds double, double* %1126, i64 %1128
store double %1125, double* %1129
%1130 = load double, double* %56
%1131 = load double, double* %67
%1132 = load double, double* %53
%1133 = load double, double* %65
%1134 = fmul double %1132, %1133
%1135 = call double @llvm.fmuladd.f64(double %1130, double %1131, double %1134)
%1136 = load double, double* %50
%1137 = fadd double %1135, %1136
store double %1137, double* %54
%1138 = load double, double* %63
%1139 = load double, double* %67
%1140 = load double, double* %60
%1141 = load double, double* %65
%1142 = fmul double %1140, %1141
%1143 = call double @llvm.fmuladd.f64(double %1138, double %1139, double %1142)
%1144 = load double, double* %57
%1145 = fadd double %1143, %1144
store double %1145, double* %61
%1146 = load double, double* %55
%1147 = load double, double* %75
%1148 = load double, double* %52
%1149 = load double, double* %73
%1150 = fmul double %1148, %1149
%1151 = call double @llvm.fmuladd.f64(double %1146, double %1147, double %1150)
store double %1151, double* %51
%1152 = load double, double* %62
%1153 = load double, double* %75
%1154 = load double, double* %59
%1155 = load double, double* %73
%1156 = fmul double %1154, %1155
%1157 = call double @llvm.fmuladd.f64(double %1152, double %1153, double %1156)
store double %1157, double* %58
%1158 = load double, double* %54
%1159 = load double, double* %58
%1160 = fsub double %1158, %1159
%1161 = load double*, double** %15
%1162 = load i32, i32* %36
%1163 = sext i32 %1162 to i64
%1164 = getelementptr inbounds double, double* %1161, i64 %1163
store double %1160, double* %1164
%1165 = load double, double* %54
%1166 = load double, double* %58
%1167 = fadd double %1165, %1166
%1168 = load double*, double** %15
%1169 = load i32, i32* %39
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds double, double* %1168, i64 %1170
store double %1167, double* %1171
%1172 = load double, double* %61
%1173 = load double, double* %51
%1174 = fadd double %1172, %1173
%1175 = load double*, double** %16
%1176 = load i32, i32* %36
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds double, double* %1175, i64 %1177
store double %1174, double* %1178
%1179 = load double, double* %61
%1180 = load double, double* %51
%1181 = fsub double %1179, %1180
%1182 = load double*, double** %16
%1183 = load i32, i32* %39
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds double, double* %1182, i64 %1184
store double %1181, double* %1185
%1186 = load double, double* %56
%1187 = load double, double* %65
%1188 = load double, double* %53
%1189 = load double, double* %67
%1190 = fmul double %1188, %1189
%1191 = call double @llvm.fmuladd.f64(double %1186, double %1187, double %1190)
%1192 = load double, double* %50
%1193 = fadd double %1191, %1192
store double %1193, double* %54
%1194 = load double, double* %63
%1195 = load double, double* %65
%1196 = load double, double* %60
%1197 = load double, double* %67
%1198 = fmul double %1196, %1197
%1199 = call double @llvm.fmuladd.f64(double %1194, double %1195, double %1198)
%1200 = load double, double* %57
%1201 = fadd double %1199, %1200
store double %1201, double* %61
%1202 = load double, double* %55
%1203 = load double, double* %73
%1204 = load double, double* %52
%1205 = load double, double* %75
%1206 = fmul double %1204, %1205
%1207 = fneg double %1206
%1208 = call double @llvm.fmuladd.f64(double %1202, double %1203, double %1207)
store double %1208, double* %51
%1209 = load double, double* %62
%1210 = load double, double* %73
%1211 = load double, double* %59
%1212 = load double, double* %75
%1213 = fmul double %1211, %1212
%1214 = fneg double %1213
%1215 = call double @llvm.fmuladd.f64(double %1209, double %1210, double %1214)
store double %1215, double* %58
%1216 = load double, double* %54
%1217 = load double, double* %58
%1218 = fsub double %1216, %1217
%1219 = load double*, double** %15
%1220 = load i32, i32* %37
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds double, double* %1219, i64 %1221
store double %1218, double* %1222
%1223 = load double, double* %54
%1224 = load double, double* %58
%1225 = fadd double %1223, %1224
%1226 = load double*, double** %15
%1227 = load i32, i32* %38
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds double, double* %1226, i64 %1228
store double %1225, double* %1229
%1230 = load double, double* %61
%1231 = load double, double* %51
%1232 = fadd double %1230, %1231
%1233 = load double*, double** %16
%1234 = load i32, i32* %37
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds double, double* %1233, i64 %1235
store double %1232, double* %1236
%1237 = load double, double* %61
%1238 = load double, double* %51
%1239 = fsub double %1237, %1238
%1240 = load double*, double** %16
%1241 = load i32, i32* %38
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds double, double* %1240, i64 %1242
store double %1239, double* %1243
%1244 = load i32, i32* %39
%1245 = load i32, i32* %43
%1246 = add nsw i32 %1244, %1245
store i32 %1246, i32* %40
%1247 = load i32, i32* %40
%1248 = load i32, i32* %48
%1249 = icmp slt i32 %1247, %1248
br i1 %1249, label %1250, label %1251
1250: ; preds = %1001
br label %1001
1251: ; preds = %1001
%1252 = load i32, i32* %48
%1253 = load i32, i32* %40
%1254 = sub nsw i32 %1253, %1252
store i32 %1254, i32* %40
%1255 = load i32, i32* %40
%1256 = load i32, i32* %43
%1257 = icmp sle i32 %1255, %1256
br i1 %1257, label %1258, label %1259
1258: ; preds = %1251
br label %1001
1259: ; preds = %1251
br label %1625
1260: ; preds = %606
%1261 = load i32*, i32** %28
%1262 = load i32, i32* %29
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds i32, i32* %1261, i64 %1263
%1265 = load i32, i32* %1264
store i32 %1265, i32* %35
%1266 = load i32, i32* %43
store i32 %1266, i32* %44
%1267 = load i32, i32* %35
%1268 = load i32, i32* %43
%1269 = sdiv i32 %1268, %1267
store i32 %1269, i32* %43
%1270 = load i32, i32* %35
%1271 = icmp eq i32 %1270, 3
br i1 %1271, label %1272, label %1273
1272: ; preds = %1260
br label %470
1273: ; preds = %1260
%1274 = load i32, i32* %35
%1275 = icmp eq i32 %1274, 5
br i1 %1275, label %1276, label %1277
1276: ; preds = %1273
br label %989
1277: ; preds = %1273
%1278 = load i32, i32* %35
%1279 = load i32, i32* %33
%1280 = icmp eq i32 %1278, %1279
br i1 %1280, label %1281, label %1282
1281: ; preds = %1277
br label %1368
1282: ; preds = %1277
%1283 = load i32, i32* %35
store i32 %1283, i32* %33
%1284 = load double, double* %70
%1285 = load i32, i32* %35
%1286 = sitofp i32 %1285 to double
%1287 = fdiv double %1286, 8.000000e+00
%1288 = fdiv double %1284, %1287
store double %1288, double* %72
%1289 = load double, double* %72
%1290 = call double @cos(double %1289)
store double %1290, double* %64
%1291 = load double, double* %72
%1292 = call double @sin(double %1291)
store double %1292, double* %72
%1293 = load double*, double** %24
%1294 = load i32, i32* %33
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds double, double* %1293, i64 %1295
store double 1.000000e+00, double* %1296
%1297 = load double*, double** %26
%1298 = load i32, i32* %33
%1299 = sext i32 %1298 to i64
%1300 = getelementptr inbounds double, double* %1297, i64 %1299
store double 0.000000e+00, double* %1300
store i32 1, i32* %31
br label %1301
1301: ; preds = %1364, %1282
%1302 = load i32, i32* %31
%1303 = load i32, i32* %35
%1304 = icmp slt i32 %1302, %1303
br i1 %1304, label %1305, label %1367
1305: ; preds = %1301
%1306 = load double*, double** %24
%1307 = load i32, i32* %35
%1308 = sext i32 %1307 to i64
%1309 = getelementptr inbounds double, double* %1306, i64 %1308
%1310 = load double, double* %1309
%1311 = load double, double* %64
%1312 = load double*, double** %26
%1313 = load i32, i32* %35
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds double, double* %1312, i64 %1314
%1316 = load double, double* %1315
%1317 = load double, double* %72
%1318 = fmul double %1316, %1317
%1319 = call double @llvm.fmuladd.f64(double %1310, double %1311, double %1318)
%1320 = load double*, double** %24
%1321 = load i32, i32* %31
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds double, double* %1320, i64 %1322
store double %1319, double* %1323
%1324 = load double*, double** %24
%1325 = load i32, i32* %35
%1326 = sext i32 %1325 to i64
%1327 = getelementptr inbounds double, double* %1324, i64 %1326
%1328 = load double, double* %1327
%1329 = load double, double* %72
%1330 = load double*, double** %26
%1331 = load i32, i32* %35
%1332 = sext i32 %1331 to i64
%1333 = getelementptr inbounds double, double* %1330, i64 %1332
%1334 = load double, double* %1333
%1335 = load double, double* %64
%1336 = fmul double %1334, %1335
%1337 = fneg double %1336
%1338 = call double @llvm.fmuladd.f64(double %1328, double %1329, double %1337)
%1339 = load double*, double** %26
%1340 = load i32, i32* %31
%1341 = sext i32 %1340 to i64
%1342 = getelementptr inbounds double, double* %1339, i64 %1341
store double %1338, double* %1342
%1343 = load i32, i32* %35
%1344 = add nsw i32 %1343, -1
store i32 %1344, i32* %35
%1345 = load double*, double** %24
%1346 = load i32, i32* %31
%1347 = sext i32 %1346 to i64
%1348 = getelementptr inbounds double, double* %1345, i64 %1347
%1349 = load double, double* %1348
%1350 = load double*, double** %24
%1351 = load i32, i32* %35
%1352 = sext i32 %1351 to i64
%1353 = getelementptr inbounds double, double* %1350, i64 %1352
store double %1349, double* %1353
%1354 = load double*, double** %26
%1355 = load i32, i32* %31
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds double, double* %1354, i64 %1356
%1358 = load double, double* %1357
%1359 = fneg double %1358
%1360 = load double*, double** %26
%1361 = load i32, i32* %35
%1362 = sext i32 %1361 to i64
%1363 = getelementptr inbounds double, double* %1360, i64 %1362
store double %1359, double* %1363
br label %1364
1364: ; preds = %1305
%1365 = load i32, i32* %31
%1366 = add nsw i32 %1365, 1
store i32 %1366, i32* %31
br label %1301
1367: ; preds = %1301
br label %1368
1368: ; preds = %1623, %1615, %1367, %1281
%1369 = load i32, i32* %40
store i32 %1369, i32* %36
%1370 = load i32, i32* %40
%1371 = load i32, i32* %44
%1372 = add nsw i32 %1370, %1371
store i32 %1372, i32* %37
%1373 = load double*, double** %15
%1374 = load i32, i32* %40
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds double, double* %1373, i64 %1375
%1377 = load double, double* %1376
store double %1377, double* %50
%1378 = load double*, double** %16
%1379 = load i32, i32* %40
%1380 = sext i32 %1379 to i64
%1381 = getelementptr inbounds double, double* %1378, i64 %1380
%1382 = load double, double* %1381
store double %1382, double* %57
%1383 = load double, double* %50
store double %1383, double* %54
%1384 = load double, double* %57
store double %1384, double* %61
store i32 1, i32* %31
%1385 = load i32, i32* %43
%1386 = load i32, i32* %36
%1387 = add nsw i32 %1386, %1385
store i32 %1387, i32* %36
br label %1388
1388: ; preds = %1473, %1368
%1389 = load i32, i32* %43
%1390 = load i32, i32* %37
%1391 = sub nsw i32 %1390, %1389
store i32 %1391, i32* %37
%1392 = load i32, i32* %31
%1393 = add nsw i32 %1392, 1
store i32 %1393, i32* %31
%1394 = load double*, double** %15
%1395 = load i32, i32* %36
%1396 = sext i32 %1395 to i64
%1397 = getelementptr inbounds double, double* %1394, i64 %1396
%1398 = load double, double* %1397
%1399 = load double*, double** %15
%1400 = load i32, i32* %37
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds double, double* %1399, i64 %1401
%1403 = load double, double* %1402
%1404 = fadd double %1398, %1403
%1405 = load double*, double** %23
%1406 = load i32, i32* %31
%1407 = sext i32 %1406 to i64
%1408 = getelementptr inbounds double, double* %1405, i64 %1407
store double %1404, double* %1408
%1409 = load double*, double** %23
%1410 = load i32, i32* %31
%1411 = sext i32 %1410 to i64
%1412 = getelementptr inbounds double, double* %1409, i64 %1411
%1413 = load double, double* %1412
%1414 = load double, double* %54
%1415 = fadd double %1413, %1414
store double %1415, double* %54
%1416 = load double*, double** %16
%1417 = load i32, i32* %36
%1418 = sext i32 %1417 to i64
%1419 = getelementptr inbounds double, double* %1416, i64 %1418
%1420 = load double, double* %1419
%1421 = load double*, double** %16
%1422 = load i32, i32* %37
%1423 = sext i32 %1422 to i64
%1424 = getelementptr inbounds double, double* %1421, i64 %1423
%1425 = load double, double* %1424
%1426 = fadd double %1420, %1425
%1427 = load double*, double** %25
%1428 = load i32, i32* %31
%1429 = sext i32 %1428 to i64
%1430 = getelementptr inbounds double, double* %1427, i64 %1429
store double %1426, double* %1430
%1431 = load double*, double** %25
%1432 = load i32, i32* %31
%1433 = sext i32 %1432 to i64
%1434 = getelementptr inbounds double, double* %1431, i64 %1433
%1435 = load double, double* %1434
%1436 = load double, double* %61
%1437 = fadd double %1435, %1436
store double %1437, double* %61
%1438 = load i32, i32* %31
%1439 = add nsw i32 %1438, 1
store i32 %1439, i32* %31
%1440 = load double*, double** %15
%1441 = load i32, i32* %36
%1442 = sext i32 %1441 to i64
%1443 = getelementptr inbounds double, double* %1440, i64 %1442
%1444 = load double, double* %1443
%1445 = load double*, double** %15
%1446 = load i32, i32* %37
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds double, double* %1445, i64 %1447
%1449 = load double, double* %1448
%1450 = fsub double %1444, %1449
%1451 = load double*, double** %23
%1452 = load i32, i32* %31
%1453 = sext i32 %1452 to i64
%1454 = getelementptr inbounds double, double* %1451, i64 %1453
store double %1450, double* %1454
%1455 = load double*, double** %16
%1456 = load i32, i32* %36
%1457 = sext i32 %1456 to i64
%1458 = getelementptr inbounds double, double* %1455, i64 %1457
%1459 = load double, double* %1458
%1460 = load double*, double** %16
%1461 = load i32, i32* %37
%1462 = sext i32 %1461 to i64
%1463 = getelementptr inbounds double, double* %1460, i64 %1462
%1464 = load double, double* %1463
%1465 = fsub double %1459, %1464
%1466 = load double*, double** %25
%1467 = load i32, i32* %31
%1468 = sext i32 %1467 to i64
%1469 = getelementptr inbounds double, double* %1466, i64 %1468
store double %1465, double* %1469
%1470 = load i32, i32* %43
%1471 = load i32, i32* %36
%1472 = add nsw i32 %1471, %1470
store i32 %1472, i32* %36
br label %1473
1473: ; preds = %1388
%1474 = load i32, i32* %36
%1475 = load i32, i32* %37
%1476 = icmp slt i32 %1474, %1475
br i1 %1476, label %1388, label %1477
1477: ; preds = %1473
%1478 = load double, double* %54
%1479 = load double*, double** %15
%1480 = load i32, i32* %40
%1481 = sext i32 %1480 to i64
%1482 = getelementptr inbounds double, double* %1479, i64 %1481
store double %1478, double* %1482
%1483 = load double, double* %61
%1484 = load double*, double** %16
%1485 = load i32, i32* %40
%1486 = sext i32 %1485 to i64
%1487 = getelementptr inbounds double, double* %1484, i64 %1486
store double %1483, double* %1487
%1488 = load i32, i32* %40
store i32 %1488, i32* %36
%1489 = load i32, i32* %40
%1490 = load i32, i32* %44
%1491 = add nsw i32 %1489, %1490
store i32 %1491, i32* %37
store i32 1, i32* %31
br label %1492
1492: ; preds = %1607, %1477
%1493 = load i32, i32* %43
%1494 = load i32, i32* %36
%1495 = add nsw i32 %1494, %1493
store i32 %1495, i32* %36
%1496 = load i32, i32* %43
%1497 = load i32, i32* %37
%1498 = sub nsw i32 %1497, %1496
store i32 %1498, i32* %37
%1499 = load i32, i32* %31
store i32 %1499, i32* %34
%1500 = load double, double* %50
store double %1500, double* %54
%1501 = load double, double* %57
store double %1501, double* %61
store double 0.000000e+00, double* %51
store double 0.000000e+00, double* %58
store i32 1, i32* %35
br label %1502
1502: ; preds = %1566, %1492
%1503 = load i32, i32* %35
%1504 = add nsw i32 %1503, 1
store i32 %1504, i32* %35
%1505 = load double*, double** %23
%1506 = load i32, i32* %35
%1507 = sext i32 %1506 to i64
%1508 = getelementptr inbounds double, double* %1505, i64 %1507
%1509 = load double, double* %1508
%1510 = load double*, double** %24
%1511 = load i32, i32* %34
%1512 = sext i32 %1511 to i64
%1513 = getelementptr inbounds double, double* %1510, i64 %1512
%1514 = load double, double* %1513
%1515 = load double, double* %54
%1516 = call double @llvm.fmuladd.f64(double %1509, double %1514, double %1515)
store double %1516, double* %54
%1517 = load double*, double** %25
%1518 = load i32, i32* %35
%1519 = sext i32 %1518 to i64
%1520 = getelementptr inbounds double, double* %1517, i64 %1519
%1521 = load double, double* %1520
%1522 = load double*, double** %24
%1523 = load i32, i32* %34
%1524 = sext i32 %1523 to i64
%1525 = getelementptr inbounds double, double* %1522, i64 %1524
%1526 = load double, double* %1525
%1527 = load double, double* %61
%1528 = call double @llvm.fmuladd.f64(double %1521, double %1526, double %1527)
store double %1528, double* %61
%1529 = load i32, i32* %35
%1530 = add nsw i32 %1529, 1
store i32 %1530, i32* %35
%1531 = load double*, double** %23
%1532 = load i32, i32* %35
%1533 = sext i32 %1532 to i64
%1534 = getelementptr inbounds double, double* %1531, i64 %1533
%1535 = load double, double* %1534
%1536 = load double*, double** %26
%1537 = load i32, i32* %34
%1538 = sext i32 %1537 to i64
%1539 = getelementptr inbounds double, double* %1536, i64 %1538
%1540 = load double, double* %1539
%1541 = load double, double* %51
%1542 = call double @llvm.fmuladd.f64(double %1535, double %1540, double %1541)
store double %1542, double* %51
%1543 = load double*, double** %25
%1544 = load i32, i32* %35
%1545 = sext i32 %1544 to i64
%1546 = getelementptr inbounds double, double* %1543, i64 %1545
%1547 = load double, double* %1546
%1548 = load double*, double** %26
%1549 = load i32, i32* %34
%1550 = sext i32 %1549 to i64
%1551 = getelementptr inbounds double, double* %1548, i64 %1550
%1552 = load double, double* %1551
%1553 = load double, double* %58
%1554 = call double @llvm.fmuladd.f64(double %1547, double %1552, double %1553)
store double %1554, double* %58
%1555 = load i32, i32* %31
%1556 = load i32, i32* %34
%1557 = add nsw i32 %1556, %1555
store i32 %1557, i32* %34
%1558 = load i32, i32* %34
%1559 = load i32, i32* %33
%1560 = icmp sgt i32 %1558, %1559
br i1 %1560, label %1561, label %1565
1561: ; preds = %1502
%1562 = load i32, i32* %33
%1563 = load i32, i32* %34
%1564 = sub nsw i32 %1563, %1562
store i32 %1564, i32* %34
br label %1565
1565: ; preds = %1561, %1502
br label %1566
1566: ; preds = %1565
%1567 = load i32, i32* %35
%1568 = load i32, i32* %33
%1569 = icmp slt i32 %1567, %1568
br i1 %1569, label %1502, label %1570
1570: ; preds = %1566
%1571 = load i32, i32* %33
%1572 = load i32, i32* %31
%1573 = sub nsw i32 %1571, %1572
store i32 %1573, i32* %35
%1574 = load double, double* %54
%1575 = load double, double* %58
%1576 = fsub double %1574, %1575
%1577 = load double*, double** %15
%1578 = load i32, i32* %36
%1579 = sext i32 %1578 to i64
%1580 = getelementptr inbounds double, double* %1577, i64 %1579
store double %1576, double* %1580
%1581 = load double, double* %61
%1582 = load double, double* %51
%1583 = fadd double %1581, %1582
%1584 = load double*, double** %16
%1585 = load i32, i32* %36
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds double, double* %1584, i64 %1586
store double %1583, double* %1587
%1588 = load double, double* %54
%1589 = load double, double* %58
%1590 = fadd double %1588, %1589
%1591 = load double*, double** %15
%1592 = load i32, i32* %37
%1593 = sext i32 %1592 to i64
%1594 = getelementptr inbounds double, double* %1591, i64 %1593
store double %1590, double* %1594
%1595 = load double, double* %61
%1596 = load double, double* %51
%1597 = fsub double %1595, %1596
%1598 = load double*, double** %16
%1599 = load i32, i32* %37
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds double, double* %1598, i64 %1600
store double %1597, double* %1601
%1602 = load i32, i32* %31
%1603 = add nsw i32 %1602, 1
store i32 %1603, i32* %31
%1604 = load i32, i32* %31
%1605 = load i32, i32* %35
%1606 = icmp slt i32 %1604, %1605
br i1 %1606, label %1607, label %1608
1607: ; preds = %1570
br label %1492
1608: ; preds = %1570
%1609 = load i32, i32* %44
%1610 = load i32, i32* %40
%1611 = add nsw i32 %1610, %1609
store i32 %1611, i32* %40
%1612 = load i32, i32* %40
%1613 = load i32, i32* %48
%1614 = icmp sle i32 %1612, %1613
br i1 %1614, label %1615, label %1616
1615: ; preds = %1608
br label %1368
1616: ; preds = %1608
%1617 = load i32, i32* %48
%1618 = load i32, i32* %40
%1619 = sub nsw i32 %1618, %1617
store i32 %1619, i32* %40
%1620 = load i32, i32* %40
%1621 = load i32, i32* %43
%1622 = icmp sle i32 %1620, %1621
br i1 %1622, label %1623, label %1624
1623: ; preds = %1616
br label %1368
1624: ; preds = %1616
br label %1625
1625: ; preds = %1624, %1259, %598
%1626 = load i32, i32* %29
%1627 = load i32, i32* %21
%1628 = icmp eq i32 %1626, %1627
br i1 %1628, label %1629, label %1630
1629: ; preds = %1625
br label %1793
1630: ; preds = %1625
%1631 = load i32, i32* %32
%1632 = add nsw i32 %1631, 1
store i32 %1632, i32* %40
br label %1633
1633: ; preds = %1764, %1630
%1634 = load double, double* %68
%1635 = fsub double 1.000000e+00, %1634
store double %1635, double* %65
%1636 = load double, double* %71
store double %1636, double* %72
%1637 = load i32, i32* %43
%1638 = load i32, i32* %41
%1639 = icmp slt i32 %1637, %1638
br i1 %1639, label %1640, label %1642
1640: ; preds = %1633
%1641 = load i32, i32* %43
br label %1644
1642: ; preds = %1633
%1643 = load i32, i32* %41
br label %1644
1644: ; preds = %1642, %1640
%1645 = phi i32 [ %1641, %1640 ], [ %1643, %1642 ]
store i32 %1645, i32* %47
br label %1664
1646: ; preds = %1745
%1647 = load double, double* %64
%1648 = load double, double* %68
%1649 = load double, double* %64
%1650 = load double, double* %71
%1651 = load double, double* %72
%1652 = fmul double %1650, %1651
%1653 = call double @llvm.fmuladd.f64(double %1648, double %1649, double %1652)
%1654 = fsub double %1647, %1653
store double %1654, double* %65
%1655 = load double, double* %72
%1656 = load double, double* %71
%1657 = load double, double* %64
%1658 = load double, double* %68
%1659 = load double, double* %72
%1660 = fmul double %1658, %1659
%1661 = fneg double %1660
%1662 = call double @llvm.fmuladd.f64(double %1656, double %1657, double %1661)
%1663 = fadd double %1655, %1662
store double %1663, double* %72
br label %1664
1664: ; preds = %1791, %1646, %1644
%1665 = load double, double* %65
store double %1665, double* %64
%1666 = load double, double* %72
store double %1666, double* %73
%1667 = load i32, i32* %43
%1668 = load i32, i32* %40
%1669 = add nsw i32 %1668, %1667
store i32 %1669, i32* %40
br label %1670
1670: ; preds = %1735, %1711, %1664
%1671 = load double*, double** %15
%1672 = load i32, i32* %40
%1673 = sext i32 %1672 to i64
%1674 = getelementptr inbounds double, double* %1671, i64 %1673
%1675 = load double, double* %1674
store double %1675, double* %54
%1676 = load double, double* %65
%1677 = load double, double* %54
%1678 = load double, double* %73
%1679 = load double*, double** %16
%1680 = load i32, i32* %40
%1681 = sext i32 %1680 to i64
%1682 = getelementptr inbounds double, double* %1679, i64 %1681
%1683 = load double, double* %1682
%1684 = fmul double %1678, %1683
%1685 = fneg double %1684
%1686 = call double @llvm.fmuladd.f64(double %1676, double %1677, double %1685)
%1687 = load double*, double** %15
%1688 = load i32, i32* %40
%1689 = sext i32 %1688 to i64
%1690 = getelementptr inbounds double, double* %1687, i64 %1689
store double %1686, double* %1690
%1691 = load double, double* %73
%1692 = load double, double* %54
%1693 = load double, double* %65
%1694 = load double*, double** %16
%1695 = load i32, i32* %40
%1696 = sext i32 %1695 to i64
%1697 = getelementptr inbounds double, double* %1694, i64 %1696
%1698 = load double, double* %1697
%1699 = fmul double %1693, %1698
%1700 = call double @llvm.fmuladd.f64(double %1691, double %1692, double %1699)
%1701 = load double*, double** %16
%1702 = load i32, i32* %40
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds double, double* %1701, i64 %1703
store double %1700, double* %1704
%1705 = load i32, i32* %44
%1706 = load i32, i32* %40
%1707 = add nsw i32 %1706, %1705
store i32 %1707, i32* %40
%1708 = load i32, i32* %40
%1709 = load i32, i32* %49
%1710 = icmp sle i32 %1708, %1709
br i1 %1710, label %1711, label %1712
1711: ; preds = %1670
br label %1670
1712: ; preds = %1670
%1713 = load double, double* %72
%1714 = load double, double* %73
%1715 = fmul double %1713, %1714
store double %1715, double* %54
%1716 = load double, double* %72
%1717 = load double, double* %65
%1718 = load double, double* %64
%1719 = load double, double* %73
%1720 = fmul double %1718, %1719
%1721 = call double @llvm.fmuladd.f64(double %1716, double %1717, double %1720)
store double %1721, double* %73
%1722 = load double, double* %64
%1723 = load double, double* %65
%1724 = load double, double* %54
%1725 = fneg double %1724
%1726 = call double @llvm.fmuladd.f64(double %1722, double %1723, double %1725)
store double %1726, double* %65
%1727 = load i32, i32* %49
%1728 = load i32, i32* %43
%1729 = sub nsw i32 %1727, %1728
%1730 = load i32, i32* %40
%1731 = sub nsw i32 %1730, %1729
store i32 %1731, i32* %40
%1732 = load i32, i32* %40
%1733 = load i32, i32* %44
%1734 = icmp sle i32 %1732, %1733
br i1 %1734, label %1735, label %1736
1735: ; preds = %1712
br label %1670
1736: ; preds = %1712
%1737 = load i32, i32* %44
%1738 = load i32, i32* %32
%1739 = sub nsw i32 %1737, %1738
%1740 = load i32, i32* %40
%1741 = sub nsw i32 %1740, %1739
store i32 %1741, i32* %40
%1742 = load i32, i32* %40
%1743 = load i32, i32* %47
%1744 = icmp sle i32 %1742, %1743
br i1 %1744, label %1745, label %1746
1745: ; preds = %1736
br label %1646
1746: ; preds = %1736
%1747 = load i32, i32* %40
%1748 = load i32, i32* %43
%1749 = icmp slt i32 %1747, %1748
br i1 %1749, label %1750, label %1751
1750: ; preds = %1746
br label %1766
1751: ; preds = %1746
%1752 = load i32, i32* %43
%1753 = load i32, i32* %32
%1754 = sub nsw i32 %1752, %1753
%1755 = load i32, i32* %30
%1756 = sub nsw i32 %1754, %1755
%1757 = load i32, i32* %40
%1758 = sub nsw i32 %1757, %1756
store i32 %1758, i32* %40
%1759 = load i32, i32* %40
%1760 = load i32, i32* %32
%1761 = load i32, i32* %32
%1762 = add nsw i32 %1760, %1761
%1763 = icmp sle i32 %1759, %1762
br i1 %1763, label %1764, label %1765
1764: ; preds = %1751
br label %1633
1765: ; preds = %1751
br label %163
1766: ; preds = %1750
%1767 = load i32, i32* %40
%1768 = sub nsw i32 %1767, 1
%1769 = load i32, i32* %32
%1770 = sdiv i32 %1768, %1769
%1771 = sitofp i32 %1770 to double
%1772 = load double, double* %69
%1773 = fmul double %1771, %1772
%1774 = load double, double* %70
%1775 = fmul double %1773, %1774
store double %1775, double* %72
%1776 = load double, double* %72
%1777 = call double @cos(double %1776)
store double %1777, double* %65
%1778 = load double, double* %72
%1779 = call double @sin(double %1778)
store double %1779, double* %72
%1780 = load i32, i32* %43
%1781 = load i32, i32* %47
%1782 = load i32, i32* %41
%1783 = add nsw i32 %1781, %1782
%1784 = icmp slt i32 %1780, %1783
br i1 %1784, label %1785, label %1787
1785: ; preds = %1766
%1786 = load i32, i32* %43
br label %1791
1787: ; preds = %1766
%1788 = load i32, i32* %47
%1789 = load i32, i32* %41
%1790 = add nsw i32 %1788, %1789
br label %1791
1791: ; preds = %1787, %1785
%1792 = phi i32 [ %1786, %1785 ], [ %1790, %1787 ]
store i32 %1792, i32* %47
br label %1664
1793: ; preds = %1629, %904, %274
%1794 = load i32, i32* %42
%1795 = load i32*, i32** %27
%1796 = getelementptr inbounds i32, i32* %1795, i64 1
store i32 %1794, i32* %1796
%1797 = load i32*, i32** %22
%1798 = load i32, i32* %1797
%1799 = icmp ne i32 %1798, 0
br i1 %1799, label %1801, label %1800
1800: ; preds = %1793
br label %2119
1801: ; preds = %1793
%1802 = load i32*, i32** %22
%1803 = load i32, i32* %1802
%1804 = load i32*, i32** %22
%1805 = load i32, i32* %1804
%1806 = add nsw i32 %1803, %1805
%1807 = add nsw i32 %1806, 1
store i32 %1807, i32* %35
%1808 = load i32, i32* %21
%1809 = load i32, i32* %35
%1810 = icmp slt i32 %1808, %1809
br i1 %1810, label %1811, label %1814
1811: ; preds = %1801
%1812 = load i32, i32* %35
%1813 = add nsw i32 %1812, -1
store i32 %1813, i32* %35
br label %1814
1814: ; preds = %1811, %1801
%1815 = load i32, i32* %32
%1816 = load i32*, i32** %27
%1817 = load i32, i32* %35
%1818 = add nsw i32 %1817, 1
%1819 = sext i32 %1818 to i64
%1820 = getelementptr inbounds i32, i32* %1816, i64 %1819
store i32 %1815, i32* %1820
store i32 1, i32* %31
br label %1821
1821: ; preds = %1858, %1814
%1822 = load i32, i32* %31
%1823 = load i32, i32* %35
%1824 = icmp slt i32 %1822, %1823
br i1 %1824, label %1825, label %1863
1825: ; preds = %1821
%1826 = load i32*, i32** %27
%1827 = load i32, i32* %31
%1828 = sext i32 %1827 to i64
%1829 = getelementptr inbounds i32, i32* %1826, i64 %1828
%1830 = load i32, i32* %1829
%1831 = load i32*, i32** %28
%1832 = load i32, i32* %31
%1833 = sext i32 %1832 to i64
%1834 = getelementptr inbounds i32, i32* %1831, i64 %1833
%1835 = load i32, i32* %1834
%1836 = sdiv i32 %1830, %1835
%1837 = load i32*, i32** %27
%1838 = load i32, i32* %31
%1839 = add nsw i32 %1838, 1
%1840 = sext i32 %1839 to i64
%1841 = getelementptr inbounds i32, i32* %1837, i64 %1840
store i32 %1836, i32* %1841
%1842 = load i32*, i32** %27
%1843 = load i32, i32* %35
%1844 = add nsw i32 %1843, 1
%1845 = sext i32 %1844 to i64
%1846 = getelementptr inbounds i32, i32* %1842, i64 %1845
%1847 = load i32, i32* %1846
%1848 = load i32*, i32** %28
%1849 = load i32, i32* %31
%1850 = sext i32 %1849 to i64
%1851 = getelementptr inbounds i32, i32* %1848, i64 %1850
%1852 = load i32, i32* %1851
%1853 = mul nsw i32 %1847, %1852
%1854 = load i32*, i32** %27
%1855 = load i32, i32* %35
%1856 = sext i32 %1855 to i64
%1857 = getelementptr inbounds i32, i32* %1854, i64 %1856
store i32 %1853, i32* %1857
br label %1858
1858: ; preds = %1825
%1859 = load i32, i32* %31
%1860 = add nsw i32 %1859, 1
store i32 %1860, i32* %31
%1861 = load i32, i32* %35
%1862 = add nsw i32 %1861, -1
store i32 %1862, i32* %35
br label %1821
1863: ; preds = %1821
%1864 = load i32*, i32** %27
%1865 = load i32, i32* %35
%1866 = add nsw i32 %1865, 1
%1867 = sext i32 %1866 to i64
%1868 = getelementptr inbounds i32, i32* %1864, i64 %1867
%1869 = load i32, i32* %1868
store i32 %1869, i32* %38
%1870 = load i32*, i32** %27
%1871 = getelementptr inbounds i32, i32* %1870, i64 2
%1872 = load i32, i32* %1871
store i32 %1872, i32* %43
%1873 = load i32, i32* %32
%1874 = add nsw i32 %1873, 1
store i32 %1874, i32* %40
%1875 = load i32, i32* %43
%1876 = add nsw i32 %1875, 1
store i32 %1876, i32* %37
store i32 1, i32* %31
%1877 = load i32, i32* %18
%1878 = load i32, i32* %17
%1879 = icmp ne i32 %1877, %1878
br i1 %1879, label %1880, label %1881
1880: ; preds = %1863
br label %1983
1881: ; preds = %1863
br label %1882
1882: ; preds = %1964, %1881
br label %1883
1883: ; preds = %1928, %1882
%1884 = load double*, double** %15
%1885 = load i32, i32* %40
%1886 = sext i32 %1885 to i64
%1887 = getelementptr inbounds double, double* %1884, i64 %1886
%1888 = load double, double* %1887
store double %1888, double* %54
%1889 = load double*, double** %15
%1890 = load i32, i32* %37
%1891 = sext i32 %1890 to i64
%1892 = getelementptr inbounds double, double* %1889, i64 %1891
%1893 = load double, double* %1892
%1894 = load double*, double** %15
%1895 = load i32, i32* %40
%1896 = sext i32 %1895 to i64
%1897 = getelementptr inbounds double, double* %1894, i64 %1896
store double %1893, double* %1897
%1898 = load double, double* %54
%1899 = load double*, double** %15
%1900 = load i32, i32* %37
%1901 = sext i32 %1900 to i64
%1902 = getelementptr inbounds double, double* %1899, i64 %1901
store double %1898, double* %1902
%1903 = load double*, double** %16
%1904 = load i32, i32* %40
%1905 = sext i32 %1904 to i64
%1906 = getelementptr inbounds double, double* %1903, i64 %1905
%1907 = load double, double* %1906
store double %1907, double* %61
%1908 = load double*, double** %16
%1909 = load i32, i32* %37
%1910 = sext i32 %1909 to i64
%1911 = getelementptr inbounds double, double* %1908, i64 %1910
%1912 = load double, double* %1911
%1913 = load double*, double** %16
%1914 = load i32, i32* %40
%1915 = sext i32 %1914 to i64
%1916 = getelementptr inbounds double, double* %1913, i64 %1915
store double %1912, double* %1916
%1917 = load double, double* %61
%1918 = load double*, double** %16
%1919 = load i32, i32* %37
%1920 = sext i32 %1919 to i64
%1921 = getelementptr inbounds double, double* %1918, i64 %1920
store double %1917, double* %1921
%1922 = load i32, i32* %30
%1923 = load i32, i32* %40
%1924 = add nsw i32 %1923, %1922
store i32 %1924, i32* %40
%1925 = load i32, i32* %43
%1926 = load i32, i32* %37
%1927 = add nsw i32 %1926, %1925
store i32 %1927, i32* %37
br label %1928
1928: ; preds = %1883
%1929 = load i32, i32* %37
%1930 = load i32, i32* %42
%1931 = icmp slt i32 %1929, %1930
br i1 %1931, label %1883, label %1932
1932: ; preds = %1928
br label %1933
1933: ; preds = %1980, %1932
br label %1934
1934: ; preds = %1951, %1933
%1935 = load i32*, i32** %27
%1936 = load i32, i32* %31
%1937 = add nsw i32 %1936, 1
store i32 %1937, i32* %31
%1938 = sext i32 %1936 to i64
%1939 = getelementptr inbounds i32, i32* %1935, i64 %1938
%1940 = load i32, i32* %1939
%1941 = load i32, i32* %37
%1942 = sub nsw i32 %1941, %1940
store i32 %1942, i32* %37
%1943 = load i32*, i32** %27
%1944 = load i32, i32* %31
%1945 = add nsw i32 %1944, 1
%1946 = sext i32 %1945 to i64
%1947 = getelementptr inbounds i32, i32* %1943, i64 %1946
%1948 = load i32, i32* %1947
%1949 = load i32, i32* %37
%1950 = add nsw i32 %1949, %1948
store i32 %1950, i32* %37
br label %1951
1951: ; preds = %1934
%1952 = load i32, i32* %37
%1953 = load i32*, i32** %27
%1954 = load i32, i32* %31
%1955 = sext i32 %1954 to i64
%1956 = getelementptr inbounds i32, i32* %1953, i64 %1955
%1957 = load i32, i32* %1956
%1958 = icmp sgt i32 %1952, %1957
br i1 %1958, label %1934, label %1959
1959: ; preds = %1951
store i32 1, i32* %31
br label %1960
1960: ; preds = %1975, %1959
%1961 = load i32, i32* %40
%1962 = load i32, i32* %37
%1963 = icmp slt i32 %1961, %1962
br i1 %1963, label %1964, label %1965
1964: ; preds = %1960
br label %1882
1965: ; preds = %1960
%1966 = load i32, i32* %30
%1967 = load i32, i32* %40
%1968 = add nsw i32 %1967, %1966
store i32 %1968, i32* %40
%1969 = load i32, i32* %43
%1970 = load i32, i32* %37
%1971 = add nsw i32 %1970, %1969
store i32 %1971, i32* %37
%1972 = load i32, i32* %37
%1973 = load i32, i32* %42
%1974 = icmp slt i32 %1972, %1973
br i1 %1974, label %1975, label %1976
1975: ; preds = %1965
br label %1960
1976: ; preds = %1965
%1977 = load i32, i32* %40
%1978 = load i32, i32* %42
%1979 = icmp slt i32 %1977, %1978
br i1 %1979, label %1980, label %1981
1980: ; preds = %1976
br label %1933
1981: ; preds = %1976
%1982 = load i32, i32* %38
store i32 %1982, i32* %32
br label %2119
1983: ; preds = %2100, %1880
br label %1984
1984: ; preds = %2064, %1983
br label %1985
1985: ; preds = %2049, %1984
%1986 = load i32, i32* %40
%1987 = load i32, i32* %32
%1988 = add nsw i32 %1986, %1987
store i32 %1988, i32* %35
br label %1989
1989: ; preds = %2034, %1985
%1990 = load double*, double** %15
%1991 = load i32, i32* %40
%1992 = sext i32 %1991 to i64
%1993 = getelementptr inbounds double, double* %1990, i64 %1992
%1994 = load double, double* %1993
store double %1994, double* %54
%1995 = load double*, double** %15
%1996 = load i32, i32* %37
%1997 = sext i32 %1996 to i64
%1998 = getelementptr inbounds double, double* %1995, i64 %1997
%1999 = load double, double* %1998
%2000 = load double*, double** %15
%2001 = load i32, i32* %40
%2002 = sext i32 %2001 to i64
%2003 = getelementptr inbounds double, double* %2000, i64 %2002
store double %1999, double* %2003
%2004 = load double, double* %54
%2005 = load double*, double** %15
%2006 = load i32, i32* %37
%2007 = sext i32 %2006 to i64
%2008 = getelementptr inbounds double, double* %2005, i64 %2007
store double %2004, double* %2008
%2009 = load double*, double** %16
%2010 = load i32, i32* %40
%2011 = sext i32 %2010 to i64
%2012 = getelementptr inbounds double, double* %2009, i64 %2011
%2013 = load double, double* %2012
store double %2013, double* %61
%2014 = load double*, double** %16
%2015 = load i32, i32* %37
%2016 = sext i32 %2015 to i64
%2017 = getelementptr inbounds double, double* %2014, i64 %2016
%2018 = load double, double* %2017
%2019 = load double*, double** %16
%2020 = load i32, i32* %40
%2021 = sext i32 %2020 to i64
%2022 = getelementptr inbounds double, double* %2019, i64 %2021
store double %2018, double* %2022
%2023 = load double, double* %61
%2024 = load double*, double** %16
%2025 = load i32, i32* %37
%2026 = sext i32 %2025 to i64
%2027 = getelementptr inbounds double, double* %2024, i64 %2026
store double %2023, double* %2027
%2028 = load i32, i32* %30
%2029 = load i32, i32* %40
%2030 = add nsw i32 %2029, %2028
store i32 %2030, i32* %40
%2031 = load i32, i32* %30
%2032 = load i32, i32* %37
%2033 = add nsw i32 %2032, %2031
store i32 %2033, i32* %37
br label %2034
2034: ; preds = %1989
%2035 = load i32, i32* %40
%2036 = load i32, i32* %35
%2037 = icmp slt i32 %2035, %2036
br i1 %2037, label %1989, label %2038
2038: ; preds = %2034
%2039 = load i32, i32* %42
%2040 = load i32, i32* %32
%2041 = sub nsw i32 %2039, %2040
%2042 = load i32, i32* %40
%2043 = add nsw i32 %2042, %2041
store i32 %2043, i32* %40
%2044 = load i32, i32* %42
%2045 = load i32, i32* %32
%2046 = sub nsw i32 %2044, %2045
%2047 = load i32, i32* %37
%2048 = add nsw i32 %2047, %2046
store i32 %2048, i32* %37
br label %2049
2049: ; preds = %2038
%2050 = load i32, i32* %40
%2051 = load i32, i32* %49
%2052 = icmp slt i32 %2050, %2051
br i1 %2052, label %1985, label %2053
2053: ; preds = %2049
%2054 = load i32, i32* %49
%2055 = load i32, i32* %43
%2056 = sub nsw i32 %2054, %2055
%2057 = load i32, i32* %37
%2058 = sub nsw i32 %2057, %2056
store i32 %2058, i32* %37
%2059 = load i32, i32* %49
%2060 = load i32, i32* %32
%2061 = sub nsw i32 %2059, %2060
%2062 = load i32, i32* %40
%2063 = sub nsw i32 %2062, %2061
store i32 %2063, i32* %40
br label %2064
2064: ; preds = %2053
%2065 = load i32, i32* %37
%2066 = load i32, i32* %42
%2067 = icmp slt i32 %2065, %2066
br i1 %2067, label %1984, label %2068
2068: ; preds = %2064
br label %2069
2069: ; preds = %2116, %2068
br label %2070
2070: ; preds = %2087, %2069
%2071 = load i32*, i32** %27
%2072 = load i32, i32* %31
%2073 = add nsw i32 %2072, 1
store i32 %2073, i32* %31
%2074 = sext i32 %2072 to i64
%2075 = getelementptr inbounds i32, i32* %2071, i64 %2074
%2076 = load i32, i32* %2075
%2077 = load i32, i32* %37
%2078 = sub nsw i32 %2077, %2076
store i32 %2078, i32* %37
%2079 = load i32*, i32** %27
%2080 = load i32, i32* %31
%2081 = add nsw i32 %2080, 1
%2082 = sext i32 %2081 to i64
%2083 = getelementptr inbounds i32, i32* %2079, i64 %2082
%2084 = load i32, i32* %2083
%2085 = load i32, i32* %37
%2086 = add nsw i32 %2085, %2084
store i32 %2086, i32* %37
br label %2087
2087: ; preds = %2070
%2088 = load i32, i32* %37
%2089 = load i32*, i32** %27
%2090 = load i32, i32* %31
%2091 = sext i32 %2090 to i64
%2092 = getelementptr inbounds i32, i32* %2089, i64 %2091
%2093 = load i32, i32* %2092
%2094 = icmp sgt i32 %2088, %2093
br i1 %2094, label %2070, label %2095
2095: ; preds = %2087
store i32 1, i32* %31
br label %2096
2096: ; preds = %2111, %2095
%2097 = load i32, i32* %40
%2098 = load i32, i32* %37
%2099 = icmp slt i32 %2097, %2098
br i1 %2099, label %2100, label %2101
2100: ; preds = %2096
br label %1983
2101: ; preds = %2096
%2102 = load i32, i32* %32
%2103 = load i32, i32* %40
%2104 = add nsw i32 %2103, %2102
store i32 %2104, i32* %40
%2105 = load i32, i32* %43
%2106 = load i32, i32* %37
%2107 = add nsw i32 %2106, %2105
store i32 %2107, i32* %37
%2108 = load i32, i32* %37
%2109 = load i32, i32* %42
%2110 = icmp slt i32 %2108, %2109
br i1 %2110, label %2111, label %2112
2111: ; preds = %2101
br label %2096
2112: ; preds = %2101
%2113 = load i32, i32* %40
%2114 = load i32, i32* %42
%2115 = icmp slt i32 %2113, %2114
br i1 %2115, label %2116, label %2117
2116: ; preds = %2112
br label %2069
2117: ; preds = %2112
%2118 = load i32, i32* %38
store i32 %2118, i32* %32
br label %2119
2119: ; preds = %2117, %1981, %1800
%2120 = load i32*, i32** %22
%2121 = load i32, i32* %2120
%2122 = mul nsw i32 2, %2121
%2123 = add nsw i32 %2122, 1
%2124 = load i32, i32* %21
%2125 = icmp sge i32 %2123, %2124
br i1 %2125, label %2126, label %2127
2126: ; preds = %2119
br label %2454
2127: ; preds = %2119
%2128 = load i32*, i32** %27
%2129 = load i32*, i32** %22
%2130 = load i32, i32* %2129
%2131 = sext i32 %2130 to i64
%2132 = getelementptr inbounds i32, i32* %2128, i64 %2131
%2133 = getelementptr inbounds i32, i32* %2132, i64 1
%2134 = load i32, i32* %2133
store i32 %2134, i32* %44
%2135 = load i32, i32* %21
%2136 = load i32*, i32** %22
%2137 = load i32, i32* %2136
%2138 = sub nsw i32 %2135, %2137
store i32 %2138, i32* %31
%2139 = load i32*, i32** %28
%2140 = load i32, i32* %31
%2141 = add nsw i32 %2140, 1
%2142 = sext i32 %2141 to i64
%2143 = getelementptr inbounds i32, i32* %2139, i64 %2142
store i32 1, i32* %2143
br label %2144
2144: ; preds = %2167, %2127
%2145 = load i32*, i32** %28
%2146 = load i32, i32* %31
%2147 = sext i32 %2146 to i64
%2148 = getelementptr inbounds i32, i32* %2145, i64 %2147
%2149 = load i32, i32* %2148
%2150 = load i32*, i32** %28
%2151 = load i32, i32* %31
%2152 = add nsw i32 %2151, 1
%2153 = sext i32 %2152 to i64
%2154 = getelementptr inbounds i32, i32* %2150, i64 %2153
%2155 = load i32, i32* %2154
%2156 = mul nsw i32 %2149, %2155
%2157 = load i32*, i32** %28
%2158 = load i32, i32* %31
%2159 = sext i32 %2158 to i64
%2160 = getelementptr inbounds i32, i32* %2157, i64 %2159
store i32 %2156, i32* %2160
%2161 = load i32, i32* %31
%2162 = add nsw i32 %2161, -1
store i32 %2162, i32* %31
%2163 = load i32, i32* %31
%2164 = load i32*, i32** %22
%2165 = load i32, i32* %2164
%2166 = icmp ne i32 %2163, %2165
br i1 %2166, label %2167, label %2168
2167: ; preds = %2144
br label %2144
2168: ; preds = %2144
%2169 = load i32*, i32** %22
%2170 = load i32, i32* %2169
%2171 = add nsw i32 %2170, 1
%2172 = load i32*, i32** %22
store i32 %2171, i32* %2172
%2173 = load i32*, i32** %28
%2174 = load i32*, i32** %22
%2175 = load i32, i32* %2174
%2176 = sext i32 %2175 to i64
%2177 = getelementptr inbounds i32, i32* %2173, i64 %2176
%2178 = load i32, i32* %2177
%2179 = sub nsw i32 %2178, 1
store i32 %2179, i32* %48
store i32 0, i32* %34
store i32 0, i32* %31
br label %2205
2180: ; preds = %2198
%2181 = load i32, i32* %37
%2182 = load i32, i32* %34
%2183 = sub nsw i32 %2182, %2181
store i32 %2183, i32* %34
%2184 = load i32, i32* %40
store i32 %2184, i32* %37
%2185 = load i32*, i32** %28
%2186 = load i32, i32* %35
%2187 = add nsw i32 %2186, 1
store i32 %2187, i32* %35
%2188 = sext i32 %2187 to i64
%2189 = getelementptr inbounds i32, i32* %2185, i64 %2188
%2190 = load i32, i32* %2189
store i32 %2190, i32* %40
br label %2191
2191: ; preds = %2225, %2180
%2192 = load i32, i32* %40
%2193 = load i32, i32* %34
%2194 = add nsw i32 %2193, %2192
store i32 %2194, i32* %34
%2195 = load i32, i32* %34
%2196 = load i32, i32* %37
%2197 = icmp sge i32 %2195, %2196
br i1 %2197, label %2198, label %2199
2198: ; preds = %2191
br label %2180
2199: ; preds = %2191
%2200 = load i32, i32* %34
%2201 = load i32*, i32** %27
%2202 = load i32, i32* %31
%2203 = sext i32 %2202 to i64
%2204 = getelementptr inbounds i32, i32* %2201, i64 %2203
store i32 %2200, i32* %2204
br label %2205
2205: ; preds = %2199, %2168
%2206 = load i32*, i32** %28
%2207 = load i32*, i32** %22
%2208 = load i32, i32* %2207
%2209 = sext i32 %2208 to i64
%2210 = getelementptr inbounds i32, i32* %2206, i64 %2209
%2211 = load i32, i32* %2210
store i32 %2211, i32* %37
%2212 = load i32*, i32** %22
%2213 = load i32, i32* %2212
%2214 = add nsw i32 %2213, 1
store i32 %2214, i32* %35
%2215 = load i32*, i32** %28
%2216 = load i32, i32* %35
%2217 = sext i32 %2216 to i64
%2218 = getelementptr inbounds i32, i32* %2215, i64 %2217
%2219 = load i32, i32* %2218
store i32 %2219, i32* %40
%2220 = load i32, i32* %31
%2221 = add nsw i32 %2220, 1
store i32 %2221, i32* %31
%2222 = load i32, i32* %31
%2223 = load i32, i32* %48
%2224 = icmp sle i32 %2222, %2223
br i1 %2224, label %2225, label %2226
2225: ; preds = %2205
br label %2191
2226: ; preds = %2205
store i32 0, i32* %31
br label %2246
2227: ; preds = %2260, %2243
%2228 = load i32, i32* %40
store i32 %2228, i32* %35
%2229 = load i32*, i32** %27
%2230 = load i32, i32* %35
%2231 = sext i32 %2230 to i64
%2232 = getelementptr inbounds i32, i32* %2229, i64 %2231
%2233 = load i32, i32* %2232
store i32 %2233, i32* %40
%2234 = load i32, i32* %40
%2235 = sub nsw i32 0, %2234
%2236 = load i32*, i32** %27
%2237 = load i32, i32* %35
%2238 = sext i32 %2237 to i64
%2239 = getelementptr inbounds i32, i32* %2236, i64 %2238
store i32 %2235, i32* %2239
%2240 = load i32, i32* %40
%2241 = load i32, i32* %31
%2242 = icmp ne i32 %2240, %2241
br i1 %2242, label %2243, label %2244
2243: ; preds = %2227
br label %2227
2244: ; preds = %2227
%2245 = load i32, i32* %40
store i32 %2245, i32* %38
br label %2246
2246: ; preds = %2271, %2255, %2244, %2226
%2247 = load i32*, i32** %27
%2248 = load i32, i32* %31
%2249 = add nsw i32 %2248, 1
store i32 %2249, i32* %31
%2250 = sext i32 %2249 to i64
%2251 = getelementptr inbounds i32, i32* %2247, i64 %2250
%2252 = load i32, i32* %2251
store i32 %2252, i32* %40
%2253 = load i32, i32* %40
%2254 = icmp slt i32 %2253, 0
br i1 %2254, label %2255, label %2256
2255: ; preds = %2246
br label %2246
2256: ; preds = %2246
%2257 = load i32, i32* %40
%2258 = load i32, i32* %31
%2259 = icmp ne i32 %2257, %2258
br i1 %2259, label %2260, label %2261
2260: ; preds = %2256
br label %2227
2261: ; preds = %2256
%2262 = load i32, i32* %31
%2263 = sub nsw i32 0, %2262
%2264 = load i32*, i32** %27
%2265 = load i32, i32* %31
%2266 = sext i32 %2265 to i64
%2267 = getelementptr inbounds i32, i32* %2264, i64 %2266
store i32 %2263, i32* %2267
%2268 = load i32, i32* %31
%2269 = load i32, i32* %48
%2270 = icmp ne i32 %2268, %2269
br i1 %2270, label %2271, label %2272
2271: ; preds = %2261
br label %2246
2272: ; preds = %2261
%2273 = load i32, i32* %30
%2274 = load i32, i32* %46
%2275 = mul nsw i32 %2274, %2273
store i32 %2275, i32* %46
br label %2440
2276: ; preds = %2452, %2438, %2285
%2277 = load i32, i32* %31
%2278 = add nsw i32 %2277, -1
store i32 %2278, i32* %31
%2279 = load i32*, i32** %27
%2280 = load i32, i32* %31
%2281 = sext i32 %2280 to i64
%2282 = getelementptr inbounds i32, i32* %2279, i64 %2281
%2283 = load i32, i32* %2282
%2284 = icmp slt i32 %2283, 0
br i1 %2284, label %2285, label %2286
2285: ; preds = %2276
br label %2276
2286: ; preds = %2276
%2287 = load i32, i32* %32
store i32 %2287, i32* %34
br label %2288
2288: ; preds = %2434, %2286
%2289 = load i32, i32* %34
store i32 %2289, i32* %43
%2290 = load i32, i32* %34
%2291 = load i32, i32* %46
%2292 = icmp sgt i32 %2290, %2291
br i1 %2292, label %2293, label %2295
2293: ; preds = %2288
%2294 = load i32, i32* %46
store i32 %2294, i32* %43
br label %2295
2295: ; preds = %2293, %2288
%2296 = load i32, i32* %43
%2297 = load i32, i32* %34
%2298 = sub nsw i32 %2297, %2296
store i32 %2298, i32* %34
%2299 = load i32*, i32** %27
%2300 = load i32, i32* %31
%2301 = sext i32 %2300 to i64
%2302 = getelementptr inbounds i32, i32* %2299, i64 %2301
%2303 = load i32, i32* %2302
store i32 %2303, i32* %35
%2304 = load i32, i32* %32
%2305 = load i32, i32* %35
%2306 = mul nsw i32 %2304, %2305
%2307 = load i32, i32* %29
%2308 = add nsw i32 %2306, %2307
%2309 = load i32, i32* %34
%2310 = add nsw i32 %2308, %2309
store i32 %2310, i32* %40
%2311 = load i32, i32* %40
%2312 = load i32, i32* %43
%2313 = add nsw i32 %2311, %2312
store i32 %2313, i32* %36
store i32 0, i32* %37
br label %2314
2314: ; preds = %2341, %2295
%2315 = load i32, i32* %37
%2316 = add nsw i32 %2315, 1
store i32 %2316, i32* %37
%2317 = load double*, double** %15
%2318 = load i32, i32* %36
%2319 = sext i32 %2318 to i64
%2320 = getelementptr inbounds double, double* %2317, i64 %2319
%2321 = load double, double* %2320
%2322 = load double*, double** %23
%2323 = load i32, i32* %37
%2324 = sext i32 %2323 to i64
%2325 = getelementptr inbounds double, double* %2322, i64 %2324
store double %2321, double* %2325
%2326 = load double*, double** %16
%2327 = load i32, i32* %36
%2328 = sext i32 %2327 to i64
%2329 = getelementptr inbounds double, double* %2326, i64 %2328
%2330 = load double, double* %2329
%2331 = load double*, double** %25
%2332 = load i32, i32* %37
%2333 = sext i32 %2332 to i64
%2334 = getelementptr inbounds double, double* %2331, i64 %2333
store double %2330, double* %2334
%2335 = load i32, i32* %30
%2336 = load i32, i32* %36
%2337 = sub nsw i32 %2336, %2335
store i32 %2337, i32* %36
%2338 = load i32, i32* %36
%2339 = load i32, i32* %40
%2340 = icmp ne i32 %2338, %2339
br i1 %2340, label %2341, label %2342
2341: ; preds = %2314
br label %2314
2342: ; preds = %2314
br label %2343
2343: ; preds = %2398, %2342
%2344 = load i32, i32* %40
%2345 = load i32, i32* %43
%2346 = add nsw i32 %2344, %2345
store i32 %2346, i32* %36
%2347 = load i32, i32* %36
%2348 = load i32, i32* %32
%2349 = load i32, i32* %35
%2350 = load i32*, i32** %27
%2351 = load i32, i32* %35
%2352 = sext i32 %2351 to i64
%2353 = getelementptr inbounds i32, i32* %2350, i64 %2352
%2354 = load i32, i32* %2353
%2355 = add nsw i32 %2349, %2354
%2356 = mul nsw i32 %2348, %2355
%2357 = sub nsw i32 %2347, %2356
store i32 %2357, i32* %37
%2358 = load i32*, i32** %27
%2359 = load i32, i32* %35
%2360 = sext i32 %2359 to i64
%2361 = getelementptr inbounds i32, i32* %2358, i64 %2360
%2362 = load i32, i32* %2361
%2363 = sub nsw i32 0, %2362
store i32 %2363, i32* %35
br label %2364
2364: ; preds = %2392, %2343
%2365 = load double*, double** %15
%2366 = load i32, i32* %37
%2367 = sext i32 %2366 to i64
%2368 = getelementptr inbounds double, double* %2365, i64 %2367
%2369 = load double, double* %2368
%2370 = load double*, double** %15
%2371 = load i32, i32* %36
%2372 = sext i32 %2371 to i64
%2373 = getelementptr inbounds double, double* %2370, i64 %2372
store double %2369, double* %2373
%2374 = load double*, double** %16
%2375 = load i32, i32* %37
%2376 = sext i32 %2375 to i64
%2377 = getelementptr inbounds double, double* %2374, i64 %2376
%2378 = load double, double* %2377
%2379 = load double*, double** %16
%2380 = load i32, i32* %36
%2381 = sext i32 %2380 to i64
%2382 = getelementptr inbounds double, double* %2379, i64 %2381
store double %2378, double* %2382
%2383 = load i32, i32* %30
%2384 = load i32, i32* %36
%2385 = sub nsw i32 %2384, %2383
store i32 %2385, i32* %36
%2386 = load i32, i32* %30
%2387 = load i32, i32* %37
%2388 = sub nsw i32 %2387, %2386
store i32 %2388, i32* %37
%2389 = load i32, i32* %36
%2390 = load i32, i32* %40
%2391 = icmp ne i32 %2389, %2390
br i1 %2391, label %2392, label %2393
2392: ; preds = %2364
br label %2364
2393: ; preds = %2364
%2394 = load i32, i32* %37
store i32 %2394, i32* %40
%2395 = load i32, i32* %35
%2396 = load i32, i32* %31
%2397 = icmp ne i32 %2395, %2396
br i1 %2397, label %2398, label %2399
2398: ; preds = %2393
br label %2343
2399: ; preds = %2393
%2400 = load i32, i32* %40
%2401 = load i32, i32* %43
%2402 = add nsw i32 %2400, %2401
store i32 %2402, i32* %36
store i32 0, i32* %37
br label %2403
2403: ; preds = %2430, %2399
%2404 = load i32, i32* %37
%2405 = add nsw i32 %2404, 1
store i32 %2405, i32* %37
%2406 = load double*, double** %23
%2407 = load i32, i32* %37
%2408 = sext i32 %2407 to i64
%2409 = getelementptr inbounds double, double* %2406, i64 %2408
%2410 = load double, double* %2409
%2411 = load double*, double** %15
%2412 = load i32, i32* %36
%2413 = sext i32 %2412 to i64
%2414 = getelementptr inbounds double, double* %2411, i64 %2413
store double %2410, double* %2414
%2415 = load double*, double** %25
%2416 = load i32, i32* %37
%2417 = sext i32 %2416 to i64
%2418 = getelementptr inbounds double, double* %2415, i64 %2417
%2419 = load double, double* %2418
%2420 = load double*, double** %16
%2421 = load i32, i32* %36
%2422 = sext i32 %2421 to i64
%2423 = getelementptr inbounds double, double* %2420, i64 %2422
store double %2419, double* %2423
%2424 = load i32, i32* %30
%2425 = load i32, i32* %36
%2426 = sub nsw i32 %2425, %2424
store i32 %2426, i32* %36
%2427 = load i32, i32* %36
%2428 = load i32, i32* %40
%2429 = icmp ne i32 %2427, %2428
br i1 %2429, label %2430, label %2431
2430: ; preds = %2403
br label %2403
2431: ; preds = %2403
%2432 = load i32, i32* %34
%2433 = icmp ne i32 %2432, 0
br i1 %2433, label %2434, label %2435
2434: ; preds = %2431
br label %2288
2435: ; preds = %2431
%2436 = load i32, i32* %31
%2437 = icmp ne i32 %2436, 1
br i1 %2437, label %2438, label %2439
2438: ; preds = %2435
br label %2276
2439: ; preds = %2435
br label %2440
2440: ; preds = %2439, %2272
%2441 = load i32, i32* %38
%2442 = add nsw i32 %2441, 1
store i32 %2442, i32* %31
%2443 = load i32, i32* %44
%2444 = load i32, i32* %49
%2445 = sub nsw i32 %2444, %2443
store i32 %2445, i32* %49
%2446 = load i32, i32* %49
%2447 = load i32, i32* %30
%2448 = sub nsw i32 %2446, %2447
%2449 = add nsw i32 %2448, 1
store i32 %2449, i32* %29
%2450 = load i32, i32* %49
%2451 = icmp sge i32 %2450, 0
br i1 %2451, label %2452, label %2453
2452: ; preds = %2440
br label %2276
2453: ; preds = %2440
br label %2454
2454: ; preds = %2453, %2126
ret void
}

LLVM IR (-O2):
define void @fftmx(double* %0, double* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* nocapture %7, double* nocapture %8, double* nocapture %9, double* nocapture %10, double* nocapture %11, i32* nocapture %12, i32* nocapture %13) {
%15 = tail call i32 @llvm.abs.i32(i32 %5, i1 true)
%16 = mul nsw i32 %15, %2
%17 = mul nsw i32 %15, %4
%18 = icmp slt i32 %5, 0
br i1 %18, label %36, label %19
19: ; preds = %14
%20 = sitofp i32 %3 to double
%21 = fdiv double 1.000000e+00, %20
%22 = icmp slt i32 %16, 1
br i1 %22, label %36, label %23
23: ; preds = %19
%24 = zext i32 %15 to i64
br label %25
25: ; preds = %23, %25
%26 = phi i64 [ 1, %23 ], [ %33, %25 ]
%27 = getelementptr inbounds double, double* %0, i64 %26
%28 = load double, double* %27
%29 = fmul double %21, %28
store double %29, double* %27
%30 = getelementptr inbounds double, double* %1, i64 %26
%31 = load double, double* %30
%32 = fmul double %21, %31
store double %32, double* %30
%33 = add nuw i64 %26, %24
%34 = trunc i64 %33 to i32
%35 = icmp slt i32 %16, %34
br i1 %35, label %36, label %25
36: ; preds = %25, %19, %14
%37 = phi double [ 0xBFE921FB54442D18, %14 ], [ 0x3FE921FB54442D18, %19 ], [ 0x3FE921FB54442D18, %25 ]
%38 = phi double [ 0xBFEE6F0E134454FF, %14 ], [ 0x3FEE6F0E134454FF, %19 ], [ 0x3FEE6F0E134454FF, %25 ]
%39 = phi double [ 0xBFEBB67AE8584CAB, %14 ], [ 0x3FEBB67AE8584CAB, %19 ], [ 0x3FEBB67AE8584CAB, %25 ]
%40 = sub nsw i32 %16, %15
%41 = sdiv i32 %17, %3
%42 = shl nsw i32 %41, 5
%43 = load i32, i32* %7
%44 = sub nsw i32 %6, %43
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %13, i64 %45
%47 = load i32, i32* %46
%48 = icmp sgt i32 %43, 0
br i1 %48, label %49, label %55
49: ; preds = %36
%50 = zext i32 %43 to i64
%51 = getelementptr inbounds i32, i32* %13, i64 %50
%52 = load i32, i32* %51
%53 = icmp slt i32 %47, %52
%54 = select i1 %53, i32 %52, i32 %47
br label %55
55: ; preds = %49, %36
%56 = phi i32 [ %47, %36 ], [ %54, %49 ]
%57 = sitofp i32 %41 to double
%58 = fmul double %57, 8.000000e+00
%59 = shl nuw nsw i32 %15, 1
%60 = shl nsw i32 %41, 1
%61 = fmul double %38, %38
%62 = fsub double 0x3FB8722191A02D62, %61
%63 = fmul double %38, 0x3FE3C6EF372FE950
%64 = add nsw i32 %41, 1
%65 = add i32 %41, %15
%66 = sub i32 %41, %16
%67 = sext i32 %16 to i64
br label %68
68: ; preds = %55, %373
%69 = phi i32 [ 0, %55 ], [ %295, %373 ]
%70 = phi i32 [ %17, %55 ], [ %256, %373 ]
%71 = phi double [ 0.000000e+00, %55 ], [ %279, %373 ]
%72 = phi double [ 0.000000e+00, %55 ], [ %280, %373 ]
%73 = phi i32 [ 0, %55 ], [ %81, %373 ]
%74 = phi double [ 0.000000e+00, %55 ], [ %282, %373 ]
%75 = phi double [ 0.000000e+00, %55 ], [ %283, %373 ]
%76 = phi i64 [ 0, %55 ], [ %98, %373 ]
br label %77
77: ; preds = %692, %68
%78 = phi i32 [ %69, %68 ], [ %630, %692 ]
%79 = phi i32 [ %70, %68 ], [ %480, %692 ]
%80 = phi double [ %71, %68 ], [ %677, %692 ]
%81 = phi i32 [ %73, %68 ], [ %631, %692 ]
%82 = phi double [ %74, %68 ], [ %675, %692 ]
%83 = phi i64 [ %76, %68 ], [ %98, %692 ]
%84 = shl i64 %83, 32
%85 = ashr exact i64 %84, 32
br label %86
86: ; preds = %196, %77
%87 = phi i64 [ %85, %77 ], [ %98, %196 ]
%88 = phi i32 [ %79, %77 ], [ %102, %196 ]
%89 = sitofp i32 %88 to double
%90 = fdiv double %58, %89
%91 = fmul double %90, 5.000000e-01
%92 = fmul double %37, %91
%93 = tail call double @sin(double %92)
%94 = fmul double %93, 2.000000e+00
%95 = fmul double %93, %94
%96 = fmul double %37, %90
%97 = tail call double @sin(double %96)
%98 = add nsw i64 %87, 1
%99 = getelementptr inbounds i32, i32* %13, i64 %98
%100 = load i32, i32* %99
switch i32 %100, label %478 [
i32 2, label %101
i32 4, label %255
]
101: ; preds = %86
%102 = sdiv i32 %88, 2
br label %103
103: ; preds = %124, %101
%104 = phi i32 [ 1, %101 ], [ %125, %124 ]
%105 = add nsw i32 %104, %102
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %0, i64 %106
%108 = load double, double* %107
%109 = getelementptr inbounds double, double* %1, i64 %106
%110 = load double, double* %109
%111 = sext i32 %104 to i64
%112 = getelementptr inbounds double, double* %0, i64 %111
%113 = load double, double* %112
%114 = fsub double %113, %108
store double %114, double* %107
%115 = getelementptr inbounds double, double* %1, i64 %111
%116 = load double, double* %115
%117 = fsub double %116, %110
store double %117, double* %109
%118 = load double, double* %112
%119 = fadd double %108, %118
store double %119, double* %112
%120 = load double, double* %115
%121 = fadd double %110, %120
store double %121, double* %115
%122 = add nsw i32 %105, %102
%123 = icmp sgt i32 %122, %40
br i1 %123, label %126, label %124
124: ; preds = %103, %126
%125 = phi i32 [ %122, %103 ], [ %127, %126 ]
br label %103
126: ; preds = %103
%127 = sub nsw i32 %122, %40
%128 = icmp sgt i32 %127, %41
br i1 %128, label %129, label %124
129: ; preds = %126
%130 = icmp sgt i32 %127, %102
br i1 %130, label %711, label %131
131: ; preds = %129
%132 = add nsw i32 %102, 2
%133 = fsub double 1.000000e+00, %95
%134 = fneg double %95
br label %135
135: ; preds = %131, %196
%136 = phi i32 [ %200, %196 ], [ %127, %131 ]
%137 = phi i32 [ %197, %196 ], [ %132, %131 ]
%138 = sdiv i32 %137, 2
br label %139
139: ; preds = %202, %135
%140 = phi i32 [ %210, %202 ], [ %42, %135 ]
%141 = phi i32 [ %185, %202 ], [ %136, %135 ]
%142 = phi double [ %208, %202 ], [ %133, %135 ]
%143 = phi double [ %209, %202 ], [ %97, %135 ]
%144 = icmp slt i32 %138, %140
%145 = select i1 %144, i32 %138, i32 %140
br label %146
146: ; preds = %139, %187
%147 = phi i32 [ %185, %187 ], [ %141, %139 ]
%148 = phi double [ %190, %187 ], [ %142, %139 ]
%149 = phi double [ %193, %187 ], [ %143, %139 ]
%150 = fneg double %149
br label %151
151: ; preds = %179, %146
%152 = phi i32 [ %147, %146 ], [ %182, %179 ]
%153 = phi double [ %148, %146 ], [ %181, %179 ]
br label %154
154: ; preds = %154, %151
%155 = phi i32 [ %152, %151 ], [ %177, %154 ]
%156 = add nsw i32 %155, %102
%157 = sext i32 %155 to i64
%158 = getelementptr inbounds double, double* %0, i64 %157
%159 = load double, double* %158
%160 = sext i32 %156 to i64
%161 = getelementptr inbounds double, double* %0, i64 %160
%162 = load double, double* %161
%163 = fsub double %159, %162
%164 = getelementptr inbounds double, double* %1, i64 %157
%165 = load double, double* %164
%166 = getelementptr inbounds double, double* %1, i64 %160
%167 = load double, double* %166
%168 = fsub double %165, %167
%169 = fadd double %159, %162
store double %169, double* %158
%170 = load double, double* %164
%171 = load double, double* %166
%172 = fadd double %170, %171
store double %172, double* %164
%173 = fmul double %168, %150
%174 = tail call double @llvm.fmuladd.f64(double %153, double %163, double %173)
store double %174, double* %161
%175 = fmul double %153, %168
%176 = tail call double @llvm.fmuladd.f64(double %149, double %163, double %175)
store double %176, double* %166
%177 = add nsw i32 %156, %102
%178 = icmp slt i32 %177, %16
br i1 %178, label %154, label %179
179: ; preds = %154
%180 = sub nsw i32 %177, %16
%181 = fneg double %153
%182 = sub nsw i32 %137, %180
%183 = icmp sgt i32 %182, %180
br i1 %183, label %151, label %184
184: ; preds = %179
%185 = add nsw i32 %182, %41
%186 = icmp sgt i32 %185, %145
br i1 %186, label %194, label %187
187: ; preds = %184
%188 = fmul double %97, %149
%189 = tail call double @llvm.fmuladd.f64(double %95, double %181, double %188)
%190 = fsub double %181, %189
%191 = fmul double %149, %134
%192 = tail call double @llvm.fmuladd.f64(double %97, double %181, double %191)
%193 = fadd double %149, %192
br label %146
194: ; preds = %184
%195 = icmp slt i32 %185, %180
br i1 %195, label %202, label %196
196: ; preds = %194
%197 = add nsw i32 %137, %59
%198 = sub nsw i32 %197, %102
%199 = sdiv i32 %198, 2
%200 = add nsw i32 %199, %41
%201 = icmp sgt i32 %200, %60
br i1 %201, label %86, label %135
202: ; preds = %194
%203 = add nsw i32 %185, -1
%204 = sdiv i32 %203, %41
%205 = sitofp i32 %204 to double
%206 = fmul double %90, %205
%207 = fmul double %37, %206
%208 = tail call double @cos(double %207)
%209 = tail call double @sin(double %207)
%210 = add nsw i32 %145, %42
br label %139
211: ; preds = %478, %250
%212 = phi i32 [ %251, %250 ], [ 1, %478 ]
%213 = add nsw i32 %212, %480
%214 = add nsw i32 %213, %480
%215 = sext i32 %212 to i64
%216 = getelementptr inbounds double, double* %0, i64 %215
%217 = load double, double* %216
%218 = getelementptr inbounds double, double* %1, i64 %215
%219 = load double, double* %218
%220 = sext i32 %213 to i64
%221 = getelementptr inbounds double, double* %0, i64 %220
%222 = load double, double* %221
%223 = sext i32 %214 to i64
%224 = getelementptr inbounds double, double* %0, i64 %223
%225 = load double, double* %224
%226 = fadd double %222, %225
%227 = getelementptr inbounds double, double* %1, i64 %220
%228 = load double, double* %227
%229 = getelementptr inbounds double, double* %1, i64 %223
%230 = load double, double* %229
%231 = fadd double %228, %230
%232 = fadd double %217, %226
store double %232, double* %216
%233 = fadd double %219, %231
store double %233, double* %218
%234 = tail call double @llvm.fmuladd.f64(double %226, double -5.000000e-01, double %217)
%235 = tail call double @llvm.fmuladd.f64(double %231, double -5.000000e-01, double %219)
%236 = load double, double* %221
%237 = load double, double* %224
%238 = fsub double %236, %237
%239 = fmul double %39, %238
%240 = load double, double* %227
%241 = load double, double* %229
%242 = fsub double %240, %241
%243 = fmul double %39, %242
%244 = fsub double %234, %243
store double %244, double* %221
%245 = fadd double %235, %239
store double %245, double* %227
%246 = fadd double %234, %243
store double %246, double* %224
%247 = fsub double %235, %239
store double %247, double* %229
%248 = add nsw i32 %214, %480
%249 = icmp slt i32 %248, %40
br i1 %249, label %250, label %252
250: ; preds = %211, %252
%251 = phi i32 [ %248, %211 ], [ %253, %252 ]
br label %211
252: ; preds = %211
%253 = sub nsw i32 %248, %40
%254 = icmp sgt i32 %253, %480
br i1 %254, label %629, label %250
255: ; preds = %86
%256 = sdiv i32 %88, 4
%257 = sub i32 %15, %256
%258 = icmp slt i32 %256, %42
%259 = select i1 %258, i32 %256, i32 %42
%260 = fneg double %95
br label %275
261: ; preds = %387, %361
%262 = phi i32 [ %286, %361 ], [ %397, %387 ]
%263 = phi double [ %364, %361 ], [ %393, %387 ]
%264 = phi double [ %367, %361 ], [ %394, %387 ]
%265 = fneg double %264
%266 = fmul double %264, %265
%267 = tail call double @llvm.fmuladd.f64(double %263, double %263, double %266)
%268 = fmul double %263, %264
%269 = fmul double %268, 2.000000e+00
%270 = fneg double %269
%271 = fmul double %264, %270
%272 = tail call double @llvm.fmuladd.f64(double %267, double %263, double %271)
%273 = fmul double %263, %269
%274 = tail call double @llvm.fmuladd.f64(double %267, double %264, double %273)
br label %275
275: ; preds = %255, %261
%276 = phi i32 [ 1, %255 ], [ %359, %261 ]
%277 = phi i32 [ %259, %255 ], [ %262, %261 ]
%278 = phi double [ 1.000000e+00, %255 ], [ %263, %261 ]
%279 = phi double [ %80, %255 ], [ %267, %261 ]
%280 = phi double [ %72, %255 ], [ %272, %261 ]
%281 = phi double [ 0.000000e+00, %255 ], [ %264, %261 ]
%282 = phi double [ %82, %255 ], [ %269, %261 ]
%283 = phi double [ %75, %255 ], [ %274, %261 ]
br label %284
284: ; preds = %275, %370
%285 = phi i32 [ %371, %370 ], [ %276, %275 ]
%286 = phi i32 [ %259, %370 ], [ %277, %275 ]
%287 = phi double [ 1.000000e+00, %370 ], [ %278, %275 ]
%288 = phi double [ 0.000000e+00, %370 ], [ %281, %275 ]
%289 = fcmp oeq double %288, 0.000000e+00
%290 = fcmp une double %288, 0.000000e+00
br label %291
291: ; preds = %355, %284
%292 = phi i32 [ %285, %284 ], [ %356, %355 ]
%293 = add nsw i32 %292, %256
%294 = add nsw i32 %293, %256
%295 = add nsw i32 %294, %256
%296 = sext i32 %292 to i64
%297 = getelementptr inbounds double, double* %0, i64 %296
%298 = load double, double* %297
%299 = sext i32 %294 to i64
%300 = getelementptr inbounds double, double* %0, i64 %299
%301 = load double, double* %300
%302 = fadd double %298, %301
%303 = fsub double %298, %301
%304 = sext i32 %293 to i64
%305 = getelementptr inbounds double, double* %0, i64 %304
%306 = load double, double* %305
%307 = sext i32 %295 to i64
%308 = getelementptr inbounds double, double* %0, i64 %307
%309 = load double, double* %308
%310 = fadd double %306, %309
%311 = fsub double %306, %309
%312 = fadd double %302, %310
store double %312, double* %297
%313 = fsub double %302, %310
%314 = getelementptr inbounds double, double* %1, i64 %296
%315 = load double, double* %314
%316 = getelementptr inbounds double, double* %1, i64 %299
%317 = load double, double* %316
%318 = fadd double %315, %317
%319 = fsub double %315, %317
%320 = getelementptr inbounds double, double* %1, i64 %304
%321 = load double, double* %320
%322 = getelementptr inbounds double, double* %1, i64 %307
%323 = load double, double* %322
%324 = fadd double %321, %323
%325 = fsub double %321, %323
%326 = fadd double %318, %324
store double %326, double* %314
%327 = fsub double %318, %324
br i1 %18, label %375, label %328
328: ; preds = %291
%329 = fsub double %303, %325
%330 = fadd double %303, %325
%331 = fadd double %311, %319
%332 = fsub double %319, %311
br i1 %289, label %380, label %333
333: ; preds = %375, %328
%334 = phi double [ %377, %375 ], [ %330, %328 ]
%335 = phi double [ %376, %375 ], [ %329, %328 ]
%336 = phi double [ %379, %375 ], [ %332, %328 ]
%337 = phi double [ %378, %375 ], [ %331, %328 ]
%338 = fneg double %337
%339 = fmul double %288, %338
%340 = tail call double @llvm.fmuladd.f64(double %335, double %287, double %339)
store double %340, double* %305
%341 = fmul double %287, %337
%342 = tail call double @llvm.fmuladd.f64(double %335, double %288, double %341)
store double %342, double* %320
%343 = fneg double %327
%344 = fmul double %282, %343
%345 = tail call double @llvm.fmuladd.f64(double %313, double %279, double %344)
store double %345, double* %300
%346 = fmul double %279, %327
%347 = tail call double @llvm.fmuladd.f64(double %313, double %282, double %346)
store double %347, double* %316
%348 = fneg double %336
%349 = fmul double %283, %348
%350 = tail call double @llvm.fmuladd.f64(double %334, double %280, double %349)
store double %350, double* %308
%351 = fmul double %280, %336
%352 = tail call double @llvm.fmuladd.f64(double %334, double %283, double %351)
store double %352, double* %322
%353 = add nsw i32 %295, %256
%354 = icmp sgt i32 %353, %16
br i1 %354, label %357, label %355
355: ; preds = %333, %380
%356 = phi i32 [ %353, %333 ], [ %385, %380 ]
br label %291
357: ; preds = %380, %333
%358 = phi i32 [ %353, %333 ], [ %385, %380 ]
%359 = add i32 %358, %66
%360 = icmp sgt i32 %359, %286
br i1 %360, label %368, label %361
361: ; preds = %357
%362 = fmul double %97, %288
%363 = tail call double @llvm.fmuladd.f64(double %95, double %287, double %362)
%364 = fsub double %287, %363
%365 = fmul double %288, %260
%366 = tail call double @llvm.fmuladd.f64(double %97, double %287, double %365)
%367 = fadd double %288, %366
br label %261
368: ; preds = %357
%369 = icmp slt i32 %359, %256
br i1 %369, label %387, label %370
370: ; preds = %368
%371 = add i32 %359, %257
%372 = icmp sgt i32 %371, %41
br i1 %372, label %373, label %284
373: ; preds = %370
%374 = icmp eq i32 %256, %41
br i1 %374, label %711, label %68
375: ; preds = %291
%376 = fadd double %303, %325
%377 = fsub double %303, %325
%378 = fsub double %319, %311
%379 = fadd double %311, %319
br i1 %290, label %333, label %380
380: ; preds = %375, %328
%381 = phi double [ %377, %375 ], [ %330, %328 ]
%382 = phi double [ %376, %375 ], [ %329, %328 ]
%383 = phi double [ %379, %375 ], [ %332, %328 ]
%384 = phi double [ %378, %375 ], [ %331, %328 ]
store double %382, double* %305
store double %384, double* %320
store double %313, double* %300
store double %327, double* %316
store double %381, double* %308
store double %383, double* %322
%385 = add nsw i32 %295, %256
%386 = icmp sgt i32 %385, %16
br i1 %386, label %357, label %355
387: ; preds = %368
%388 = add nsw i32 %359, -1
%389 = sdiv i32 %388, %41
%390 = sitofp i32 %389 to double
%391 = fmul double %90, %390
%392 = fmul double %37, %391
%393 = tail call double @cos(double %392)
%394 = tail call double @sin(double %392)
%395 = add nsw i32 %286, %42
%396 = icmp slt i32 %256, %395
%397 = select i1 %396, i32 %256, i32 %395
br label %261
398: ; preds = %478, %473
%399 = phi i32 [ %474, %473 ], [ 1, %478 ]
%400 = add nsw i32 %399, %480
%401 = add nsw i32 %400, %480
%402 = add nsw i32 %401, %480
%403 = add nsw i32 %402, %480
%404 = sext i32 %400 to i64
%405 = getelementptr inbounds double, double* %0, i64 %404
%406 = load double, double* %405
%407 = sext i32 %403 to i64
%408 = getelementptr inbounds double, double* %0, i64 %407
%409 = load double, double* %408
%410 = fadd double %406, %409
%411 = fsub double %406, %409
%412 = getelementptr inbounds double, double* %1, i64 %404
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %1, i64 %407
%415 = load double, double* %414
%416 = fadd double %413, %415
%417 = fsub double %413, %415
%418 = sext i32 %401 to i64
%419 = getelementptr inbounds double, double* %0, i64 %418
%420 = load double, double* %419
%421 = sext i32 %402 to i64
%422 = getelementptr inbounds double, double* %0, i64 %421
%423 = load double, double* %422
%424 = fadd double %420, %423
%425 = fsub double %420, %423
%426 = getelementptr inbounds double, double* %1, i64 %418
%427 = load double, double* %426
%428 = getelementptr inbounds double, double* %1, i64 %421
%429 = load double, double* %428
%430 = fadd double %427, %429
%431 = fsub double %427, %429
%432 = sext i32 %399 to i64
%433 = getelementptr inbounds double, double* %0, i64 %432
%434 = load double, double* %433
%435 = getelementptr inbounds double, double* %1, i64 %432
%436 = load double, double* %435
%437 = fadd double %410, %434
%438 = fadd double %424, %437
store double %438, double* %433
%439 = fadd double %416, %436
%440 = fadd double %430, %439
store double %440, double* %435
%441 = fmul double %62, %424
%442 = tail call double @llvm.fmuladd.f64(double %410, double 0x3FD3C6EF372FE950, double %441)
%443 = fadd double %442, %434
%444 = fmul double %62, %430
%445 = tail call double @llvm.fmuladd.f64(double %416, double 0x3FD3C6EF372FE950, double %444)
%446 = fadd double %436, %445
%447 = fmul double %63, %425
%448 = tail call double @llvm.fmuladd.f64(double %411, double %38, double %447)
%449 = fmul double %63, %431
%450 = tail call double @llvm.fmuladd.f64(double %417, double %38, double %449)
%451 = fsub double %443, %450
store double %451, double* %405
%452 = fadd double %443, %450
store double %452, double* %408
%453 = fadd double %448, %446
store double %453, double* %412
%454 = fsub double %446, %448
store double %454, double* %414
%455 = fmul double %424, 0x3FD3C6EF372FE950
%456 = tail call double @llvm.fmuladd.f64(double %410, double %62, double %455)
%457 = fadd double %456, %434
%458 = fmul double %430, 0x3FD3C6EF372FE950
%459 = tail call double @llvm.fmuladd.f64(double %416, double %62, double %458)
%460 = fadd double %436, %459
%461 = fneg double %425
%462 = fmul double %38, %461
%463 = tail call double @llvm.fmuladd.f64(double %411, double %63, double %462)
%464 = fneg double %431
%465 = fmul double %38, %464
%466 = tail call double @llvm.fmuladd.f64(double %417, double %63, double %465)
%467 = fsub double %457, %466
store double %467, double* %419
%468 = fadd double %457, %466
store double %468, double* %422
%469 = fadd double %463, %460
store double %469, double* %426
%470 = fsub double %460, %463
store double %470, double* %428
%471 = add nsw i32 %403, %480
%472 = icmp slt i32 %471, %40
br i1 %472, label %473, label %475
473: ; preds = %398, %475
%474 = phi i32 [ %471, %398 ], [ %476, %475 ]
br label %398
475: ; preds = %398
%476 = sub nsw i32 %471, %40
%477 = icmp sgt i32 %476, %480
br i1 %477, label %629, label %473
478: ; preds = %86
%479 = trunc i64 %98 to i32
%480 = sdiv i32 %88, %100
switch i32 %100, label %481 [
i32 3, label %211
i32 5, label %398
]
481: ; preds = %478
%482 = icmp eq i32 %100, %81
br i1 %482, label %483, label %485
483: ; preds = %481
%484 = sext i32 %81 to i64
br label %495
485: ; preds = %481
%486 = sitofp i32 %100 to double
%487 = fmul double %486, 1.250000e-01
%488 = fdiv double %37, %487
%489 = tail call double @cos(double %488)
%490 = tail call double @sin(double %488)
%491 = sext i32 %100 to i64
%492 = getelementptr inbounds double, double* %9, i64 %491
store double 1.000000e+00, double* %492
%493 = getelementptr inbounds double, double* %11, i64 %491
store double 0.000000e+00, double* %493
%494 = icmp sgt i32 %100, 1
br i1 %494, label %499, label %495
495: ; preds = %499, %483, %485
%496 = phi i64 [ %484, %483 ], [ %491, %485 ], [ %491, %499 ]
%497 = phi i32 [ %81, %483 ], [ %100, %485 ], [ %100, %499 ]
%498 = sext i32 %480 to i64
br label %523
499: ; preds = %485, %499
%500 = phi double [ %519, %499 ], [ 0.000000e+00, %485 ]
%501 = phi i64 [ %515, %499 ], [ %491, %485 ]
%502 = phi i64 [ %521, %499 ], [ 1, %485 ]
%503 = getelementptr inbounds double, double* %9, i64 %501
%504 = load double, double* %503
%505 = getelementptr inbounds double, double* %11, i64 %501
%506 = fmul double %490, %500
%507 = tail call double @llvm.fmuladd.f64(double %504, double %489, double %506)
%508 = getelementptr inbounds double, double* %9, i64 %502
store double %507, double* %508
%509 = load double, double* %503
%510 = load double, double* %505
%511 = fneg double %510
%512 = fmul double %489, %511
%513 = tail call double @llvm.fmuladd.f64(double %509, double %490, double %512)
%514 = getelementptr inbounds double, double* %11, i64 %502
store double %513, double* %514
%515 = add nsw i64 %501, -1
%516 = load double, double* %508
%517 = getelementptr inbounds double, double* %9, i64 %515
store double %516, double* %517
%518 = load double, double* %514
%519 = fneg double %518
%520 = getelementptr inbounds double, double* %11, i64 %515
store double %519, double* %520
%521 = add nuw nsw i64 %502, 1
%522 = icmp slt i64 %521, %515
br i1 %522, label %499, label %495
523: ; preds = %624, %495
%524 = phi i32 [ 1, %495 ], [ %625, %624 ]
%525 = add nsw i32 %524, %88
%526 = sext i32 %524 to i64
%527 = getelementptr inbounds double, double* %0, i64 %526
%528 = load double, double* %527
%529 = getelementptr inbounds double, double* %1, i64 %526
%530 = load double, double* %529
%531 = add i32 %524, %480
%532 = sext i32 %531 to i64
br label %533
533: ; preds = %533, %523
%534 = phi i64 [ %556, %533 ], [ 1, %523 ]
%535 = phi i64 [ %565, %533 ], [ %532, %523 ]
%536 = phi i32 [ %539, %533 ], [ %525, %523 ]
%537 = phi double [ %548, %533 ], [ %528, %523 ]
%538 = phi double [ %555, %533 ], [ %530, %523 ]
%539 = sub nsw i32 %536, %480
%540 = add nuw nsw i64 %534, 1
%541 = getelementptr inbounds double, double* %0, i64 %535
%542 = load double, double* %541
%543 = sext i32 %539 to i64
%544 = getelementptr inbounds double, double* %0, i64 %543
%545 = load double, double* %544
%546 = fadd double %542, %545
%547 = getelementptr inbounds double, double* %8, i64 %540
store double %546, double* %547
%548 = fadd double %537, %546
%549 = getelementptr inbounds double, double* %1, i64 %535
%550 = load double, double* %549
%551 = getelementptr inbounds double, double* %1, i64 %543
%552 = load double, double* %551
%553 = fadd double %550, %552
%554 = getelementptr inbounds double, double* %10, i64 %540
store double %553, double* %554
%555 = fadd double %538, %553
%556 = add nuw nsw i64 %534, 2
%557 = load double, double* %541
%558 = load double, double* %544
%559 = fsub double %557, %558
%560 = getelementptr inbounds double, double* %8, i64 %556
store double %559, double* %560
%561 = load double, double* %549
%562 = load double, double* %551
%563 = fsub double %561, %562
%564 = getelementptr inbounds double, double* %10, i64 %556
store double %563, double* %564
%565 = add i64 %535, %498
%566 = icmp slt i64 %565, %543
br i1 %566, label %533, label %567
567: ; preds = %533
store double %548, double* %527
store double %555, double* %529
br label %568
568: ; preds = %606, %567
%569 = phi i64 [ %572, %606 ], [ %526, %567 ]
%570 = phi i32 [ %607, %606 ], [ %525, %567 ]
%571 = phi i32 [ %620, %606 ], [ 1, %567 ]
%572 = add i64 %569, %498
br label %573
573: ; preds = %573, %568
%574 = phi i64 [ %589, %573 ], [ 1, %568 ]
%575 = phi double [ %585, %573 ], [ %528, %568 ]
%576 = phi double [ %588, %573 ], [ %530, %568 ]
%577 = phi i32 [ %604, %573 ], [ %571, %568 ]
%578 = phi <2 x double> [ %600, %573 ], [ zeroinitializer, %568 ]
%579 = add nuw nsw i64 %574, 1
%580 = getelementptr inbounds double, double* %8, i64 %579
%581 = load double, double* %580
%582 = sext i32 %577 to i64
%583 = getelementptr inbounds double, double* %9, i64 %582
%584 = load double, double* %583
%585 = tail call double @llvm.fmuladd.f64(double %581, double %584, double %575)
%586 = getelementptr inbounds double, double* %10, i64 %579
%587 = load double, double* %586
%588 = tail call double @llvm.fmuladd.f64(double %587, double %584, double %576)
%589 = add nuw nsw i64 %574, 2
%590 = getelementptr inbounds double, double* %8, i64 %589
%591 = load double, double* %590
%592 = getelementptr inbounds double, double* %11, i64 %582
%593 = load double, double* %592
%594 = getelementptr inbounds double, double* %10, i64 %589
%595 = load double, double* %594
%596 = insertelement <2 x double> poison, double %591, i64 0
%597 = insertelement <2 x double> %596, double %595, i64 1
%598 = insertelement <2 x double> poison, double %593, i64 0
%599 = shufflevector <2 x double> %598, <2 x double> poison, <2 x i32> zeroinitializer
%600 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %597, <2 x double> %599, <2 x double> %578)
%601 = add nsw i32 %577, %571
%602 = icmp sgt i32 %601, %497
%603 = select i1 %602, i32 %497, i32 0
%604 = sub nsw i32 %601, %603
%605 = icmp slt i64 %589, %496
br i1 %605, label %573, label %606
606: ; preds = %573
%607 = sub nsw i32 %570, %480
%608 = sub nsw i32 %497, %571
%609 = extractelement <2 x double> %600, i64 1
%610 = fsub double %585, %609
%611 = getelementptr inbounds double, double* %0, i64 %572
store double %610, double* %611
%612 = extractelement <2 x double> %600, i64 0
%613 = fadd double %588, %612
%614 = getelementptr inbounds double, double* %1, i64 %572
store double %613, double* %614
%615 = fadd double %585, %609
%616 = sext i32 %607 to i64
%617 = getelementptr inbounds double, double* %0, i64 %616
store double %615, double* %617
%618 = fsub double %588, %612
%619 = getelementptr inbounds double, double* %1, i64 %616
store double %618, double* %619
%620 = add nuw nsw i32 %571, 1
%621 = icmp slt i32 %620, %608
br i1 %621, label %568, label %622
622: ; preds = %606
%623 = icmp sgt i32 %525, %40
br i1 %623, label %626, label %624
624: ; preds = %622, %626
%625 = phi i32 [ %525, %622 ], [ %627, %626 ]
br label %523
626: ; preds = %622
%627 = sub nsw i32 %525, %40
%628 = icmp sgt i32 %627, %480
br i1 %628, label %629, label %624
629: ; preds = %475, %252, %626
%630 = phi i32 [ %78, %626 ], [ %78, %252 ], [ %402, %475 ]
%631 = phi i32 [ %497, %626 ], [ %81, %252 ], [ %81, %475 ]
%632 = icmp eq i32 %479, %6
br i1 %632, label %711, label %633
633: ; preds = %629
%634 = sub i32 %65, %480
%635 = fsub double 1.000000e+00, %95
%636 = icmp slt i32 %480, %42
%637 = select i1 %636, i32 %480, i32 %42
%638 = sub i32 %41, %88
%639 = sub i32 %480, %16
%640 = fneg double %95
%641 = sext i32 %88 to i64
br label %642
642: ; preds = %706, %633
%643 = phi i32 [ %64, %633 ], [ %707, %706 ]
%644 = phi i32 [ %637, %633 ], [ %708, %706 ]
%645 = phi double [ %635, %633 ], [ %709, %706 ]
%646 = phi double [ %97, %633 ], [ %710, %706 ]
br label %647
647: ; preds = %642, %683
%648 = phi i32 [ %681, %683 ], [ %643, %642 ]
%649 = phi double [ %686, %683 ], [ %645, %642 ]
%650 = phi double [ %689, %683 ], [ %646, %642 ]
%651 = add nsw i32 %648, %480
%652 = fneg double %650
br label %653
653: ; preds = %672, %647
%654 = phi i32 [ %678, %672 ], [ %651, %647 ]
%655 = phi double [ %677, %672 ], [ %649, %647 ]
%656 = phi double [ %675, %672 ], [ %650, %647 ]
%657 = fneg double %656
%658 = sext i32 %654 to i64
br label %659
659: ; preds = %653, %659
%660 = phi i64 [ %658, %653 ], [ %670, %659 ]
%661 = getelementptr inbounds double, double* %0, i64 %660
%662 = load double, double* %661
%663 = getelementptr inbounds double, double* %1, i64 %660
%664 = load double, double* %663
%665 = fmul double %664, %657
%666 = tail call double @llvm.fmuladd.f64(double %655, double %662, double %665)
store double %666, double* %661
%667 = load double, double* %663
%668 = fmul double %655, %667
%669 = tail call double @llvm.fmuladd.f64(double %656, double %662, double %668)
store double %669, double* %663
%670 = add i64 %660, %641
%671 = icmp sgt i64 %670, %67
br i1 %671, label %672, label %659
672: ; preds = %659
%673 = trunc i64 %670 to i32
%674 = fmul double %649, %656
%675 = tail call double @llvm.fmuladd.f64(double %650, double %655, double %674)
%676 = fmul double %656, %652
%677 = tail call double @llvm.fmuladd.f64(double %649, double %655, double %676)
%678 = add i32 %639, %673
%679 = icmp sgt i32 %678, %88
br i1 %679, label %680, label %653
680: ; preds = %672
%681 = add i32 %678, %638
%682 = icmp sgt i32 %681, %644
br i1 %682, label %690, label %683
683: ; preds = %680
%684 = fmul double %97, %650
%685 = tail call double @llvm.fmuladd.f64(double %95, double %649, double %684)
%686 = fsub double %649, %685
%687 = fmul double %650, %640
%688 = tail call double @llvm.fmuladd.f64(double %97, double %649, double %687)
%689 = fadd double %650, %688
br label %647
690: ; preds = %680
%691 = icmp slt i32 %681, %480
br i1 %691, label %695, label %692
692: ; preds = %690
%693 = add i32 %634, %681
%694 = icmp sgt i32 %693, %60
br i1 %694, label %77, label %706
695: ; preds = %690
%696 = add nsw i32 %681, -1
%697 = sdiv i32 %696, %41
%698 = sitofp i32 %697 to double
%699 = fmul double %90, %698
%700 = fmul double %37, %699
%701 = tail call double @cos(double %700)
%702 = tail call double @sin(double %700)
%703 = add nsw i32 %644, %42
%704 = icmp slt i32 %480, %703
%705 = select i1 %704, i32 %480, i32 %703
br label %706
706: ; preds = %695, %692
%707 = phi i32 [ %681, %695 ], [ %693, %692 ]
%708 = phi i32 [ %705, %695 ], [ %637, %692 ]
%709 = phi double [ %701, %695 ], [ %635, %692 ]
%710 = phi double [ %702, %695 ], [ %97, %692 ]
br label %642
711: ; preds = %373, %629, %129
%712 = phi i32 [ %78, %129 ], [ %630, %629 ], [ %295, %373 ]
%713 = getelementptr inbounds i32, i32* %12, i64 1
store i32 %17, i32* %713
%714 = load i32, i32* %7
%715 = icmp eq i32 %714, 0
br i1 %715, label %872, label %716
716: ; preds = %711
%717 = shl nsw i32 %714, 1
%718 = or i32 %717, 1
%719 = icmp sgt i32 %718, %6
%720 = select i1 %719, i32 %717, i32 %718
%721 = add nsw i32 %720, 1
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds i32, i32* %12, i64 %722
store i32 %41, i32* %723
%724 = icmp sgt i32 %720, 1
br i1 %724, label %725, label %748
725: ; preds = %716
%726 = zext i32 %720 to i64
br label %727
727: ; preds = %725, %727
%728 = phi i64 [ %726, %725 ], [ %743, %727 ]
%729 = phi i64 [ 1, %725 ], [ %735, %727 ]
%730 = getelementptr inbounds i32, i32* %12, i64 %729
%731 = load i32, i32* %730
%732 = getelementptr inbounds i32, i32* %13, i64 %729
%733 = load i32, i32* %732
%734 = sdiv i32 %731, %733
%735 = add nuw nsw i64 %729, 1
%736 = getelementptr inbounds i32, i32* %12, i64 %735
store i32 %734, i32* %736
%737 = add nsw i64 %728, 1
%738 = getelementptr inbounds i32, i32* %12, i64 %737
%739 = load i32, i32* %738
%740 = load i32, i32* %732
%741 = mul nsw i32 %740, %739
%742 = getelementptr inbounds i32, i32* %12, i64 %728
store i32 %741, i32* %742
%743 = add nsw i64 %728, -1
%744 = icmp slt i64 %735, %743
br i1 %744, label %727, label %745
745: ; preds = %727
%746 = shl i64 %728, 32
%747 = ashr exact i64 %746, 32
br label %748
748: ; preds = %745, %716
%749 = phi i64 [ %747, %745 ], [ %722, %716 ]
%750 = getelementptr inbounds i32, i32* %12, i64 %749
%751 = load i32, i32* %750
%752 = getelementptr inbounds i32, i32* %12, i64 2
%753 = load i32, i32* %752
%754 = add nsw i32 %753, 1
%755 = icmp eq i32 %3, %2
br i1 %755, label %756, label %761
756: ; preds = %748
%757 = zext i32 %15 to i64
%758 = sext i32 %753 to i64
%759 = sext i32 %17 to i64
%760 = load i32, i32* %713
br label %766
761: ; preds = %748
%762 = sub i32 %753, %16
%763 = sub nsw i32 %17, %41
%764 = zext i32 %15 to i64
%765 = load i32, i32* %713
br label %813
766: ; preds = %803, %756
%767 = phi i32 [ %64, %756 ], [ %804, %803 ]
%768 = phi i32 [ %754, %756 ], [ %805, %803 ]
%769 = sext i32 %767 to i64
%770 = sext i32 %768 to i64
br label %771
771: ; preds = %771, %766
%772 = phi i64 [ %783, %771 ], [ %770, %766 ]
%773 = phi i64 [ %782, %771 ], [ %769, %766 ]
%774 = getelementptr inbounds double, double* %0, i64 %773
%775 = load double, double* %774
%776 = getelementptr inbounds double, double* %0, i64 %772
%777 = load double, double* %776
store double %777, double* %774
store double %775, double* %776
%778 = getelementptr inbounds double, double* %1, i64 %773
%779 = load double, double* %778
%780 = getelementptr inbounds double, double* %1, i64 %772
%781 = load double, double* %780
store double %781, double* %778
store double %779, double* %780
%782 = add i64 %773, %757
%783 = add i64 %772, %758
%784 = icmp slt i64 %783, %759
br i1 %784, label %771, label %785
785: ; preds = %771
%786 = trunc i64 %783 to i32
%787 = trunc i64 %782 to i32
br label %788
788: ; preds = %785, %811
%789 = phi i32 [ %808, %811 ], [ %787, %785 ]
%790 = phi i32 [ %809, %811 ], [ %786, %785 ]
br label %791
791: ; preds = %791, %788
%792 = phi i32 [ %800, %791 ], [ %753, %788 ]
%793 = phi i32 [ %792, %791 ], [ %760, %788 ]
%794 = phi i64 [ %796, %791 ], [ 1, %788 ]
%795 = phi i32 [ %801, %791 ], [ %790, %788 ]
%796 = add nuw nsw i64 %794, 1
%797 = sub nsw i32 %795, %793
%798 = add nuw nsw i64 %794, 2
%799 = getelementptr inbounds i32, i32* %12, i64 %798
%800 = load i32, i32* %799
%801 = add nsw i32 %797, %800
%802 = icmp sgt i32 %801, %792
br i1 %802, label %791, label %803
803: ; preds = %791, %807
%804 = phi i32 [ %808, %807 ], [ %789, %791 ]
%805 = phi i32 [ %809, %807 ], [ %801, %791 ]
%806 = icmp slt i32 %804, %805
br i1 %806, label %766, label %807
807: ; preds = %803
%808 = add nsw i32 %804, %15
%809 = add nsw i32 %805, %753
%810 = icmp slt i32 %809, %17
br i1 %810, label %803, label %811
811: ; preds = %807
%812 = icmp slt i32 %808, %17
br i1 %812, label %788, label %872
813: ; preds = %840, %761
%814 = phi i32 [ %64, %761 ], [ %841, %840 ]
%815 = phi i32 [ %754, %761 ], [ %842, %840 ]
%816 = add nsw i32 %814, %41
%817 = sext i32 %814 to i64
%818 = sext i32 %816 to i64
%819 = sext i32 %815 to i64
br label %820
820: ; preds = %820, %813
%821 = phi i64 [ %832, %820 ], [ %819, %813 ]
%822 = phi i64 [ %831, %820 ], [ %817, %813 ]
%823 = getelementptr inbounds double, double* %0, i64 %822
%824 = load double, double* %823
%825 = getelementptr inbounds double, double* %0, i64 %821
%826 = load double, double* %825
store double %826, double* %823
store double %824, double* %825
%827 = getelementptr inbounds double, double* %1, i64 %822
%828 = load double, double* %827
%829 = getelementptr inbounds double, double* %1, i64 %821
%830 = load double, double* %829
store double %830, double* %827
store double %828, double* %829
%831 = add i64 %822, %764
%832 = add i64 %821, %764
%833 = icmp slt i64 %831, %818
br i1 %833, label %820, label %834
834: ; preds = %820
%835 = trunc i64 %832 to i32
%836 = trunc i64 %831 to i32
%837 = add nsw i32 %763, %836
%838 = add nsw i32 %763, %835
%839 = icmp slt i32 %837, %16
br i1 %839, label %840, label %843
840: ; preds = %862, %834, %843
%841 = phi i32 [ %837, %834 ], [ %845, %843 ], [ %863, %862 ]
%842 = phi i32 [ %838, %834 ], [ %844, %843 ], [ %864, %862 ]
br label %813
843: ; preds = %834
%844 = add i32 %838, %762
%845 = add i32 %837, %66
%846 = icmp slt i32 %844, %17
br i1 %846, label %840, label %847
847: ; preds = %843, %870
%848 = phi i32 [ %867, %870 ], [ %845, %843 ]
%849 = phi i32 [ %868, %870 ], [ %844, %843 ]
br label %850
850: ; preds = %850, %847
%851 = phi i32 [ %859, %850 ], [ %753, %847 ]
%852 = phi i32 [ %851, %850 ], [ %765, %847 ]
%853 = phi i64 [ %855, %850 ], [ 1, %847 ]
%854 = phi i32 [ %860, %850 ], [ %849, %847 ]
%855 = add nuw nsw i64 %853, 1
%856 = sub nsw i32 %854, %852
%857 = add nuw nsw i64 %853, 2
%858 = getelementptr inbounds i32, i32* %12, i64 %857
%859 = load i32, i32* %858
%860 = add nsw i32 %856, %859
%861 = icmp sgt i32 %860, %851
br i1 %861, label %850, label %862
862: ; preds = %850, %866
%863 = phi i32 [ %867, %866 ], [ %848, %850 ]
%864 = phi i32 [ %868, %866 ], [ %860, %850 ]
%865 = icmp slt i32 %863, %864
br i1 %865, label %840, label %866
866: ; preds = %862
%867 = add nsw i32 %863, %41
%868 = add nsw i32 %864, %753
%869 = icmp slt i32 %868, %17
br i1 %869, label %862, label %870
870: ; preds = %866
%871 = icmp slt i32 %867, %17
br i1 %871, label %847, label %872
872: ; preds = %870, %811, %711
%873 = phi i32 [ %712, %711 ], [ %751, %811 ], [ %751, %870 ]
%874 = phi i32 [ %41, %711 ], [ %751, %811 ], [ %751, %870 ]
%875 = load i32, i32* %7
%876 = shl nsw i32 %875, 1
%877 = or i32 %876, 1
%878 = icmp slt i32 %877, %6
br i1 %878, label %879, label %1056
879: ; preds = %872
%880 = sext i32 %875 to i64
%881 = getelementptr inbounds i32, i32* %12, i64 %880
%882 = getelementptr inbounds i32, i32* %881, i64 1
%883 = load i32, i32* %882
%884 = sub nsw i32 %6, %875
%885 = add nsw i32 %884, 1
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds i32, i32* %13, i64 %886
store i32 1, i32* %887
%888 = sext i32 %884 to i64
br label %889
889: ; preds = %889, %879
%890 = phi i64 [ %897, %889 ], [ %888, %879 ]
%891 = getelementptr inbounds i32, i32* %13, i64 %890
%892 = load i32, i32* %891
%893 = add nsw i64 %890, 1
%894 = getelementptr inbounds i32, i32* %13, i64 %893
%895 = load i32, i32* %894
%896 = mul nsw i32 %895, %892
store i32 %896, i32* %891
%897 = add i64 %890, -1
%898 = load i32, i32* %7
%899 = trunc i64 %897 to i32
%900 = icmp eq i32 %898, %899
br i1 %900, label %901, label %889
901: ; preds = %889
%902 = add nsw i32 %898, 1
store i32 %902, i32* %7
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds i32, i32* %13, i64 %903
%905 = load i32, i32* %904
%906 = add nsw i32 %905, -1
%907 = icmp sgt i32 %905, 1
br i1 %907, label %908, label %935
908: ; preds = %901
%909 = zext i32 %905 to i64
br label %929
910: ; preds = %910, %929
%911 = phi i64 [ %914, %910 ], [ %934, %929 ]
%912 = phi i32 [ %916, %910 ], [ %930, %929 ]
%913 = phi i32 [ %919, %910 ], [ %933, %929 ]
%914 = add nsw i64 %911, 1
%915 = getelementptr inbounds i32, i32* %13, i64 %914
%916 = load i32, i32* %915
%917 = add nsw i32 %916, %913
%918 = icmp slt i32 %917, %912
%919 = sub nsw i32 %917, %912
br i1 %918, label %920, label %910
920: ; preds = %910
%921 = getelementptr inbounds i32, i32* %12, i64 %931
store i32 %917, i32* %921
%922 = load i32, i32* %7
%923 = add nuw nsw i64 %931, 1
%924 = icmp eq i64 %923, %909
br i1 %924, label %935, label %925
925: ; preds = %920
%926 = sext i32 %922 to i64
%927 = getelementptr inbounds i32, i32* %13, i64 %926
%928 = load i32, i32* %927
br label %929
929: ; preds = %925, %908
%930 = phi i32 [ %905, %908 ], [ %928, %925 ]
%931 = phi i64 [ 1, %908 ], [ %923, %925 ]
%932 = phi i32 [ %902, %908 ], [ %922, %925 ]
%933 = phi i32 [ 0, %908 ], [ %917, %925 ]
%934 = sext i32 %932 to i64
br label %910
935: ; preds = %920, %901
%936 = sext i32 %906 to i64
br label %944
937: ; preds = %959, %937
%938 = phi i32 [ %941, %937 ], [ %953, %959 ]
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds i32, i32* %12, i64 %939
%941 = load i32, i32* %940
%942 = sub nsw i32 0, %941
store i32 %942, i32* %940
%943 = icmp eq i32 %941, %960
br i1 %943, label %944, label %937
944: ; preds = %937, %935
%945 = phi i32 [ %873, %935 ], [ %960, %937 ]
%946 = phi i64 [ 0, %935 ], [ %951, %937 ]
%947 = shl i64 %946, 32
%948 = ashr exact i64 %947, 32
br label %949
949: ; preds = %955, %944
%950 = phi i64 [ %948, %944 ], [ %951, %955 ]
%951 = add nsw i64 %950, 1
%952 = getelementptr inbounds i32, i32* %12, i64 %951
%953 = load i32, i32* %952
%954 = icmp slt i32 %953, 0
br i1 %954, label %955, label %956
955: ; preds = %949, %961
br label %949
956: ; preds = %949
%957 = trunc i64 %951 to i32
%958 = icmp eq i32 %953, %957
br i1 %958, label %961, label %959
959: ; preds = %956
%960 = trunc i64 %951 to i32
br label %937
961: ; preds = %956
%962 = trunc i64 %950 to i32
%963 = xor i32 %962, -1
store i32 %963, i32* %952
%964 = icmp eq i64 %951, %936
br i1 %964, label %965, label %955
965: ; preds = %961
%966 = mul nsw i32 %56, %15
%967 = sub nsw i32 %16, %883
%968 = icmp sgt i32 %967, -1
br i1 %968, label %969, label %1056
969: ; preds = %965
%970 = add i32 %945, 1
%971 = sub nsw i32 1, %15
%972 = sext i32 %970 to i64
br label %1053
973: ; preds = %979, %1053
%974 = phi i64 [ %972, %1053 ], [ %975, %979 ]
%975 = add i64 %974, -1
%976 = getelementptr inbounds i32, i32* %12, i64 %975
%977 = load i32, i32* %976
%978 = icmp slt i32 %977, 0
br i1 %978, label %979, label %980
979: ; preds = %973, %1048
br label %973
980: ; preds = %973
%981 = mul nsw i32 %977, %874
%982 = add i32 %1055, %981
%983 = trunc i64 %975 to i32
br label %984
984: ; preds = %980, %1046
%985 = phi i32 [ %988, %1046 ], [ %874, %980 ]
%986 = icmp sgt i32 %985, %966
%987 = select i1 %986, i32 %966, i32 %985
%988 = sub nsw i32 %985, %987
%989 = add nsw i32 %988, %982
%990 = add i32 %985, %982
br label %991
991: ; preds = %991, %984
%992 = phi i64 [ %994, %991 ], [ 0, %984 ]
%993 = phi i32 [ %1002, %991 ], [ %990, %984 ]
%994 = add nuw nsw i64 %992, 1
%995 = sext i32 %993 to i64
%996 = getelementptr inbounds double, double* %0, i64 %995
%997 = load double, double* %996
%998 = getelementptr inbounds double, double* %8, i64 %994
store double %997, double* %998
%999 = getelementptr inbounds double, double* %1, i64 %995
%1000 = load double, double* %999
%1001 = getelementptr inbounds double, double* %10, i64 %994
store double %1000, double* %1001
%1002 = sub nsw i32 %993, %15
%1003 = icmp eq i32 %1002, %989
br i1 %1003, label %1004, label %991
1004: ; preds = %991, %1028
%1005 = phi i32 [ %1026, %1028 ], [ %989, %991 ]
%1006 = phi i32 [ %1029, %1028 ], [ %977, %991 ]
%1007 = add nsw i32 %1005, %987
%1008 = sext i32 %1006 to i64
%1009 = getelementptr inbounds i32, i32* %12, i64 %1008
%1010 = load i32, i32* %1009
%1011 = add nsw i32 %1010, %1006
%1012 = mul nsw i32 %1011, %874
%1013 = sub nsw i32 %1007, %1012
br label %1014
1014: ; preds = %1014, %1004
%1015 = phi i32 [ %1013, %1004 ], [ %1026, %1014 ]
%1016 = phi i32 [ %1007, %1004 ], [ %1025, %1014 ]
%1017 = sext i32 %1015 to i64
%1018 = getelementptr inbounds double, double* %0, i64 %1017
%1019 = load double, double* %1018
%1020 = sext i32 %1016 to i64
%1021 = getelementptr inbounds double, double* %0, i64 %1020
store double %1019, double* %1021
%1022 = getelementptr inbounds double, double* %1, i64 %1017
%1023 = load double, double* %1022
%1024 = getelementptr inbounds double, double* %1, i64 %1020
store double %1023, double* %1024
%1025 = sub nsw i32 %1016, %15
%1026 = sub nsw i32 %1015, %15
%1027 = icmp eq i32 %1025, %1005
br i1 %1027, label %1028, label %1014
1028: ; preds = %1014
%1029 = sub nsw i32 0, %1010
%1030 = icmp eq i32 %983, %1029
br i1 %1030, label %1031, label %1004
1031: ; preds = %1028
%1032 = add nsw i32 %1026, %987
br label %1033
1033: ; preds = %1033, %1031
%1034 = phi i64 [ %1036, %1033 ], [ 0, %1031 ]
%1035 = phi i32 [ %1044, %1033 ], [ %1032, %1031 ]
%1036 = add nuw nsw i64 %1034, 1
%1037 = getelementptr inbounds double, double* %8, i64 %1036
%1038 = load double, double* %1037
%1039 = sext i32 %1035 to i64
%1040 = getelementptr inbounds double, double* %0, i64 %1039
store double %1038, double* %1040
%1041 = getelementptr inbounds double, double* %10, i64 %1036
%1042 = load double, double* %1041
%1043 = getelementptr inbounds double, double* %1, i64 %1039
store double %1042, double* %1043
%1044 = sub nsw i32 %1035, %15
%1045 = icmp eq i32 %1035, %1015
br i1 %1045, label %1046, label %1033
1046: ; preds = %1033
%1047 = icmp eq i32 %988, 0
br i1 %1047, label %1048, label %984
1048: ; preds = %1046
%1049 = icmp eq i32 %1010, -1
br i1 %1049, label %1050, label %979
1050: ; preds = %1048
%1051 = sub nsw i32 %1054, %883
%1052 = icmp sgt i32 %1051, -1
br i1 %1052, label %1053, label %1056
1053: ; preds = %969, %1050
%1054 = phi i32 [ %967, %969 ], [ %1051, %1050 ]
%1055 = add i32 %971, %1054
br label %973
1056: ; preds = %1050, %965, %872
ret void
}