int fourt(float *datar, float *datai, int *nn, int ndim, int ifrwd, int icplx,
          float *workr, float *worki) {
  int ifact[21];
  int i, i1, i2, i3, j, j1, j2, j3, iff, ifp1, ifp2, idiv, iquot, irem, inon2;
  int imax, jmax, nhalf, jmin, j2max, j3max;
  int icase, idim, ntot, n, np1, np2, ntwo, non2p, m, mmax, mmin;
  int ifmin, np2hf, i1max, i2max, i1rng, np0, nprev, imin, istep, mstep;
  float twopi, theta, wstpr, wstpi, wminr, wmini, wr, wi, wtemp, wmstr, wmsti,
      thetm;
  float oldsr, oldsi, stmpr, stmpi, sumr, sumi, twowr, sr, si, difr, difi,
      tempr, tempi;
  datar--;
  datai--;
  nn--;
  workr--;
  worki--;
  if (ndim < 1)
    return 0;
  ntot = 1;
  for (idim = 1; idim <= ndim; idim++)
    ntot = ntot * nn[idim];
  twopi = 3.14159265358979323846 * 2.0;
  np1 = 1;
  for (idim = 1; idim <= ndim; idim++) {
    n = nn[idim];
    np2 = np1 * n;
    if (n < 1)
      return 0;
    if (n == 1) {
      np0 = np1;
      np1 = np2;
      nprev = n;
      continue;
    }
    m = n;
    ntwo = np1;
    iff = 1;
    idiv = 2;
    while (1) {
      iquot = m / idiv;
      irem = m - idiv * iquot;
      if (iquot < idiv) {
        inon2 = iff;
        if (irem == 0)
          ntwo += ntwo;
        else
          ifact[iff] = m;
        break;
      }
      if (irem != 0) {
        idiv = 3;
        inon2 = iff;
        while (1) {
          iquot = m / idiv;
          irem = m - idiv * iquot;
          if (iquot < idiv) {
            ifact[iff] = m;
            break;
          }
          if (irem == 0) {
            ifact[iff] = idiv;
            iff++;
            m = iquot;
          } else
            idiv += 2;
        }
        break;
      }
      ntwo += ntwo;
      ifact[iff] = idiv;
      iff++;
      m = iquot;
    }
    non2p = np2 / ntwo;
    assert(iff <= 21);
    icase = 1;
    ifmin = 1;
    if (icplx == 0) {
      icase = 2;
      if (idim <= 1) {
        icase = 3;
        if (ntwo > np1) {
          icase = 4;
          ifmin = 2;
          ntwo /= 2;
          n /= 2;
          np2 /= 2;
          ntot /= 2;
          i = 1;
          for (j = 1; j <= ntot; j++) {
            datar[j] = datar[i];
            datai[j] = datar[i + 1];
            i += 2;
          }
        }
      }
    }
    if (non2p <= 1) {
      np2hf = np2 / 2;
      j = 1;
      for (i2 = 1; i2 <= np2; i2 += np1) {
        if (j < i2) {
          i1max = i2 + np1 - 1;
          for (i1 = i2; i1 <= i1max; i1++) {
            for (i3 = i1; i3 <= ntot; i3 += np2) {
              j3 = j + i3 - i2;
              tempr = datar[i3];
              tempi = datai[i3];
              datar[i3] = datar[j3];
              datai[i3] = datai[j3];
              datar[j3] = tempr;
              datai[j3] = tempi;
            }
          }
        }
        m = np2hf;
        while (j > m) {
          j -= m;
          m /= 2;
          if (m < np1)
            break;
        }
        j += m;
      }
    } else {
      for (i1 = 1; i1 <= np1; i1++) {
        for (i3 = i1; i3 <= ntot; i3 += np2) {
          j = i3;
          for (i = 1; i <= n; i++) {
            if (icase != 3) {
              workr[i] = datar[j];
              worki[i] = datai[j];
            } else {
              workr[i] = datar[j];
              worki[i] = 0.0;
            }
            ifp2 = np2;
            iff = ifmin;
            do {
              ifp1 = ifp2 / ifact[iff];
              j += ifp1;
              if (j - i3 - ifp2 < 0)
                break;
              j -= ifp2;
              ifp2 = ifp1;
              iff++;
            } while (ifp2 > np1);
          }
          i2max = i3 + np2 - np1;
          i = 1l;
          for (i2 = i3; i2 <= i2max; i2 += np1) {
            datar[i2] = workr[i];
            datai[i2] = worki[i];
            i++;
          }
        }
      }
    }
    i1rng = np1;
    if (icase == 2)
      i1rng = np0 * (1 + nprev / 2);
    if (ntwo > np1) {
      for (i1 = 1; i1 <= i1rng; i1++) {
        imin = np1 + i1;
        istep = 2 * np1;
        while (istep <= ntwo) {
          j = i1;
          for (i = imin; i <= ntot; i += istep) {
            tempr = datar[i];
            tempi = datai[i];
            datar[i] = datar[j] - tempr;
            datai[i] = datai[j] - tempi;
            datar[j] += tempr;
            datai[j] += tempi;
            j += istep;
          }
          imin += imin - i1;
          istep += istep;
        }
        imin = 3 * np1 + i1;
        istep = 4 * np1;
        while (istep <= ntwo) {
          j = imin - istep / 2;
          for (i = imin; i <= ntot; i += istep) {
            if (ifrwd != 0) {
              tempr = datai[i];
              tempi = -datar[i];
            } else {
              tempr = -datai[i];
              tempi = datar[i];
            }
            datar[i] = datar[j] - tempr;
            datai[i] = datai[j] - tempi;
            datar[j] += tempr;
            datai[j] += tempi;
            j += istep;
          }
          imin += imin - i1;
          istep += istep;
        }
      }
      theta = -twopi / 8.0;
      wstpr = 0.0;
      wstpi = -1.0;
      if (ifrwd == 0) {
        theta = -theta;
        wstpi = 1.0;
      }
      mmax = 8 * np1;
      while (mmax <= ntwo) {
        wminr = cos(theta);
        wmini = sin(theta);
        wr = wminr;
        wi = wmini;
        mmin = mmax / 2 + np1;
        mstep = np1 + np1;
        for (m = mmin; m <= mmax; m += mstep) {
          for (i1 = 1; i1 <= i1rng; i1++) {
            istep = mmax;
            imin = m + i1;
            do {
              j = imin - istep / 2;
              for (i = imin; i <= ntot; i += istep) {
                tempr = datar[i] * wr - datai[i] * wi;
                tempi = datar[i] * wi + datai[i] * wr;
                datar[i] = datar[j] - tempr;
                datai[i] = datai[j] - tempi;
                datar[j] += tempr;
                datai[j] += tempi;
                j += istep;
              }
              imin += imin - i1;
              istep += istep;
            } while (istep <= ntwo);
          }
          wtemp = wr * wstpi;
          wr = wr * wstpr - wi * wstpi;
          wi = wi * wstpr + wtemp;
        }
        wstpr = wminr;
        wstpi = wmini;
        theta /= 2.0;
        mmax += mmax;
      }
    }
    if (non2p > 1) {
      ifp1 = ntwo;
      iff = inon2;
      do {
        ifp2 = ifact[iff] * ifp1;
        theta = -twopi / ((float)ifact[iff]);
        if (ifrwd == 0)
          theta = -theta;
        thetm = theta / ((float)(ifp1 / np1));
        wstpr = cos(theta);
        wstpi = sin(theta);
        wmstr = cos(thetm);
        wmsti = sin(thetm);
        wminr = 1.0;
        wmini = 0.0;
        for (j1 = 1; j1 <= ifp1; j1 += np1) {
          i1max = j1 + i1rng - 1;
          for (i1 = j1; i1 <= i1max; i1++) {
            for (i3 = i1; i3 <= ntot; i3 += np2) {
              i = 1;
              wr = wminr;
              wi = wmini;
              j2max = i3 + ifp2 - ifp1;
              for (j2 = i3; j2 <= j2max; j2 += ifp1) {
                twowr = wr + wr;
                jmin = i3;
                j3max = j2 + np2 - ifp2;
                for (j3 = j2; j3 <= j3max; j3 += ifp2) {
                  j = jmin + ifp2 - ifp1;
                  sr = datar[j];
                  si = datai[j];
                  oldsr = 0.0;
                  oldsi = 0.0;
                  j -= ifp1;
                  do {
                    stmpr = sr;
                    stmpi = si;
                    sr = twowr * sr - oldsr + datar[j];
                    si = twowr * si - oldsi + datai[j];
                    oldsr = stmpr;
                    oldsi = stmpi;
                    j -= ifp1;
                  } while (j > jmin);
                  workr[i] = wr * sr - wi * si - oldsr + datar[j];
                  worki[i] = wi * sr + wr * si - oldsi + datai[j];
                  jmin += ifp2;
                  i++;
                }
                wtemp = wr * wstpi;
                wr = wr * wstpr - wi * wstpi;
                wi = wi * wstpr + wtemp;
              }
              i = 1;
              for (j2 = i3; j2 <= j2max; j2 += ifp1) {
                j3max = j2 + np2 - ifp2;
                for (j3 = j2; j3 <= j3max; j3 += ifp2) {
                  datar[j3] = workr[i];
                  datai[j3] = worki[i];
                  i++;
                }
              }
            }
          }
          wtemp = wminr * wmsti;
          wminr = wminr * wmstr - wmini * wmsti;
          wmini = wmini * wmstr + wtemp;
        }
        iff++;
        ifp1 = ifp2;
      } while (ifp1 < np2);
    }
    if (icase == 4) {
      nhalf = n;
      n = n + n;
      theta = -twopi / (float)n;
      if (ifrwd == 0)
        theta = -theta;
      wstpr = cos(theta);
      wstpi = sin(theta);
      wr = wstpr;
      wi = wstpi;
      imin = 2;
      jmin = nhalf;
      while (imin - jmin < 0) {
        j = jmin;
        for (i = imin; i <= ntot; i += np2) {
          sumr = (datar[i] + datar[j]) / 2.0;
          sumi = (datai[i] + datai[j]) / 2.0;
          difr = (datar[i] - datar[j]) / 2.0;
          difi = (datai[i] - datai[j]) / 2.0;
          tempr = wr * sumi + wi * difr;
          tempi = wi * sumi - wr * difr;
          datar[i] = sumr + tempr;
          datai[i] = difi + tempi;
          datar[j] = sumr - tempr;
          datai[j] = -difi + tempi;
          j += np2;
        }
        imin++;
        jmin--;
        wtemp = wr * wstpi;
        wr = wr * wstpr - wi * wstpi;
        wi = wi * wstpr + wtemp;
      }
      if (imin - jmin == 0) {
        if (ifrwd != 0) {
          for (i = imin; i <= ntot; i += np2)
            datai[i] = -datai[i];
        }
      }
      np2 = np2 + np2;
      ntot = ntot + ntot;
      j = ntot + 1;
      imax = ntot / 2 + 1;
      do {
        imin = imax - nhalf;
        i = imin;
        i++;
        j--;
        while (i - imax < 0) {
          datar[j] = datar[i];
          datai[j] = -datai[i];
          i++;
          j--;
        }
        datar[j] = datar[imin] - datai[imin];
        datai[j] = 0.0;
        if (i - j >= 0)
          break;
        i--;
        j--;
        while (i - imin > 0) {
          datar[j] = datar[i];
          datai[j] = datai[i];
          i--;
          j--;
        }
        datar[j] = datar[imin] + datai[imin];
        datai[j] = 0.0;
        imax = imin;
      } while (1);
      datar[1] = datar[1] + datai[1];
      datai[1] = 0.0;
    } else if (icase == 2) {
      if (nprev - 2 > 0) {
        for (i3 = 1; i3 <= ntot; i3 += np2) {
          i2max = i3 + np2 - np1;
          for (i2 = i3; i2 <= i2max; i2 += np1) {
            imax = i2 + np1 - 1;
            imin = i2 + i1rng;
            jmax = i3 + i3 + np1 - imin;
            if (i2 - i3 > 0)
              jmax += np2;
            if (idim - 2 > 0) {
              j = jmax + np0;
              for (i = imin; i <= imax; i++) {
                datar[i] = datar[j];
                datai[i] = -datai[j];
                j -= 1;
              }
            }
            j = jmax;
            for (i = imin; i <= imax; i += np0) {
              datar[i] = datar[j];
              datai[i] = -datai[j];
              j += np0;
            }
          }
        }
      }
    }
    np0 = np1;
    np1 = np2;
    nprev = n;
  }
  return 0;
}


x86 assembly (clang, -O0):
<fourt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
cmpl   $0x1,-0x24(%rbp)
jge    11ac <fourt+0x7c>
movl   $0x0,-0x4(%rbp)
jmp    3395 <fourt+0x2265>
movl   $0x1,-0xe0(%rbp)
movl   $0x1,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11fe <fourt+0xce>
mov    -0xe0(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0xdc(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    11c0 <fourt+0x90>
movss  0x2dfa(%rip),%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
movl   $0x1,-0xe8(%rbp)
movl   $0x1,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     338e <fourt+0x225e>
mov    -0x20(%rbp),%rax
movslq -0xdc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe8(%rbp),%eax
imul   -0xe4(%rbp),%eax
mov    %eax,-0xec(%rbp)
cmpl   $0x1,-0xe4(%rbp)
jge    1271 <fourt+0x141>
movl   $0x0,-0x4(%rbp)
jmp    3395 <fourt+0x2265>
cmpl   $0x1,-0xe4(%rbp)
jne    12a7 <fourt+0x177>
mov    -0xe8(%rbp),%eax
mov    %eax,-0x118(%rbp)
mov    -0xec(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe4(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    337a <fourt+0x224a>
mov    -0xe4(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %eax,-0xf0(%rbp)
movl   $0x1,-0xa4(%rbp)
movl   $0x2,-0xb0(%rbp)
mov    -0xf8(%rbp),%eax
cltd
idivl  -0xb0(%rbp)
mov    %eax,-0xb4(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0xb0(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1359 <fourt+0x229>
mov    -0xa4(%rbp),%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x0,-0xb8(%rbp)
jne    1343 <fourt+0x213>
mov    -0xf0(%rbp),%eax
add    -0xf0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
jmp    1354 <fourt+0x224>
mov    -0xf8(%rbp),%ecx
movslq -0xa4(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
jmp    146c <fourt+0x33c>
cmpl   $0x0,-0xb8(%rbp)
je     1429 <fourt+0x2f9>
movl   $0x3,-0xb0(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xf8(%rbp),%eax
cltd
idivl  -0xb0(%rbp)
mov    %eax,-0xb4(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0xb0(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    13d2 <fourt+0x2a2>
mov    -0xf8(%rbp),%ecx
movslq -0xa4(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
jmp    1424 <fourt+0x2f4>
cmpl   $0x0,-0xb8(%rbp)
jne    1410 <fourt+0x2e0>
mov    -0xb0(%rbp),%ecx
movslq -0xa4(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    141f <fourt+0x2ef>
mov    -0xb0(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xb0(%rbp)
jmp    137c <fourt+0x24c>
jmp    146c <fourt+0x33c>
mov    -0xf0(%rbp),%eax
add    -0xf0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xb0(%rbp),%ecx
movslq -0xa4(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    12d3 <fourt+0x1a3>
mov    -0xec(%rbp),%eax
cltd
idivl  -0xf0(%rbp)
mov    %eax,-0xf4(%rbp)
cmpl   $0x15,-0xa4(%rbp)
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1030 <assert@plt>
movl   $0x1,-0xd8(%rbp)
movl   $0x1,-0x104(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    15e7 <fourt+0x4b7>
movl   $0x2,-0xd8(%rbp)
cmpl   $0x1,-0xdc(%rbp)
jg     15e2 <fourt+0x4b2>
movl   $0x3,-0xd8(%rbp)
mov    -0xf0(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jle    15dd <fourt+0x4ad>
movl   $0x4,-0xd8(%rbp)
movl   $0x2,-0x104(%rbp)
mov    -0xf0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xf0(%rbp)
mov    -0xe4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xe4(%rbp)
mov    -0xec(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xe0(%rbp)
movl   $0x1,-0x84(%rbp)
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     15d8 <fourt+0x4a8>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    155e <fourt+0x42e>
jmp    15dd <fourt+0x4ad>
jmp    15e2 <fourt+0x4b2>
jmp    15e7 <fourt+0x4b7>
cmpl   $0x1,-0xf4(%rbp)
jg     180e <fourt+0x6de>
mov    -0xec(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x108(%rbp)
movl   $0x1,-0x94(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0xec(%rbp),%eax
jg     1809 <fourt+0x6d9>
mov    -0x94(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    177e <fourt+0x64e>
mov    -0x8c(%rbp),%eax
add    -0xe8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jg     1779 <fourt+0x649>
mov    -0x88(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     1760 <fourt+0x630>
mov    -0x94(%rbp),%eax
add    -0x90(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xec(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    167f <fourt+0x54f>
jmp    1765 <fourt+0x635>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1661 <fourt+0x531>
jmp    177e <fourt+0x64e>
mov    -0x108(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xf8(%rbp),%eax
jle    17e0 <fourt+0x6b0>
mov    -0xf8(%rbp),%ecx
mov    -0x94(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0xf8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jge    17db <fourt+0x6ab>
jmp    17e0 <fourt+0x6b0>
jmp    178a <fourt+0x65a>
mov    -0xf8(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0xe8(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    161c <fourt+0x4ec>
jmp    1a91 <fourt+0x961>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jg     1a8c <fourt+0x95c>
mov    -0x88(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     1a73 <fourt+0x943>
mov    -0x90(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x1,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jg     19b1 <fourt+0x881>
cmpl   $0x3,-0xd8(%rbp)
je     18c2 <fourt+0x792>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    18f5 <fourt+0x7c5>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xec(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x104(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xac(%rbp),%eax
movslq -0xa4(%rbp),%rcx
cltd
idivl  -0x80(%rbp,%rcx,4)
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
sub    -0x90(%rbp),%eax
sub    -0xac(%rbp),%eax
cmp    $0x0,%eax
jge    1957 <fourt+0x827>
jmp    1998 <fourt+0x868>
mov    -0xac(%rbp),%ecx
mov    -0x94(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa8(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jg     190d <fourt+0x7dd>
jmp    199d <fourt+0x86d>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    185e <fourt+0x72e>
mov    -0x90(%rbp),%eax
add    -0xec(%rbp),%eax
sub    -0xe8(%rbp),%eax
mov    %eax,-0x110(%rbp)
movl   $0x1,-0x84(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x110(%rbp),%eax
jg     1a57 <fourt+0x927>
mov    0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0xe8(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    19df <fourt+0x8af>
jmp    1a5c <fourt+0x92c>
mov    -0xec(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1836 <fourt+0x706>
jmp    1a78 <fourt+0x948>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1818 <fourt+0x6e8>
jmp    1a91 <fourt+0x961>
mov    -0xe8(%rbp),%eax
mov    %eax,-0x114(%rbp)
cmpl   $0x2,-0xd8(%rbp)
jne    1ad8 <fourt+0x9a8>
mov    -0x118(%rbp),%eax
mov    %eax,-0x190(%rbp)
mov    -0x11c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x190(%rbp),%eax
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x114(%rbp)
mov    -0xf0(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jle    22c8 <fourt+0x1198>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x114(%rbp),%eax
jg     1e75 <fourt+0xd45>
mov    -0xe8(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0xe8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jg     1c75 <fourt+0xb45>
mov    -0x88(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     1c46 <fourt+0xb16>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x124(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x124(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1b51 <fourt+0xa21>
mov    -0x120(%rbp),%eax
sub    -0x88(%rbp),%eax
add    -0x120(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x124(%rbp),%eax
add    -0x124(%rbp),%eax
mov    %eax,-0x124(%rbp)
jmp    1b27 <fourt+0x9f7>
imul   $0x3,-0xe8(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0xe8(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jg     1e5c <fourt+0xd2c>
mov    -0x120(%rbp),%eax
mov    %eax,-0x194(%rbp)
mov    -0x124(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x194(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     1e2d <fourt+0xcfd>
cmpl   $0x0,-0x28(%rbp)
je     1d3d <fourt+0xc0d>
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
jmp    1d7a <fourt+0xc4a>
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x124(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x124(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1cdf <fourt+0xbaf>
mov    -0x120(%rbp),%eax
sub    -0x88(%rbp),%eax
add    -0x120(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x124(%rbp),%eax
add    -0x124(%rbp),%eax
mov    %eax,-0x124(%rbp)
jmp    1c97 <fourt+0xb67>
jmp    1e61 <fourt+0xd31>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1af4 <fourt+0x9c4>
movss  -0x12c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x217a(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  0x214b(%rip),%xmm0
movss  %xmm0,-0x138(%rbp)
ff
cmpl   $0x0,-0x28(%rbp)
jne    1ef8 <fourt+0xdc8>
movss  -0x130(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  0x2118(%rip),%xmm0
movss  %xmm0,-0x138(%rbp)
ff
mov    -0xe8(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jg     22c3 <fourt+0x1193>
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
mov    -0xfc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0xe8(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0xe8(%rbp),%eax
add    -0xe8(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x100(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0xfc(%rbp),%eax
jg     2268 <fourt+0x1138>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x114(%rbp),%eax
jg     21d4 <fourt+0x10a4>
mov    -0xfc(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0xf8(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x198(%rbp)
mov    -0x124(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x198(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     217f <fourt+0x104f>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x144(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x148(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x148(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x144(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x124(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x124(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    202d <fourt+0xefd>
mov    -0x120(%rbp),%eax
sub    -0x88(%rbp),%eax
add    -0x120(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x124(%rbp),%eax
add    -0x124(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jle    1ff7 <fourt+0xec7>
jmp    21c0 <fourt+0x1090>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1fc7 <fourt+0xe97>
movss  -0x144(%rbp),%xmm0
ff
mulss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x148(%rbp),%xmm1
ff
mulss  -0x138(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x14c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
mov    -0x128(%rbp),%eax
add    -0xf8(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    1fab <fourt+0xe7b>
movss  -0x13c(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1d7c(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
mov    -0xfc(%rbp),%eax
add    -0xfc(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1f07 <fourt+0xdd7>
jmp    22c8 <fourt+0x1198>
cmpl   $0x1,-0xf4(%rbp)
jle    29eb <fourt+0x18bb>
mov    -0xf0(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movslq -0xa4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
imul   -0xa8(%rbp),%eax
mov    %eax,-0xac(%rbp)
movss  -0x12c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0xa4(%rbp),%rax
cvtsi2ssl -0x80(%rbp,%rax,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
cmpl   $0x0,-0x28(%rbp)
jne    235a <fourt+0x122a>
movss  -0x130(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%eax
cltd
idivl  -0xe8(%rbp)
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x158(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
movss  -0x158(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  0x1c0d(%rip),%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     29b9 <fourt+0x1889>
mov    -0x98(%rbp),%eax
add    -0x114(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jg     2925 <fourt+0x17f5>
mov    -0x88(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     290c <fourt+0x17dc>
movl   $0x1,-0x84(%rbp)
movss  -0x13c(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
mov    -0x90(%rbp),%eax
add    -0xac(%rbp),%eax
sub    -0xa8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jg     2810 <fourt+0x16e0>
movss  -0x144(%rbp),%xmm0
ff
addss  -0x144(%rbp),%xmm0
ff
movss  %xmm0,-0x174(%rbp)
ff
mov    -0x90(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x9c(%rbp),%eax
add    -0xec(%rbp),%eax
sub    -0xac(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jg     277c <fourt+0x164c>
mov    -0xcc(%rbp),%eax
add    -0xac(%rbp),%eax
sub    -0xa8(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x178(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x17c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x15c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x160(%rbp)
ff
mov    -0xa8(%rbp),%ecx
mov    -0x94(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
movss  -0x178(%rbp),%xmm0
ff
movss  %xmm0,-0x164(%rbp)
ff
movss  -0x17c(%rbp),%xmm0
ff
movss  %xmm0,-0x168(%rbp)
ff
movss  -0x174(%rbp),%xmm0
ff
movss  -0x178(%rbp),%xmm2
ff
movss  -0x15c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x178(%rbp)
ff
movss  -0x174(%rbp),%xmm0
ff
movss  -0x17c(%rbp),%xmm2
ff
movss  -0x160(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x17c(%rbp)
ff
movss  -0x164(%rbp),%xmm0
ff
movss  %xmm0,-0x15c(%rbp)
ff
movss  -0x168(%rbp),%xmm0
ff
movss  %xmm0,-0x160(%rbp)
ff
mov    -0xa8(%rbp),%ecx
mov    -0x94(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jg     25a7 <fourt+0x1477>
movss  -0x144(%rbp),%xmm0
ff
movss  -0x178(%rbp),%xmm2
ff
movss  -0x148(%rbp),%xmm1
ff
mulss  -0x17c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x15c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x148(%rbp),%xmm0
ff
movss  -0x178(%rbp),%xmm2
ff
movss  -0x144(%rbp),%xmm1
ff
mulss  -0x17c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  -0x160(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    -0xcc(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0xac(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    2523 <fourt+0x13f3>
movss  -0x144(%rbp),%xmm0
ff
mulss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x148(%rbp),%xmm1
ff
mulss  -0x138(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x14c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
mov    -0xa8(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    24c9 <fourt+0x1399>
movl   $0x1,-0x84(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jg     28f0 <fourt+0x17c0>
mov    -0x9c(%rbp),%eax
add    -0xec(%rbp),%eax
sub    -0xac(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jg     28d4 <fourt+0x17a4>
mov    0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0xac(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    285c <fourt+0x172c>
jmp    28d9 <fourt+0x17a9>
mov    -0xa8(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    2826 <fourt+0x16f6>
jmp    28f5 <fourt+0x17c5>
mov    -0xec(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    2469 <fourt+0x1339>
jmp    2911 <fourt+0x17e1>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    244b <fourt+0x131b>
movss  -0x13c(%rbp),%xmm0
ff
mulss  -0x154(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
movss  -0x150(%rbp),%xmm2
ff
movss  -0x140(%rbp),%xmm1
ff
mulss  -0x154(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
movss  -0x150(%rbp),%xmm2
ff
movss  -0x14c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
mov    -0xe8(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    2418 <fourt+0x12e8>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0xec(%rbp),%eax
jl     22ed <fourt+0x11bd>
jmp    29eb <fourt+0x18bb>
cmpl   $0x4,-0xd8(%rbp)
jne    30db <fourt+0x1fab>
mov    -0xe4(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xe4(%rbp),%eax
add    -0xe4(%rbp),%eax
mov    %eax,-0xe4(%rbp)
movss  -0x12c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtsi2ssl -0xe4(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
cmpl   $0x0,-0x28(%rbp)
jne    2a66 <fourt+0x1936>
movss  -0x130(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
movl   $0x2,-0x120(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x120(%rbp),%eax
sub    -0xcc(%rbp),%eax
cmp    $0x0,%eax
jge    2dc8 <fourt+0x1c98>
mov    -0xcc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     2d28 <fourt+0x1bf8>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x14d7(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x149b(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x170(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x145f(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x180(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1423(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x184(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  -0x170(%rbp),%xmm2
ff
movss  -0x148(%rbp),%xmm1
ff
mulss  -0x180(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x188(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
movss  -0x170(%rbp),%xmm2
ff
movss  -0x144(%rbp),%xmm1
ff
mulss  -0x180(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
movss  -0x16c(%rbp),%xmm0
ff
addss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x184(%rbp),%xmm0
ff
addss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x16c(%rbp),%xmm0
ff
subss  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x184(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  -0x18c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xec(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0xec(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    2b03 <fourt+0x19d3>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
mov    -0xcc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xcc(%rbp)
movss  -0x144(%rbp),%xmm0
ff
mulss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x148(%rbp),%xmm1
ff
mulss  -0x138(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
movss  -0x134(%rbp),%xmm2
ff
movss  -0x14c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
jmp    2ad6 <fourt+0x19a6>
mov    -0x120(%rbp),%eax
sub    -0xcc(%rbp),%eax
cmp    $0x0,%eax
jne    2e53 <fourt+0x1d23>
cmpl   $0x0,-0x28(%rbp)
je     2e4e <fourt+0x1d1e>
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     2e49 <fourt+0x1d19>
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xec(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    2df3 <fourt+0x1cc3>
jmp    2e4e <fourt+0x1d1e>
jmp    2e53 <fourt+0x1d23>
mov    -0xec(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xe0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
sub    -0xc8(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
mov    -0x84(%rbp),%eax
sub    -0xc0(%rbp),%eax
cmp    $0x0,%eax
jge    2f5e <fourt+0x1e2e>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    2ed9 <fourt+0x1da9>
mov    -0x10(%rbp),%rax
movslq -0x120(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x120(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
sub    -0x94(%rbp),%eax
cmp    $0x0,%eax
jl     2fbb <fourt+0x1e8b>
jmp    30af <fourt+0x1f7f>
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
mov    -0x84(%rbp),%eax
sub    -0x120(%rbp),%eax
cmp    $0x0,%eax
jle    3051 <fourt+0x1f21>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    2fd9 <fourt+0x1ea9>
mov    -0x10(%rbp),%rax
movslq -0x120(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x120(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x120(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    2e9d <fourt+0x1d6d>
jmp    30af <fourt+0x1f7f>
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
jmp    3356 <fourt+0x2226>
cmpl   $0x2,-0xd8(%rbp)
jne    3351 <fourt+0x2221>
mov    -0x11c(%rbp),%eax
sub    $0x2,%eax
cmp    $0x0,%eax
jle    334c <fourt+0x221c>
movl   $0x1,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jg     3347 <fourt+0x2217>
mov    -0x90(%rbp),%eax
add    -0xec(%rbp),%eax
sub    -0xe8(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x110(%rbp),%eax
jg     332b <fourt+0x21fb>
mov    -0x8c(%rbp),%eax
add    -0xe8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x8c(%rbp),%eax
add    -0x114(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x90(%rbp),%eax
add    -0x90(%rbp),%eax
add    -0xe8(%rbp),%eax
sub    -0x120(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x8c(%rbp),%eax
sub    -0x90(%rbp),%eax
cmp    $0x0,%eax
jle    31b8 <fourt+0x2088>
mov    -0xec(%rbp),%eax
add    -0xc4(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xdc(%rbp),%eax
sub    $0x2,%eax
cmp    $0x0,%eax
jle    326f <fourt+0x213f>
mov    -0xc4(%rbp),%eax
add    -0x118(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xc0(%rbp),%eax
jg     326a <fourt+0x213a>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    31e8 <fourt+0x20b8>
jmp    326f <fourt+0x213f>
mov    -0xc4(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xc0(%rbp),%eax
jg     330f <fourt+0x21df>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x118(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x118(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    3287 <fourt+0x2157>
jmp    3314 <fourt+0x21e4>
mov    -0xe8(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    313a <fourt+0x200a>
jmp    3330 <fourt+0x2200>
mov    -0xec(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    3104 <fourt+0x1fd4>
jmp    334c <fourt+0x221c>
jmp    3351 <fourt+0x2221>
jmp    3356 <fourt+0x2226>
mov    -0xe8(%rbp),%eax
mov    %eax,-0x118(%rbp)
mov    -0xec(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe4(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1222 <fourt+0xf2>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fourt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x208,%rsp
mov    %r9d,0x138(%rsp)
mov    %r8d,0x4c(%rsp)
test   %ecx,%ecx
jle    2d86 <fourt+0x1c56>
mov    %rdi,%rbp
mov    0x248(%rsp),%rdi
mov    0x240(%rsp),%rbx
mov    %ecx,%r8d
lea    0x1(%r8),%r9
cmp    $0x8,%ecx
jae    1185 <fourt+0x55>
mov    $0x1,%r10d
mov    $0x1,%eax
jmp    1380 <fourt+0x250>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbx
mov    %rbx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rbx
jae    11b8 <fourt+0x88>
movdqa 0x1e53(%rip),%xmm0
xor    %ebx,%ebx
movdqa %xmm0,%xmm1
jmp    129b <fourt+0x16b>
and    $0xfffffffffffffffc,%rdi
movdqa 0x1e3c(%rip),%xmm0
xor    %ebx,%ebx
movdqa %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%rdx,%rbx,4),%xmm3
movdqu 0x10(%rdx,%rbx,4),%xmm2
movdqu 0x20(%rdx,%rbx,4),%xmm4
movdqu 0x30(%rdx,%rbx,4),%xmm5
pshufd $0xf5,%xmm3,%xmm6
pshufd $0xf5,%xmm0,%xmm7
pmuludq %xmm6,%xmm7
pmuludq %xmm0,%xmm3
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm0,%xmm6
pmuludq %xmm1,%xmm2
pmuludq %xmm4,%xmm3
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm7,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm6,%xmm1
movdqu 0x40(%rdx,%rbx,4),%xmm4
movdqu 0x50(%rdx,%rbx,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm0,%xmm6
pmuludq %xmm4,%xmm3
pshufd $0xf5,%xmm5,%xmm4
pmuludq %xmm1,%xmm4
pmuludq %xmm5,%xmm2
movdqu 0x60(%rdx,%rbx,4),%xmm1
movdqu 0x70(%rdx,%rbx,4),%xmm5
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    11d0 <fourt+0xa0>
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm3
test   %rcx,%rcx
je     131a <fourt+0x1ea>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rbx,4),%rdi
or     $0x4,%rdi
movdqu -0x4(%rdx,%rdi,1),%xmm2
movdqu 0xc(%rdx,%rdi,1),%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm3
add    $0x8,%rbx
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
add    $0xffffffffffffffff,%rcx
jne    12b0 <fourt+0x180>
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%r10d
cmp    %rax,%r8
jne    135e <fourt+0x22e>
mov    0x248(%rsp),%rdi
mov    0x240(%rsp),%rbx
jmp    138f <fourt+0x25f>
or     $0x1,%rax
mov    0x248(%rsp),%rdi
mov    0x240(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
imul   -0x4(%rdx,%rax,4),%r10d
add    $0x1,%rax
cmp    %rax,%r9
jne    1380 <fourt+0x250>
lea    -0x4(%rsi),%r13
xor    %eax,%eax
cmpl   $0x0,0x4c(%rsp)
sete   %al
lea    0x1c8c(%rip),%rcx
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x134(%rsp)
lea    0x1c7f(%rip),%rcx
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x130(%rsp)
lea    -0x4(%rbp),%rax
mov    %rax,0xe8(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,0x1a8(%rsp)
lea    -0x4(%rdi),%rax
mov    %rax,0x1a0(%rsp)
lea    0x4(%rbp),%rax
mov    %rax,0x170(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,0x168(%rsp)
lea    -0x10(%rsi),%rax
mov    %rax,0x180(%rsp)
lea    -0x10(%rbp),%rax
mov    %rax,0x178(%rsp)
mov    $0x1,%r15d
mov    $0x1,%ecx
mov    %rdx,0xe0(%rsp)
mov    %rsi,0x58(%rsp)
mov    %r9,0xd8(%rsp)
jmp    145c <fourt+0x32c>
nopl   (%rax)
mov    %r10d,%edi
add    $0x1,%rcx
mov    %r8d,%eax
mov    %r15d,%ebx
mov    %esi,%r15d
mov    %edi,%r10d
cmp    %r9,%rcx
je     2d86 <fourt+0x1c56>
mov    -0x4(%rdx,%rcx,4),%edi
test   %edi,%edi
jle    2d86 <fourt+0x1c56>
mov    %edi,%esi
imul   %r15d,%esi
mov    $0x1,%r8d
cmp    $0x1,%edi
je     1440 <fourt+0x310>
mov    %edi,%r12d
shr    %r12d
mov    %edi,%edx
sub    %r12d,%edx
sub    %r12d,%edx
mov    $0x1,%r8d
cmp    $0x4,%edi
mov    %rcx,0xa8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rdi,0x50(%rsp)
mov    %rbx,0x140(%rsp)
mov    %eax,0xb4(%rsp)
jae    14e0 <fourt+0x3b0>
mov    %r15d,%r14d
mov    %edi,%eax
test   %edx,%edx
mov    %r8,0x60(%rsp)
je     1551 <fourt+0x421>
mov    %r8d,%ecx
mov    %eax,0x1b0(%rsp,%rcx,4)
jmp    1554 <fourt+0x424>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1,%r8d
mov    %edi,%ecx
mov    %r15d,%r14d
test   %edx,%edx
jne    1534 <fourt+0x404>
mov    $0x1,%r8d
mov    %r15d,%r14d
mov    %r12d,%eax
mov    %r12d,%edi
xchg   %ax,%ax
add    %r14d,%r14d
movl   $0x2,0x1b0(%rsp,%r8,4)
shr    $0x1f,%edi
add    %eax,%edi
mov    %edi,%ecx
and    $0xfffffffe,%ecx
mov    %eax,%edx
sub    %ecx,%edx
cmp    $0x4,%eax
jl     2ca4 <fourt+0x1b74>
sar    %edi
add    $0x1,%r8
mov    %eax,%ecx
mov    %edi,%eax
test   %edx,%edx
je     1500 <fourt+0x3d0>
cmp    $0x9,%ecx
jae    1607 <fourt+0x4d7>
mov    %r8d,%ebx
mov    %r8,0x60(%rsp)
movslq %ebx,%rax
mov    %ecx,0x1b0(%rsp,%rax,4)
jmp    1557 <fourt+0x427>
add    %r14d,%r14d
mov    %r8d,%ebx
mov    %esi,0xc(%rsp)
mov    %esi,%eax
cltd
idiv   %r14d
mov    %eax,0x80(%rsp)
xor    %edi,%edi
cmp    $0x16,%ebx
setl   %dil
movl   $0x0,0x24(%rsp)
xor    %eax,%eax
call   1030 <assert@plt>
mov    $0x1,%r10d
cmpl   $0x0,0x138(%rsp)
jne    1650 <fourt+0x520>
cmpq   $0x1,0xa8(%rsp)
ja     164a <fourt+0x51a>
cmp    %r15d,%r14d
jle    2cad <fourt+0x1b7d>
mov    %r14d,%eax
shr    $0x1f,%eax
add    %eax,%r14d
sar    %r14d
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
shr    $0x1f,%eax
add    %eax,%ecx
sar    %ecx
mov    %ecx,0xc(%rsp)
mov    0x10(%rsp),%rax
mov    %eax,%r9d
shr    $0x1f,%r9d
add    %eax,%r9d
sar    %r9d
mov    $0x2,%r10d
cmp    $0x2,%eax
jge    2cc7 <fourt+0x1b97>
mov    $0x1,%al
mov    %eax,0x48(%rsp)
movl   $0x0,0x24(%rsp)
xor    %r11d,%r11d
mov    %r9,0x10(%rsp)
mov    %r12,0x50(%rsp)
jmp    165b <fourt+0x52b>
mov    %ecx,%eax
mov    $0xaaaaaaab,%edx
imul   %rdx,%rax
shr    $0x21,%rax
mov    $0x3,%edi
mov    %r8d,%ebx
jmp    1632 <fourt+0x502>
add    $0x2,%edi
mov    %ecx,%eax
mov    %eax,%ecx
cltd
idiv   %edi
cmp    %edi,%eax
jl     1540 <fourt+0x410>
mov    %eax,%edx
imul   %edi,%edx
cmp    %edx,%ecx
jne    1620 <fourt+0x4f0>
movslq %ebx,%rbx
mov    %edi,0x1b0(%rsp,%rbx,4)
add    $0x1,%ebx
jmp    1625 <fourt+0x4f5>
mov    $0x1,%al
mov    %eax,0x24(%rsp)
movl   $0x0,0x48(%rsp)
xor    %r11d,%r11d
movaps 0x19ad(%rip),%xmm14
cmpl   $0x2,0x80(%rsp)
02
mov    %r15,0x28(%rsp)
jge    17b0 <fourt+0x680>
cmpl   $0x0,0xc(%rsp)
jle    1920 <fourt+0x7f0>
mov    0xc(%rsp),%eax
mov    %eax,%r9d
shr    $0x1f,%r9d
add    %eax,%r9d
sar    %r9d
movslq 0x28(%rsp),%rcx
mov    %rcx,0x30(%rsp)
mov    %eax,%edx
movslq 0x10(%rsp),%rsi
mov    $0x1,%r15d
mov    $0x1,%r10d
jmp    16da <fourt+0x5aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%edi
mov    %r15d,%ecx
add    %ecx,%edi
add    0x30(%rsp),%r10
mov    %edi,%r15d
cmp    %r10d,0xc(%rsp)
jl     1920 <fourt+0x7f0>
cmp    %r10d,%r15d
jge    1770 <fourt+0x640>
cmpl   $0x0,0x28(%rsp)
jle    1770 <fourt+0x640>
mov    0x28(%rsp),%rax
lea    (%rax,%r10,1),%r11d
mov    %r15d,%r12d
mov    %r10,%rax
jmp    170d <fourt+0x5dd>
nop
add    $0x1,%rax
add    $0x1,%r12d
cmp    %eax,%r11d
jle    1770 <fourt+0x640>
cmp    %eax,0x10(%rsp)
mov    0x58(%rsp),%rbx
mov    0xc(%rsp),%r8d
jl     1700 <fourt+0x5d0>
mov    %r12d,%ecx
mov    %rax,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rbp,%rdi,4),%xmm0
movd   -0x4(%rbx,%rdi,4),%xmm1
movslq %ecx,%rcx
movss  -0x4(%rbp,%rcx,4),%xmm2
movss  %xmm2,-0x4(%rbp,%rdi,4)
movd   -0x4(%rbx,%rcx,4),%xmm2
movd   %xmm2,-0x4(%rbx,%rdi,4)
movss  %xmm0,-0x4(%rbp,%rcx,4)
movd   %xmm1,-0x4(%rbx,%rcx,4)
add    %rdx,%rdi
add    %r8d,%ecx
cmp    %rsi,%rdi
jle    1730 <fourt+0x600>
jmp    1700 <fourt+0x5d0>
mov    %r9d,%eax
mov    %r15d,%ecx
cs nopw 0x0(%rax,%rax,1)
sub    %eax,%ecx
jle    16c0 <fourt+0x590>
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
sar    %edi
mov    %edi,%eax
mov    %ecx,%r15d
cmp    0x28(%rsp),%edi
jge    1780 <fourt+0x650>
jmp    16c5 <fourt+0x595>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r15d,%r15d
jle    1920 <fourt+0x7f0>
mov    0x50(%rsp),%rax
lea    0x1(%rax),%r12d
movslq 0xc(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x28(%rsp),%rax
mov    %eax,%r15d
movslq 0x10(%rsp),%r9
add    $0x1,%eax
mov    %rax,0x70(%rsp)
lea    (%rsp,%r10,4),%r8
add    $0x1b0,%r8
mov    $0x1,%ecx
jmp    1814 <fourt+0x6e4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
cmp    0x70(%rsp),%rcx
je     1920 <fourt+0x7f0>
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    %ecx,0x10(%rsp)
jge    1835 <fourt+0x705>
jmp    1800 <fourt+0x6d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r9,%rax
jg     1800 <fourt+0x6d0>
mov    %rax,%r10
cmpl   $0x0,0x50(%rsp)
jle    18c0 <fourt+0x790>
mov    $0x1,%ebx
mov    %r10d,%edi
jmp    1859 <fourt+0x729>
nopl   (%rax)
add    $0x1,%rbx
cmp    %r12,%rbx
je     18c0 <fourt+0x790>
movslq %edi,%rax
movss  -0x4(%rbp,%rax,4),%xmm0
mov    0x240(%rsp),%rcx
movss  %xmm0,-0x4(%rcx,%rbx,4)
xorps  %xmm0,%xmm0
test   %r11b,%r11b
jne    187f <fourt+0x74f>
movss  0x0(%r13,%rax,4),%xmm0
mov    0x248(%rsp),%rax
movss  %xmm0,-0x4(%rax,%rbx,4)
mov    %r8,%rsi
mov    0xc(%rsp),%eax
mov    %eax,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,%eax
cltd
idivl  (%rsi)
add    %eax,%edi
lea    (%rcx,%r10,1),%edx
cmp    %edx,%edi
js     1850 <fourt+0x720>
sub    %ecx,%edi
add    $0x4,%rsi
mov    %eax,%ecx
cmp    0x28(%rsp),%eax
jg     18a0 <fourt+0x770>
jmp    1850 <fourt+0x720>
nop
mov    0x30(%rsp),%rax
add    %r10,%rax
mov    %rax,%rcx
sub    %r15,%rcx
cmp    %rcx,%r10
mov    0x58(%rsp),%rsi
mov    0x248(%rsp),%rdi
mov    0x240(%rsp),%rbx
jg     1830 <fourt+0x700>
xor    %edx,%edx
xchg   %ax,%ax
movss  (%rbx,%rdx,1),%xmm0
movss  %xmm0,-0x4(%rbp,%r10,4)
movss  (%rdi,%rdx,1),%xmm0
movss  %xmm0,-0x4(%rsi,%r10,4)
add    %r15,%r10
add    $0x4,%rdx
cmp    %rcx,%r10
jle    18f0 <fourt+0x7c0>
jmp    1830 <fourt+0x700>
nopl   0x0(%rax)
mov    0x28(%rsp),%r15
mov    %r15d,%r11d
cmpb   $0x0,0x24(%rsp)
je     1950 <fourt+0x820>
mov    0xb4(%rsp),%eax
mov    %eax,%r11d
shr    $0x1f,%r11d
add    %eax,%r11d
sar    %r11d
add    $0x1,%r11d
imul   0x140(%rsp),%r11d
cmp    %r15d,%r14d
mov    %r11,0x88(%rsp)
jle    1b3e <fourt+0xa0e>
test   %r11d,%r11d
jle    1b20 <fourt+0x9f0>
mov    0x28(%rsp),%rax
lea    (%rax,%rax,1),%r10d
lea    (%rax,%rax,2),%ecx
mov    %rcx,0x18(%rsp)
lea    0x0(,%rax,4),%r11d
movslq 0x10(%rsp),%rsi
mov    0x88(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x30(%rsp)
mov    $0xffffffff,%r15d
mov    $0x1,%r9d
xor    %r12d,%r12d
jmp    19cf <fourt+0x89f>
nopl   0x0(%rax)
mov    %r9d,%r15d
mov    %r9,%rax
add    $0x1,%rax
not    %r15d
add    $0x1,%r12
mov    %rax,%r9
cmp    0x30(%rsp),%rax
je     1b20 <fourt+0x9f0>
cmp    %r14d,%r10d
mov    0x58(%rsp),%rax
jle    1aa0 <fourt+0x970>
cmp    %r14d,%r11d
jg     19b0 <fourt+0x880>
mov    0x18(%rsp),%rax
add    %r9d,%eax
mov    %r11d,%edx
jmp    19fb <fourt+0x8cb>
nop
lea    (%r15,%rax,2),%eax
add    %edx,%edx
cmp    %r14d,%edx
jg     19b0 <fourt+0x880>
cmp    0x10(%rsp),%eax
jg     19f0 <fourt+0x8c0>
mov    %edx,%ecx
shr    $0x1f,%ecx
add    %edx,%ecx
sar    %ecx
mov    %eax,%r8d
sub    %ecx,%r8d
movslq %eax,%rdi
movslq %edx,%rbx
movslq %r8d,%r8
jmp    1a78 <fourt+0x948>
nopl   0x0(%rax,%rax,1)
xorps  %xmm14,%xmm0
movss  -0x4(%rbp,%rdi,4),%xmm1
movss  -0x4(%rbp,%r8,4),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbp,%rdi,4)
movss  0x0(%r13,%r8,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x0(%r13,%rdi,4)
addss  -0x4(%rbp,%r8,4),%xmm0
movss  %xmm0,-0x4(%rbp,%r8,4)
addss  0x0(%r13,%r8,4),%xmm1
movss  %xmm1,0x0(%r13,%r8,4)
add    %rbx,%r8
add    %rbx,%rdi
cmp    %rsi,%rdi
jg     19f0 <fourt+0x8c0>
movss  0x0(%r13,%rdi,4),%xmm0
cmpl   $0x0,0x4c(%rsp)
je     1a20 <fourt+0x8f0>
movss  -0x4(%rbp,%rdi,4),%xmm1
xorps  %xmm14,%xmm1
jmp    1a2a <fourt+0x8fa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,1),%r8d
mov    %r10d,%edx
jmp    1abf <fourt+0x98f>
xchg   %ax,%ax
lea    (%r15,%r8,2),%r8d
add    %edx,%edx
cmp    %r14d,%edx
jg     19dd <fourt+0x8ad>
cmp    0x10(%rsp),%r8d
jg     1ab0 <fourt+0x980>
movslq %r8d,%rdi
movslq %edx,%rbx
mov    %r12,%rcx
nop
movss  -0x4(%rbp,%rdi,4),%xmm0
movss  -0x4(%rax,%rdi,4),%xmm1
movss  0x0(%rbp,%rcx,4),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbp,%rdi,4)
movss  (%rax,%rcx,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rax,%rdi,4)
addss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
addss  (%rax,%rcx,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    %rbx,%rdi
add    %rbx,%rcx
cmp    %rsi,%rdi
jle    1ad0 <fourt+0x9a0>
jmp    1ab0 <fourt+0x980>
xchg   %ax,%ax
mov    0x28(%rsp),%r15
lea    0x0(,%r15,8),%r12d
cmp    %r14d,%r12d
mov    0x88(%rsp),%r11
jle    24af <fourt+0x137f>
cmpl   $0x2,0x80(%rsp)
02
mov    0x248(%rsp),%rbx
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%rdi
jl     2110 <fourt+0xfe0>
movslq %r15d,%rax
movslq %esi,%rcx
movslq %edi,%rdx
mov    %rdx,0x118(%rsp)
mov    0x60(%rsp),%edx
mov    %rax,0x198(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x190(%rsp)
mov    %rcx,0x120(%rsp)
lea    0x0(,%rcx,4),%rax
mov    %rax,0x110(%rsp)
jmp    1bd8 <fourt+0xaa8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x188(%rsp),%rdx
add    $0x1,%rdx
mov    0x18(%rsp),%eax
mov    %eax,%r14d
cmp    %eax,%esi
mov    0x10(%rsp),%rdi
mov    0x88(%rsp),%r11
jle    2110 <fourt+0xfe0>
mov    0x1b0(%rsp,%rdx,4),%eax
mov    %eax,%r12d
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0x1453(%rip),%xmm1
divss  %xmm0,%xmm1
cmpl   $0x0,0x4c(%rsp)
mov    %rdx,0x188(%rsp)
jne    1c08 <fourt+0xad8>
xorps  %xmm14,%xmm1
mov    %r14d,%eax
cltd
idiv   %r15d
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mov    %r12d,%eax
imul   %r14d,%eax
mov    %eax,0x18(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x70(%rsp)
divss  %xmm2,%xmm1
movaps %xmm1,0x30(%rsp)
call   1050 <cos@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x70(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movaps 0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
call   1050 <cos@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x30(%rsp),%xmm0
call   1040 <sin@plt>
test   %r14d,%r14d
movaps 0x1387(%rip),%xmm14
mov    0xc(%rsp),%esi
jle    1bb0 <fourt+0xa80>
movsd  0xc0(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm11
movsd  0x70(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm12
cvtsd2ss %xmm0,%xmm8
movsd  0x90(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm9
mov    0x18(%rsp),%eax
mov    %eax,%ecx
sub    %r14d,%ecx
mov    %rcx,0x128(%rsp)
mov    %esi,%ecx
sub    %eax,%ecx
movslq %eax,%r11
mov    %r14d,%eax
shufps $0x0,%xmm9,%xmm9
shufps $0x0,%xmm8,%xmm8
shufps $0x0,%xmm12,%xmm12
shufps $0x0,%xmm11,%xmm11
add    $0xfffffffd,%r12d
imul   %r14d,%r12d
add    $0x1,%r12d
mov    %r12d,0xb8(%rsp)
mov    %rcx,%r12
mov    %rax,0x30(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x80(%rsp)
mov    $0x1,%eax
mov    %rax,0x108(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    %rbp,0x148(%rsp)
movaps 0x12dc(%rip),%xmm10
mov    %rcx,0x68(%rsp)
jmp    1db4 <fourt+0xc84>
nopl   0x0(%rax,%rax,1)
movaps %xmm10,%xmm0
xorps  %xmm14,%xmm0
shufps $0xd4,%xmm10,%xmm0
shufps $0x52,%xmm10,%xmm0
mulps  %xmm8,%xmm0
mulps  %xmm9,%xmm10
addps  %xmm0,%xmm10
mov    0x108(%rsp),%rcx
add    0x198(%rsp),%rcx
mov    0x28(%rsp),%r15
add    %r15d,0xb8(%rsp)
mov    0x190(%rsp),%rax
add    %rax,0x148(%rsp)
add    %rax,0x150(%rsp)
mov    %rcx,0x108(%rsp)
cmp    %ecx,%r14d
jl     1bb0 <fourt+0xa80>
cmpl   $0x0,0x88(%rsp)
jle    1d50 <fourt+0xc20>
mov    0x88(%rsp),%rax
mov    0x108(%rsp),%rcx
add    %ecx,%eax
mov    %eax,0x13c(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0x160(%rsp)
mov    0x148(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0xb8(%rsp),%eax
mov    %eax,0xbc(%rsp)
jmp    1e43 <fourt+0xd13>
nopw   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0xbc(%rsp)
01
addq   $0x4,0x158(%rsp)
addq   $0x4,0x160(%rsp)
cmp    %ecx,0x13c(%rsp)
jle    1d50 <fourt+0xc20>
mov    %rcx,0xf0(%rsp)
cmp    %ecx,0x10(%rsp)
jl     1e10 <fourt+0xce0>
mov    0x160(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0xbc(%rsp),%eax
mov    %eax,0xc0(%rsp)
mov    0xf0(%rsp),%rcx
jmp    1ece <fourt+0xd9e>
nopl   0x0(%rax)
mov    0x70(%rsp),%rcx
add    0x120(%rsp),%rcx
mov    0xc(%rsp),%esi
add    %esi,0xc0(%rsp)
mov    0x110(%rsp),%rax
add    %rax,0xf8(%rsp)
add    %rax,0x100(%rsp)
cmp    0x118(%rsp),%rcx
jg     1e10 <fourt+0xce0>
mov    0x128(%rsp),%rax
lea    (%rax,%rcx,1),%esi
movslq %esi,%rax
mov    %rcx,0x70(%rsp)
cmp    %rax,%rcx
jg     1e90 <fourt+0xd60>
mov    %rax,0x60(%rsp)
mov    $0x1,%r10d
mov    0x70(%rsp),%rax
mov    %eax,%edx
movaps %xmm10,%xmm2
mov    %esi,0x90(%rsp)
jmp    1f2a <fourt+0xdfa>
cs nopw 0x0(%rax,%rax,1)
nop
unpcklps %xmm13,%xmm0
mulps  %xmm12,%xmm0
mulps  %xmm11,%xmm2
addps  %xmm0,%xmm2
add    %r14d,%edx
cmp    %esi,%edx
jg     2050 <fourt+0xf20>
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
lea    (%r12,%rdx,1),%edi
movaps %xmm2,%xmm13
xorps  %xmm14,%xmm13
cmp    %edi,%edx
jg     1f10 <fourt+0xde0>
movaps %xmm0,%xmm5
addss  %xmm0,%xmm5
movslq %r10d,%r10
shufps $0x0,%xmm5,%xmm5
mov    0xc0(%rsp),%esi
mov    %edx,%r12d
nopl   0x0(%rax)
lea    (%rax,%r11,1),%r15
mov    %r15,%rcx
sub    0x30(%rsp),%rcx
movss  0x0(%r13,%rcx,4),%xmm1
movss  -0x4(%rbp,%rcx,4),%xmm3
sub    %r14d,%ecx
unpcklps %xmm1,%xmm3
pxor   %xmm4,%xmm4
mov    %esi,%r8d
cs nopw 0x0(%rax,%rax,1)
movaps %xmm3,%xmm1
movslq %ecx,%rcx
movaps %xmm5,%xmm6
mulps  %xmm3,%xmm6
subps  %xmm4,%xmm6
movss  0x0(%r13,%rcx,4),%xmm4
movss  -0x4(%rbp,%rcx,4),%xmm3
unpcklps %xmm4,%xmm3
addps  %xmm6,%xmm3
sub    %r14d,%ecx
movslq %r8d,%r9
mov    %r9d,%r8d
sub    %r14d,%r8d
movaps %xmm1,%xmm4
cmp    %r9,%rax
jl     1f90 <fourt+0xe60>
movaps %xmm3,%xmm4
shufps $0x55,%xmm3,%xmm4
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm13,%xmm4
movaps %xmm0,%xmm7
mulss  %xmm3,%xmm7
addss  %xmm4,%xmm7
subss  %xmm1,%xmm7
addss  -0x4(%rbp,%r9,4),%xmm7
mov    0x240(%rsp),%rax
movss  %xmm7,-0x4(%rax,%r10,4)
mulss  %xmm2,%xmm3
addss  %xmm6,%xmm3
shufps $0x55,%xmm1,%xmm1
subss  %xmm1,%xmm3
addss  0x0(%r13,%r9,4),%xmm3
movss  %xmm3,-0x4(%rbx,%r10,4)
add    $0x1,%r10
mov    0x18(%rsp),%eax
add    %eax,%r12d
add    %eax,%esi
mov    %r15,%rax
cmp    %edi,%r12d
jle    1f60 <fourt+0xe30>
mov    0x68(%rsp),%r12
mov    0x70(%rsp),%rax
mov    0x90(%rsp),%esi
jmp    1f10 <fourt+0xde0>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rcx
cmp    %rcx,%rax
jg     1e90 <fourt+0xd60>
mov    $0x1,%r8d
mov    0x100(%rsp),%r9
mov    0xf8(%rsp),%r10
mov    0x70(%rsp),%r15
jmp    209c <fourt+0xf6c>
nopl   0x0(%rax,%rax,1)
add    0x30(%rsp),%r15
mov    0x80(%rsp),%rax
add    %rax,%r10
add    %rax,%r9
cmp    %rcx,%r15
jg     1e90 <fourt+0xd60>
lea    (%r12,%r15,1),%eax
movslq %eax,%rsi
cmp    %rsi,%r15
jg     2080 <fourt+0xf50>
movslq %r8d,%rax
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
mov    0x1a0(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
xor    %edx,%edx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
add    %r11,%rax
lea    (%r15,%rax,1),%rdi
add    $0x1,%rdx
cmp    %rsi,%rdi
jle    20d0 <fourt+0xfa0>
add    %edx,%r8d
mov    0x248(%rsp),%rbx
mov    0x60(%rsp),%rcx
jmp    2080 <fourt+0xf50>
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x48(%rsp)
je     22e0 <fourt+0x11b0>
mov    0x50(%rsp),%r14
lea    (%r14,%r14,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0xf11(%rip),%xmm0
divss  %xmm1,%xmm0
cmpl   $0x0,0x4c(%rsp)
mov    %eax,0x110(%rsp)
jne    2149 <fourt+0x1019>
xorps  %xmm14,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
call   1050 <cos@plt>
movaps %xmm0,0x70(%rsp)
movsd  0x30(%rsp),%xmm0
call   1040 <sin@plt>
mov    %r14d,%ebx
cmp    $0x3,%r14d
mov    %rbx,0x18(%rsp)
jl     26a7 <fourt+0x1577>
unpcklpd 0x70(%rsp),%xmm0
cvtpd2ps %xmm0,%xmm0
movslq 0xc(%rsp),%r8
movslq 0x10(%rsp),%r10
movapd %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
movaps %xmm0,%xmm9
shufps $0x55,%xmm0,%xmm9
mov    0xe8(%rsp),%rax
lea    (%rax,%rbx,4),%rsi
lea    0x0(%r13,%rbx,4),%rdi
mov    $0x2,%r11d
mov    %rbx,%r9
mov    0x168(%rsp),%rbx
mov    0x170(%rsp),%rcx
movss  0xe6d(%rip),%xmm4
movaps 0xe35(%rip),%xmm12
jmp    221e <fourt+0x10ee>
nopl   (%rax)
add    $0x1,%r11
add    $0xffffffffffffffff,%r9
movaps %xmm0,%xmm1
xorps  %xmm12,%xmm1
shufps $0xd4,%xmm0,%xmm1
shufps $0x52,%xmm0,%xmm1
mulps  %xmm8,%xmm1
mulps  %xmm9,%xmm0
addps  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rdi
add    $0x4,%rcx
add    $0x4,%rbx
mov    %r11d,%edx
sub    %r9d,%edx
jns    26ca <fourt+0x159a>
cmp    %r11d,0x10(%rsp)
jl     21e0 <fourt+0x10b0>
movaps %xmm0,%xmm10
shufps $0x55,%xmm0,%xmm10
movaps %xmm10,%xmm11
xorps  %xmm12,%xmm11
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm5
movss  (%rsi,%rdx,4),%xmm2
movaps %xmm5,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm4,%xmm1
movss  (%rbx,%rdx,4),%xmm6
movss  (%rdi,%rdx,4),%xmm3
movaps %xmm6,%xmm7
addss  %xmm3,%xmm7
mulss  %xmm4,%xmm7
subss  %xmm2,%xmm5
mulss  %xmm4,%xmm5
subss  %xmm3,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm10,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm11,%xmm5
mulss  %xmm0,%xmm7
addss  %xmm5,%xmm7
movaps %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rcx,%rdx,4)
movaps %xmm6,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,(%rbx,%rdx,4)
subss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
subss  %xmm6,%xmm7
movss  %xmm7,(%rdi,%rdx,4)
add    %r8,%rdx
lea    (%r11,%rdx,1),%rax
cmp    %r10,%rax
jle    2240 <fourt+0x1110>
jmp    21e0 <fourt+0x10b0>
nopl   0x0(%rax)
cmpb   $0x0,0x24(%rsp)
je     2cc5 <fourt+0x1b95>
cmpl   $0x3,0xb4(%rsp)
03
mov    0xe0(%rsp),%rdx
mov    0xd8(%rsp),%r9
mov    0xa8(%rsp),%rcx
mov    0x50(%rsp),%rax
jl     2c9c <fourt+0x1b6c>
test   %edi,%edi
jle    2c9c <fourt+0x1b6c>
cmp    $0x3,%rcx
setae  %al
lea    0x1(%r11),%r10d
lea    0x1(%r15),%edx
mov    0x140(%rsp),%rcx
lea    (%r15,%rcx,1),%ebx
add    $0x1,%ebx
sub    %r11d,%ebx
movslq %ecx,%r12
sub    %r11d,%edx
movslq %esi,%rcx
mov    %rcx,0x68(%rsp)
movslq %r15d,%rcx
mov    %rcx,0x80(%rsp)
mov    %edi,%ecx
mov    %rcx,0x60(%rsp)
cmp    %r15d,%r11d
setl   %cl
and    %al,%cl
mov    %cl,0x30(%rsp)
lea    0x0(,%r12,4),%rdi
mov    $0x1,%r8d
jmp    23ae <fourt+0x127e>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%esi
mov    0x18(%rsp),%r10d
add    %esi,%r10d
mov    0xc0(%rsp),%ebx
add    %esi,%ebx
mov    0x70(%rsp),%edx
add    %esi,%edx
mov    0x90(%rsp),%r8
cmp    0x60(%rsp),%r8
jg     2c70 <fourt+0x1b40>
mov    0x68(%rsp),%rax
lea    (%r8,%rax,1),%r11
mov    %r11,0x90(%rsp)
mov    0x80(%rsp),%rsi
sub    %rsi,%r11
mov    %r8,%rcx
mov    %edx,0x70(%rsp)
mov    %ebx,0xc0(%rsp)
mov    %ebx,%eax
mov    %r10d,0x18(%rsp)
cmp    %r11,%r8
jle    23fe <fourt+0x12ce>
jmp    2380 <fourt+0x1250>
cs nopw 0x0(%rax,%rax,1)
add    %r15d,%r10d
sub    %r15d,%eax
sub    %r15d,%edx
cmp    %r11,%rcx
jg     2380 <fourt+0x1250>
movslq %r10d,%r9
cmp    %r8,%rcx
lea    (%rcx,%rsi,1),%rcx
mov    $0x0,%r14d
cmovg  0xc(%rsp),%r14d
cmpb   $0x0,0x30(%rsp)
je     245c <fourt+0x132c>
lea    (%r14,%rax,1),%ebx
movslq %ebx,%r15
shl    $0x2,%r15
mov    %r9,%rbx
nopl   0x0(%rax)
movss  -0x4(%rbp,%r15,1),%xmm0
movss  %xmm0,-0x4(%rbp,%rbx,4)
movss  0x0(%r13,%r15,1),%xmm0
xorps  %xmm14,%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%r15
cmp    %rcx,%rbx
jl     2430 <fourt+0x1300>
mov    0x28(%rsp),%r15
cmp    %r15d,0x88(%rsp)
jge    23f0 <fourt+0x12c0>
add    %edx,%r14d
movslq %r14d,%rbx
shl    $0x2,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rbp,%rbx,1),%xmm0
movss  %xmm0,-0x4(%rbp,%r9,4)
movss  0x0(%r13,%rbx,1),%xmm0
xorps  %xmm14,%xmm0
movss  %xmm0,0x0(%r13,%r9,4)
add    %r12,%r9
add    %rdi,%rbx
cmp    %rcx,%r9
jl     2480 <fourt+0x1350>
jmp    23f0 <fourt+0x12c0>
lea    (%r15,%r15,1),%eax
mov    %eax,0x30(%rsp)
movslq 0x10(%rsp),%rbx
pxor   %xmm2,%xmm2
movss  0x130(%rsp),%xmm0
movss  0x134(%rsp),%xmm1
jmp    24fe <fourt+0x13ce>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x18(%rsp),%xmm1
mulss  %xmm7,%xmm1
add    %r12d,%r12d
movapd %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
cmp    %r14d,%r12d
jg     1b3e <fourt+0xa0e>
movaps %xmm0,0xc0(%rsp)
movdqa %xmm2,0x70(%rsp)
movss  %xmm1,0x18(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x68(%rsp)
call   1050 <cos@plt>
movaps %xmm0,0x90(%rsp)
movsd  0x68(%rsp),%xmm0
call   1040 <sin@plt>
movaps 0xc0(%rsp),%xmm9
movaps 0x70(%rsp),%xmm8
mov    0x88(%rsp),%r11
movaps 0xaba(%rip),%xmm14
movss  0xae2(%rip),%xmm7
unpcklpd 0x90(%rsp),%xmm0
cvtpd2ps %xmm0,%xmm0
mov    %r12d,%r8d
shr    $0x1f,%r8d
add    %r12d,%r8d
sar    %r8d
add    %r15d,%r8d
cmp    %r12d,%r8d
mov    0x10(%rsp),%r10
jg     24e0 <fourt+0x13b0>
shufps $0x0,%xmm9,%xmm9
shufps $0x0,%xmm8,%xmm8
movapd %xmm0,%xmm1
jmp    25c8 <fourt+0x1498>
nopl   0x0(%rax)
movaps %xmm1,%xmm2
xorps  %xmm14,%xmm2
shufps $0xd4,%xmm1,%xmm2
shufps $0x52,%xmm1,%xmm2
mulps  %xmm9,%xmm2
mulps  %xmm8,%xmm1
addps  %xmm2,%xmm1
add    0x30(%rsp),%r8d
cmp    %r12d,%r8d
jg     24e0 <fourt+0x13b0>
test   %r11d,%r11d
jle    25a0 <fourt+0x1470>
movapd %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mov    $0x1,%r9d
jmp    25ec <fourt+0x14bc>
nopl   (%rax)
lea    0x1(%r9),%eax
cmp    %r11d,%r9d
mov    %eax,%r9d
je     25a0 <fourt+0x1470>
lea    (%r9,%r8,1),%edx
mov    %r12d,%esi
jmp    260c <fourt+0x14dc>
cs nopw 0x0(%rax,%rax,1)
nop
add    %edx,%edx
sub    %r9d,%edx
add    %esi,%esi
cmp    %r14d,%esi
jg     25e0 <fourt+0x14b0>
cmp    %r10d,%edx
jg     2600 <fourt+0x14d0>
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
sar    %eax
mov    %edx,%ecx
sub    %eax,%ecx
movslq %edx,%rdi
movslq %esi,%rax
movslq %ecx,%rcx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbp,%rdi,4),%xmm3
movss  0x0(%r13,%rdi,4),%xmm4
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm3,%xmm6
mulss  %xmm2,%xmm6
subss  %xmm5,%xmm6
mulss  %xmm2,%xmm4
mulss  %xmm1,%xmm3
addss  %xmm4,%xmm3
movss  -0x4(%rbp,%rcx,4),%xmm4
subss  %xmm6,%xmm4
movss  %xmm4,-0x4(%rbp,%rdi,4)
movss  0x0(%r13,%rcx,4),%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,0x0(%r13,%rdi,4)
addss  -0x4(%rbp,%rcx,4),%xmm6
movss  %xmm6,-0x4(%rbp,%rcx,4)
addss  0x0(%r13,%rcx,4),%xmm3
movss  %xmm3,0x0(%r13,%rcx,4)
add    %rax,%rcx
add    %rax,%rdi
cmp    %rbx,%rdi
jle    2630 <fourt+0x1500>
jmp    2600 <fourt+0x14d0>
mov    $0x2,%r11d
mov    $0x2,%edx
sub    %r14d,%edx
movaps 0x953(%rip),%xmm12
mov    0xc(%rsp),%ecx
cmpl   $0x0,0x4c(%rsp)
jne    26da <fourt+0x15aa>
jmp    270a <fourt+0x15da>
mov    0xc(%rsp),%ecx
mov    0x18(%rsp),%rbx
cmpl   $0x0,0x4c(%rsp)
je     270a <fourt+0x15da>
test   %edx,%edx
jne    270a <fourt+0x15da>
cmp    0x10(%rsp),%r11d
jg     270a <fourt+0x15da>
mov    %r11d,%eax
movslq %ecx,%rcx
movslq 0x10(%rsp),%rdx
movss  0x0(%r13,%rax,4),%xmm0
xorps  %xmm12,%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    %rcx,%rax
cmp    %rdx,%rax
jle    26f0 <fourt+0x15c0>
mov    0x10(%rsp),%r11
lea    (%r11,%r11,1),%eax
mov    %eax,0xf0(%rsp)
lea    (%r11,%r11,1),%r15d
add    $0x1,%r15d
lea    0x1(%r11),%r8d
lea    0x2(%r11),%ecx
movslq %r14d,%rax
not    %r11d
mov    %rax,0x70(%rsp)
neg    %rax
mov    %rax,0x118(%rsp)
mov    %r8d,%r12d
jmp    277b <fourt+0x164b>
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rbp,%r14,4),%xmm0
addss  0x0(%r13,%r14,4),%xmm0
movslq %r15d,%rax
movss  %xmm0,-0x4(%rbp,%rax,4)
movl   $0x0,0x0(%r13,%rax,4)
add    %rbx,%r11
mov    %r12d,%r8d
mov    0x50(%rsp),%r14
sub    %r14d,%ecx
sub    %r14d,%r12d
lea    0x1(%r12),%eax
lea    -0x1(%r15),%r10d
cmp    %r8d,%eax
jge    2870 <fourt+0x1740>
movslq %ecx,%rsi
movslq %r10d,%r15
mov    %rsi,%r9
mov    %r15,%r10
test   $0x1,%r14b
jne    27cc <fourt+0x169c>
movss  -0x4(%rbp,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rbp,%r15,4)
movss  0x0(%r13,%rsi,4),%xmm0
xorps  %xmm12,%xmm0
movss  %xmm0,0x0(%r13,%r15,4)
lea    0x1(%rsi),%r9
lea    -0x1(%r15),%r10
cmp    $0x2,%r14d
je     285f <fourt+0x172f>
mov    %ecx,0x30(%rsp)
mov    %r11,%r14
add    %r9,%r11
mov    0x58(%rsp),%rsi
lea    (%rsi,%r9,4),%rdi
lea    0x0(,%r9,4),%rbx
add    %rbp,%rbx
lea    -0x1(%r10),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  -0x4(%rdi,%rax,4),%xmm0
xorps  %xmm12,%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rcx,4)
movss  (%rdi,%rax,4),%xmm0
xorps  %xmm12,%xmm0
movss  %xmm0,-0x4(%rsi,%rcx,4)
add    $0x2,%rax
add    $0xfffffffffffffffe,%rcx
mov    %eax,%edx
add    %r11d,%edx
jne    2800 <fourt+0x16d0>
lea    (%r9,%rax,1),%rsi
add    $0xffffffffffffffff,%rsi
sub    %rax,%r10
lea    0x1(%r10),%r15
mov    %r14,%r11
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%ecx
mov    %r8d,%eax
jmp    2873 <fourt+0x1743>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%esi
movslq %r12d,%r14
movss  -0x4(%rbp,%r14,4),%xmm0
subss  0x0(%r13,%r14,4),%xmm0
movslq %r10d,%rdx
movss  %xmm0,-0x4(%rbp,%rdx,4)
movl   $0x0,0x0(%r13,%rdx,4)
cmp    %edx,%eax
jge    2c20 <fourt+0x1af0>
add    $0xfffffffe,%r15d
cmp    %r12d,%esi
jle    2750 <fourt+0x1620>
movslq %r8d,%rdx
mov    %rdx,%rdi
sub    0x70(%rsp),%rdi
movslq %esi,%r9
movslq %r15d,%r15
lea    -0x1(%r9),%r10
cmp    %r10,%rdi
mov    %r10,%rax
cmovl  %rdi,%rax
mov    %r9,%rbx
sub    %rax,%rbx
cmp    $0x4,%rbx
mov    %ecx,0x30(%rsp)
jae    2950 <fourt+0x1820>
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r15,4),%rax
lea    0x0(,%r15,4),%rdx
add    %r13,%rdx
lea    (%rcx,%r9,4),%rsi
lea    0x0(,%r9,4),%rbx
add    %r13,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
lea    (%r9,%rdi,1),%rcx
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rdi
cmp    %r14,%rcx
jg     2910 <fourt+0x17e0>
add    %rdi,%r15
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%ecx
jmp    2750 <fourt+0x1620>
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,0xc0(%rsp)
cmp    %r10,%rdi
mov    %r10,%rax
cmovl  %rdi,%rax
not    %rax
add    %r9,%rax
mov    $0x4,%ecx
mul    %rcx
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
seto   %dl
mov    %rcx,%rsi
sub    %rax,%rsi
cmp    %rcx,%rsi
ja     28da <fourt+0x17aa>
test   %dl,%dl
jne    28da <fourt+0x17aa>
lea    0x0(,%r15,4),%rcx
add    %r13,%rcx
mov    %rcx,%rsi
sub    %rax,%rsi
cmp    %rcx,%rsi
ja     28da <fourt+0x17aa>
test   %dl,%dl
jne    28da <fourt+0x17aa>
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r9,4),%rcx
mov    %rcx,%rsi
sub    %rax,%rsi
cmp    %rcx,%rsi
ja     28da <fourt+0x17aa>
test   %dl,%dl
jne    28da <fourt+0x17aa>
lea    0x0(,%r9,4),%rcx
add    %r13,%rcx
mov    %rcx,%rsi
sub    %rax,%rsi
cmp    %rcx,%rsi
ja     28da <fourt+0x17aa>
test   %dl,%dl
jne    28da <fourt+0x17aa>
mov    %rbx,0x120(%rsp)
mov    %r11,0x10(%rsp)
cmp    %r10,%rdi
cmovge %r10,%rdi
lea    (%rdi,%r15,1),%rax
sub    %r9,%rax
lea    0x0(,%rax,4),%rdx
add    %rbp,%rdx
lea    0x0(%rbp,%r15,4),%rsi
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%r11
lea    (%rcx,%r15,4),%rbx
lea    0x0(%rbp,%rdi,4),%rax
lea    0x0(%rbp,%r9,4),%r8
lea    (%rcx,%rdi,4),%rdi
mov    %rdi,0x80(%rsp)
lea    (%rcx,%r9,4),%rdi
cmp    %rbx,%rdx
setb   0x90(%rsp)
cmp    %rsi,%r11
setb   0x68(%rsp)
cmp    %r8,%rdx
setb   0x60(%rsp)
cmp    %rsi,%rax
setb   0x100(%rsp)
cmp    %rdi,%rdx
setb   %dl
mov    0x80(%rsp),%rcx
cmp    %rsi,%rcx
setb   0xf8(%rsp)
cmp    %r8,%r11
setb   %sil
cmp    %rbx,%rax
setb   0x128(%rsp)
cmp    %rdi,%r11
setb   %al
cmp    %rbx,%rcx
setb   %bl
mov    0x68(%rsp),%cl
test   %cl,0x90(%rsp)
jne    2c14 <fourt+0x1ae4>
mov    0x100(%rsp),%cl
and    %cl,0x60(%rsp)
jne    2c14 <fourt+0x1ae4>
and    0xf8(%rsp),%dl
mov    0x10(%rsp),%r11
jne    28da <fourt+0x17aa>
and    0x128(%rsp),%sil
jne    28da <fourt+0x17aa>
and    %bl,%al
jne    28da <fourt+0x17aa>
mov    0x120(%rsp),%r8
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
lea    -0x4(%rdi),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     2bcb <fourt+0x1a9b>
mov    %rdx,0x68(%rsp)
mov    %rdi,0x90(%rsp)
mov    0xc0(%rsp),%rcx
add    0x118(%rsp),%rcx
mov    0x180(%rsp),%rax
lea    (%rax,%r15,4),%rsi
mov    0x178(%rsp),%rdx
lea    (%rdx,%r15,4),%rdi
lea    (%rax,%r9,4),%r11
cmp    %r10,%rcx
cmovge %r10,%rcx
lea    (%rdx,%r9,4),%rdx
mov    %r9,%rbx
sub    %rcx,%rbx
and    $0xfffffffffffffffc,%rbx
add    $0xfffffffffffffffc,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %eax,%eax
nopl   (%rax)
movups (%rdx,%rax,4),%xmm0
movups %xmm0,(%rdi,%rax,4)
movups (%r11,%rax,4),%xmm0
movups %xmm0,(%rsi,%rax,4)
movups -0x10(%rdx,%rax,4),%xmm0
movups %xmm0,-0x10(%rdi,%rax,4)
movups -0x10(%r11,%rax,4),%xmm0
movups %xmm0,-0x10(%rsi,%rax,4)
add    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffffe,%rbx
jne    2b80 <fourt+0x1a50>
neg    %rax
mov    0x10(%rsp),%r11
mov    0x30(%rsp),%ecx
mov    0x90(%rsp),%rdi
mov    0x68(%rsp),%rdx
jmp    2bd1 <fourt+0x1aa1>
xor    %eax,%eax
mov    0x30(%rsp),%ecx
test   $0x1,%dl
mov    0x18(%rsp),%rbx
je     2c00 <fourt+0x1ad0>
mov    %r15,%rdx
sub    %rax,%rdx
mov    %r9,%rsi
sub    %rax,%rsi
movups -0x10(%rbp,%rsi,4),%xmm0
movups %xmm0,-0x10(%rbp,%rdx,4)
mov    0x58(%rsp),%rax
movups -0x10(%rax,%rsi,4),%xmm0
movups %xmm0,-0x10(%rax,%rdx,4)
sub    %rdi,%r15
cmp    %rdi,%r8
je     2750 <fourt+0x1620>
sub    %rdi,%r9
jmp    28da <fourt+0x17aa>
mov    0x10(%rsp),%r11
jmp    28da <fourt+0x17aa>
xchg   %ax,%ax
mov    0xc(%rsp),%esi
add    %esi,%esi
movss  0x0(%rbp),%xmm0
mov    0x58(%rsp),%rax
addss  (%rax),%xmm0
movss  %xmm0,0x0(%rbp)
movl   $0x0,(%rax)
mov    0xe0(%rsp),%rdx
mov    0xd8(%rsp),%r9
mov    0x28(%rsp),%r15
mov    0xa8(%rsp),%rcx
mov    0x110(%rsp),%r8d
mov    0xf0(%rsp),%edi
jmp    1443 <fourt+0x313>
mov    0x10(%rsp),%rax
mov    %eax,%edi
mov    0x50(%rsp),%rax
mov    %eax,%r8d
mov    0xe0(%rsp),%rdx
mov    0xd8(%rsp),%r9
mov    0xa8(%rsp),%rcx
jmp    1443 <fourt+0x313>
mov    %eax,%r8d
jmp    1443 <fourt+0x313>
add    $0x1,%r8d
jmp    14b8 <fourt+0x388>
mov    $0x1,%r11b
movl   $0x0,0x24(%rsp)
movl   $0x0,0x48(%rsp)
jmp    165b <fourt+0x52b>
jmp    2c77 <fourt+0x1b47>
mov    $0x1,%al
mov    %eax,0x48(%rsp)
lea    0x1(%r9),%edx
lea    -0x1(%rdx),%r8
mov    $0x1,%esi
mov    $0x1,%edi
cmp    $0x2,%edx
mov    0x58(%rsp),%rax
je     2d45 <fourt+0x1c15>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%esi
mov    $0x1,%edi
nopl   (%rax)
movss  -0x8(%rbp,%rsi,8),%xmm0
movss  %xmm0,-0x4(%rbp,%rsi,4)
movss  -0x4(%rbp,%rsi,8),%xmm0
movss  %xmm0,-0x4(%rax,%rsi,4)
movss  0x0(%rbp,%rsi,8),%xmm0
movss  %xmm0,0x0(%rbp,%rsi,4)
movss  0x4(%rbp,%rsi,8),%xmm0
movss  %xmm0,(%rax,%rsi,4)
add    $0x4,%rdi
lea    (%rdx,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
cmp    $0x1,%rcx
jne    2d00 <fourt+0x1bd0>
test   $0x1,%r8b
movaps 0x2bf(%rip),%xmm14
je     2d6c <fourt+0x1c3c>
movss  -0x4(%rbp,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rsi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,0x0(%r13,%rsi,4)
movl   $0x0,0x24(%rsp)
xor    %r11d,%r11d
mov    %r9,0x10(%rsp)
mov    %r12,0x50(%rsp)
jmp    1663 <fourt+0x533>
xor    %eax,%eax
add    $0x208,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @fourt(float* %0, float* %1, i32* %2, i32 %3, i32 %4, i32 %5, float* %6, float* %7) {
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca float*
%17 = alloca float*
%18 = alloca [21 x i32]
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%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 i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca float
%62 = alloca float
%63 = alloca float
%64 = alloca float
%65 = alloca float
%66 = alloca float
%67 = alloca float
%68 = alloca float
%69 = alloca float
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float
%74 = alloca float
%75 = alloca float
%76 = alloca float
%77 = alloca float
%78 = alloca float
%79 = alloca float
%80 = alloca float
%81 = alloca float
%82 = alloca float
%83 = alloca float
%84 = alloca float
%85 = alloca float
store float* %0, float** %10
store float* %1, float** %11
store i32* %2, i32** %12
store i32 %3, i32* %13
store i32 %4, i32* %14
store i32 %5, i32* %15
store float* %6, float** %16
store float* %7, float** %17
%86 = load float*, float** %10
%87 = getelementptr inbounds float, float* %86, i32 -1
store float* %87, float** %10
%88 = load float*, float** %11
%89 = getelementptr inbounds float, float* %88, i32 -1
store float* %89, float** %11
%90 = load i32*, i32** %12
%91 = getelementptr inbounds i32, i32* %90, i32 -1
store i32* %91, i32** %12
%92 = load float*, float** %16
%93 = getelementptr inbounds float, float* %92, i32 -1
store float* %93, float** %16
%94 = load float*, float** %17
%95 = getelementptr inbounds float, float* %94, i32 -1
store float* %95, float** %17
%96 = load i32, i32* %13
%97 = icmp slt i32 %96, 1
br i1 %97, label %98, label %99
98: ; preds = %8
store i32 0, i32* %9
br label %1683
99: ; preds = %8
store i32 1, i32* %42
store i32 1, i32* %41
br label %100
100: ; preds = %112, %99
%101 = load i32, i32* %41
%102 = load i32, i32* %13
%103 = icmp sle i32 %101, %102
br i1 %103, label %104, label %115
104: ; preds = %100
%105 = load i32, i32* %42
%106 = load i32*, i32** %12
%107 = load i32, i32* %41
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %106, i64 %108
%110 = load i32, i32* %109
%111 = mul nsw i32 %105, %110
store i32 %111, i32* %42
br label %112
112: ; preds = %104
%113 = load i32, i32* %41
%114 = add nsw i32 %113, 1
store i32 %114, i32* %41
br label %100
115: ; preds = %100
store float 0x401921FB60000000, float* %61
store i32 1, i32* %44
store i32 1, i32* %41
br label %116
116: ; preds = %1679, %115
%117 = load i32, i32* %41
%118 = load i32, i32* %13
%119 = icmp sle i32 %117, %118
br i1 %119, label %120, label %1682
120: ; preds = %116
%121 = load i32*, i32** %12
%122 = load i32, i32* %41
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %121, i64 %123
%125 = load i32, i32* %124
store i32 %125, i32* %43
%126 = load i32, i32* %44
%127 = load i32, i32* %43
%128 = mul nsw i32 %126, %127
store i32 %128, i32* %45
%129 = load i32, i32* %43
%130 = icmp slt i32 %129, 1
br i1 %130, label %131, label %132
131: ; preds = %120
store i32 0, i32* %9
br label %1683
132: ; preds = %120
%133 = load i32, i32* %43
%134 = icmp eq i32 %133, 1
br i1 %134, label %135, label %139
135: ; preds = %132
%136 = load i32, i32* %44
store i32 %136, i32* %56
%137 = load i32, i32* %45
store i32 %137, i32* %44
%138 = load i32, i32* %43
store i32 %138, i32* %57
br label %1679
139: ; preds = %132
%140 = load i32, i32* %43
store i32 %140, i32* %48
%141 = load i32, i32* %44
store i32 %141, i32* %46
store i32 1, i32* %27
store i32 2, i32* %30
br label %142
142: ; preds = %139, %206
%143 = load i32, i32* %48
%144 = load i32, i32* %30
%145 = sdiv i32 %143, %144
store i32 %145, i32* %31
%146 = load i32, i32* %48
%147 = load i32, i32* %30
%148 = load i32, i32* %31
%149 = mul nsw i32 %147, %148
%150 = sub nsw i32 %146, %149
store i32 %150, i32* %32
%151 = load i32, i32* %31
%152 = load i32, i32* %30
%153 = icmp slt i32 %151, %152
br i1 %153, label %154, label %168
154: ; preds = %142
%155 = load i32, i32* %27
store i32 %155, i32* %33
%156 = load i32, i32* %32
%157 = icmp eq i32 %156, 0
br i1 %157, label %158, label %162
158: ; preds = %154
%159 = load i32, i32* %46
%160 = load i32, i32* %46
%161 = add nsw i32 %160, %159
store i32 %161, i32* %46
br label %167
162: ; preds = %154
%163 = load i32, i32* %48
%164 = load i32, i32* %27
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %165
store i32 %163, i32* %166
br label %167
167: ; preds = %162, %158
br label %217
168: ; preds = %142
%169 = load i32, i32* %32
%170 = icmp ne i32 %169, 0
br i1 %170, label %171, label %206
171: ; preds = %168
store i32 3, i32* %30
%172 = load i32, i32* %27
store i32 %172, i32* %33
br label %173
173: ; preds = %171, %204
%174 = load i32, i32* %48
%175 = load i32, i32* %30
%176 = sdiv i32 %174, %175
store i32 %176, i32* %31
%177 = load i32, i32* %48
%178 = load i32, i32* %30
%179 = load i32, i32* %31
%180 = mul nsw i32 %178, %179
%181 = sub nsw i32 %177, %180
store i32 %181, i32* %32
%182 = load i32, i32* %31
%183 = load i32, i32* %30
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %190
185: ; preds = %173
%186 = load i32, i32* %48
%187 = load i32, i32* %27
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %188
store i32 %186, i32* %189
br label %205
190: ; preds = %173
%191 = load i32, i32* %32
%192 = icmp eq i32 %191, 0
br i1 %192, label %193, label %201
193: ; preds = %190
%194 = load i32, i32* %30
%195 = load i32, i32* %27
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %196
store i32 %194, i32* %197
%198 = load i32, i32* %27
%199 = add nsw i32 %198, 1
store i32 %199, i32* %27
%200 = load i32, i32* %31
store i32 %200, i32* %48
br label %204
201: ; preds = %190
%202 = load i32, i32* %30
%203 = add nsw i32 %202, 2
store i32 %203, i32* %30
br label %204
204: ; preds = %201, %193
br label %173
205: ; preds = %185
br label %217
206: ; preds = %168
%207 = load i32, i32* %46
%208 = load i32, i32* %46
%209 = add nsw i32 %208, %207
store i32 %209, i32* %46
%210 = load i32, i32* %30
%211 = load i32, i32* %27
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %212
store i32 %210, i32* %213
%214 = load i32, i32* %27
%215 = add nsw i32 %214, 1
store i32 %215, i32* %27
%216 = load i32, i32* %31
store i32 %216, i32* %48
br label %142
217: ; preds = %205, %167
%218 = load i32, i32* %45
%219 = load i32, i32* %46
%220 = sdiv i32 %218, %219
store i32 %220, i32* %47
%221 = load i32, i32* %27
%222 = icmp sle i32 %221, 21
%223 = zext i1 %222 to i32
%224 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %223)
store i32 1, i32* %40
store i32 1, i32* %51
%225 = load i32, i32* %15
%226 = icmp eq i32 %225, 0
br i1 %226, label %227, label %275
227: ; preds = %217
store i32 2, i32* %40
%228 = load i32, i32* %41
%229 = icmp sle i32 %228, 1
br i1 %229, label %230, label %274
230: ; preds = %227
store i32 3, i32* %40
%231 = load i32, i32* %46
%232 = load i32, i32* %44
%233 = icmp sgt i32 %231, %232
br i1 %233, label %234, label %273
234: ; preds = %230
store i32 4, i32* %40
store i32 2, i32* %51
%235 = load i32, i32* %46
%236 = sdiv i32 %235, 2
store i32 %236, i32* %46
%237 = load i32, i32* %43
%238 = sdiv i32 %237, 2
store i32 %238, i32* %43
%239 = load i32, i32* %45
%240 = sdiv i32 %239, 2
store i32 %240, i32* %45
%241 = load i32, i32* %42
%242 = sdiv i32 %241, 2
store i32 %242, i32* %42
store i32 1, i32* %19
store i32 1, i32* %23
br label %243
243: ; preds = %269, %234
%244 = load i32, i32* %23
%245 = load i32, i32* %42
%246 = icmp sle i32 %244, %245
br i1 %246, label %247, label %272
247: ; preds = %243
%248 = load float*, float** %10
%249 = load i32, i32* %19
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %248, i64 %250
%252 = load float, float* %251
%253 = load float*, float** %10
%254 = load i32, i32* %23
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %253, i64 %255
store float %252, float* %256
%257 = load float*, float** %10
%258 = load i32, i32* %19
%259 = add nsw i32 %258, 1
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds float, float* %257, i64 %260
%262 = load float, float* %261
%263 = load float*, float** %11
%264 = load i32, i32* %23
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %263, i64 %265
store float %262, float* %266
%267 = load i32, i32* %19
%268 = add nsw i32 %267, 2
store i32 %268, i32* %19
br label %269
269: ; preds = %247
%270 = load i32, i32* %23
%271 = add nsw i32 %270, 1
store i32 %271, i32* %23
br label %243
272: ; preds = %243
br label %273
273: ; preds = %272, %230
br label %274
274: ; preds = %273, %227
br label %275
275: ; preds = %274, %217
%276 = load i32, i32* %47
%277 = icmp sle i32 %276, 1
br i1 %277, label %278, label %384
278: ; preds = %275
%279 = load i32, i32* %45
%280 = sdiv i32 %279, 2
store i32 %280, i32* %52
store i32 1, i32* %23
store i32 1, i32* %21
br label %281
281: ; preds = %379, %278
%282 = load i32, i32* %21
%283 = load i32, i32* %45
%284 = icmp sle i32 %282, %283
br i1 %284, label %285, label %383
285: ; preds = %281
%286 = load i32, i32* %23
%287 = load i32, i32* %21
%288 = icmp slt i32 %286, %287
br i1 %288, label %289, label %358
289: ; preds = %285
%290 = load i32, i32* %21
%291 = load i32, i32* %44
%292 = add nsw i32 %290, %291
%293 = sub nsw i32 %292, 1
store i32 %293, i32* %53
%294 = load i32, i32* %21
store i32 %294, i32* %20
br label %295
295: ; preds = %354, %289
%296 = load i32, i32* %20
%297 = load i32, i32* %53
%298 = icmp sle i32 %296, %297
br i1 %298, label %299, label %357
299: ; preds = %295
%300 = load i32, i32* %20
store i32 %300, i32* %22
br label %301
301: ; preds = %349, %299
%302 = load i32, i32* %22
%303 = load i32, i32* %42
%304 = icmp sle i32 %302, %303
br i1 %304, label %305, label %353
305: ; preds = %301
%306 = load i32, i32* %23
%307 = load i32, i32* %22
%308 = add nsw i32 %306, %307
%309 = load i32, i32* %21
%310 = sub nsw i32 %308, %309
store i32 %310, i32* %26
%311 = load float*, float** %10
%312 = load i32, i32* %22
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
store float %315, float* %84
%316 = load float*, float** %11
%317 = load i32, i32* %22
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %316, i64 %318
%320 = load float, float* %319
store float %320, float* %85
%321 = load float*, float** %10
%322 = load i32, i32* %26
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float, float* %321, i64 %323
%325 = load float, float* %324
%326 = load float*, float** %10
%327 = load i32, i32* %22
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds float, float* %326, i64 %328
store float %325, float* %329
%330 = load float*, float** %11
%331 = load i32, i32* %26
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %330, i64 %332
%334 = load float, float* %333
%335 = load float*, float** %11
%336 = load i32, i32* %22
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
store float %334, float* %338
%339 = load float, float* %84
%340 = load float*, float** %10
%341 = load i32, i32* %26
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds float, float* %340, i64 %342
store float %339, float* %343
%344 = load float, float* %85
%345 = load float*, float** %11
%346 = load i32, i32* %26
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %345, i64 %347
store float %344, float* %348
br label %349
349: ; preds = %305
%350 = load i32, i32* %45
%351 = load i32, i32* %22
%352 = add nsw i32 %351, %350
store i32 %352, i32* %22
br label %301
353: ; preds = %301
br label %354
354: ; preds = %353
%355 = load i32, i32* %20
%356 = add nsw i32 %355, 1
store i32 %356, i32* %20
br label %295
357: ; preds = %295
br label %358
358: ; preds = %357, %285
%359 = load i32, i32* %52
store i32 %359, i32* %48
br label %360
360: ; preds = %374, %358
%361 = load i32, i32* %23
%362 = load i32, i32* %48
%363 = icmp sgt i32 %361, %362
br i1 %363, label %364, label %375
364: ; preds = %360
%365 = load i32, i32* %48
%366 = load i32, i32* %23
%367 = sub nsw i32 %366, %365
store i32 %367, i32* %23
%368 = load i32, i32* %48
%369 = sdiv i32 %368, 2
store i32 %369, i32* %48
%370 = load i32, i32* %48
%371 = load i32, i32* %44
%372 = icmp slt i32 %370, %371
br i1 %372, label %373, label %374
373: ; preds = %364
br label %375
374: ; preds = %364
br label %360
375: ; preds = %373, %360
%376 = load i32, i32* %48
%377 = load i32, i32* %23
%378 = add nsw i32 %377, %376
store i32 %378, i32* %23
br label %379
379: ; preds = %375
%380 = load i32, i32* %44
%381 = load i32, i32* %21
%382 = add nsw i32 %381, %380
store i32 %382, i32* %21
br label %281
383: ; preds = %281
br label %518
384: ; preds = %275
store i32 1, i32* %20
br label %385
385: ; preds = %514, %384
%386 = load i32, i32* %20
%387 = load i32, i32* %44
%388 = icmp sle i32 %386, %387
br i1 %388, label %389, label %517
389: ; preds = %385
%390 = load i32, i32* %20
store i32 %390, i32* %22
br label %391
391: ; preds = %509, %389
%392 = load i32, i32* %22
%393 = load i32, i32* %42
%394 = icmp sle i32 %392, %393
br i1 %394, label %395, label %513
395: ; preds = %391
%396 = load i32, i32* %22
store i32 %396, i32* %23
store i32 1, i32* %19
br label %397
397: ; preds = %469, %395
%398 = load i32, i32* %19
%399 = load i32, i32* %43
%400 = icmp sle i32 %398, %399
br i1 %400, label %401, label %472
401: ; preds = %397
%402 = load i32, i32* %40
%403 = icmp ne i32 %402, 3
br i1 %403, label %404, label %423
404: ; preds = %401
%405 = load float*, float** %10
%406 = load i32, i32* %23
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds float, float* %405, i64 %407
%409 = load float, float* %408
%410 = load float*, float** %16
%411 = load i32, i32* %19
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float, float* %410, i64 %412
store float %409, float* %413
%414 = load float*, float** %11
%415 = load i32, i32* %23
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
%419 = load float*, float** %17
%420 = load i32, i32* %19
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds float, float* %419, i64 %421
store float %418, float* %422
br label %437
423: ; preds = %401
%424 = load float*, float** %10
%425 = load i32, i32* %23
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
%428 = load float, float* %427
%429 = load float*, float** %16
%430 = load i32, i32* %19
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %429, i64 %431
store float %428, float* %432
%433 = load float*, float** %17
%434 = load i32, i32* %19
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %433, i64 %435
store float 0.000000e+00, float* %436
br label %437
437: ; preds = %423, %404
%438 = load i32, i32* %45
store i32 %438, i32* %29
%439 = load i32, i32* %51
store i32 %439, i32* %27
br label %440
440: ; preds = %464, %437
%441 = load i32, i32* %29
%442 = load i32, i32* %27
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %443
%445 = load i32, i32* %444
%446 = sdiv i32 %441, %445
store i32 %446, i32* %28
%447 = load i32, i32* %28
%448 = load i32, i32* %23
%449 = add nsw i32 %448, %447
store i32 %449, i32* %23
%450 = load i32, i32* %23
%451 = load i32, i32* %22
%452 = sub nsw i32 %450, %451
%453 = load i32, i32* %29
%454 = sub nsw i32 %452, %453
%455 = icmp slt i32 %454, 0
br i1 %455, label %456, label %457
456: ; preds = %440
br label %468
457: ; preds = %440
%458 = load i32, i32* %29
%459 = load i32, i32* %23
%460 = sub nsw i32 %459, %458
store i32 %460, i32* %23
%461 = load i32, i32* %28
store i32 %461, i32* %29
%462 = load i32, i32* %27
%463 = add nsw i32 %462, 1
store i32 %463, i32* %27
br label %464
464: ; preds = %457
%465 = load i32, i32* %29
%466 = load i32, i32* %44
%467 = icmp sgt i32 %465, %466
br i1 %467, label %440, label %468
468: ; preds = %464, %456
br label %469
469: ; preds = %468
%470 = load i32, i32* %19
%471 = add nsw i32 %470, 1
store i32 %471, i32* %19
br label %397
472: ; preds = %397
%473 = load i32, i32* %22
%474 = load i32, i32* %45
%475 = add nsw i32 %473, %474
%476 = load i32, i32* %44
%477 = sub nsw i32 %475, %476
store i32 %477, i32* %54
store i32 1, i32* %19
%478 = load i32, i32* %22
store i32 %478, i32* %21
br label %479
479: ; preds = %504, %472
%480 = load i32, i32* %21
%481 = load i32, i32* %54
%482 = icmp sle i32 %480, %481
br i1 %482, label %483, label %508
483: ; preds = %479
%484 = load float*, float** %16
%485 = load i32, i32* %19
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
%488 = load float, float* %487
%489 = load float*, float** %10
%490 = load i32, i32* %21
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds float, float* %489, i64 %491
store float %488, float* %492
%493 = load float*, float** %17
%494 = load i32, i32* %19
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %493, i64 %495
%497 = load float, float* %496
%498 = load float*, float** %11
%499 = load i32, i32* %21
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float, float* %498, i64 %500
store float %497, float* %501
%502 = load i32, i32* %19
%503 = add nsw i32 %502, 1
store i32 %503, i32* %19
br label %504
504: ; preds = %483
%505 = load i32, i32* %44
%506 = load i32, i32* %21
%507 = add nsw i32 %506, %505
store i32 %507, i32* %21
br label %479
508: ; preds = %479
br label %509
509: ; preds = %508
%510 = load i32, i32* %45
%511 = load i32, i32* %22
%512 = add nsw i32 %511, %510
store i32 %512, i32* %22
br label %391
513: ; preds = %391
br label %514
514: ; preds = %513
%515 = load i32, i32* %20
%516 = add nsw i32 %515, 1
store i32 %516, i32* %20
br label %385
517: ; preds = %385
br label %518
518: ; preds = %517, %383
%519 = load i32, i32* %44
store i32 %519, i32* %55
%520 = load i32, i32* %40
%521 = icmp eq i32 %520, 2
br i1 %521, label %522, label %528
522: ; preds = %518
%523 = load i32, i32* %56
%524 = load i32, i32* %57
%525 = sdiv i32 %524, 2
%526 = add nsw i32 1, %525
%527 = mul nsw i32 %523, %526
store i32 %527, i32* %55
br label %528
528: ; preds = %522, %518
%529 = load i32, i32* %46
%530 = load i32, i32* %44
%531 = icmp sgt i32 %529, %530
br i1 %531, label %532, label %903
532: ; preds = %528
store i32 1, i32* %20
br label %533
533: ; preds = %719, %532
%534 = load i32, i32* %20
%535 = load i32, i32* %55
%536 = icmp sle i32 %534, %535
br i1 %536, label %537, label %722
537: ; preds = %533
%538 = load i32, i32* %44
%539 = load i32, i32* %20
%540 = add nsw i32 %538, %539
store i32 %540, i32* %58
%541 = load i32, i32* %44
%542 = mul nsw i32 2, %541
store i32 %542, i32* %59
br label %543
543: ; preds = %608, %537
%544 = load i32, i32* %59
%545 = load i32, i32* %46
%546 = icmp sle i32 %544, %545
br i1 %546, label %547, label %617
547: ; preds = %543
%548 = load i32, i32* %20
store i32 %548, i32* %23
%549 = load i32, i32* %58
store i32 %549, i32* %19
br label %550
550: ; preds = %604, %547
%551 = load i32, i32* %19
%552 = load i32, i32* %42
%553 = icmp sle i32 %551, %552
br i1 %553, label %554, label %608
554: ; preds = %550
%555 = load float*, float** %10
%556 = load i32, i32* %19
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds float, float* %555, i64 %557
%559 = load float, float* %558
store float %559, float* %84
%560 = load float*, float** %11
%561 = load i32, i32* %19
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds float, float* %560, i64 %562
%564 = load float, float* %563
store float %564, float* %85
%565 = load float*, float** %10
%566 = load i32, i32* %23
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds float, float* %565, i64 %567
%569 = load float, float* %568
%570 = load float, float* %84
%571 = fsub float %569, %570
%572 = load float*, float** %10
%573 = load i32, i32* %19
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float, float* %572, i64 %574
store float %571, float* %575
%576 = load float*, float** %11
%577 = load i32, i32* %23
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds float, float* %576, i64 %578
%580 = load float, float* %579
%581 = load float, float* %85
%582 = fsub float %580, %581
%583 = load float*, float** %11
%584 = load i32, i32* %19
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds float, float* %583, i64 %585
store float %582, float* %586
%587 = load float, float* %84
%588 = load float*, float** %10
%589 = load i32, i32* %23
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
%593 = fadd float %592, %587
store float %593, float* %591
%594 = load float, float* %85
%595 = load float*, float** %11
%596 = load i32, i32* %23
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds float, float* %595, i64 %597
%599 = load float, float* %598
%600 = fadd float %599, %594
store float %600, float* %598
%601 = load i32, i32* %59
%602 = load i32, i32* %23
%603 = add nsw i32 %602, %601
store i32 %603, i32* %23
br label %604
604: ; preds = %554
%605 = load i32, i32* %59
%606 = load i32, i32* %19
%607 = add nsw i32 %606, %605
store i32 %607, i32* %19
br label %550
608: ; preds = %550
%609 = load i32, i32* %58
%610 = load i32, i32* %20
%611 = sub nsw i32 %609, %610
%612 = load i32, i32* %58
%613 = add nsw i32 %612, %611
store i32 %613, i32* %58
%614 = load i32, i32* %59
%615 = load i32, i32* %59
%616 = add nsw i32 %615, %614
store i32 %616, i32* %59
br label %543
617: ; preds = %543
%618 = load i32, i32* %44
%619 = mul nsw i32 3, %618
%620 = load i32, i32* %20
%621 = add nsw i32 %619, %620
store i32 %621, i32* %58
%622 = load i32, i32* %44
%623 = mul nsw i32 4, %622
store i32 %623, i32* %59
br label %624
624: ; preds = %709, %617
%625 = load i32, i32* %59
%626 = load i32, i32* %46
%627 = icmp sle i32 %625, %626
br i1 %627, label %628, label %718
628: ; preds = %624
%629 = load i32, i32* %58
%630 = load i32, i32* %59
%631 = sdiv i32 %630, 2
%632 = sub nsw i32 %629, %631
store i32 %632, i32* %23
%633 = load i32, i32* %58
store i32 %633, i32* %19
br label %634
634: ; preds = %705, %628
%635 = load i32, i32* %19
%636 = load i32, i32* %42
%637 = icmp sle i32 %635, %636
br i1 %637, label %638, label %709
638: ; preds = %634
%639 = load i32, i32* %14
%640 = icmp ne i32 %639, 0
br i1 %640, label %641, label %653
641: ; preds = %638
%642 = load float*, float** %11
%643 = load i32, i32* %19
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds float, float* %642, i64 %644
%646 = load float, float* %645
store float %646, float* %84
%647 = load float*, float** %10
%648 = load i32, i32* %19
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds float, float* %647, i64 %649
%651 = load float, float* %650
%652 = fneg float %651
store float %652, float* %85
br label %665
653: ; preds = %638
%654 = load float*, float** %11
%655 = load i32, i32* %19
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %654, i64 %656
%658 = load float, float* %657
%659 = fneg float %658
store float %659, float* %84
%660 = load float*, float** %10
%661 = load i32, i32* %19
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %660, i64 %662
%664 = load float, float* %663
store float %664, float* %85
br label %665
665: ; preds = %653, %641
%666 = load float*, float** %10
%667 = load i32, i32* %23
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds float, float* %666, i64 %668
%670 = load float, float* %669
%671 = load float, float* %84
%672 = fsub float %670, %671
%673 = load float*, float** %10
%674 = load i32, i32* %19
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds float, float* %673, i64 %675
store float %672, float* %676
%677 = load float*, float** %11
%678 = load i32, i32* %23
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds float, float* %677, i64 %679
%681 = load float, float* %680
%682 = load float, float* %85
%683 = fsub float %681, %682
%684 = load float*, float** %11
%685 = load i32, i32* %19
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds float, float* %684, i64 %686
store float %683, float* %687
%688 = load float, float* %84
%689 = load float*, float** %10
%690 = load i32, i32* %23
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %689, i64 %691
%693 = load float, float* %692
%694 = fadd float %693, %688
store float %694, float* %692
%695 = load float, float* %85
%696 = load float*, float** %11
%697 = load i32, i32* %23
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds float, float* %696, i64 %698
%700 = load float, float* %699
%701 = fadd float %700, %695
store float %701, float* %699
%702 = load i32, i32* %59
%703 = load i32, i32* %23
%704 = add nsw i32 %703, %702
store i32 %704, i32* %23
br label %705
705: ; preds = %665
%706 = load i32, i32* %59
%707 = load i32, i32* %19
%708 = add nsw i32 %707, %706
store i32 %708, i32* %19
br label %634
709: ; preds = %634
%710 = load i32, i32* %58
%711 = load i32, i32* %20
%712 = sub nsw i32 %710, %711
%713 = load i32, i32* %58
%714 = add nsw i32 %713, %712
store i32 %714, i32* %58
%715 = load i32, i32* %59
%716 = load i32, i32* %59
%717 = add nsw i32 %716, %715
store i32 %717, i32* %59
br label %624
718: ; preds = %624
br label %719
719: ; preds = %718
%720 = load i32, i32* %20
%721 = add nsw i32 %720, 1
store i32 %721, i32* %20
br label %533
722: ; preds = %533
%723 = load float, float* %61
%724 = fneg float %723
%725 = fpext float %724 to double
%726 = fdiv double %725, 8.000000e+00
%727 = fptrunc double %726 to float
store float %727, float* %62
store float 0.000000e+00, float* %63
store float -1.000000e+00, float* %64
%728 = load i32, i32* %14
%729 = icmp eq i32 %728, 0
br i1 %729, label %730, label %733
730: ; preds = %722
%731 = load float, float* %62
%732 = fneg float %731
store float %732, float* %62
store float 1.000000e+00, float* %64
br label %733
733: ; preds = %730, %722
%734 = load i32, i32* %44
%735 = mul nsw i32 8, %734
store i32 %735, i32* %49
br label %736
736: ; preds = %892, %733
%737 = load i32, i32* %49
%738 = load i32, i32* %46
%739 = icmp sle i32 %737, %738
br i1 %739, label %740, label %902
740: ; preds = %736
%741 = load float, float* %62
%742 = fpext float %741 to double
%743 = call double @cos(double %742)
%744 = fptrunc double %743 to float
store float %744, float* %65
%745 = load float, float* %62
%746 = fpext float %745 to double
%747 = call double @sin(double %746)
%748 = fptrunc double %747 to float
store float %748, float* %66
%749 = load float, float* %65
store float %749, float* %67
%750 = load float, float* %66
store float %750, float* %68
%751 = load i32, i32* %49
%752 = sdiv i32 %751, 2
%753 = load i32, i32* %44
%754 = add nsw i32 %752, %753
store i32 %754, i32* %50
%755 = load i32, i32* %44
%756 = load i32, i32* %44
%757 = add nsw i32 %755, %756
store i32 %757, i32* %60
%758 = load i32, i32* %50
store i32 %758, i32* %48
br label %759
759: ; preds = %888, %740
%760 = load i32, i32* %48
%761 = load i32, i32* %49
%762 = icmp sle i32 %760, %761
br i1 %762, label %763, label %892
763: ; preds = %759
store i32 1, i32* %20
br label %764
764: ; preds = %870, %763
%765 = load i32, i32* %20
%766 = load i32, i32* %55
%767 = icmp sle i32 %765, %766
br i1 %767, label %768, label %873
768: ; preds = %764
%769 = load i32, i32* %49
store i32 %769, i32* %59
%770 = load i32, i32* %48
%771 = load i32, i32* %20
%772 = add nsw i32 %770, %771
store i32 %772, i32* %58
br label %773
773: ; preds = %865, %768
%774 = load i32, i32* %58
%775 = load i32, i32* %59
%776 = sdiv i32 %775, 2
%777 = sub nsw i32 %774, %776
store i32 %777, i32* %23
%778 = load i32, i32* %58
store i32 %778, i32* %19
br label %779
779: ; preds = %852, %773
%780 = load i32, i32* %19
%781 = load i32, i32* %42
%782 = icmp sle i32 %780, %781
br i1 %782, label %783, label %856
783: ; preds = %779
%784 = load float*, float** %10
%785 = load i32, i32* %19
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float, float* %784, i64 %786
%788 = load float, float* %787
%789 = load float, float* %67
%790 = load float*, float** %11
%791 = load i32, i32* %19
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds float, float* %790, i64 %792
%794 = load float, float* %793
%795 = load float, float* %68
%796 = fmul float %794, %795
%797 = fneg float %796
%798 = call float @llvm.fmuladd.f32(float %788, float %789, float %797)
store float %798, float* %84
%799 = load float*, float** %10
%800 = load i32, i32* %19
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds float, float* %799, i64 %801
%803 = load float, float* %802
%804 = load float, float* %68
%805 = load float*, float** %11
%806 = load i32, i32* %19
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds float, float* %805, i64 %807
%809 = load float, float* %808
%810 = load float, float* %67
%811 = fmul float %809, %810
%812 = call float @llvm.fmuladd.f32(float %803, float %804, float %811)
store float %812, float* %85
%813 = load float*, float** %10
%814 = load i32, i32* %23
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds float, float* %813, i64 %815
%817 = load float, float* %816
%818 = load float, float* %84
%819 = fsub float %817, %818
%820 = load float*, float** %10
%821 = load i32, i32* %19
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds float, float* %820, i64 %822
store float %819, float* %823
%824 = load float*, float** %11
%825 = load i32, i32* %23
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds float, float* %824, i64 %826
%828 = load float, float* %827
%829 = load float, float* %85
%830 = fsub float %828, %829
%831 = load float*, float** %11
%832 = load i32, i32* %19
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %831, i64 %833
store float %830, float* %834
%835 = load float, float* %84
%836 = load float*, float** %10
%837 = load i32, i32* %23
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float, float* %836, i64 %838
%840 = load float, float* %839
%841 = fadd float %840, %835
store float %841, float* %839
%842 = load float, float* %85
%843 = load float*, float** %11
%844 = load i32, i32* %23
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds float, float* %843, i64 %845
%847 = load float, float* %846
%848 = fadd float %847, %842
store float %848, float* %846
%849 = load i32, i32* %59
%850 = load i32, i32* %23
%851 = add nsw i32 %850, %849
store i32 %851, i32* %23
br label %852
852: ; preds = %783
%853 = load i32, i32* %59
%854 = load i32, i32* %19
%855 = add nsw i32 %854, %853
store i32 %855, i32* %19
br label %779
856: ; preds = %779
%857 = load i32, i32* %58
%858 = load i32, i32* %20
%859 = sub nsw i32 %857, %858
%860 = load i32, i32* %58
%861 = add nsw i32 %860, %859
store i32 %861, i32* %58
%862 = load i32, i32* %59
%863 = load i32, i32* %59
%864 = add nsw i32 %863, %862
store i32 %864, i32* %59
br label %865
865: ; preds = %856
%866 = load i32, i32* %59
%867 = load i32, i32* %46
%868 = icmp sle i32 %866, %867
br i1 %868, label %773, label %869
869: ; preds = %865
br label %870
870: ; preds = %869
%871 = load i32, i32* %20
%872 = add nsw i32 %871, 1
store i32 %872, i32* %20
br label %764
873: ; preds = %764
%874 = load float, float* %67
%875 = load float, float* %64
%876 = fmul float %874, %875
store float %876, float* %69
%877 = load float, float* %67
%878 = load float, float* %63
%879 = load float, float* %68
%880 = load float, float* %64
%881 = fmul float %879, %880
%882 = fneg float %881
%883 = call float @llvm.fmuladd.f32(float %877, float %878, float %882)
store float %883, float* %67
%884 = load float, float* %68
%885 = load float, float* %63
%886 = load float, float* %69
%887 = call float @llvm.fmuladd.f32(float %884, float %885, float %886)
store float %887, float* %68
br label %888
888: ; preds = %873
%889 = load i32, i32* %60
%890 = load i32, i32* %48
%891 = add nsw i32 %890, %889
store i32 %891, i32* %48
br label %759
892: ; preds = %759
%893 = load float, float* %65
store float %893, float* %63
%894 = load float, float* %66
store float %894, float* %64
%895 = load float, float* %62
%896 = fpext float %895 to double
%897 = fdiv double %896, 2.000000e+00
%898 = fptrunc double %897 to float
store float %898, float* %62
%899 = load i32, i32* %49
%900 = load i32, i32* %49
%901 = add nsw i32 %900, %899
store i32 %901, i32* %49
br label %736
902: ; preds = %736
br label %903
903: ; preds = %902, %528
%904 = load i32, i32* %47
%905 = icmp sgt i32 %904, 1
br i1 %905, label %906, label %1203
906: ; preds = %903
%907 = load i32, i32* %46
store i32 %907, i32* %28
%908 = load i32, i32* %33
store i32 %908, i32* %27
br label %909
909: ; preds = %1198, %906
%910 = load i32, i32* %27
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %911
%913 = load i32, i32* %912
%914 = load i32, i32* %28
%915 = mul nsw i32 %913, %914
store i32 %915, i32* %29
%916 = load float, float* %61
%917 = fneg float %916
%918 = load i32, i32* %27
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %919
%921 = load i32, i32* %920
%922 = sitofp i32 %921 to float
%923 = fdiv float %917, %922
store float %923, float* %62
%924 = load i32, i32* %14
%925 = icmp eq i32 %924, 0
br i1 %925, label %926, label %929
926: ; preds = %909
%927 = load float, float* %62
%928 = fneg float %927
store float %928, float* %62
br label %929
929: ; preds = %926, %909
%930 = load float, float* %62
%931 = load i32, i32* %28
%932 = load i32, i32* %44
%933 = sdiv i32 %931, %932
%934 = sitofp i32 %933 to float
%935 = fdiv float %930, %934
store float %935, float* %72
%936 = load float, float* %62
%937 = fpext float %936 to double
%938 = call double @cos(double %937)
%939 = fptrunc double %938 to float
store float %939, float* %63
%940 = load float, float* %62
%941 = fpext float %940 to double
%942 = call double @sin(double %941)
%943 = fptrunc double %942 to float
store float %943, float* %64
%944 = load float, float* %72
%945 = fpext float %944 to double
%946 = call double @cos(double %945)
%947 = fptrunc double %946 to float
store float %947, float* %70
%948 = load float, float* %72
%949 = fpext float %948 to double
%950 = call double @sin(double %949)
%951 = fptrunc double %950 to float
store float %951, float* %71
store float 1.000000e+00, float* %65
store float 0.000000e+00, float* %66
store i32 1, i32* %24
br label %952
952: ; preds = %1190, %929
%953 = load i32, i32* %24
%954 = load i32, i32* %28
%955 = icmp sle i32 %953, %954
br i1 %955, label %956, label %1194
956: ; preds = %952
%957 = load i32, i32* %24
%958 = load i32, i32* %55
%959 = add nsw i32 %957, %958
%960 = sub nsw i32 %959, 1
store i32 %960, i32* %53
%961 = load i32, i32* %24
store i32 %961, i32* %20
br label %962
962: ; preds = %1172, %956
%963 = load i32, i32* %20
%964 = load i32, i32* %53
%965 = icmp sle i32 %963, %964
br i1 %965, label %966, label %1175
966: ; preds = %962
%967 = load i32, i32* %20
store i32 %967, i32* %22
br label %968
968: ; preds = %1167, %966
%969 = load i32, i32* %22
%970 = load i32, i32* %42
%971 = icmp sle i32 %969, %970
br i1 %971, label %972, label %1171
972: ; preds = %968
store i32 1, i32* %19
%973 = load float, float* %65
store float %973, float* %67
%974 = load float, float* %66
store float %974, float* %68
%975 = load i32, i32* %22
%976 = load i32, i32* %29
%977 = add nsw i32 %975, %976
%978 = load i32, i32* %28
%979 = sub nsw i32 %977, %978
store i32 %979, i32* %38
%980 = load i32, i32* %22
store i32 %980, i32* %25
br label %981
981: ; preds = %1115, %972
%982 = load i32, i32* %25
%983 = load i32, i32* %38
%984 = icmp sle i32 %982, %983
br i1 %984, label %985, label %1119
985: ; preds = %981
%986 = load float, float* %67
%987 = load float, float* %67
%988 = fadd float %986, %987
store float %988, float* %79
%989 = load i32, i32* %22
store i32 %989, i32* %37
%990 = load i32, i32* %25
%991 = load i32, i32* %45
%992 = add nsw i32 %990, %991
%993 = load i32, i32* %29
%994 = sub nsw i32 %992, %993
store i32 %994, i32* %39
%995 = load i32, i32* %25
store i32 %995, i32* %26
br label %996
996: ; preds = %1096, %985
%997 = load i32, i32* %26
%998 = load i32, i32* %39
%999 = icmp sle i32 %997, %998
br i1 %999, label %1000, label %1100
1000: ; preds = %996
%1001 = load i32, i32* %37
%1002 = load i32, i32* %29
%1003 = add nsw i32 %1001, %1002
%1004 = load i32, i32* %28
%1005 = sub nsw i32 %1003, %1004
store i32 %1005, i32* %23
%1006 = load float*, float** %10
%1007 = load i32, i32* %23
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds float, float* %1006, i64 %1008
%1010 = load float, float* %1009
store float %1010, float* %80
%1011 = load float*, float** %11
%1012 = load i32, i32* %23
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds float, float* %1011, i64 %1013
%1015 = load float, float* %1014
store float %1015, float* %81
store float 0.000000e+00, float* %73
store float 0.000000e+00, float* %74
%1016 = load i32, i32* %28
%1017 = load i32, i32* %23
%1018 = sub nsw i32 %1017, %1016
store i32 %1018, i32* %23
br label %1019
1019: ; preds = %1049, %1000
%1020 = load float, float* %80
store float %1020, float* %75
%1021 = load float, float* %81
store float %1021, float* %76
%1022 = load float, float* %79
%1023 = load float, float* %80
%1024 = load float, float* %73
%1025 = fneg float %1024
%1026 = call float @llvm.fmuladd.f32(float %1022, float %1023, float %1025)
%1027 = load float*, float** %10
%1028 = load i32, i32* %23
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds float, float* %1027, i64 %1029
%1031 = load float, float* %1030
%1032 = fadd float %1026, %1031
store float %1032, float* %80
%1033 = load float, float* %79
%1034 = load float, float* %81
%1035 = load float, float* %74
%1036 = fneg float %1035
%1037 = call float @llvm.fmuladd.f32(float %1033, float %1034, float %1036)
%1038 = load float*, float** %11
%1039 = load i32, i32* %23
%1040 = sext i32 %1039 to i64
%1041 = getelementptr inbounds float, float* %1038, i64 %1040
%1042 = load float, float* %1041
%1043 = fadd float %1037, %1042
store float %1043, float* %81
%1044 = load float, float* %75
store float %1044, float* %73
%1045 = load float, float* %76
store float %1045, float* %74
%1046 = load i32, i32* %28
%1047 = load i32, i32* %23
%1048 = sub nsw i32 %1047, %1046
store i32 %1048, i32* %23
br label %1049
1049: ; preds = %1019
%1050 = load i32, i32* %23
%1051 = load i32, i32* %37
%1052 = icmp sgt i32 %1050, %1051
br i1 %1052, label %1019, label %1053
1053: ; preds = %1049
%1054 = load float, float* %67
%1055 = load float, float* %80
%1056 = load float, float* %68
%1057 = load float, float* %81
%1058 = fmul float %1056, %1057
%1059 = fneg float %1058
%1060 = call float @llvm.fmuladd.f32(float %1054, float %1055, float %1059)
%1061 = load float, float* %73
%1062 = fsub float %1060, %1061
%1063 = load float*, float** %10
%1064 = load i32, i32* %23
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds float, float* %1063, i64 %1065
%1067 = load float, float* %1066
%1068 = fadd float %1062, %1067
%1069 = load float*, float** %16
%1070 = load i32, i32* %19
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds float, float* %1069, i64 %1071
store float %1068, float* %1072
%1073 = load float, float* %68
%1074 = load float, float* %80
%1075 = load float, float* %67
%1076 = load float, float* %81
%1077 = fmul float %1075, %1076
%1078 = call float @llvm.fmuladd.f32(float %1073, float %1074, float %1077)
%1079 = load float, float* %74
%1080 = fsub float %1078, %1079
%1081 = load float*, float** %11
%1082 = load i32, i32* %23
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds float, float* %1081, i64 %1083
%1085 = load float, float* %1084
%1086 = fadd float %1080, %1085
%1087 = load float*, float** %17
%1088 = load i32, i32* %19
%1089 = sext i32 %1088 to i64
%1090 = getelementptr inbounds float, float* %1087, i64 %1089
store float %1086, float* %1090
%1091 = load i32, i32* %29
%1092 = load i32, i32* %37
%1093 = add nsw i32 %1092, %1091
store i32 %1093, i32* %37
%1094 = load i32, i32* %19
%1095 = add nsw i32 %1094, 1
store i32 %1095, i32* %19
br label %1096
1096: ; preds = %1053
%1097 = load i32, i32* %29
%1098 = load i32, i32* %26
%1099 = add nsw i32 %1098, %1097
store i32 %1099, i32* %26
br label %996
1100: ; preds = %996
%1101 = load float, float* %67
%1102 = load float, float* %64
%1103 = fmul float %1101, %1102
store float %1103, float* %69
%1104 = load float, float* %67
%1105 = load float, float* %63
%1106 = load float, float* %68
%1107 = load float, float* %64
%1108 = fmul float %1106, %1107
%1109 = fneg float %1108
%1110 = call float @llvm.fmuladd.f32(float %1104, float %1105, float %1109)
store float %1110, float* %67
%1111 = load float, float* %68
%1112 = load float, float* %63
%1113 = load float, float* %69
%1114 = call float @llvm.fmuladd.f32(float %1111, float %1112, float %1113)
store float %1114, float* %68
br label %1115
1115: ; preds = %1100
%1116 = load i32, i32* %28
%1117 = load i32, i32* %25
%1118 = add nsw i32 %1117, %1116
store i32 %1118, i32* %25
br label %981
1119: ; preds = %981
store i32 1, i32* %19
%1120 = load i32, i32* %22
store i32 %1120, i32* %25
br label %1121
1121: ; preds = %1162, %1119
%1122 = load i32, i32* %25
%1123 = load i32, i32* %38
%1124 = icmp sle i32 %1122, %1123
br i1 %1124, label %1125, label %1166
1125: ; preds = %1121
%1126 = load i32, i32* %25
%1127 = load i32, i32* %45
%1128 = add nsw i32 %1126, %1127
%1129 = load i32, i32* %29
%1130 = sub nsw i32 %1128, %1129
store i32 %1130, i32* %39
%1131 = load i32, i32* %25
store i32 %1131, i32* %26
br label %1132
1132: ; preds = %1157, %1125
%1133 = load i32, i32* %26
%1134 = load i32, i32* %39
%1135 = icmp sle i32 %1133, %1134
br i1 %1135, label %1136, label %1161
1136: ; preds = %1132
%1137 = load float*, float** %16
%1138 = load i32, i32* %19
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds float, float* %1137, i64 %1139
%1141 = load float, float* %1140
%1142 = load float*, float** %10
%1143 = load i32, i32* %26
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds float, float* %1142, i64 %1144
store float %1141, float* %1145
%1146 = load float*, float** %17
%1147 = load i32, i32* %19
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds float, float* %1146, i64 %1148
%1150 = load float, float* %1149
%1151 = load float*, float** %11
%1152 = load i32, i32* %26
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds float, float* %1151, i64 %1153
store float %1150, float* %1154
%1155 = load i32, i32* %19
%1156 = add nsw i32 %1155, 1
store i32 %1156, i32* %19
br label %1157
1157: ; preds = %1136
%1158 = load i32, i32* %29
%1159 = load i32, i32* %26
%1160 = add nsw i32 %1159, %1158
store i32 %1160, i32* %26
br label %1132
1161: ; preds = %1132
br label %1162
1162: ; preds = %1161
%1163 = load i32, i32* %28
%1164 = load i32, i32* %25
%1165 = add nsw i32 %1164, %1163
store i32 %1165, i32* %25
br label %1121
1166: ; preds = %1121
br label %1167
1167: ; preds = %1166
%1168 = load i32, i32* %45
%1169 = load i32, i32* %22
%1170 = add nsw i32 %1169, %1168
store i32 %1170, i32* %22
br label %968
1171: ; preds = %968
br label %1172
1172: ; preds = %1171
%1173 = load i32, i32* %20
%1174 = add nsw i32 %1173, 1
store i32 %1174, i32* %20
br label %962
1175: ; preds = %962
%1176 = load float, float* %65
%1177 = load float, float* %71
%1178 = fmul float %1176, %1177
store float %1178, float* %69
%1179 = load float, float* %65
%1180 = load float, float* %70
%1181 = load float, float* %66
%1182 = load float, float* %71
%1183 = fmul float %1181, %1182
%1184 = fneg float %1183
%1185 = call float @llvm.fmuladd.f32(float %1179, float %1180, float %1184)
store float %1185, float* %65
%1186 = load float, float* %66
%1187 = load float, float* %70
%1188 = load float, float* %69
%1189 = call float @llvm.fmuladd.f32(float %1186, float %1187, float %1188)
store float %1189, float* %66
br label %1190
1190: ; preds = %1175
%1191 = load i32, i32* %44
%1192 = load i32, i32* %24
%1193 = add nsw i32 %1192, %1191
store i32 %1193, i32* %24
br label %952
1194: ; preds = %952
%1195 = load i32, i32* %27
%1196 = add nsw i32 %1195, 1
store i32 %1196, i32* %27
%1197 = load i32, i32* %29
store i32 %1197, i32* %28
br label %1198
1198: ; preds = %1194
%1199 = load i32, i32* %28
%1200 = load i32, i32* %45
%1201 = icmp slt i32 %1199, %1200
br i1 %1201, label %909, label %1202
1202: ; preds = %1198
br label %1203
1203: ; preds = %1202, %903
%1204 = load i32, i32* %40
%1205 = icmp eq i32 %1204, 4
br i1 %1205, label %1206, label %1543
1206: ; preds = %1203
%1207 = load i32, i32* %43
store i32 %1207, i32* %36
%1208 = load i32, i32* %43
%1209 = load i32, i32* %43
%1210 = add nsw i32 %1208, %1209
store i32 %1210, i32* %43
%1211 = load float, float* %61
%1212 = fneg float %1211
%1213 = load i32, i32* %43
%1214 = sitofp i32 %1213 to float
%1215 = fdiv float %1212, %1214
store float %1215, float* %62
%1216 = load i32, i32* %14
%1217 = icmp eq i32 %1216, 0
br i1 %1217, label %1218, label %1221
1218: ; preds = %1206
%1219 = load float, float* %62
%1220 = fneg float %1219
store float %1220, float* %62
br label %1221
1221: ; preds = %1218, %1206
%1222 = load float, float* %62
%1223 = fpext float %1222 to double
%1224 = call double @cos(double %1223)
%1225 = fptrunc double %1224 to float
store float %1225, float* %63
%1226 = load float, float* %62
%1227 = fpext float %1226 to double
%1228 = call double @sin(double %1227)
%1229 = fptrunc double %1228 to float
store float %1229, float* %64
%1230 = load float, float* %63
store float %1230, float* %67
%1231 = load float, float* %64
store float %1231, float* %68
store i32 2, i32* %58
%1232 = load i32, i32* %36
store i32 %1232, i32* %37
br label %1233
1233: ; preds = %1351, %1221
%1234 = load i32, i32* %58
%1235 = load i32, i32* %37
%1236 = sub nsw i32 %1234, %1235
%1237 = icmp slt i32 %1236, 0
br i1 %1237, label %1238, label %1370
1238: ; preds = %1233
%1239 = load i32, i32* %37
store i32 %1239, i32* %23
%1240 = load i32, i32* %58
store i32 %1240, i32* %19
br label %1241
1241: ; preds = %1347, %1238
%1242 = load i32, i32* %19
%1243 = load i32, i32* %42
%1244 = icmp sle i32 %1242, %1243
br i1 %1244, label %1245, label %1351
1245: ; preds = %1241
%1246 = load float*, float** %10
%1247 = load i32, i32* %19
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds float, float* %1246, i64 %1248
%1250 = load float, float* %1249
%1251 = load float*, float** %10
%1252 = load i32, i32* %23
%1253 = sext i32 %1252 to i64
%1254 = getelementptr inbounds float, float* %1251, i64 %1253
%1255 = load float, float* %1254
%1256 = fadd float %1250, %1255
%1257 = fpext float %1256 to double
%1258 = fdiv double %1257, 2.000000e+00
%1259 = fptrunc double %1258 to float
store float %1259, float* %77
%1260 = load float*, float** %11
%1261 = load i32, i32* %19
%1262 = sext i32 %1261 to i64
%1263 = getelementptr inbounds float, float* %1260, i64 %1262
%1264 = load float, float* %1263
%1265 = load float*, float** %11
%1266 = load i32, i32* %23
%1267 = sext i32 %1266 to i64
%1268 = getelementptr inbounds float, float* %1265, i64 %1267
%1269 = load float, float* %1268
%1270 = fadd float %1264, %1269
%1271 = fpext float %1270 to double
%1272 = fdiv double %1271, 2.000000e+00
%1273 = fptrunc double %1272 to float
store float %1273, float* %78
%1274 = load float*, float** %10
%1275 = load i32, i32* %19
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds float, float* %1274, i64 %1276
%1278 = load float, float* %1277
%1279 = load float*, float** %10
%1280 = load i32, i32* %23
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds float, float* %1279, i64 %1281
%1283 = load float, float* %1282
%1284 = fsub float %1278, %1283
%1285 = fpext float %1284 to double
%1286 = fdiv double %1285, 2.000000e+00
%1287 = fptrunc double %1286 to float
store float %1287, float* %82
%1288 = load float*, float** %11
%1289 = load i32, i32* %19
%1290 = sext i32 %1289 to i64
%1291 = getelementptr inbounds float, float* %1288, i64 %1290
%1292 = load float, float* %1291
%1293 = load float*, float** %11
%1294 = load i32, i32* %23
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds float, float* %1293, i64 %1295
%1297 = load float, float* %1296
%1298 = fsub float %1292, %1297
%1299 = fpext float %1298 to double
%1300 = fdiv double %1299, 2.000000e+00
%1301 = fptrunc double %1300 to float
store float %1301, float* %83
%1302 = load float, float* %67
%1303 = load float, float* %78
%1304 = load float, float* %68
%1305 = load float, float* %82
%1306 = fmul float %1304, %1305
%1307 = call float @llvm.fmuladd.f32(float %1302, float %1303, float %1306)
store float %1307, float* %84
%1308 = load float, float* %68
%1309 = load float, float* %78
%1310 = load float, float* %67
%1311 = load float, float* %82
%1312 = fmul float %1310, %1311
%1313 = fneg float %1312
%1314 = call float @llvm.fmuladd.f32(float %1308, float %1309, float %1313)
store float %1314, float* %85
%1315 = load float, float* %77
%1316 = load float, float* %84
%1317 = fadd float %1315, %1316
%1318 = load float*, float** %10
%1319 = load i32, i32* %19
%1320 = sext i32 %1319 to i64
%1321 = getelementptr inbounds float, float* %1318, i64 %1320
store float %1317, float* %1321
%1322 = load float, float* %83
%1323 = load float, float* %85
%1324 = fadd float %1322, %1323
%1325 = load float*, float** %11
%1326 = load i32, i32* %19
%1327 = sext i32 %1326 to i64
%1328 = getelementptr inbounds float, float* %1325, i64 %1327
store float %1324, float* %1328
%1329 = load float, float* %77
%1330 = load float, float* %84
%1331 = fsub float %1329, %1330
%1332 = load float*, float** %10
%1333 = load i32, i32* %23
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds float, float* %1332, i64 %1334
store float %1331, float* %1335
%1336 = load float, float* %83
%1337 = fneg float %1336
%1338 = load float, float* %85
%1339 = fadd float %1337, %1338
%1340 = load float*, float** %11
%1341 = load i32, i32* %23
%1342 = sext i32 %1341 to i64
%1343 = getelementptr inbounds float, float* %1340, i64 %1342
store float %1339, float* %1343
%1344 = load i32, i32* %45
%1345 = load i32, i32* %23
%1346 = add nsw i32 %1345, %1344
store i32 %1346, i32* %23
br label %1347
1347: ; preds = %1245
%1348 = load i32, i32* %45
%1349 = load i32, i32* %19
%1350 = add nsw i32 %1349, %1348
store i32 %1350, i32* %19
br label %1241
1351: ; preds = %1241
%1352 = load i32, i32* %58
%1353 = add nsw i32 %1352, 1
store i32 %1353, i32* %58
%1354 = load i32, i32* %37
%1355 = add nsw i32 %1354, -1
store i32 %1355, i32* %37
%1356 = load float, float* %67
%1357 = load float, float* %64
%1358 = fmul float %1356, %1357
store float %1358, float* %69
%1359 = load float, float* %67
%1360 = load float, float* %63
%1361 = load float, float* %68
%1362 = load float, float* %64
%1363 = fmul float %1361, %1362
%1364 = fneg float %1363
%1365 = call float @llvm.fmuladd.f32(float %1359, float %1360, float %1364)
store float %1365, float* %67
%1366 = load float, float* %68
%1367 = load float, float* %63
%1368 = load float, float* %69
%1369 = call float @llvm.fmuladd.f32(float %1366, float %1367, float %1368)
store float %1369, float* %68
br label %1233
1370: ; preds = %1233
%1371 = load i32, i32* %58
%1372 = load i32, i32* %37
%1373 = sub nsw i32 %1371, %1372
%1374 = icmp eq i32 %1373, 0
br i1 %1374, label %1375, label %1401
1375: ; preds = %1370
%1376 = load i32, i32* %14
%1377 = icmp ne i32 %1376, 0
br i1 %1377, label %1378, label %1400
1378: ; preds = %1375
%1379 = load i32, i32* %58
store i32 %1379, i32* %19
br label %1380
1380: ; preds = %1395, %1378
%1381 = load i32, i32* %19
%1382 = load i32, i32* %42
%1383 = icmp sle i32 %1381, %1382
br i1 %1383, label %1384, label %1399
1384: ; preds = %1380
%1385 = load float*, float** %11
%1386 = load i32, i32* %19
%1387 = sext i32 %1386 to i64
%1388 = getelementptr inbounds float, float* %1385, i64 %1387
%1389 = load float, float* %1388
%1390 = fneg float %1389
%1391 = load float*, float** %11
%1392 = load i32, i32* %19
%1393 = sext i32 %1392 to i64
%1394 = getelementptr inbounds float, float* %1391, i64 %1393
store float %1390, float* %1394
br label %1395
1395: ; preds = %1384
%1396 = load i32, i32* %45
%1397 = load i32, i32* %19
%1398 = add nsw i32 %1397, %1396
store i32 %1398, i32* %19
br label %1380
1399: ; preds = %1380
br label %1400
1400: ; preds = %1399, %1375
br label %1401
1401: ; preds = %1400, %1370
%1402 = load i32, i32* %45
%1403 = load i32, i32* %45
%1404 = add nsw i32 %1402, %1403
store i32 %1404, i32* %45
%1405 = load i32, i32* %42
%1406 = load i32, i32* %42
%1407 = add nsw i32 %1405, %1406
store i32 %1407, i32* %42
%1408 = load i32, i32* %42
%1409 = add nsw i32 %1408, 1
store i32 %1409, i32* %23
%1410 = load i32, i32* %42
%1411 = sdiv i32 %1410, 2
%1412 = add nsw i32 %1411, 1
store i32 %1412, i32* %34
br label %1413
1413: ; preds = %1530, %1401
%1414 = load i32, i32* %34
%1415 = load i32, i32* %36
%1416 = sub nsw i32 %1414, %1415
store i32 %1416, i32* %58
%1417 = load i32, i32* %58
store i32 %1417, i32* %19
%1418 = load i32, i32* %19
%1419 = add nsw i32 %1418, 1
store i32 %1419, i32* %19
%1420 = load i32, i32* %23
%1421 = add nsw i32 %1420, -1
store i32 %1421, i32* %23
br label %1422
1422: ; preds = %1427, %1413
%1423 = load i32, i32* %19
%1424 = load i32, i32* %34
%1425 = sub nsw i32 %1423, %1424
%1426 = icmp slt i32 %1425, 0
br i1 %1426, label %1427, label %1451
1427: ; preds = %1422
%1428 = load float*, float** %10
%1429 = load i32, i32* %19
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds float, float* %1428, i64 %1430
%1432 = load float, float* %1431
%1433 = load float*, float** %10
%1434 = load i32, i32* %23
%1435 = sext i32 %1434 to i64
%1436 = getelementptr inbounds float, float* %1433, i64 %1435
store float %1432, float* %1436
%1437 = load float*, float** %11
%1438 = load i32, i32* %19
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds float, float* %1437, i64 %1439
%1441 = load float, float* %1440
%1442 = fneg float %1441
%1443 = load float*, float** %11
%1444 = load i32, i32* %23
%1445 = sext i32 %1444 to i64
%1446 = getelementptr inbounds float, float* %1443, i64 %1445
store float %1442, float* %1446
%1447 = load i32, i32* %19
%1448 = add nsw i32 %1447, 1
store i32 %1448, i32* %19
%1449 = load i32, i32* %23
%1450 = add nsw i32 %1449, -1
store i32 %1450, i32* %23
br label %1422
1451: ; preds = %1422
%1452 = load float*, float** %10
%1453 = load i32, i32* %58
%1454 = sext i32 %1453 to i64
%1455 = getelementptr inbounds float, float* %1452, i64 %1454
%1456 = load float, float* %1455
%1457 = load float*, float** %11
%1458 = load i32, i32* %58
%1459 = sext i32 %1458 to i64
%1460 = getelementptr inbounds float, float* %1457, i64 %1459
%1461 = load float, float* %1460
%1462 = fsub float %1456, %1461
%1463 = load float*, float** %10
%1464 = load i32, i32* %23
%1465 = sext i32 %1464 to i64
%1466 = getelementptr inbounds float, float* %1463, i64 %1465
store float %1462, float* %1466
%1467 = load float*, float** %11
%1468 = load i32, i32* %23
%1469 = sext i32 %1468 to i64
%1470 = getelementptr inbounds float, float* %1467, i64 %1469
store float 0.000000e+00, float* %1470
%1471 = load i32, i32* %19
%1472 = load i32, i32* %23
%1473 = sub nsw i32 %1471, %1472
%1474 = icmp sge i32 %1473, 0
br i1 %1474, label %1475, label %1476
1475: ; preds = %1451
br label %1531
1476: ; preds = %1451
%1477 = load i32, i32* %19
%1478 = add nsw i32 %1477, -1
store i32 %1478, i32* %19
%1479 = load i32, i32* %23
%1480 = add nsw i32 %1479, -1
store i32 %1480, i32* %23
br label %1481
1481: ; preds = %1486, %1476
%1482 = load i32, i32* %19
%1483 = load i32, i32* %58
%1484 = sub nsw i32 %1482, %1483
%1485 = icmp sgt i32 %1484, 0
br i1 %1485, label %1486, label %1509
1486: ; preds = %1481
%1487 = load float*, float** %10
%1488 = load i32, i32* %19
%1489 = sext i32 %1488 to i64
%1490 = getelementptr inbounds float, float* %1487, i64 %1489
%1491 = load float, float* %1490
%1492 = load float*, float** %10
%1493 = load i32, i32* %23
%1494 = sext i32 %1493 to i64
%1495 = getelementptr inbounds float, float* %1492, i64 %1494
store float %1491, float* %1495
%1496 = load float*, float** %11
%1497 = load i32, i32* %19
%1498 = sext i32 %1497 to i64
%1499 = getelementptr inbounds float, float* %1496, i64 %1498
%1500 = load float, float* %1499
%1501 = load float*, float** %11
%1502 = load i32, i32* %23
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds float, float* %1501, i64 %1503
store float %1500, float* %1504
%1505 = load i32, i32* %19
%1506 = add nsw i32 %1505, -1
store i32 %1506, i32* %19
%1507 = load i32, i32* %23
%1508 = add nsw i32 %1507, -1
store i32 %1508, i32* %23
br label %1481
1509: ; preds = %1481
%1510 = load float*, float** %10
%1511 = load i32, i32* %58
%1512 = sext i32 %1511 to i64
%1513 = getelementptr inbounds float, float* %1510, i64 %1512
%1514 = load float, float* %1513
%1515 = load float*, float** %11
%1516 = load i32, i32* %58
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds float, float* %1515, i64 %1517
%1519 = load float, float* %1518
%1520 = fadd float %1514, %1519
%1521 = load float*, float** %10
%1522 = load i32, i32* %23
%1523 = sext i32 %1522 to i64
%1524 = getelementptr inbounds float, float* %1521, i64 %1523
store float %1520, float* %1524
%1525 = load float*, float** %11
%1526 = load i32, i32* %23
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds float, float* %1525, i64 %1527
store float 0.000000e+00, float* %1528
%1529 = load i32, i32* %58
store i32 %1529, i32* %34
br label %1530
1530: ; preds = %1509
br i1 true, label %1413, label %1531
1531: ; preds = %1530, %1475
%1532 = load float*, float** %10
%1533 = getelementptr inbounds float, float* %1532, i64 1
%1534 = load float, float* %1533
%1535 = load float*, float** %11
%1536 = getelementptr inbounds float, float* %1535, i64 1
%1537 = load float, float* %1536
%1538 = fadd float %1534, %1537
%1539 = load float*, float** %10
%1540 = getelementptr inbounds float, float* %1539, i64 1
store float %1538, float* %1540
%1541 = load float*, float** %11
%1542 = getelementptr inbounds float, float* %1541, i64 1
store float 0.000000e+00, float* %1542
br label %1675
1543: ; preds = %1203
%1544 = load i32, i32* %40
%1545 = icmp eq i32 %1544, 2
br i1 %1545, label %1546, label %1674
1546: ; preds = %1543
%1547 = load i32, i32* %57
%1548 = sub nsw i32 %1547, 2
%1549 = icmp sgt i32 %1548, 0
br i1 %1549, label %1550, label %1673
1550: ; preds = %1546
store i32 1, i32* %22
br label %1551
1551: ; preds = %1668, %1550
%1552 = load i32, i32* %22
%1553 = load i32, i32* %42
%1554 = icmp sle i32 %1552, %1553
br i1 %1554, label %1555, label %1672
1555: ; preds = %1551
%1556 = load i32, i32* %22
%1557 = load i32, i32* %45
%1558 = add nsw i32 %1556, %1557
%1559 = load i32, i32* %44
%1560 = sub nsw i32 %1558, %1559
store i32 %1560, i32* %54
%1561 = load i32, i32* %22
store i32 %1561, i32* %21
br label %1562
1562: ; preds = %1663, %1555
%1563 = load i32, i32* %21
%1564 = load i32, i32* %54
%1565 = icmp sle i32 %1563, %1564
br i1 %1565, label %1566, label %1667
1566: ; preds = %1562
%1567 = load i32, i32* %21
%1568 = load i32, i32* %44
%1569 = add nsw i32 %1567, %1568
%1570 = sub nsw i32 %1569, 1
store i32 %1570, i32* %34
%1571 = load i32, i32* %21
%1572 = load i32, i32* %55
%1573 = add nsw i32 %1571, %1572
store i32 %1573, i32* %58
%1574 = load i32, i32* %22
%1575 = load i32, i32* %22
%1576 = add nsw i32 %1574, %1575
%1577 = load i32, i32* %44
%1578 = add nsw i32 %1576, %1577
%1579 = load i32, i32* %58
%1580 = sub nsw i32 %1578, %1579
store i32 %1580, i32* %35
%1581 = load i32, i32* %21
%1582 = load i32, i32* %22
%1583 = sub nsw i32 %1581, %1582
%1584 = icmp sgt i32 %1583, 0
br i1 %1584, label %1585, label %1589
1585: ; preds = %1566
%1586 = load i32, i32* %45
%1587 = load i32, i32* %35
%1588 = add nsw i32 %1587, %1586
store i32 %1588, i32* %35
br label %1589
1589: ; preds = %1585, %1566
%1590 = load i32, i32* %41
%1591 = sub nsw i32 %1590, 2
%1592 = icmp sgt i32 %1591, 0
br i1 %1592, label %1593, label %1628
1593: ; preds = %1589
%1594 = load i32, i32* %35
%1595 = load i32, i32* %56
%1596 = add nsw i32 %1594, %1595
store i32 %1596, i32* %23
%1597 = load i32, i32* %58
store i32 %1597, i32* %19
br label %1598
1598: ; preds = %1624, %1593
%1599 = load i32, i32* %19
%1600 = load i32, i32* %34
%1601 = icmp sle i32 %1599, %1600
br i1 %1601, label %1602, label %1627
1602: ; preds = %1598
%1603 = load float*, float** %10
%1604 = load i32, i32* %23
%1605 = sext i32 %1604 to i64
%1606 = getelementptr inbounds float, float* %1603, i64 %1605
%1607 = load float, float* %1606
%1608 = load float*, float** %10
%1609 = load i32, i32* %19
%1610 = sext i32 %1609 to i64
%1611 = getelementptr inbounds float, float* %1608, i64 %1610
store float %1607, float* %1611
%1612 = load float*, float** %11
%1613 = load i32, i32* %23
%1614 = sext i32 %1613 to i64
%1615 = getelementptr inbounds float, float* %1612, i64 %1614
%1616 = load float, float* %1615
%1617 = fneg float %1616
%1618 = load float*, float** %11
%1619 = load i32, i32* %19
%1620 = sext i32 %1619 to i64
%1621 = getelementptr inbounds float, float* %1618, i64 %1620
store float %1617, float* %1621
%1622 = load i32, i32* %23
%1623 = sub nsw i32 %1622, 1
store i32 %1623, i32* %23
br label %1624
1624: ; preds = %1602
%1625 = load i32, i32* %19
%1626 = add nsw i32 %1625, 1
store i32 %1626, i32* %19
br label %1598
1627: ; preds = %1598
br label %1628
1628: ; preds = %1627, %1589
%1629 = load i32, i32* %35
store i32 %1629, i32* %23
%1630 = load i32, i32* %58
store i32 %1630, i32* %19
br label %1631
1631: ; preds = %1658, %1628
%1632 = load i32, i32* %19
%1633 = load i32, i32* %34
%1634 = icmp sle i32 %1632, %1633
br i1 %1634, label %1635, label %1662
1635: ; preds = %1631
%1636 = load float*, float** %10
%1637 = load i32, i32* %23
%1638 = sext i32 %1637 to i64
%1639 = getelementptr inbounds float, float* %1636, i64 %1638
%1640 = load float, float* %1639
%1641 = load float*, float** %10
%1642 = load i32, i32* %19
%1643 = sext i32 %1642 to i64
%1644 = getelementptr inbounds float, float* %1641, i64 %1643
store float %1640, float* %1644
%1645 = load float*, float** %11
%1646 = load i32, i32* %23
%1647 = sext i32 %1646 to i64
%1648 = getelementptr inbounds float, float* %1645, i64 %1647
%1649 = load float, float* %1648
%1650 = fneg float %1649
%1651 = load float*, float** %11
%1652 = load i32, i32* %19
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds float, float* %1651, i64 %1653
store float %1650, float* %1654
%1655 = load i32, i32* %56
%1656 = load i32, i32* %23
%1657 = add nsw i32 %1656, %1655
store i32 %1657, i32* %23
br label %1658
1658: ; preds = %1635
%1659 = load i32, i32* %56
%1660 = load i32, i32* %19
%1661 = add nsw i32 %1660, %1659
store i32 %1661, i32* %19
br label %1631
1662: ; preds = %1631
br label %1663
1663: ; preds = %1662
%1664 = load i32, i32* %44
%1665 = load i32, i32* %21
%1666 = add nsw i32 %1665, %1664
store i32 %1666, i32* %21
br label %1562
1667: ; preds = %1562
br label %1668
1668: ; preds = %1667
%1669 = load i32, i32* %45
%1670 = load i32, i32* %22
%1671 = add nsw i32 %1670, %1669
store i32 %1671, i32* %22
br label %1551
1672: ; preds = %1551
br label %1673
1673: ; preds = %1672, %1546
br label %1674
1674: ; preds = %1673, %1543
br label %1675
1675: ; preds = %1674, %1531
%1676 = load i32, i32* %44
store i32 %1676, i32* %56
%1677 = load i32, i32* %45
store i32 %1677, i32* %44
%1678 = load i32, i32* %43
store i32 %1678, i32* %57
br label %1679
1679: ; preds = %1675, %135
%1680 = load i32, i32* %41
%1681 = add nsw i32 %1680, 1
store i32 %1681, i32* %41
br label %116
1682: ; preds = %116
store i32 0, i32* %9
br label %1683
1683: ; preds = %1682, %131, %98
%1684 = load i32, i32* %9
ret i32 %1684
}

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