void fftmx(a, b, ntot, n, nspan, isn, m, kt, at, ck, bt, sk, np, nfac) float *a,
    *b, *at, *ck, *bt, *sk;
int *np;
int ntot, n, nspan, isn, m;
int *kt;
int nfac[];
{
  int i, inc, j, jc, jf, jj, k, k1, k2, k3 = 0, 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 = 0, c3 = 0, c72, cd, dr, rad, sd, s1, s2 = 0, s3 = 0, s72, s120;
  double xx;
  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] *= ak;
      b[j] *= 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]) : (maxf));
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]) - ak;
      b[k2] = (b[kk]) - bk;
      a[kk] = (a[kk]) + ak;
      b[kk] = (b[kk]) + 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] = (c1 * ak) - (s1 * bk);
      b[k2] = (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] = ak + aj;
  b[kk] = bk + bj;
  ak += (-0.5 * aj);
  bk += (-0.5 * bj);
  aj = (a[k1] - a[k2]) * s120;
  bj = (b[k1] - b[k2]) * s120;
  a[k1] = ak - bj;
  b[k1] = bk + aj;
  a[k2] = ak + bj;
  b[k2] = 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] = 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] = 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] = (akp * c1) - (bkp * s1);
  b[k1] = (akp * s1) + (bkp * c1);
  a[k2] = (ajp * c2) - (bjp * s2);
  b[k2] = (ajp * s2) + (bjp * c2);
  a[k3] = (akm * c3) - (bkm * s3);
  b[k3] = (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] = akp;
  b[k1] = bkp;
  a[k2] = ajp;
  b[k2] = bjp;
  a[k3] = akm;
  b[k3] = 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] = aa + akp + ajp;
  b[kk] = 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] = ak - bj;
  a[k4] = ak + bj;
  b[k1] = bk + aj;
  b[k4] = 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] = ak - bj;
  a[k3] = ak + bj;
  b[k2] = bk + aj;
  b[k3] = 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] = (ck[k]) * c1 + (sk[k]) * s1;
    sk[j] = (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] = ak;
  b[kk] = 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] = ak - bj;
  b[k1] = bk + aj;
  a[k2] = ak + bj;
  b[k2] = 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] = (c2 * ak) - (s2 * b[kk]);
  b[kk] = (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] = ak;
    bk = b[kk];
    b[kk] = b[k2];
    b[k2] = 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] = ak;
        bk = b[kk];
        b[kk] = b[k2];
        b[k2] = 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    $0x180,%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,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%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    1311 <fftmx+0x1e1>
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     130c <fftmx+0x1dc>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    12a6 <fftmx+0x176>
jmp    1311 <fftmx+0x1e1>
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    13b2 <fftmx+0x282>
mov    0x48(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x68(%rbp),%eax
jle    13a0 <fftmx+0x270>
mov    0x48(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x15c(%rbp)
jmp    13a9 <fftmx+0x279>
mov    -0x68(%rbp),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    13b7 <fftmx+0x287>
cvtsi2sdl -0x30(%rbp),%xmm1
movsd  0x2c74(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x5c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x2c4f(%rip),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x2c22(%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     1461 <fftmx+0x331>
jmp    1b72 <fftmx+0xa42>
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    147d <fftmx+0x34d>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    147d <fftmx+0x34d>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    1478 <fftmx+0x348>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    159d <fftmx+0x46d>
jmp    3248 <fftmx+0x2118>
jmp    15a2 <fftmx+0x472>
movsd  0x2a76(%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    15f4 <fftmx+0x4c4>
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x160(%rbp)
jmp    15fd <fftmx+0x4cd>
mov    -0x54(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    16a6 <fftmx+0x576>
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    16ab <fftmx+0x57b>
jmp    16b0 <fftmx+0x580>
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
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
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jl     16b0 <fftmx+0x580>
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     16ab <fftmx+0x57b>
mov    -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     1850 <fftmx+0x720>
jmp    160b <fftmx+0x4db>
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1861 <fftmx+0x731>
jmp    189c <fftmx+0x76c>
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     1897 <fftmx+0x767>
jmp    15a2 <fftmx+0x472>
jmp    13b7 <fftmx+0x287>
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    191b <fftmx+0x7eb>
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x164(%rbp)
jmp    1927 <fftmx+0x7f7>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x164(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    16a6 <fftmx+0x576>
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
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0x2621(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  0x25f9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1b51 <fftmx+0xa21>
jmp    1935 <fftmx+0x805>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     1b6d <fftmx+0xa3d>
jmp    1935 <fftmx+0x805>
jmp    2ebc <fftmx+0x1d8c>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
je     1b89 <fftmx+0xa59>
jmp    28e2 <fftmx+0x17b2>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
movsd  0x247b(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1bd2 <fftmx+0xaa2>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x168(%rbp)
jmp    1bdb <fftmx+0xaab>
mov    -0x54(%rbp),%eax
mov    %eax,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1d66 <fftmx+0xc36>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
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  0x2345(%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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
cmpl   $0x0,-0x20(%rbp)
jge    1f32 <fftmx+0xe02>
jmp    21d6 <fftmx+0x10a6>
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    1fb2 <fftmx+0xe82>
jp     1fb2 <fftmx+0xe82>
jmp    2260 <fftmx+0x1130>
jmp    1fb7 <fftmx+0xe87>
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
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xb0(%rbp),%xmm0
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0x140(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     216c <fftmx+0x103c>
jmp    1d66 <fftmx+0xc36>
jmp    2171 <fftmx+0x1041>
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     2190 <fftmx+0x1060>
jmp    1be9 <fftmx+0xab9>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    21a1 <fftmx+0x1071>
jmp    2315 <fftmx+0x11e5>
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     21c0 <fftmx+0x1090>
jmp    1b9d <fftmx+0xa6d>
mov    -0x5c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    21d1 <fftmx+0x10a1>
jmp    3248 <fftmx+0x2118>
jmp    13b7 <fftmx+0x287>
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    2256 <fftmx+0x1126>
jp     2256 <fftmx+0x1126>
jmp    225b <fftmx+0x112b>
jmp    1fb7 <fftmx+0xe87>
jmp    2260 <fftmx+0x1130>
movsd  -0xb0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xe8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xe0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2310 <fftmx+0x11e0>
jmp    1d66 <fftmx+0xc36>
jmp    2171 <fftmx+0x1041>
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    2384 <fftmx+0x1254>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    2390 <fftmx+0x1260>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1c84 <fftmx+0xb54>
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  0x1c3b(%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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    28c1 <fftmx+0x1791>
jmp    2405 <fftmx+0x12d5>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     28dd <fftmx+0x17ad>
jmp    2405 <fftmx+0x12d5>
jmp    2ebc <fftmx+0x1d8c>
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    2911 <fftmx+0x17e1>
jmp    1935 <fftmx+0x805>
cmpl   $0x5,-0x3c(%rbp)
jne    2920 <fftmx+0x17f0>
jmp    239e <fftmx+0x126e>
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    2931 <fftmx+0x1801>
jmp    2ac8 <fftmx+0x1998>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  0x16ec(%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
movss  0x16b2(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2ac3 <fftmx+0x1993>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x130(%rbp),%xmm2
ff
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    29b2 <fftmx+0x1882>
jmp    2ac8 <fftmx+0x1998>
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
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jl     2b33 <fftmx+0x1a03>
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
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    2dc9 <fftmx+0x1c99>
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
jmp    2dce <fftmx+0x1c9e>
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     2cdf <fftmx+0x1baf>
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2e81 <fftmx+0x1d51>
jmp    2c8b <fftmx+0x1b5b>
mov    -0x60(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x70(%rbp),%eax
jg     2e9b <fftmx+0x1d6b>
jmp    2ac8 <fftmx+0x1998>
mov    -0x70(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     2eb7 <fftmx+0x1d87>
jmp    2ac8 <fftmx+0x1998>
jmp    2ebc <fftmx+0x1d8c>
mov    -0x24(%rbp),%eax
cmp    0x10(%rbp),%eax
jne    2ecd <fftmx+0x1d9d>
jmp    3248 <fftmx+0x2118>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movsd  0x1142(%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    2f18 <fftmx+0x1de8>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x170(%rbp)
jmp    2f21 <fftmx+0x1df1>
mov    -0x54(%rbp),%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    2fbe <fftmx+0x1e8e>
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
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     30bd <fftmx+0x1f8d>
jmp    2fe7 <fftmx+0x1eb7>
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     3163 <fftmx+0x2033>
jmp    2fe7 <fftmx+0x1eb7>
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     3182 <fftmx+0x2052>
jmp    2f2f <fftmx+0x1dff>
mov    -0x50(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    3193 <fftmx+0x2063>
jmp    31bf <fftmx+0x208f>
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     31ba <fftmx+0x208a>
jmp    2ed6 <fftmx+0x1da6>
jmp    13b7 <fftmx+0x287>
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    322e <fftmx+0x20fe>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x174(%rbp)
jmp    323a <fftmx+0x210a>
mov    -0x6c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x174(%rbp)
mov    -0x174(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    2fbe <fftmx+0x1e8e>
mov    -0x58(%rbp),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    3264 <fftmx+0x2134>
jmp    367f <fftmx+0x254f>
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    328b <fftmx+0x215b>
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    3318 <fftmx+0x21e8>
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    32a5 <fftmx+0x2175>
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     335f <fftmx+0x222f>
jmp    34c7 <fftmx+0x2397>
jmp    3364 <fftmx+0x2234>
jmp    3369 <fftmx+0x2239>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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     3369 <fftmx+0x2239>
jmp    3424 <fftmx+0x22f4>
jmp    3429 <fftmx+0x22f9>
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     3429 <fftmx+0x22f9>
movl   $0x1,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    3488 <fftmx+0x2358>
jmp    3364 <fftmx+0x2234>
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    34ab <fftmx+0x237b>
jmp    3477 <fftmx+0x2347>
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    34bc <fftmx+0x238c>
jmp    3424 <fftmx+0x22f4>
mov    -0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    367f <fftmx+0x254f>
jmp    34cc <fftmx+0x239c>
jmp    34d1 <fftmx+0x23a1>
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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     34da <fftmx+0x23aa>
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     34d1 <fftmx+0x23a1>
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     34cc <fftmx+0x239c>
jmp    35e1 <fftmx+0x24b1>
jmp    35e6 <fftmx+0x24b6>
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     35e6 <fftmx+0x24b6>
movl   $0x1,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    3645 <fftmx+0x2515>
jmp    34c7 <fftmx+0x2397>
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    3668 <fftmx+0x2538>
jmp    3634 <fftmx+0x2504>
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    3679 <fftmx+0x2549>
jmp    35e1 <fftmx+0x24b1>
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     3699 <fftmx+0x2569>
jmp    3ac2 <fftmx+0x2992>
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     370f <fftmx+0x25df>
jmp    36cb <fftmx+0x259b>
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    3794 <fftmx+0x2664>
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     3786 <fftmx+0x2656>
jmp    3745 <fftmx+0x2615>
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     37d9 <fftmx+0x26a9>
jmp    376c <fftmx+0x263c>
movl   $0x0,-0x2c(%rbp)
jmp    3820 <fftmx+0x26f0>
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     381a <fftmx+0x26ea>
jmp    37e5 <fftmx+0x26b5>
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    3845 <fftmx+0x2715>
jmp    3820 <fftmx+0x26f0>
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     3856 <fftmx+0x2726>
jmp    37e5 <fftmx+0x26b5>
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     3877 <fftmx+0x2747>
jmp    3820 <fftmx+0x26f0>
mov    -0x28(%rbp),%eax
imul   -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    3a8e <fftmx+0x295e>
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    38a6 <fftmx+0x2776>
jmp    3886 <fftmx+0x2756>
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    38c4 <fftmx+0x2794>
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
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     3956 <fftmx+0x2826>
jmp    38fd <fftmx+0x27cd>
jmp    395b <fftmx+0x282b>
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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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     39eb <fftmx+0x28bb>
jmp    3990 <fftmx+0x2860>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     3a02 <fftmx+0x28d2>
jmp    395b <fftmx+0x282b>
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
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     3a6b <fftmx+0x293b>
jmp    3a12 <fftmx+0x28e2>
cmpl   $0x0,-0x38(%rbp)
je     3a7a <fftmx+0x294a>
jmp    38ac <fftmx+0x277c>
cmpl   $0x1,-0x2c(%rbp)
je     3a89 <fftmx+0x2959>
jmp    3886 <fftmx+0x2756>
jmp    3a8e <fftmx+0x295e>
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     3abd <fftmx+0x298d>
jmp    3886 <fftmx+0x2756>
jmp    3ac2 <fftmx+0x2992>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fftmx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %r9d,%r10d
mov    %ecx,%r14d
mov    %edx,0xc(%rsp)
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    0x228(%rsp),%rdi
mov    0x1f8(%rsp),%r15
mov    %r9d,%r11d
neg    %r11d
cmovs  %r9d,%r11d
mov    %r11d,%r13d
imul   %edx,%r13d
mov    %r11d,%esi
mov    %r8,0xf8(%rsp)
imul   %r8d,%esi
test   %r9d,%r9d
js     121b <fftmx+0xfb>
movsd  0x1e9e(%rip),%xmm0
movsd  %xmm0,0x120(%rsp)
movsd  0x1e95(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movsd  0x1e8d(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
test   %r13d,%r13d
jle    124a <fftmx+0x12a>
cvtsi2sd %r14d,%xmm1
movsd  0x1e59(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %r11d,%eax
shl    $0x2,%rax
mov    $0x4,%ecx
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%rcx,1),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x0(%rbp,%rcx,1)
movss  (%rbx,%rcx,1),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rcx,1)
add    %rax,%rcx
add    %r11d,%edx
cmp    %edx,%r13d
jge    11e0 <fftmx+0xc0>
jmp    124a <fftmx+0x12a>
movsd  0x1ddd(%rip),%xmm0
movsd  %xmm0,0x120(%rsp)
movsd  0x1dd4(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movsd  0x1dcc(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %esi,%eax
cltd
idiv   %r14d
mov    %eax,%r9d
mov    (%r15),%eax
mov    0x1f0(%rsp),%ecx
sub    %eax,%ecx
movslq %ecx,%rcx
mov    (%rdi,%rcx,4),%ecx
test   %eax,%eax
mov    %r14d,0xd0(%rsp)
jle    1279 <fftmx+0x159>
mov    (%rdi,%rax,4),%eax
cmp    %ecx,%eax
cmovg  %eax,%ecx
mov    %ecx,0x4c(%rsp)
mov    0x210(%rsp),%r15
mov    %r13d,%eax
sub    %r11d,%eax
mov    %eax,0x44(%rsp)
mov    %r9d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %r9d,%xmm0
shl    $0x5,%eax
mov    %eax,0x58(%rsp)
mulsd  0x1d8f(%rip),%xmm0
movsd  %xmm0,0x178(%rsp)
lea    (%r11,%r11,1),%eax
mov    %eax,0x10c(%rsp)
lea    (%r9,%r9,1),%eax
mov    %eax,0xdc(%rsp)
movapd 0x130(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d5f(%rip),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x168(%rsp)
movsd  0x1d52(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x160(%rsp)
movapd 0x1d65(%rip),%xmm0
xorpd  %xmm1,%xmm0
movapd %xmm0,0x190(%rsp)
lea    0x1(%r9),%eax
mov    %rax,0xf0(%rsp)
mov    %r9d,%r8d
sub    %r13d,%r8d
movslq %r13d,%rax
mov    %rax,0x128(%rsp)
mov    %r13d,%eax
neg    %eax
mov    %rax,0xc8(%rsp)
mov    $0x1,%eax
sub    0xc(%rsp),%eax
imul   %r11d,%eax
lea    (%rax,%r9,2),%eax
mov    %eax,0x104(%rsp)
lea    -0x1(%r8),%eax
mov    %rax,0x148(%rsp)
xorpd  %xmm1,%xmm1
xorpd  %xmm12,%xmm12
xorpd  %xmm4,%xmm4
xorps  %xmm14,%xmm14
xor    %eax,%eax
mov    %rax,0x78(%rsp)
mov    %esi,%r12d
movl   $0x0,0x48(%rsp)
xor    %eax,%eax
mov    %esi,0x34(%rsp)
mov    %r11,0x38(%rsp)
mov    %r9,0x10(%rsp)
mov    %r10d,0xd4(%rsp)
mov    %r8,0xb8(%rsp)
movsd  %xmm12,0x158(%rsp)
movsd  %xmm14,0x150(%rsp)
movapd %xmm4,0x110(%rsp)
movsd  %xmm1,0x50(%rsp)
cltq
mov    %rax,0xc0(%rsp)
mov    %esi,%r14d
jmp    13e8 <fftmx+0x2c8>
nopl   0x0(%rax,%rax,1)
mov    0x210(%rsp),%r15
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0x178(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%rsp)
movapd %xmm1,%xmm0
mulsd  0x1c3e(%rip),%xmm0
mulsd  0x20(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0xa0(%rsp)
movsd  0x20(%rsp),%xmm0
mulsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm15
mov    0x228(%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    1760 <fftmx+0x640>
mov    %r14d,%eax
shr    $0x1f,%eax
add    %r14d,%eax
mov    %eax,%r14d
sar    %r14d
mov    $0x1,%eax
mov    0x38(%rsp),%r11
mov    0x10(%rsp),%r9
mov    0x44(%rsp),%edx
movapd 0x1bc7(%rip),%xmm6
nopl   0x0(%rax)
lea    (%rax,%r14,1),%ecx
movslq %ecx,%r15
movss  0x0(%rbp,%r15,4),%xmm0
movss  (%rbx,%r15,4),%xmm1
cltq
movss  0x0(%rbp,%rax,4),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,0x0(%rbp,%r15,4)
movss  (%rbx,%rax,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%r15,4)
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
addss  (%rbx,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    %r14d,%r15d
mov    %r15d,%eax
sub    %edx,%r15d
jle    14b0 <fftmx+0x390>
mov    %r15d,%eax
cmp    %r9d,%r15d
jle    14b0 <fftmx+0x390>
cmp    %r14d,%r15d
mov    0xc8(%rsp),%rdx
movapd 0xa0(%rsp),%xmm9
jg     26d7 <fftmx+0x15b7>
lea    0x2(%r14),%r12d
movsd  0x1ae2(%rip),%xmm0
subsd  %xmm9,%xmm0
movsd  %xmm0,0x18(%rsp)
movapd %xmm9,%xmm8
xorpd  %xmm6,%xmm8
movapd %xmm8,0xe0(%rsp)
jmp    158c <fftmx+0x46c>
nopw   0x0(%rax,%rax,1)
add    0x10c(%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     13e0 <fftmx+0x2c0>
mov    %r12d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
sar    %eax
mov    %eax,0x28(%rsp)
mov    0x58(%rsp),%esi
movsd  0x18(%rsp),%xmm7
movapd %xmm15,%xmm0
nopw   0x0(%rax,%rax,1)
mov    0x28(%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
movss  0x0(%rbp,%rcx,4),%xmm2
cltq
movss  0x0(%rbp,%rax,4),%xmm3
movaps %xmm2,%xmm4
subss  %xmm3,%xmm4
cvtss2sd %xmm4,%xmm4
movss  (%rbx,%rcx,4),%xmm5
subss  (%rbx,%rax,4),%xmm5
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  (%rbx,%rcx,4),%xmm2
addss  (%rbx,%rax,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
movss  %xmm2,(%rbx,%rcx,4)
movapd %xmm1,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm7,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm2,%xmm5
xorps  %xmm2,%xmm2
cvtsd2ss %xmm5,%xmm2
mulsd  %xmm7,%xmm3
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm2,0x0(%rbp,%rax,4)
movss  %xmm3,(%rbx,%rax,4)
add    %r14d,%eax
cmp    %r13d,%eax
jl     15e0 <fftmx+0x4c0>
add    %edx,%eax
xorpd  %xmm6,%xmm7
mov    %r12d,%r15d
sub    %eax,%r15d
cmp    %eax,%r15d
jg     15d0 <fftmx+0x4b0>
add    %r9d,%r15d
cmp    %esi,%r15d
jg     16d0 <fftmx+0x5b0>
movapd %xmm15,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm15,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm2,%xmm7
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
jmp    15c0 <fftmx+0x4a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %eax,%r15d
jge    1560 <fftmx+0x440>
lea    -0x1(%r15),%eax
cltd
idiv   %r9d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
mov    %esi,(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x90(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x90(%rsp),%xmm7
mov    (%rsp),%esi
movaps 0xe0(%rsp),%xmm8
movsd  0x80(%rsp),%xmm15
movaps 0xa0(%rsp),%xmm9
movaps 0x1929(%rip),%xmm6
mov    0xc8(%rsp),%rdx
mov    0x10(%rsp),%r9
add    0x58(%rsp),%esi
jmp    15b0 <fftmx+0x490>
nopl   (%rax)
cmp    $0x4,%r12d
mov    0x38(%rsp),%r11
mov    0xd4(%rsp),%r10d
movapd 0x18f7(%rip),%xmm7
movsd  0x158(%rsp),%xmm12
movsd  0x150(%rsp),%xmm14
je     22a0 <fftmx+0x1180>
mov    %r14d,%eax
cltd
idiv   %r12d
mov    %eax,%r10d
cmp    $0x3,%r12d
mov    0xb8(%rsp),%rdi
movapd 0xa0(%rsp),%xmm9
mov    %r10,0x18(%rsp)
je     1aab <fftmx+0x98b>
cmp    $0x5,%r12d
jne    1bc4 <fftmx+0xaa4>
mov    $0x1,%edi
mov    0x10(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdi,%r10,1),%eax
lea    (%rax,%r10,1),%ecx
lea    (%rcx,%r10,1),%r8d
lea    (%r8,%r10,1),%edx
movslq %eax,%rsi
movss  0x0(%rbp,%rsi,4),%xmm0
movslq %edx,%rax
movss  0x0(%rbp,%rax,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
xorps  %xmm12,%xmm12
cvtss2sd %xmm2,%xmm12
subss  %xmm1,%xmm0
xorps  %xmm11,%xmm11
cvtss2sd %xmm0,%xmm11
movss  (%rbx,%rsi,4),%xmm3
movss  (%rbx,%rax,4),%xmm4
movaps %xmm3,%xmm1
addss  %xmm4,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
subss  %xmm4,%xmm3
xorps  %xmm14,%xmm14
cvtss2sd %xmm3,%xmm14
movslq %ecx,%rcx
movss  0x0(%rbp,%rcx,4),%xmm4
movslq %r8d,%rdx
movss  0x0(%rbp,%rdx,4),%xmm5
movaps %xmm4,%xmm6
addss  %xmm5,%xmm6
xorps  %xmm15,%xmm15
cvtss2sd %xmm6,%xmm15
subss  %xmm5,%xmm4
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movsd  %xmm3,(%rsp)
movss  (%rbx,%rcx,4),%xmm4
movss  (%rbx,%rdx,4),%xmm5
movaps %xmm4,%xmm7
addss  %xmm5,%xmm7
xorps  %xmm9,%xmm9
cvtss2sd %xmm7,%xmm9
subss  %xmm5,%xmm4
xorps  %xmm10,%xmm10
cvtss2sd %xmm4,%xmm10
movslq %edi,%rdi
movss  0x0(%rbp,%rdi,4),%xmm4
cvtss2sd %xmm4,%xmm13
movss  (%rbx,%rdi,4),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
movsd  %xmm0,0x60(%rsp)
movaps %xmm12,%xmm5
addsd  %xmm13,%xmm5
addsd  %xmm15,%xmm5
cvtsd2ss %xmm5,%xmm5
movaps %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm5,0x0(%rbp,%rdi,4)
movss  %xmm1,(%rbx,%rdi,4)
movsd  0x168(%rsp),%xmm8
movapd %xmm8,%xmm1
mulsd  %xmm15,%xmm1
movaps %xmm12,%xmm5
movsd  0x174e(%rip),%xmm4
mulsd  %xmm4,%xmm5
addsd  %xmm1,%xmm5
addsd  %xmm13,%xmm5
movapd %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movaps %xmm2,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  0x160(%rsp),%xmm7
movapd %xmm7,%xmm1
mulsd  %xmm3,%xmm1
movaps %xmm11,%xmm4
movapd 0x130(%rsp),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm7,%xmm1
mulsd  %xmm10,%xmm1
movaps %xmm14,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm5,%xmm1
subsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x0(%rbp,%rsi,4)
addsd  %xmm5,%xmm3
movsd  0x60(%rsp),%xmm5
addsd  %xmm5,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
movapd %xmm4,%xmm1
addsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
subsd  %xmm4,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rax,4)
movsd  0x169e(%rip),%xmm0
mulsd  %xmm0,%xmm15
mulsd  %xmm8,%xmm12
addsd  %xmm15,%xmm12
addsd  %xmm13,%xmm12
mulsd  %xmm0,%xmm9
mulsd  %xmm8,%xmm2
addsd  %xmm9,%xmm2
addsd  %xmm5,%xmm2
movapd 0x190(%rsp),%xmm0
movsd  (%rsp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm11
addsd  %xmm1,%xmm11
mulsd  %xmm0,%xmm10
mulsd  %xmm7,%xmm14
addsd  %xmm10,%xmm14
movapd %xmm12,%xmm0
subsd  %xmm14,%xmm0
addsd  %xmm12,%xmm14
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm14,%xmm1
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  %xmm1,0x0(%rbp,%rdx,4)
movapd %xmm11,%xmm0
addsd  %xmm2,%xmm0
subsd  %xmm11,%xmm2
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm0,(%rbx,%rcx,4)
movss  %xmm1,(%rbx,%rdx,4)
add    %r10d,%eax
mov    %eax,%edi
sub    0x44(%rsp),%eax
jl     17e0 <fftmx+0x6c0>
mov    %eax,%edi
cmp    %r10d,%eax
jle    17e0 <fftmx+0x6c0>
mov    %r8,0x78(%rsp)
mov    0x38(%rsp),%r11
mov    0xb8(%rsp),%rdi
mov    0xc8(%rsp),%rcx
movapd 0x15de(%rip),%xmm7
movapd 0xa0(%rsp),%xmm9
movsd  0x80(%rsp),%xmm15
jmp    1f85 <fftmx+0xe65>
mov    $0x1,%eax
lea    (%rax,%r10,1),%edx
movslq %eax,%rsi
movss  0x0(%rbp,%rsi,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
movss  (%rbx,%rsi,4),%xmm4
xorps  %xmm8,%xmm8
cvtss2sd %xmm4,%xmm8
movslq %edx,%rcx
add    %r10d,%edx
movss  0x0(%rbp,%rcx,4),%xmm6
movslq %edx,%rax
addss  0x0(%rbp,%rax,4),%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
movss  (%rbx,%rcx,4),%xmm5
addss  (%rbx,%rax,4),%xmm5
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
addss  %xmm2,%xmm6
movss  %xmm6,0x0(%rbp,%rsi,4)
addss  %xmm4,%xmm5
movss  %xmm5,(%rbx,%rsi,4)
movsd  0x1546(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm8,%xmm0
movss  0x0(%rbp,%rcx,4),%xmm2
subss  0x0(%rbp,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%rbx,%rcx,4),%xmm3
subss  (%rbx,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
movsd  0x120(%rsp),%xmm5
mulsd  %xmm5,%xmm3
movapd %xmm1,%xmm4
subsd  %xmm3,%xmm4
cvtsd2ss %xmm4,%xmm4
mulsd  %xmm5,%xmm2
movapd %xmm0,%xmm5
addsd  %xmm2,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm4,0x0(%rbp,%rcx,4)
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm5,(%rbx,%rcx,4)
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm1,0x0(%rbp,%rax,4)
movss  %xmm0,(%rbx,%rax,4)
add    %r10d,%eax
mov    %eax,%ecx
sub    0x44(%rsp),%ecx
jl     1ab0 <fftmx+0x990>
mov    %ecx,%eax
cmp    %r10d,%ecx
jle    1ab0 <fftmx+0x990>
mov    0x38(%rsp),%r11
mov    0x10(%rsp),%r9
jmp    1f7d <fftmx+0xe5d>
mov    0x48(%rsp),%eax
cmp    %eax,%r12d
jne    1bdc <fftmx+0xabc>
cltq
mov    %rax,0x90(%rsp)
jmp    1d37 <fftmx+0xc17>
xorps  %xmm1,%xmm1
cvtsi2sd %r12d,%xmm1
mulsd  0x147c(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x60(%rsp)
movsd  (%rsp),%xmm0
call   1030 <sin@plt>
mov    0x208(%rsp),%rdi
movl   $0x3f800000,(%rdi,%r12,4)
3f
mov    0x218(%rsp),%rsi
movl   $0x0,(%rsi,%r12,4)
cmp    $0x2,%r12d
mov    %r12,0x90(%rsp)
jl     1d0e <fftmx+0xbee>
movapd 0x60(%rsp),%xmm5
movapd %xmm5,%xmm1
movapd 0x141c(%rip),%xmm7
xorpd  %xmm7,%xmm1
xorpd  %xmm2,%xmm2
mov    $0x2,%eax
mov    %r12,%rcx
movapd 0x1414(%rip),%xmm4
movsd  0x80(%rsp),%xmm15
mov    0x18(%rsp),%r10
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm2,-0x4(%rdi,%rax,4)
movss  (%rdi,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%rsi,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,-0x4(%rsi,%rax,4)
movss  -0x4(%rdi,%rax,4),%xmm2
movss  %xmm2,-0x4(%rdi,%rcx,4)
movss  -0x4(%rsi,%rax,4),%xmm2
xorpd  %xmm4,%xmm2
movss  %xmm2,-0x4(%rsi,%rcx,4)
add    $0xffffffffffffffff,%rcx
lea    0x1(%rax),%rdx
cmp    %rcx,%rax
mov    %rdx,%rax
jl     1c80 <fftmx+0xb60>
mov    %r12d,%eax
mov    %r12d,0x48(%rsp)
movapd 0xa0(%rsp),%xmm9
jmp    1d37 <fftmx+0xc17>
mov    %r12d,%eax
mov    %r12d,0x48(%rsp)
movapd 0x1352(%rip),%xmm7
movapd 0xa0(%rsp),%xmm9
movsd  0x80(%rsp),%xmm15
mov    0x18(%rsp),%r10
movslq %r10d,%r8
mov    %r14d,%eax
sub    %r10d,%eax
mov    %rax,0xe0(%rsp)
mov    $0x1,%r9d
mov    %r8,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r9d,%r11
add    %r14d,%r9d
movss  (%rbx,%r11,4),%xmm0
movss  0x0(%rbp,%r11,4),%xmm1
unpcklps %xmm0,%xmm1
cvtps2pd %xmm1,%xmm0
lea    (%r11,%r10,1),%eax
movslq %eax,%rcx
mov    0xe0(%rsp),%rax
add    %r11d,%eax
mov    $0x3,%edx
movapd %xmm0,%xmm1
mov    0x200(%rsp),%rsi
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm2
movslq %eax,%rdi
addss  0x0(%rbp,%rdi,4),%xmm2
movss  %xmm2,-0x4(%rsi,%rdx,4)
movss  (%rbx,%rcx,4),%xmm3
addss  (%rbx,%rdi,4),%xmm3
movss  %xmm3,-0x4(%r15,%rdx,4)
unpcklps %xmm3,%xmm2
cvtps2pd %xmm2,%xmm2
addpd  %xmm2,%xmm1
movss  0x0(%rbp,%rcx,4),%xmm2
subss  0x0(%rbp,%rdi,4),%xmm2
movss  %xmm2,(%rsi,%rdx,4)
movss  (%rbx,%rcx,4),%xmm2
subss  (%rbx,%rdi,4),%xmm2
movss  %xmm2,(%r15,%rdx,4)
add    %r8,%rcx
add    $0x2,%rdx
mov    %edi,%eax
sub    %r10d,%eax
cmp    %rdi,%rcx
jl     1da0 <fftmx+0xc80>
xorps  %xmm2,%xmm2
cvtsd2ss %xmm1,%xmm2
movss  %xmm2,0x0(%rbp,%r11,4)
movhlps %xmm1,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%r11,4)
mov    $0x1,%edi
mov    %r9d,0x28(%rsp)
mov    %r9d,%r12d
nopw   0x0(%rax,%rax,1)
add    %r8,%r11
mov    %r11,(%rsp)
xorps  %xmm1,%xmm1
mov    $0x1,%eax
xorps  %xmm2,%xmm2
mov    %edi,%ecx
movapd %xmm0,%xmm3
mov    0x200(%rsp),%rdx
mov    0x218(%rsp),%r8
mov    0x208(%rsp),%r9
mov    0x48(%rsp),%r10d
mov    0x90(%rsp),%r11
nopl   (%rax)
movslq %ecx,%rcx
movss  (%r9,%rcx,4),%xmm4
shufps $0x0,%xmm4,%xmm4
movss  0x4(%r15,%rax,4),%xmm5
movss  0x4(%rdx,%rax,4),%xmm6
unpcklps %xmm5,%xmm6
mulps  %xmm4,%xmm6
cvtps2pd %xmm6,%xmm4
addpd  %xmm4,%xmm3
movss  (%r8,%rcx,4),%xmm4
movss  0x8(%rdx,%rax,4),%xmm5
mulss  %xmm4,%xmm5
mulss  0x8(%r15,%rax,4),%xmm4
lea    0x2(%rax),%rsi
cvtss2sd %xmm5,%xmm5
addsd  %xmm5,%xmm1
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm2
add    %edi,%ecx
cmp    %r10d,%ecx
mov    $0x0,%eax
cmovg  %r10d,%eax
sub    %eax,%ecx
mov    %rsi,%rax
cmp    %r11,%rsi
jl     1e70 <fftmx+0xd50>
sub    0x18(%rsp),%r12d
sub    %edi,%r10d
movapd %xmm3,%xmm4
subsd  %xmm2,%xmm4
cvtsd2ss %xmm4,%xmm4
mov    (%rsp),%r11
movss  %xmm4,0x0(%rbp,%r11,4)
movapd %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
movapd %xmm4,%xmm5
addsd  %xmm1,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm5,(%rbx,%r11,4)
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movslq %r12d,%rcx
subsd  %xmm1,%xmm4
xorps  %xmm1,%xmm1
cvtsd2ss %xmm4,%xmm1
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%edi
cmp    %r10d,%edi
mov    0x60(%rsp),%r8
jl     1e30 <fftmx+0xd10>
mov    0x28(%rsp),%r9d
mov    %r9d,%eax
sub    0x44(%rsp),%eax
mov    0x18(%rsp),%r10
jle    1d60 <fftmx+0xc40>
mov    %eax,%r9d
cmp    %r10d,%eax
jle    1d60 <fftmx+0xc40>
mov    0x38(%rsp),%r11
mov    0x10(%rsp),%r9
mov    0xb8(%rsp),%rdi
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rax
cmp    0x1f0(%rsp),%eax
je     26d7 <fftmx+0x15b7>
movsd  0x1076(%rip),%xmm0
subsd  %xmm9,%xmm0
mov    0x58(%rsp),%eax
cmp    %eax,%r10d
mov    %eax,%edx
cmovl  %r10d,%edx
mov    %r9d,%eax
sub    %r14d,%eax
mov    %eax,0x110(%rsp)
mov    %r10d,%r12d
sub    %r13d,%r12d
movapd %xmm9,%xmm10
xorpd  %xmm7,%xmm10
movslq %r14d,%rax
mov    %rax,(%rsp)
lea    (%rdi,%r10,1),%eax
sub    %r14d,%eax
mov    %eax,0x60(%rsp)
mov    0x104(%rsp),%eax
sub    %r14d,%eax
mov    %eax,0x90(%rsp)
mov    0x148(%rsp),%rax
add    %r10d,%eax
sub    %r14d,%eax
mov    %eax,0x28(%rsp)
lea    (%rcx,%r10,1),%eax
mov    %eax,0xe0(%rsp)
mov    0xf0(%rsp),%rax
mov    %eax,%ecx
mov    %edx,0x108(%rsp)
mov    %edx,0x50(%rsp)
movsd  %xmm0,0x170(%rsp)
movapd %xmm0,%xmm11
movapd %xmm15,%xmm0
mov    0x128(%rsp),%r10
mov    %r12d,0xd8(%rsp)
movapd %xmm10,0x1a0(%rsp)
jmp    2097 <fftmx+0xf77>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm15,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movapd %xmm15,%xmm3
mulsd  %xmm11,%xmm3
subsd  %xmm2,%xmm11
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    0x18(%rsp),%ecx
movapd %xmm0,%xmm8
xorpd  %xmm7,%xmm8
movapd %xmm11,%xmm1
movapd %xmm0,%xmm2
xchg   %ax,%ax
mov    %ecx,%r8d
movapd %xmm2,%xmm3
xorpd  %xmm7,%xmm3
movslq %ecx,%rcx
xor    %edi,%edi
mov    0xe0(%rsp),%eax
mov    %eax,%esi
mov    0x28(%rsp),%eax
mov    0x90(%rsp),%edx
mov    0x60(%rsp),%r15d
mov    (%rsp),%r11
nopl   (%rax)
movss  0x0(%rbp,%rcx,4),%xmm4
cvtss2sd %xmm4,%xmm4
movss  (%rbx,%rcx,4),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
movss  %xmm5,0x0(%rbp,%rcx,4)
movss  (%rbx,%rcx,4),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm1,%xmm5
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rbx,%rcx,4)
add    %r11,%rcx
add    %r14d,%r15d
add    %r14d,%edx
add    %r14d,%eax
add    %r14d,%esi
add    %r14d,%edi
cmp    %r10,%rcx
jle    20e0 <fftmx+0xfc0>
add    %r8d,%edi
add    %r12d,%edi
movapd %xmm11,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm8,%xmm2
mulsd  %xmm11,%xmm1
addsd  %xmm2,%xmm1
lea    (%r8,%rsi,1),%ecx
movapd %xmm4,%xmm2
cmp    %r14d,%edi
jle    20b0 <fftmx+0xf90>
add    %r8d,%esi
mov    %esi,%ecx
add    0x110(%rsp),%ecx
cmp    0x50(%rsp),%ecx
jle    2060 <fftmx+0xf40>
mov    0x18(%rsp),%r12
cmp    %r12d,%ecx
jge    2245 <fftmx+0x1125>
add    %r8d,%r15d
add    %r8d,%eax
cltd
idiv   %r9d
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x20(%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),%xmm11
movapd 0x1a0(%rsp),%xmm10
movsd  0x80(%rsp),%xmm15
movapd 0xa0(%rsp),%xmm9
movapd 0xe5b(%rip),%xmm7
mov    0x128(%rsp),%r10
mov    0x10(%rsp),%r9
mov    0x50(%rsp),%eax
add    0x58(%rsp),%eax
cmp    %eax,%r12d
cmovl  %r12d,%eax
mov    %eax,0x50(%rsp)
mov    %r15d,%ecx
mov    0xd8(%rsp),%r12d
jmp    2097 <fftmx+0xf77>
add    %edx,%r8d
mov    %r8d,%ecx
mov    0x108(%rsp),%eax
mov    %eax,0x50(%rsp)
movsd  0x170(%rsp),%xmm11
movapd %xmm15,%xmm0
cmp    0xdc(%rsp),%r8d
mov    0xd8(%rsp),%r12d
jle    2097 <fftmx+0xf77>
mov    0x210(%rsp),%r15
mov    0xc0(%rsp),%rax
mov    0x18(%rsp),%rsi
jmp    13bd <fftmx+0x29d>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x3(%r14),%esi
test   %r14d,%r14d
cmovns %r14d,%esi
sar    $0x2,%esi
mov    %r11d,%eax
sub    %esi,%eax
mov    %eax,(%rsp)
mov    0x58(%rsp),%r12d
cmp    %r12d,%esi
cmovl  %esi,%r12d
movapd 0xa0(%rsp),%xmm0
xorpd  %xmm7,%xmm0
movapd %xmm0,0x90(%rsp)
xorpd  %xmm0,%xmm0
mov    $0x1,%r14d
mov    %r12d,0x60(%rsp)
movsd  0xd28(%rip),%xmm13
mov    0x10(%rsp),%r9
mov    0xb8(%rsp),%r8
xorpd  %xmm11,%xmm11
mov    %rsi,0x18(%rsp)
jmp    240c <fftmx+0x12ec>
nopl   0x0(%rax)
ucomisd %xmm11,%xmm0
movapd %xmm1,%xmm5
addsd  %xmm6,%xmm5
subsd  %xmm6,%xmm1
movapd %xmm3,%xmm6
subsd  %xmm8,%xmm6
addsd  %xmm8,%xmm3
jne    2337 <fftmx+0x1217>
jnp    2503 <fftmx+0x13e3>
movapd %xmm0,%xmm2
mulsd  %xmm6,%xmm2
movapd %xmm5,%xmm4
movapd %xmm13,%xmm7
mulsd  %xmm13,%xmm4
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulsd  %xmm13,%xmm6
mulsd  %xmm0,%xmm5
addsd  %xmm6,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  %xmm4,(%rbx,%rcx,4)
movapd 0x110(%rsp),%xmm6
movapd %xmm6,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm10,%xmm4
movsd  0x50(%rsp),%xmm5
mulsd  %xmm5,%xmm4
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulsd  %xmm5,%xmm9
mulsd  %xmm6,%xmm10
addsd  %xmm9,%xmm10
xorps  %xmm4,%xmm4
cvtsd2ss %xmm10,%xmm4
movss  %xmm2,0x0(%rbp,%rax,4)
movss  %xmm4,(%rbx,%rax,4)
movaps %xmm14,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm1,%xmm4
mulsd  %xmm12,%xmm4
subsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
mulsd  %xmm12,%xmm3
mulsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm2,0x0(%rbp,%r14,4)
movss  %xmm1,(%rbx,%r14,4)
add    %esi,%r14d
cmp    %r13d,%r14d
jg     2554 <fftmx+0x1434>
lea    (%r14,%rsi,1),%ecx
lea    (%rcx,%rsi,1),%eax
lea    (%rax,%rsi,1),%edi
movslq %r14d,%rdx
movss  0x0(%rbp,%rdx,4),%xmm1
cltq
movss  0x0(%rbp,%rax,4),%xmm3
movaps %xmm1,%xmm4
addss  %xmm3,%xmm4
xorps  %xmm10,%xmm10
cvtss2sd %xmm4,%xmm10
subss  %xmm3,%xmm1
cvtss2sd %xmm1,%xmm1
movslq %ecx,%rcx
movss  0x0(%rbp,%rcx,4),%xmm3
mov    %rdi,0x78(%rsp)
movslq %edi,%r14
movss  0x0(%rbp,%r14,4),%xmm5
movaps %xmm3,%xmm6
addss  %xmm5,%xmm6
xorps  %xmm7,%xmm7
cvtss2sd %xmm6,%xmm7
subsd  %xmm7,%xmm10
subss  %xmm5,%xmm3
cvtss2sd %xmm3,%xmm8
addss  %xmm4,%xmm6
movss  %xmm6,0x0(%rbp,%rdx,4)
movss  (%rbx,%rdx,4),%xmm3
movss  (%rbx,%rax,4),%xmm5
movaps %xmm3,%xmm7
addss  %xmm5,%xmm7
xorps  %xmm9,%xmm9
cvtss2sd %xmm7,%xmm9
subss  %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%rbx,%rcx,4),%xmm4
movss  (%rbx,%r14,4),%xmm6
movaps %xmm4,%xmm5
addss  %xmm6,%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
subsd  %xmm2,%xmm9
subss  %xmm6,%xmm4
xorps  %xmm6,%xmm6
cvtss2sd %xmm4,%xmm6
addss  %xmm7,%xmm5
movss  %xmm5,(%rbx,%rdx,4)
test   %r10d,%r10d
js     2310 <fftmx+0x11f0>
ucomisd %xmm11,%xmm0
movaps %xmm1,%xmm5
subsd  %xmm6,%xmm5
addsd  %xmm6,%xmm1
movaps %xmm8,%xmm6
addsd  %xmm3,%xmm6
subsd  %xmm8,%xmm3
jne    2337 <fftmx+0x1217>
jp     2337 <fftmx+0x1217>
xorps  %xmm2,%xmm2
cvtsd2ss %xmm5,%xmm2
xorps  %xmm4,%xmm4
cvtsd2ss %xmm6,%xmm4
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  %xmm4,(%rbx,%rcx,4)
xorps  %xmm2,%xmm2
cvtsd2ss %xmm10,%xmm2
movss  %xmm2,0x0(%rbp,%rax,4)
xorps  %xmm2,%xmm2
cvtsd2ss %xmm9,%xmm2
movss  %xmm2,(%rbx,%rax,4)
cvtsd2ss %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  %xmm1,0x0(%rbp,%r14,4)
movss  %xmm2,(%rbx,%r14,4)
jmp    2400 <fftmx+0x12e0>
add    %r8d,%r14d
cmp    %r12d,%r14d
jle    2585 <fftmx+0x1465>
cmp    %esi,%r14d
jl     25c6 <fftmx+0x14a6>
add    (%rsp),%r14d
xorpd  %xmm0,%xmm0
mov    0x60(%rsp),%r12d
movsd  0xaa1(%rip),%xmm13
cmp    %r9d,%r14d
jle    240c <fftmx+0x12ec>
jmp    26b0 <fftmx+0x1590>
movapd %xmm15,%xmm1
mulsd  %xmm0,%xmm1
movapd 0xa0(%rsp),%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm1
mulsd  0x90(%rsp),%xmm1
movapd %xmm15,%xmm3
mulsd  %xmm13,%xmm3
subsd  %xmm2,%xmm13
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
jmp    2644 <fftmx+0x1524>
lea    -0x1(%r14),%eax
cltd
idiv   %r9d
cvtsi2sd %eax,%xmm0
mulsd  0x88(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0xe0(%rsp)
movsd  0x28(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0xe0(%rsp),%xmm13
mov    0x18(%rsp),%rsi
movsd  0x80(%rsp),%xmm15
xorpd  %xmm11,%xmm11
mov    0xb8(%rsp),%r8
mov    0xd4(%rsp),%r10d
mov    0x10(%rsp),%r9
mov    0x38(%rsp),%r11
add    0x58(%rsp),%r12d
cmp    %r12d,%esi
cmovl  %esi,%r12d
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm13,%xmm14
mulsd  %xmm13,%xmm14
subsd  %xmm1,%xmm14
movapd %xmm13,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm14,%xmm12
mulsd  %xmm13,%xmm12
subsd  %xmm1,%xmm12
movapd %xmm13,%xmm1
movapd %xmm2,0x110(%rsp)
mulsd  %xmm2,%xmm1
movsd  %xmm14,0x50(%rsp)
mulsd  %xmm0,%xmm14
addsd  %xmm1,%xmm14
jmp    240c <fftmx+0x12ec>
nopw   0x0(%rax,%rax,1)
cmp    %r9d,%esi
mov    0xc0(%rsp),%rax
mov    0x34(%rsp),%r12d
movsd  0x50(%rsp),%xmm1
movapd 0x110(%rsp),%xmm4
jne    13a9 <fftmx+0x289>
jmp    26dc <fftmx+0x15bc>
mov    0x34(%rsp),%r12d
mov    0x220(%rsp),%rdx
mov    %r12d,0x4(%rdx)
mov    0x1f8(%rsp),%r15
mov    (%r15),%ecx
test   %ecx,%ecx
je     27a5 <fftmx+0x1685>
mov    %ecx,%eax
add    %ecx,%eax
add    %ecx,%ecx
add    $0x1,%ecx
cmp    0x1f0(%rsp),%ecx
cmovle %ecx,%eax
movslq %eax,%rcx
mov    %r9d,0x4(%rdx,%rcx,4)
cmp    $0x2,%ecx
jl     27b5 <fftmx+0x1695>
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    0x220(%rsp),%r9
mov    0x228(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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     2760 <fftmx+0x1640>
sar    $0x20,%rcx
mov    0xc(%rsp),%eax
mov    0x38(%rsp),%r11
mov    0x10(%rsp),%r9
jmp    27bd <fftmx+0x169d>
mov    %rdx,%rsi
mov    0x228(%rsp),%r14
jmp    2a25 <fftmx+0x1905>
add    $0x1,%rcx
mov    0xc(%rsp),%eax
mov    0xd0(%rsp),%edi
mov    0x220(%rsp),%rdx
mov    (%rdx,%rcx,4),%ecx
mov    %rcx,0x78(%rsp)
mov    0x8(%rdx),%r15d
lea    0x1(%r15),%ecx
cmp    %eax,%edi
jne    28c4 <fftmx+0x17a4>
movslq %r15d,%r10
mov    %r11d,%r11d
movslq %r12d,%r14
mov    0x4(%rdx),%eax
mov    %eax,(%rsp)
lea    0xc(%rdx),%r9
jmp    2808 <fftmx+0x16e8>
nopl   0x0(%rax)
mov    %rdx,0xf0(%rsp)
mov    0xf0(%rsp),%r8
movslq %r8d,%r8
movslq %ecx,%rcx
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%rbp,%r8,4),%xmm0
movss  0x0(%rbp,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%r8,4)
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  (%rbx,%r8,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%r8,4)
movss  %xmm0,(%rbx,%rcx,4)
add    %r11,%r8
add    %r10,%rcx
cmp    %r14,%rcx
jl     2820 <fftmx+0x1700>
mov    %r9,%rax
mov    %r15d,%edx
mov    (%rsp),%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    %esi,%ecx
mov    %edx,%edi
mov    (%rax),%edx
add    %edx,%ecx
add    $0x4,%rax
mov    %edi,%esi
cmp    %edi,%ecx
jg     2870 <fftmx+0x1750>
mov    0x38(%rsp),%rax
mov    0x220(%rsp),%rsi
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %ecx,%edx
jl     2800 <fftmx+0x16e0>
add    %eax,%edx
add    %r15d,%ecx
cmp    %r12d,%ecx
jl     28a0 <fftmx+0x1780>
mov    %rdx,%r8
cmp    %r12d,%edx
jl     285b <fftmx+0x173b>
mov    0x78(%rsp),%r9
jmp    2a15 <fftmx+0x18f5>
mov    %r11d,%r14d
mov    0x4(%rdx),%esi
mov    %esi,0x90(%rsp)
mov    %r12d,%esi
sub    %r9d,%esi
mov    %rsi,(%rsp)
mov    0xf8(%rsp),%rdi
sub    %eax,%edi
imul   %r11d,%edi
mov    %rdi,0xf8(%rsp)
lea    (%r15,%rdi,1),%eax
sub    %r9d,%eax
mov    %eax,0x60(%rsp)
lea    0xc(%rdx),%rax
mov    %rax,0x28(%rsp)
mov    0xf0(%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,4),%rsi
lea    (%rbx,%rdi,4),%r8
lea    0x0(,%rcx,4),%r9
add    %rbp,%r9
lea    (%rbx,%rcx,4),%r10
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  (%r9,%rdi,4),%xmm0
movss  (%rsi,%rdi,4),%xmm1
movss  %xmm1,(%r9,%rdi,4)
movss  %xmm0,(%rsi,%rdi,4)
movss  (%r10,%rdi,4),%xmm0
movss  (%r8,%rdi,4),%xmm1
movss  %xmm1,(%r10,%rdi,4)
movss  %xmm0,(%r8,%rdi,4)
add    %r14,%rdi
lea    (%rcx,%rdi,1),%r11
cmp    %rax,%r11
jl     2940 <fftmx+0x1820>
mov    (%rsp),%rcx
lea    (%rcx,%r12,1),%eax
add    %edi,%eax
add    %edx,%ecx
add    %edi,%ecx
cmp    %r13d,%eax
mov    0x10(%rsp),%r9
jl     2910 <fftmx+0x17f0>
add    0x60(%rsp),%edx
mov    %edx,%ecx
add    %edi,%ecx
add    0xf8(%rsp),%r12d
mov    %r12d,%eax
add    %edi,%eax
cmp    0x34(%rsp),%ecx
jl     2910 <fftmx+0x17f0>
mov    0x34(%rsp),%r8d
mov    %rax,%r10
mov    0x28(%rsp),%rax
mov    %r15d,%esi
mov    0x90(%rsp),%edi
nopl   0x0(%rax)
sub    %edi,%ecx
mov    %esi,%edx
mov    (%rax),%esi
add    %esi,%ecx
add    $0x4,%rax
mov    %edx,%edi
cmp    %edx,%ecx
jg     29d0 <fftmx+0x18b0>
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %ecx,%eax
jl     2910 <fftmx+0x17f0>
add    %r9d,%eax
add    %r15d,%ecx
cmp    %r8d,%ecx
jl     29f0 <fftmx+0x18d0>
cmp    %r8d,%eax
jl     29ba <fftmx+0x189a>
mov    0x78(%rsp),%r9
mov    0x220(%rsp),%rsi
mov    0x228(%rsp),%r14
mov    0x1f8(%rsp),%r15
movslq (%r15),%rax
lea    (%rax,%rax,1),%ecx
add    $0x1,%ecx
mov    0x1f0(%rsp),%edi
cmp    %edi,%ecx
jge    2dd9 <fftmx+0x1cb9>
mov    %r9,0x10(%rsp)
mov    0x4(%rsi,%rax,4),%ecx
mov    %ecx,0x20(%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    2a60 <fftmx+0x1940>
lea    0x1(%rdx),%rcx
mov    %ecx,(%r15)
movslq 0x4(%r14,%rdx,4),%rdi
lea    -0x1(%rdi),%r8
cmp    $0x2,%rdi
jl     2ae3 <fftmx+0x19c3>
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    2ab0 <fftmx+0x1990>
mov    0x220(%rsp),%rsi
mov    %edx,(%rsi,%r11,4)
add    $0x1,%r11
cmp    %r9,%r11
je     2ae3 <fftmx+0x19c3>
mov    (%r15),%ecx
movslq %ecx,%rax
mov    (%r14,%rax,4),%edi
jmp    2aa0 <fftmx+0x1980>
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    2b17 <fftmx+0x19f7>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%esi
add    $0x1,%rdi
mov    (%r15,%rdi,4),%eax
test   %eax,%eax
js     2b10 <fftmx+0x19f0>
lea    (%r14,%rdi,1),%rcx
lea    (%r11,%rdi,1),%edx
cmp    %eax,%edx
jne    2b40 <fftmx+0x1a20>
mov    %esi,(%r15,%rdi,4)
test   %rcx,%rcx
jne    2b10 <fftmx+0x19f0>
jmp    2b8c <fftmx+0x1a6c>
cs nopw 0x0(%rax,%rax,1)
lea    (%r10,%rdi,1),%rcx
add    $0x1,%rcx
add    %rdi,%r11
mov    0x220(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rdx
mov    (%rsi,%rdx,4),%eax
mov    %eax,%esi
neg    %esi
mov    0x220(%rsp),%rdi
mov    %esi,(%rdi,%rdx,4)
mov    0x220(%rsp),%rsi
cmp    %eax,%r11d
jne    2b60 <fftmx+0x1a40>
mov    %r11,0x78(%rsp)
jmp    2aec <fftmx+0x19cc>
sub    0x20(%rsp),%r13d
mov    0x38(%rsp),%rdx
mov    0x4c(%rsp),%r10d
mov    0x220(%rsp),%rsi
mov    0x210(%rsp),%r11
mov    0x200(%rsp),%r14
mov    0x10(%rsp),%r9
js     2dd9 <fftmx+0x1cb9>
imul   %edx,%r10d
mov    0x78(%rsp),%rax
add    $0x1,%eax
mov    $0x1,%edi
sub    %edx,%edi
mov    %rdi,0xa0(%rsp)
cltq
mov    %rax,0x88(%rsp)
mov    0xc(%rsp),%eax
add    $0xffffffff,%eax
imul   %edx,%eax
sub    0x20(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
mov    %r9d,%eax
neg    %eax
mov    %eax,(%rsp)
mov    %r10d,0x4c(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
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     2c30 <fftmx+0x1b10>
mov    %r15d,%esi
imul   %r9d,%esi
mov    0x58(%rsp),%rax
add    %esi,%eax
mov    %rax,0xe0(%rsp)
add    0xc(%rsp),%esi
mov    %rsi,0x28(%rsp)
mov    %r9d,%ecx
mov    %r15d,0x90(%rsp)
nopl   0x0(%rax,%rax,1)
cmp    %r10d,%ecx
mov    %ecx,%edi
cmovg  %r10d,%edi
mov    0x28(%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    $0x4,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r8,%rdx,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%r14,%rsi,1)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r11,%rsi,1)
add    $0x4,%rsi
sub    %r10d,%edx
cmp    %edx,%ecx
jne    2cb0 <fftmx+0x1b90>
mov    %r15d,%eax
mov    %r10,%rdx
mov    0x220(%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    (%rsp),%eax
mov    %eax,%r9d
imul   %r10d,%r9d
xor    %r14d,%r14d
xchg   %ax,%ax
lea    (%r9,%r15,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm0
movslq %r15d,%r15
movss  %xmm0,0x0(%rbp,%r15,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%r15,4)
sub    %edx,%r15d
add    %edx,%r14d
cmp    %r14d,%edi
jne    2d10 <fftmx+0x1bf0>
mov    %r8d,%eax
neg    %eax
add    %r15d,%r9d
cmp    %eax,%r12d
jne    2cf0 <fftmx+0x1bd0>
lea    (%r11,%rdi,2),%edi
mov    0x10(%rsp),%r9
imul   %r9d,%r10d
sub    %r10d,%edi
sub    %r14d,%edi
mov    $0x4,%eax
mov    0x210(%rsp),%r11
mov    0x200(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,1),%xmm0
movslq %edi,%rdi
movss  %xmm0,0x0(%rbp,%rdi,4)
movss  (%r11,%rax,1),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
sub    %edx,%edi
add    $0x4,%rax
add    %edx,%ecx
jne    2d80 <fftmx+0x1c60>
mov    0x60(%rsp),%rcx
test   %ecx,%ecx
mov    0x4c(%rsp),%r10d
mov    0x90(%rsp),%r15d
jne    2c70 <fftmx+0x1b50>
cmp    $0xffffffff,%r8d
jne    2c30 <fftmx+0x1b10>
mov    0x20(%rsp),%eax
sub    %eax,0xc(%rsp)
sub    %eax,%r13d
jns    2c10 <fftmx+0x1af0>
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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