int main(void) {
  int iy, ix;
  int jy, jx;
  int ky, kx;
  double Ly = 3., Lx = 3.;
  double DQy, DQx, Q2, Q;
  double Qy, Qx, Ky, Kx, K2, K;
  int my = 6, mx = 6;
  int Ny, Ny1, Nx, Nx1;
  int i, k, N = 3;
  double f[5], g[5];
  double x[5], xx;
  Ny = 2 * my + 1;
  Ny1 = Ny + 5;
  Nx = 2 * mx + 1;
  Nx1 = Nx + 5;
  DQy = 2 * Ly / (Ny - 1);
  DQx = 2 * Lx / (Nx - 1);
  double Dt = .01, t;
  double bx[Nx1][Ny1], by[Nx1][Ny1], ex[Nx1][Ny1], ey[Nx1][Ny1], vx[Nx1][Ny1],
      vy[Nx1][Ny1], ax[Nx1][Ny1], ay[Nx1][Ny1];
  double qx[Nx1], Vx[Nx1][Ny1], Vy[Nx1][Ny1], Bx[Nx1][Ny1], By[Nx1][Ny1];
  double nx, ny, nxp, nyp;
  double lvx[Nx1][Ny1], lvy[Nx1][Ny1], lbx[Nx1][Ny1], lby[Nx1][Ny1], vn, Qb,
      Qpb, Qv, bb, nlv;
  double energy;
  double wc = 0;
  double nuk = 1 / 1000., num = 1 / 137., Pk, Pm;
  double v2, b2;
  for (iy = 1; iy <= Ny + 4; iy++)
    for (ix = 1; ix <= Nx + 4; ix++) {
      vx[ix][iy] = 4.3 * 10E-5;
      vy[ix][iy] = 4.3 * 10E-5;
      bx[ix][iy] = 4.3 * 10E-5;
      by[ix][iy] = 4.3 * 10E-5;
    }
  for (t = 0; t <= 5.5; t = t + Dt) {
    energy = 0.;
    Pk = nuk;
    Pm = 0.;
    for (ix = 1; ix <= Nx; ix++) {
      Qx = -Lx + (ix - 1) * DQx;
      qx[ix] = Qx;
      for (iy = 1; iy <= Ny; iy++) {
        Qy = -Ly + (iy - 1) * DQy;
        Q2 = Qx * Qx + Qy * Qy;
        Q = sqrt(Q2);
        if (Q != 0.) {
          nx = Qx / Q;
          ny = Qy / Q;
        } else {
          nx = 0;
          ny = 0;
        }
        ex[ix][iy] = ey[ix][iy] = ax[ix][iy] = ay[ix][iy] = 0;
        ex[ix][iy] += -num * Q2 * bx[ix][iy];
        ey[ix][iy] += +bx[ix][iy] - num * Q2 * by[ix][iy];
        ax[ix][iy] += 2 * nx * ny * vx[ix][iy] +
                      2 * wc * nx * (ny * vx[ix][iy] - nx * vy[ix][iy]) +
                      2 * wc * vy[ix][iy] - nuk * Q2 * vx[ix][iy];
        ay[ix][iy] += -vx[ix][iy] + 2 * ny * ny * vx[ix][iy] +
                      2 * wc * ny * (ny * vx[ix][iy] - nx * vy[ix][iy]) -
                      2 * wc * vx[ix][iy] - nuk * Q2 * vy[ix][iy];
        lvx[ix][iy] = lvy[ix][iy] = lbx[ix][iy] = lby[ix][iy] = 0;
        for (jx = 1; jx <= Nx; jx++) {
          Kx = -Lx + (jx - 1) * DQx;
          kx = ix - jx + mx + 1;
          if (kx < 0)
            goto jump;
          if (kx > Nx)
            goto jump;
          for (jy = 1; jy <= Ny; jy++) {
            Ky = -Ly + (jy - 1) * DQy;
            ky = iy - jy + my + 1;
            if (ky < 0)
              goto jump;
            if (ky > Ny)
              goto jump;
            vn = vx[jx][jy] * Qx + vy[jx][jy] * Qy;
            Qb = Qx * bx[kx][ky] + Qy * by[kx][ky];
            Qv = Qx * vx[jx][jy] + Qy * vy[jx][jy];
            Qpb = Kx * bx[kx][ky] + Ky * by[kx][ky];
            bb = bx[jx][jy] * bx[kx][ky] + by[jx][jy] * by[kx][ky];
            lvx[ix][iy] += vx[kx][ky] * vn + bx[jx][jy] * Qpb - Kx * bb;
            lvy[ix][iy] += vy[kx][ky] * vn + by[jx][jy] * Qpb - Ky * bb;
            lbx[ix][iy] += -vx[kx][ky] * Qb + bx[kx][ky] * Qv;
            lby[ix][iy] += -vy[kx][ky] * Qb + by[kx][ky] * Qv;
          jump:;
          }
        }
        if (Q != 0.) {
          nlv = nx * lvx[Nx1][Ny1] + ny * lvy[Nx1][Ny1];
          lvx[Nx1][Ny1] = nx * nlv;
          lvy[Nx1][Ny1] = ny * nlv;
        }
        vx[ix][iy] += (ax[ix][iy] + lvx[ix][iy]) * Dt;
        vy[ix][iy] += (ay[ix][iy] + lvy[ix][iy]) * Dt;
        bx[ix][iy] += (ex[ix][iy] + lbx[ix][iy]) * Dt;
        by[ix][iy] += (ey[ix][iy] + lby[ix][iy]) * Dt;
        v2 = vx[ix][iy] * vx[ix][iy] + vy[ix][iy] * vy[ix][iy];
        b2 = by[ix][iy] * by[ix][iy] + bx[ix][iy] * bx[ix][iy];
        xx = qx[ix] + Qy * Dt;
        if (ix == 1) {
          x[0] = qx[1];
          x[1] = qx[2];
          x[2] = qx[3];
          x[3] = qx[4];
          f[0] = vx[1][iy];
          f[1] = vx[2][iy];
          f[2] = vx[3][iy];
          f[3] = vx[4][iy];
        }
        if (ix > 1 && ix < Nx - 1) {
          x[0] = qx[ix - 1];
          x[1] = qx[ix];
          x[2] = qx[ix + 1];
          x[3] = qx[ix + 2];
          f[0] = vx[ix - 1][iy];
          f[1] = vx[ix][iy];
          f[2] = vx[ix + 1][iy];
          f[3] = vx[ix + 2][iy];
        }
        if (ix == Nx - 1) {
          x[0] = qx[Nx - 1];
          x[1] = qx[Nx];
          x[2] = qx[Nx - 1];
          x[3] = qx[Nx - 2];
          f[0] = vx[Nx - 1][iy];
          f[1] = vx[Nx][iy];
          f[2] = vx[Nx - 1][iy];
          f[3] = vx[Nx - 2][iy];
        }
        if (ix == Nx) {
          x[0] = qx[Nx];
          x[1] = qx[Nx - 1];
          x[2] = qx[Nx - 2];
          x[3] = qx[Nx - 3];
          f[0] = vx[Nx][iy];
          f[1] = vx[Nx - 1][iy];
          f[2] = vx[Nx - 2][iy];
          f[3] = vx[Nx - 3][iy];
        }
        for (k = 0; k < N; k++)
          for (i = k + 1; i <= N; i++) {
            f[i] = ((x[k] - xx) * f[i] - (x[i] - xx) * f[k]) /
                   ((x[k] - xx) - (x[i] - xx));
          }
        Vx[ix][iy] = f[N];
        if (ix == 1) {
          x[0] = qx[1];
          x[1] = qx[2];
          x[2] = qx[3];
          x[3] = qx[4];
          f[0] = bx[1][iy];
          f[1] = bx[2][iy];
          f[2] = bx[3][iy];
          f[3] = bx[4][iy];
        }
        if (ix > 1 && ix < Nx - 1) {
          x[0] = qx[ix - 1];
          x[1] = qx[ix];
          x[2] = qx[ix + 1];
          x[3] = qx[ix + 2];
          f[0] = bx[ix - 1][iy];
          f[1] = bx[ix][iy];
          f[2] = bx[ix + 1][iy];
          f[3] = bx[ix + 2][iy];
        }
        if (ix == Nx - 1) {
          x[0] = qx[Nx - 1];
          x[1] = qx[Nx];
          x[2] = qx[Nx - 1];
          x[3] = qx[Nx - 2];
          f[0] = bx[Nx - 1][iy];
          f[1] = bx[Nx][iy];
          f[2] = bx[Nx - 1][iy];
          f[3] = bx[Nx - 2][iy];
        }
        if (ix == Nx) {
          x[0] = qx[Nx];
          x[1] = qx[Nx - 1];
          x[2] = qx[Nx - 2];
          x[3] = qx[Nx - 3];
          f[0] = bx[Nx][iy];
          f[1] = bx[Nx - 1][iy];
          f[2] = bx[Nx - 2][iy];
          f[3] = bx[Nx - 3][iy];
        }
        for (k = 0; k < N; k++)
          for (i = k + 1; i <= N; i++) {
            f[i] = ((x[k] - xx) * f[i] - (x[i] - xx) * f[k]) /
                   ((x[k] - xx) - (x[i] - xx));
          }
        Bx[ix][iy] = f[N];
        if (ix == 1) {
          x[0] = qx[1];
          x[1] = qx[2];
          x[2] = qx[3];
          x[3] = qx[4];
          f[0] = vy[1][iy];
          f[1] = vy[2][iy];
          f[2] = vy[3][iy];
          f[3] = vy[4][iy];
        }
        if (ix > 1 && ix < Nx - 1) {
          x[0] = qx[ix - 1];
          x[1] = qx[ix];
          x[2] = qx[ix + 1];
          x[3] = qx[ix + 2];
          f[0] = vy[ix - 1][iy];
          f[1] = vy[ix][iy];
          f[2] = vy[ix + 1][iy];
          f[3] = vy[ix + 2][iy];
        }
        if (ix == Nx - 1) {
          x[0] = qx[Nx - 1];
          x[1] = qx[Nx];
          x[2] = qx[Nx - 1];
          x[3] = qx[Nx - 2];
          f[0] = vy[Nx - 1][iy];
          f[1] = vy[Nx][iy];
          f[2] = vy[Nx - 1][iy];
          f[3] = vy[Nx - 2][iy];
        }
        if (ix == Nx) {
          x[0] = qx[Nx];
          x[1] = qx[Nx - 1];
          x[2] = qx[Nx - 2];
          x[3] = qx[Nx - 3];
          f[0] = vy[Nx][iy];
          f[1] = vy[Nx - 1][iy];
          f[2] = vy[Nx - 2][iy];
          f[3] = vy[Nx - 3][iy];
        }
        for (k = 0; k < N; k++)
          for (i = k + 1; i <= N; i++) {
            f[i] = ((x[k] - xx) * f[i] - (x[i] - xx) * f[k]) /
                   ((x[k] - xx) - (x[i] - xx));
          }
        Vy[ix][iy] = f[N];
        if (ix == 1) {
          x[0] = qx[1];
          x[1] = qx[2];
          x[2] = qx[3];
          x[3] = qx[4];
          f[0] = by[1][iy];
          f[1] = by[2][iy];
          f[2] = by[3][iy];
          f[3] = by[4][iy];
        }
        if (ix > 1 && ix < Nx - 1) {
          x[0] = qx[ix - 1];
          x[1] = qx[ix];
          x[2] = qx[ix + 1];
          x[3] = qx[ix + 2];
          f[0] = by[ix - 1][iy];
          f[1] = by[ix][iy];
          f[2] = by[ix + 1][iy];
          f[3] = by[ix + 2][iy];
        }
        if (ix == Nx - 1) {
          x[0] = qx[Nx - 1];
          x[1] = qx[Nx];
          x[2] = qx[Nx - 1];
          x[3] = qx[Nx - 2];
          f[0] = by[Nx - 1][iy];
          f[1] = by[Nx][iy];
          f[2] = by[Nx - 1][iy];
          f[3] = by[Nx - 2][iy];
        }
        if (ix == Nx) {
          x[0] = qx[Nx];
          x[1] = qx[Nx - 1];
          x[2] = qx[Nx - 2];
          x[3] = qx[Nx - 3];
          f[0] = by[Nx][iy];
          f[1] = by[Nx - 1][iy];
          f[2] = by[Nx - 2][iy];
          f[3] = by[Nx - 3][iy];
        }
        for (k = 0; k < N; k++)
          for (i = k + 1; i <= N; i++) {
            f[i] = ((x[k] - xx) * f[i] - (x[i] - xx) * f[k]) /
                   ((x[k] - xx) - (x[i] - xx));
          }
        By[ix][iy] = f[N];
        energy += (v2 + b2) / 2.;
      }
    }
    for (ix = 1; ix <= Nx; ix++) {
      for (iy = 1; iy <= Ny; iy++) {
        vx[ix][iy] = Vx[ix][iy];
        vy[ix][iy] = Vy[ix][iy];
        bx[ix][iy] = Bx[ix][iy];
        by[ix][iy] = By[ix][iy];
      }
    }
    printf("%g %g\n", t, log(energy));
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x408,%rsp
movl   $0x0,-0x2c(%rbp)
movabs $0x4008000000000000,%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x58(%rbp)
movl   $0x6,-0xac(%rbp)
movl   $0x6,-0xb0(%rbp)
movl   $0x3,-0xcc(%rbp)
mov    -0xac(%rbp),%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,1),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb0(%rbp),%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,1),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0xc0(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  %xmm0,%xmm0
mov    -0xb4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  %xmm0,%xmm0
mov    -0xbc(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movabs $0x3f847ae147ae147b,%rax
7a 84 3f
mov    %rax,-0x170(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x420(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x180(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x418(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x188(%rbp)
mov    %rax,-0x190(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x410(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x408(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x198(%rbp)
mov    %rax,-0x1a0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x400(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3f8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1a8(%rbp)
mov    %rax,-0x1b0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x3f0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3e8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1b8(%rbp)
mov    %rax,-0x1c0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x3e0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3d8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1c8(%rbp)
mov    %rax,-0x1d0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x3d0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3c8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1d8(%rbp)
mov    %rax,-0x1e0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x3c0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3b8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1e8(%rbp)
mov    %rax,-0x1f0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x3b0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3a8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1f8(%rbp)
mov    %rax,-0x200(%rbp)
mov    -0xc0(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x3a0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x208(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x398(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x390(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x210(%rbp)
mov    %rax,-0x218(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x388(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x380(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x220(%rbp)
mov    %rax,-0x228(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x378(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x370(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x230(%rbp)
mov    %rax,-0x238(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x368(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x360(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x240(%rbp)
mov    %rax,-0x248(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x358(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x350(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x270(%rbp)
mov    %rax,-0x278(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x348(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x340(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x280(%rbp)
mov    %rax,-0x288(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x338(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x330(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x290(%rbp)
mov    %rax,-0x298(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
mov    %rax,-0x328(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x320(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x2a0(%rbp)
mov    %rax,-0x2a8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  0x3956(%rip),%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  0x393e(%rip),%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xb4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     17db <main+0x6ab>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     17c8 <main+0x698>
mov    -0x408(%rbp),%rax
mov    -0x410(%rbp),%rdx
mov    -0x418(%rbp),%rcx
mov    -0x420(%rbp),%rdi
mov    -0x3c8(%rbp),%rsi
mov    -0x3d0(%rbp),%r9
mov    -0x3d8(%rbp),%r8
mov    -0x3e0(%rbp),%r11
movslq -0x34(%rbp),%r10
imul   %r11,%r10
shl    $0x3,%r10
add    %r10,%r8
movslq -0x30(%rbp),%r10
movsd  0x38cd(%rip),%xmm0
movsd  %xmm0,(%r8,%r10,8)
movslq -0x34(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x30(%rbp),%r8
movsd  0x38ac(%rip),%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  0x388b(%rip),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  0x386b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16ec <main+0x5bc>
jmp    17cd <main+0x69d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16d1 <main+0x5a1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x3822(%rip),%xmm0
ucomisd -0x178(%rbp),%xmm0
ff
jb     418d <main+0x305d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0x2f0(%rbp),%xmm0
ff
movsd  %xmm0,-0x300(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     3fb6 <main+0x2e86>
mov    -0x3a0(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm1
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jg     3fa3 <main+0x2e73>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    192c <main+0x7fc>
jp     192c <main+0x7fc>
jmp    1958 <main+0x828>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
jmp    196e <main+0x83e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x358(%rbp),%rdx
mov    -0x348(%rbp),%rdi
mov    -0x330(%rbp),%rsi
mov    -0x338(%rbp),%r9
mov    -0x320(%rbp),%r8
mov    -0x328(%rbp),%r11
mov    -0x3a8(%rbp),%r10
mov    -0x3b0(%rbp),%r14
mov    -0x3c8(%rbp),%rbx
mov    -0x3d0(%rbp),%r12
mov    -0x3d8(%rbp),%r15
mov    -0x3e0(%rbp),%r13
movslq -0x34(%rbp),%rax
imul   %r14,%rax
shl    $0x3,%rax
mov    %r10,%rcx
add    %rax,%rcx
movslq -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    -0x3c0(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x3b8(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3f0(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x3e8(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    -0x400(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x3f8(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x2f8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
mov    -0x420(%rbp),%rcx
movq   %rax,%xmm0
mulsd  -0x70(%rbp),%xmm0
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x418(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x30(%rbp),%rax
movsd  (%rcx,%rax,8),%xmm2
mov    -0x400(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x3f8(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x420(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x418(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x30(%rbp),%rax
movsd  (%rcx,%rax,8),%xmm1
mov    -0x410(%rbp),%rax
movsd  -0x2f8(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x408(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rax
xor    %rax,%rcx
mov    -0x3f0(%rbp),%rax
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x3e8(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3495(%rip),%xmm0
mulsd  -0x250(%rbp),%xmm0
ff
mulsd  -0x258(%rbp),%xmm0
ff
movslq -0x34(%rbp),%rcx
imul   %r13,%rcx
shl    $0x3,%rcx
mov    %r15,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3462(%rip),%xmm1
mulsd  -0x2e8(%rbp),%xmm1
ff
mulsd  -0x250(%rbp),%xmm1
ff
movsd  -0x258(%rbp),%xmm3
ff
movslq -0x34(%rbp),%rcx
imul   %r13,%rcx
shl    $0x3,%rcx
mov    %r15,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  -0x250(%rbp),%xmm4
ff
movslq -0x34(%rbp),%rcx
imul   %r12,%rcx
shl    $0x3,%rcx
mov    %rbx,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x33d9(%rip),%xmm1
mulsd  -0x2e8(%rbp),%xmm1
ff
movslq -0x34(%rbp),%rcx
imul   %r12,%rcx
shl    $0x3,%rcx
mov    %rbx,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x2f0(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
imul   %r13,%rcx
shl    $0x3,%rcx
mov    %r15,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rax
xor    %rax,%rcx
mov    -0x3c0(%rbp),%rax
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x3b8(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x34(%rbp),%rcx
imul   %r13,%rcx
shl    $0x3,%rcx
mov    %r15,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
mov    -0x340(%rbp),%rcx
movq   %rax,%xmm0
movsd  0x32fb(%rip),%xmm1
mulsd  -0x258(%rbp),%xmm1
ff
mulsd  -0x258(%rbp),%xmm1
ff
movslq -0x34(%rbp),%rax
imul   %r13,%rax
shl    $0x3,%rax
mov    %r15,%r13
add    %rax,%r13
movslq -0x30(%rbp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    -0x3e0(%rbp),%rax
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x32b7(%rip),%xmm0
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  -0x258(%rbp),%xmm0
ff
movsd  -0x258(%rbp),%xmm2
ff
movslq -0x34(%rbp),%r13
imul   %rax,%r13
shl    $0x3,%r13
mov    %r15,%rax
add    %r13,%rax
movslq -0x30(%rbp),%r13
movsd  (%rax,%r13,8),%xmm4
movsd  -0x250(%rbp),%xmm3
ff
movslq -0x34(%rbp),%r13
imul   %r12,%r13
shl    $0x3,%r13
mov    %rbx,%rax
add    %r13,%rax
movslq -0x30(%rbp),%r13
mulsd  (%rax,%r13,8),%xmm3
movq   %xmm3,%r13
movabs $0x8000000000000000,%rax
xor    %rax,%r13
mov    -0x3e0(%rbp),%rax
movq   %r13,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x3229(%rip),%xmm1
mulsd  -0x2e8(%rbp),%xmm1
ff
movslq -0x34(%rbp),%r13
imul   %rax,%r13
mov    -0x350(%rbp),%rax
shl    $0x3,%r13
add    %r13,%r15
movslq -0x30(%rbp),%r13
movsd  (%r15,%r13,8),%xmm2
movq   %xmm1,%r15
movabs $0x8000000000000000,%r13
xor    %r13,%r15
movq   %r15,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x2f0(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
movslq -0x34(%rbp),%r15
imul   %r12,%r15
shl    $0x3,%r15
add    %r15,%rbx
movslq -0x30(%rbp),%r15
movsd  (%rbx,%r15,8),%xmm2
movq   %xmm0,%rbx
movabs $0x8000000000000000,%r15
xor    %r15,%rbx
movq   %rbx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rbx
imul   %r14,%rbx
shl    $0x3,%rbx
add    %rbx,%r10
movslq -0x30(%rbp),%rbx
addsd  (%r10,%rbx,8),%xmm0
movsd  %xmm0,(%r10,%rbx,8)
movslq -0x34(%rbp),%r10
imul   %r11,%r10
shl    $0x3,%r10
add    %r10,%r8
movslq -0x30(%rbp),%r10
xorps  %xmm0,%xmm0
movsd  %xmm0,(%r8,%r10,8)
movslq -0x34(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x30(%rbp),%r8
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     24ba <main+0x138a>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x34(%rbp),%eax
sub    -0x3c(%rbp),%eax
add    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    1f7a <main+0xe4a>
jmp    2494 <main+0x1364>
mov    -0x44(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jle    1f8e <main+0xe5e>
jmp    2494 <main+0x1364>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jg     24a7 <main+0x1377>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%eax
sub    -0x38(%rbp),%eax
add    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    2000 <main+0xed0>
jmp    2494 <main+0x1364>
mov    -0x40(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jle    2014 <main+0xee4>
jmp    2494 <main+0x1364>
mov    -0x328(%rbp),%rdx
mov    -0x408(%rbp),%rcx
mov    -0x410(%rbp),%rdi
mov    -0x3c8(%rbp),%rsi
mov    -0x3d0(%rbp),%r9
mov    -0x330(%rbp),%r8
mov    -0x338(%rbp),%r11
mov    -0x418(%rbp),%r10
mov    -0x420(%rbp),%r14
mov    -0x3d8(%rbp),%rbx
mov    -0x3e0(%rbp),%r12
mov    -0x340(%rbp),%r15
movslq -0x3c(%rbp),%r13
imul   %r12,%r13
shl    $0x3,%r13
mov    %rbx,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movslq -0x3c(%rbp),%r13
imul   %r9,%r13
shl    $0x3,%r13
mov    %rsi,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movslq -0x44(%rbp),%r13
imul   %r14,%r13
shl    $0x3,%r13
mov    %r10,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
movsd  (%rax,%r13,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movslq -0x44(%rbp),%r13
imul   %rdi,%r13
shl    $0x3,%r13
mov    %rcx,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
mulsd  (%rax,%r13,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movslq -0x3c(%rbp),%r13
imul   %r12,%r13
shl    $0x3,%r13
mov    %rbx,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm2
movsd  -0x80(%rbp),%xmm1
movslq -0x3c(%rbp),%r13
imul   %r9,%r13
shl    $0x3,%r13
mov    %rsi,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
mulsd  (%rax,%r13,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movslq -0x44(%rbp),%r13
imul   %r14,%r13
shl    $0x3,%r13
mov    %r10,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
movsd  (%rax,%r13,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
movslq -0x44(%rbp),%r13
imul   %rdi,%r13
shl    $0x3,%r13
mov    %rcx,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
mulsd  (%rax,%r13,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
movslq -0x3c(%rbp),%r13
imul   %r14,%r13
shl    $0x3,%r13
mov    %r10,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm0
movslq -0x44(%rbp),%r13
imul   %r14,%r13
shl    $0x3,%r13
mov    %r10,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
movsd  (%rax,%r13,8),%xmm2
movslq -0x3c(%rbp),%r13
imul   %rdi,%r13
shl    $0x3,%r13
mov    %rcx,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm1
movslq -0x44(%rbp),%r13
imul   %rdi,%r13
shl    $0x3,%r13
mov    %rcx,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
mulsd  (%rax,%r13,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movslq -0x44(%rbp),%r13
imul   %r12,%r13
shl    $0x3,%r13
mov    %rbx,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
movsd  (%rax,%r13,8),%xmm1
movsd  -0x2b0(%rbp),%xmm2
ff
movslq -0x3c(%rbp),%r13
imul   %r14,%r13
shl    $0x3,%r13
mov    %r10,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm0
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movq   %xmm0,%r13
movabs $0x8000000000000000,%rax
xor    %rax,%r13
mov    -0x358(%rbp),%rax
movq   %r13,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%r13
imul   %rax,%r13
mov    -0x350(%rbp),%rax
shl    $0x3,%r13
add    %r13,%rax
movslq -0x30(%rbp),%r13
addsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,(%rax,%r13,8)
movslq -0x44(%rbp),%r13
imul   %r9,%r13
shl    $0x3,%r13
mov    %rsi,%rax
add    %r13,%rax
movslq -0x40(%rbp),%r13
movsd  (%rax,%r13,8),%xmm1
movsd  -0x2b0(%rbp),%xmm2
ff
movslq -0x3c(%rbp),%r13
imul   %rdi,%r13
shl    $0x3,%r13
mov    %rcx,%rax
add    %r13,%rax
movslq -0x38(%rbp),%r13
movsd  (%rax,%r13,8),%xmm0
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
movq   %xmm0,%r13
movabs $0x8000000000000000,%rax
xor    %rax,%r13
mov    -0x348(%rbp),%rax
movq   %r13,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%r13
imul   %rax,%r13
mov    -0x320(%rbp),%rax
shl    $0x3,%r13
add    %r13,%r15
movslq -0x30(%rbp),%r13
addsd  (%r15,%r13,8),%xmm0
movsd  %xmm0,(%r15,%r13,8)
movslq -0x44(%rbp),%r15
imul   %r12,%r15
shl    $0x3,%r15
add    %r15,%rbx
movslq -0x40(%rbp),%r15
movsd  (%rbx,%r15,8),%xmm0
movq   %xmm0,%rbx
movabs $0x8000000000000000,%r15
xor    %r15,%rbx
movq   %rbx,%xmm0
movsd  -0x2b8(%rbp),%xmm2
ff
movslq -0x44(%rbp),%rbx
imul   %r14,%rbx
shl    $0x3,%rbx
add    %rbx,%r10
movslq -0x40(%rbp),%rbx
movsd  (%r10,%rbx,8),%xmm1
mulsd  -0x2c8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%r10
imul   %r11,%r10
shl    $0x3,%r10
add    %r10,%r8
movslq -0x30(%rbp),%r10
addsd  (%r8,%r10,8),%xmm0
movsd  %xmm0,(%r8,%r10,8)
movslq -0x44(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x40(%rbp),%r8
movsd  (%rsi,%r8,8),%xmm0
movq   %xmm0,%rsi
movabs $0x8000000000000000,%r8
xor    %r8,%rsi
movq   %rsi,%xmm0
movsd  -0x2b8(%rbp),%xmm2
ff
movslq -0x44(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x40(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
mulsd  -0x2c8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2499 <main+0x1369>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1f95 <main+0xe65>
jmp    24ac <main+0x137c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1f0f <main+0xddf>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24d7 <main+0x13a7>
jp     24d7 <main+0x13a7>
jmp    25b3 <main+0x1483>
mov    -0x340(%rbp),%rax
mov    -0x348(%rbp),%rdx
mov    -0x350(%rbp),%rcx
mov    -0x358(%rbp),%rdi
movsd  -0x250(%rbp),%xmm0
ff
movslq -0xc0(%rbp),%r8
imul   %rdi,%r8
shl    $0x3,%r8
mov    %rcx,%rsi
add    %r8,%rsi
movslq -0xb8(%rbp),%r8
movsd  (%rsi,%r8,8),%xmm2
movsd  -0x258(%rbp),%xmm1
ff
movslq -0xc0(%rbp),%r8
imul   %rdx,%r8
shl    $0x3,%r8
mov    %rax,%rsi
add    %r8,%rsi
movslq -0xb8(%rbp),%r8
mulsd  (%rsi,%r8,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
mulsd  -0x2d8(%rbp),%xmm0
ff
movslq -0xc0(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0xb8(%rbp),%rsi
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x258(%rbp),%xmm0
ff
mulsd  -0x2d8(%rbp),%xmm0
ff
movslq -0xc0(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x420(%rbp),%rsi
mov    -0x408(%rbp),%rdx
mov    -0x410(%rbp),%r8
mov    -0x3c8(%rbp),%rdi
mov    -0x3d0(%rbp),%r10
mov    -0x3d8(%rbp),%r9
mov    -0x3e0(%rbp),%rbx
mov    -0x320(%rbp),%r11
mov    -0x328(%rbp),%r15
mov    -0x3e8(%rbp),%r14
mov    -0x3f0(%rbp),%r13
mov    -0x3f8(%rbp),%r12
mov    -0x3c0(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x3b8(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x30(%rbp),%rax
movsd  (%rcx,%rax,8),%xmm0
mov    -0x358(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x350(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x170(%rbp),%xmm2
ff
movslq -0x34(%rbp),%rcx
imul   %rbx,%rcx
shl    $0x3,%rcx
mov    %r9,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3b0(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x3a8(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x30(%rbp),%rax
movsd  (%rcx,%rax,8),%xmm0
mov    -0x348(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   %rax,%rcx
mov    -0x340(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x170(%rbp),%xmm2
ff
movslq -0x34(%rbp),%rcx
imul   %r10,%rcx
shl    $0x3,%rcx
mov    %rdi,%rax
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x400(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x418(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%r12
movslq -0x30(%rbp),%rax
movsd  (%r12,%rax,8),%xmm0
mov    -0x338(%rbp),%rax
movslq -0x34(%rbp),%r12
imul   %rax,%r12
mov    -0x330(%rbp),%rax
shl    $0x3,%r12
add    %r12,%rax
movslq -0x30(%rbp),%r12
addsd  (%rax,%r12,8),%xmm0
movsd  -0x170(%rbp),%xmm2
ff
movslq -0x34(%rbp),%rax
imul   %rsi,%rax
shl    $0x3,%rax
mov    %rcx,%r12
add    %rax,%r12
movslq -0x30(%rbp),%rax
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rax,8)
mov    -0x3a0(%rbp),%rax
movslq -0x34(%rbp),%r12
imul   %r13,%r12
shl    $0x3,%r12
add    %r12,%r14
movslq -0x30(%rbp),%r12
movsd  (%r14,%r12,8),%xmm0
movslq -0x34(%rbp),%r14
imul   %r15,%r14
shl    $0x3,%r14
add    %r14,%r11
movslq -0x30(%rbp),%r14
addsd  (%r11,%r14,8),%xmm0
movsd  -0x170(%rbp),%xmm2
ff
movslq -0x34(%rbp),%r14
imul   %r8,%r14
shl    $0x3,%r14
mov    %rdx,%r11
add    %r14,%r11
movslq -0x30(%rbp),%r14
movsd  (%r11,%r14,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%r14,8)
movslq -0x34(%rbp),%r14
imul   %rbx,%r14
shl    $0x3,%r14
mov    %r9,%r11
add    %r14,%r11
movslq -0x30(%rbp),%r14
movsd  (%r11,%r14,8),%xmm0
movslq -0x34(%rbp),%r11
imul   %rbx,%r11
shl    $0x3,%r11
add    %r11,%r9
movslq -0x30(%rbp),%r11
movsd  (%r9,%r11,8),%xmm2
movslq -0x34(%rbp),%r11
imul   %r10,%r11
shl    $0x3,%r11
mov    %rdi,%r9
add    %r11,%r9
movslq -0x30(%rbp),%r11
movsd  (%r9,%r11,8),%xmm1
movslq -0x34(%rbp),%r9
imul   %r10,%r9
shl    $0x3,%r9
add    %r9,%rdi
movslq -0x30(%rbp),%r9
mulsd  (%rdi,%r9,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movslq -0x34(%rbp),%r9
imul   %r8,%r9
shl    $0x3,%r9
mov    %rdx,%rdi
add    %r9,%rdi
movslq -0x30(%rbp),%r9
movsd  (%rdi,%r9,8),%xmm0
movslq -0x34(%rbp),%rdi
imul   %r8,%rdi
shl    $0x3,%rdi
add    %rdi,%rdx
movslq -0x30(%rbp),%rdi
movsd  (%rdx,%rdi,8),%xmm2
movslq -0x34(%rbp),%rdi
imul   %rsi,%rdi
shl    $0x3,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x30(%rbp),%rdi
movsd  (%rdx,%rdi,8),%xmm1
movslq -0x34(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x170(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
cmpl   $0x1,-0x34(%rbp)
jne    29d3 <main+0x18a3>
mov    -0x3d8(%rbp),%rax
mov    -0x3e0(%rbp),%rcx
mov    -0x3a0(%rbp),%rdx
movsd  0x8(%rdx),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x20(%rdx),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    %rcx,%rsi
shl    $0x0,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    %rcx,%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
imul   $0x3,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
shl    $0x2,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x34(%rbp)
jle    2af1 <main+0x19c1>
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2af1 <main+0x19c1>
mov    -0x3d8(%rbp),%rax
mov    -0x3e0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0x34(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    2c1d <main+0x1aed>
mov    -0x3d8(%rbp),%rax
mov    -0x3e0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jne    2d44 <main+0x1c14>
mov    -0x3d8(%rbp),%rax
mov    -0x3e0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x3,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jge    2e65 <main+0x1d35>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jg     2e4c <main+0x1d1c>
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x168(%rbp),%xmm0
ff
movslq -0xc4(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc8(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm2
ff ff
subsd  -0x168(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    2d6f <main+0x1c3f>
jmp    2e51 <main+0x1d21>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    2d4e <main+0x1c1e>
mov    -0x390(%rbp),%rax
mov    -0x398(%rbp),%rdx
movslq -0xcc(%rbp),%rcx
movsd  -0x100(%rbp,%rcx,8),%xmm0
ff ff
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x34(%rbp)
jne    2f6d <main+0x1e3d>
mov    -0x418(%rbp),%rax
mov    -0x420(%rbp),%rcx
mov    -0x3a0(%rbp),%rdx
movsd  0x8(%rdx),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x20(%rdx),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    %rcx,%rsi
shl    $0x0,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    %rcx,%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
imul   $0x3,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
shl    $0x2,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x34(%rbp)
jle    308b <main+0x1f5b>
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    308b <main+0x1f5b>
mov    -0x418(%rbp),%rax
mov    -0x420(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0x34(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    31b7 <main+0x2087>
mov    -0x418(%rbp),%rax
mov    -0x420(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jne    32de <main+0x21ae>
mov    -0x418(%rbp),%rax
mov    -0x420(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x3,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jge    33ff <main+0x22cf>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jg     33e6 <main+0x22b6>
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x168(%rbp),%xmm0
ff
movslq -0xc4(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc8(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm2
ff ff
subsd  -0x168(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    3309 <main+0x21d9>
jmp    33eb <main+0x22bb>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    32e8 <main+0x21b8>
mov    -0x370(%rbp),%rax
mov    -0x378(%rbp),%rdx
movslq -0xcc(%rbp),%rcx
movsd  -0x100(%rbp,%rcx,8),%xmm0
ff ff
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x34(%rbp)
jne    3507 <main+0x23d7>
mov    -0x3c8(%rbp),%rax
mov    -0x3d0(%rbp),%rcx
mov    -0x3a0(%rbp),%rdx
movsd  0x8(%rdx),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x20(%rdx),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    %rcx,%rsi
shl    $0x0,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    %rcx,%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
imul   $0x3,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
shl    $0x2,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x34(%rbp)
jle    3625 <main+0x24f5>
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    3625 <main+0x24f5>
mov    -0x3c8(%rbp),%rax
mov    -0x3d0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0x34(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    3751 <main+0x2621>
mov    -0x3c8(%rbp),%rax
mov    -0x3d0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jne    3878 <main+0x2748>
mov    -0x3c8(%rbp),%rax
mov    -0x3d0(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x3,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jge    3999 <main+0x2869>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jg     3980 <main+0x2850>
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x168(%rbp),%xmm0
ff
movslq -0xc4(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc8(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm2
ff ff
subsd  -0x168(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    38a3 <main+0x2773>
jmp    3985 <main+0x2855>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    3882 <main+0x2752>
mov    -0x380(%rbp),%rax
mov    -0x388(%rbp),%rdx
movslq -0xcc(%rbp),%rcx
movsd  -0x100(%rbp,%rcx,8),%xmm0
ff ff
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x34(%rbp)
jne    3aa1 <main+0x2971>
mov    -0x408(%rbp),%rax
mov    -0x410(%rbp),%rcx
mov    -0x3a0(%rbp),%rdx
movsd  0x8(%rdx),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x20(%rdx),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    %rcx,%rsi
shl    $0x0,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    %rcx,%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
imul   $0x3,%rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
movslq -0x30(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
shl    $0x2,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x34(%rbp)
jle    3bbf <main+0x2a8f>
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    3bbf <main+0x2a8f>
mov    -0x408(%rbp),%rax
mov    -0x410(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movslq -0x34(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x34(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    3ceb <main+0x2bbb>
mov    -0x408(%rbp),%rax
mov    -0x410(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jne    3e12 <main+0x2ce2>
mov    -0x408(%rbp),%rax
mov    -0x410(%rbp),%rdx
mov    -0x3a0(%rbp),%rcx
movslq -0xbc(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xbc(%rbp),%esi
sub    $0x3,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movslq -0xbc(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xbc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jge    3f33 <main+0x2e03>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jg     3f1a <main+0x2dea>
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x168(%rbp),%xmm0
ff
movslq -0xc4(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm2
ff ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc8(%rbp),%rax
mulsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc8(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x168(%rbp),%xmm1
ff
movslq -0xc4(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm2
ff ff
subsd  -0x168(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    3e3d <main+0x2d0d>
jmp    3f1f <main+0x2def>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    3e1c <main+0x2cec>
mov    -0x360(%rbp),%rax
mov    -0x368(%rbp),%rdx
movslq -0xcc(%rbp),%rcx
movsd  -0x100(%rbp,%rcx,8),%xmm0
ff ff
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x310(%rbp),%xmm0
ff
addsd  -0x318(%rbp),%xmm0
ff
movsd  0x1097(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x2e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1892 <main+0x762>
jmp    3fa8 <main+0x2e78>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1829 <main+0x6f9>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jg     413a <main+0x300a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jg     4127 <main+0x2ff7>
mov    -0x410(%rbp),%rdx
mov    -0x368(%rbp),%rdi
mov    -0x418(%rbp),%rsi
mov    -0x420(%rbp),%r9
mov    -0x370(%rbp),%r8
mov    -0x378(%rbp),%r11
mov    -0x3c8(%rbp),%r10
mov    -0x3d0(%rbp),%r14
mov    -0x380(%rbp),%rbx
mov    -0x388(%rbp),%r12
mov    -0x3d8(%rbp),%r15
mov    -0x390(%rbp),%r13
mov    -0x398(%rbp),%rcx
movslq -0x34(%rbp),%rax
imul   %rcx,%rax
mov    -0x360(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%r13
movslq -0x30(%rbp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    -0x3e0(%rbp),%rax
movslq -0x34(%rbp),%r13
imul   %rax,%r13
mov    -0x408(%rbp),%rax
shl    $0x3,%r13
add    %r13,%r15
movslq -0x30(%rbp),%r13
movsd  %xmm0,(%r15,%r13,8)
movslq -0x34(%rbp),%r15
imul   %r12,%r15
shl    $0x3,%r15
add    %r15,%rbx
movslq -0x30(%rbp),%r15
movsd  (%rbx,%r15,8),%xmm0
movslq -0x34(%rbp),%rbx
imul   %r14,%rbx
shl    $0x3,%rbx
add    %rbx,%r10
movslq -0x30(%rbp),%rbx
movsd  %xmm0,(%r10,%rbx,8)
movslq -0x34(%rbp),%r10
imul   %r11,%r10
shl    $0x3,%r10
add    %r10,%r8
movslq -0x30(%rbp),%r10
movsd  (%r8,%r10,8),%xmm0
movslq -0x34(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x30(%rbp),%r8
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x30(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    3fd3 <main+0x2ea3>
jmp    412c <main+0x2ffc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3fbd <main+0x2e8d>
movsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x428(%rbp)
ff
movsd  -0x2e0(%rbp),%xmm0
ff
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x428(%rbp),%xmm0
ff
lea    0xebf(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x178(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
jmp    17e6 <main+0x6b6>
movl   $0x0,-0x2c(%rbp)
mov    -0x180(%rbp),%rax
mov    %rax,%rsp
mov    -0x2c(%rbp),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x6808,%rsp
mov    %rsp,0x200(%rsp)
lea    0xe08(%rsp),%rax
lea    0x1828(%rsp),%rcx
lea    0x2248(%rsp),%rdx
lea    0x3e8(%rsp),%rsi
mov    $0x1,%edi
movabs $0x3f3c2e33eff19503,%rbp
2e 3c 3f
jmp    119a <main+0x6a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x8,%rax
add    $0x8,%rcx
add    $0x8,%rdx
add    $0x8,%rsi
cmp    $0x12,%rdi
je     11e2 <main+0xb2>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %rbp,-0x90(%rsi,%rbx,1)
ff
mov    %rbp,-0x90(%rdx,%rbx,1)
ff
mov    %rbp,-0x90(%rcx,%rbx,1)
ff
mov    %rbp,-0x90(%rax,%rbx,1)
ff
cmp    $0x900,%rbx
je     1180 <main+0x50>
mov    %rbp,(%rsi,%rbx,1)
mov    %rbp,(%rdx,%rbx,1)
mov    %rbp,(%rcx,%rbx,1)
mov    %rbp,(%rax,%rbx,1)
add    $0x120,%rbx
jmp    11a0 <main+0x70>
movsd  0x290(%rsp),%xmm11
lea    0x21b0(%rsp),%rbx
xorpd  %xmm12,%xmm12
movsd  0x1dfe(%rip),%xmm8
movsd  0x1dfd(%rip),%xmm9
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x88(%rsp)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ebp
movl   $0xfffffff9,0x5c(%rsp)
ff
lea    0x2120(%rsp),%rax
mov    %rax,0x118(%rsp)
lea    0x2c0(%rsp),%rax
mov    %rax,0x110(%rsp)
lea    0xce0(%rsp),%rax
mov    %rax,0x108(%rsp)
lea    0x1700(%rsp),%rax
mov    %rax,0x100(%rsp)
movsd  %xmm11,0x98(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xb0(%rsp)
movaps 0x1d0(%rsp),%xmm14
movaps 0x1c0(%rsp),%xmm10
jmp    12f1 <main+0x1c1>
nopl   0x0(%rax,%rax,1)
addq   $0x90,0x100(%rsp)
addq   $0x90,0x108(%rsp)
addq   $0x90,0x110(%rsp)
addq   $0x90,0x118(%rsp)
addl   $0x1,0x5c(%rsp)
movsd  %xmm11,0x98(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,%rbp
cmp    $0xe,%rax
je     2630 <main+0x1500>
mov    %rbp,%rax
shl    $0x4,%rax
lea    (%rax,%rax,8),%rax
lea    -0x1(%rbp),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm9,%xmm0
movsd  %xmm0,0x120(%rsp,%rbp,8)
lea    0x1700(%rsp,%rax,1),%rcx
mov    %rcx,0xd0(%rsp)
lea    0xce0(%rsp,%rax,1),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x2c0(%rsp,%rax,1),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x2120(%rsp,%rax,1),%rcx
mov    %rcx,0xc0(%rsp)
lea    0x2b40(%rsp,%rax,1),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x3560(%rsp,%rax,1),%r12
lea    0x5de0(%rsp,%rax,1),%rcx
mov    %rcx,0x228(%rsp)
lea    0x49a0(%rsp,%rax,1),%rcx
mov    %rcx,0x220(%rsp)
lea    0x53c0(%rsp,%rax,1),%rcx
mov    %rcx,0x218(%rsp)
lea    0x3f80(%rsp,%rax,1),%rcx
mov    %rcx,0x210(%rsp)
lea    0x1(%rbp),%rcx
mov    %rcx,0x50(%rsp)
lea    0x3e0(%rsp,%rax,1),%rax
mov    %rax,0x208(%rsp)
movapd %xmm0,0x70(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x250(%rsp)
mov    $0x8,%r15d
mov    $0x1,%r14d
jmp    1542 <main+0x412>
xchg   %ax,%ax
movapd %xmm14,%xmm4
movapd 0x60(%rsp),%xmm2
subsd  %xmm2,%xmm4
subsd  %xmm2,%xmm15
movapd %xmm11,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm4,%xmm6
subsd  %xmm0,%xmm6
movapd %xmm4,%xmm0
subsd  %xmm15,%xmm0
divsd  %xmm0,%xmm6
movsd  0x10(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
subsd  %xmm2,%xmm0
movapd %xmm11,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm13
subsd  %xmm3,%xmm13
movapd %xmm4,%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm3,%xmm13
movsd  0x18(%rsp),%xmm3
movapd %xmm3,0x30(%rsp)
subsd  %xmm2,%xmm3
movapd %xmm5,%xmm1
movapd %xmm11,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm4,%xmm1
subsd  %xmm5,%xmm1
movsd  0x8(%rsp),%xmm10
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm1
movapd %xmm10,%xmm4
subsd  %xmm2,%xmm4
movapd %xmm6,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm4,%xmm13
subsd  %xmm5,%xmm13
movapd %xmm4,%xmm5
subsd  %xmm0,%xmm5
divsd  %xmm5,%xmm13
movsd  %xmm6,0xf8(%rsp)
movapd %xmm6,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm4,%xmm1
subsd  %xmm5,%xmm1
movapd %xmm1,%xmm5
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm5
movapd %xmm13,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm5
subsd  %xmm4,%xmm5
subsd  %xmm3,%xmm0
divsd  %xmm0,%xmm5
addsd  0x1b0(%rsp),%xmm12
mov    0x210(%rsp),%rax
movsd  %xmm5,(%rax,%r14,8)
mulsd  %xmm8,%xmm12
movsd  0xb0(%rsp),%xmm0
addsd  %xmm12,%xmm0
movsd  %xmm0,0xb0(%rsp)
add    $0x1,%r14
add    $0x1,%r15d
movsd  %xmm11,0x98(%rsp)
cmp    $0xe,%r14
xorpd  %xmm12,%xmm12
je     12a0 <main+0x170>
movsd  %xmm5,0x90(%rsp)
movaps %xmm10,0x1c0(%rsp)
movsd  %xmm13,0xa0(%rsp)
movsd  %xmm11,0xa8(%rsp)
movaps %xmm14,0x1d0(%rsp)
lea    -0x1(%r14),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm9,%xmm0
movapd %xmm0,0x60(%rsp)
mulsd  %xmm0,%xmm0
movapd 0x70(%rsp),%xmm5
mulsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
ucomisd %xmm12,%xmm5
jae    15de <main+0x4ae>
movapd %xmm5,%xmm0
movapd %xmm5,0xe0(%rsp)
call   1050 <sqrt@plt>
movapd 0xe0(%rsp),%xmm5
movsd  0x1a38(%rip),%xmm9
movsd  0x1a27(%rip),%xmm8
xorpd  %xmm12,%xmm12
mov    %rbp,%r11
xorpd  %xmm2,%xmm2
ucomisd %xmm12,%xmm0
xorpd  %xmm3,%xmm3
jne    15f2 <main+0x4c2>
jnp    160d <main+0x4dd>
movapd 0x250(%rsp),%xmm3
movlpd 0x60(%rsp),%xmm3
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
divpd  %xmm1,%xmm3
movapd %xmm0,0x280(%rsp)
movapd %xmm5,%xmm13
mulsd  0x19ec(%rip),%xmm13
mov    0xd0(%rsp),%rax
movsd  (%rax,%r14,8),%xmm10
mov    0xc8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm11
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm0
mov    0xb8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm6
mov    0xc0(%rsp),%rax
movsd  (%rax,%r14,8),%xmm14
movapd %xmm14,%xmm7
mulsd  %xmm1,%xmm7
movapd %xmm3,%xmm4
mulsd  %xmm6,%xmm4
subsd  %xmm7,%xmm4
movapd %xmm1,0x260(%rsp)
mulsd  %xmm12,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm14,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm0,%xmm1
mulsd  0x1963(%rip),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,0x1b0(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm3,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm3,0x270(%rsp)
mulsd  %xmm3,%xmm1
mulsd  %xmm6,%xmm1
subsd  %xmm6,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm6,0x230(%rsp)
movapd %xmm6,%xmm1
mulsd  0x1913(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm13,0x1e0(%rsp)
movapd %xmm13,%xmm0
movsd  %xmm11,0x248(%rsp)
mulsd  %xmm11,%xmm0
movsd  %xmm10,0x240(%rsp)
addsd  %xmm10,%xmm0
movapd %xmm0,0x1f0(%rsp)
movsd  %xmm14,0x238(%rsp)
mulsd  %xmm14,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm5,0xe0(%rsp)
mov    0xd8(%rsp),%rax
movq   $0x0,(%rax,%r14,8)
movq   $0x0,(%r12,%r14,8)
xor    %r8d,%r8d
mov    $0x3f0,%ecx
lea    0x350(%rsp),%r9
mov    %rbx,%r10
mov    %rbx,%rsi
lea    0x1790(%rsp),%rdi
lea    0xd70(%rsp),%rbx
mov    0x5c(%rsp),%ebp
xorpd  %xmm5,%xmm5
jmp    17e7 <main+0x6b7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8d
add    $0xffffffffffffff70,%rcx
add    $0xffffffff,%ebp
add    $0x90,%rbx
add    $0x90,%rdi
add    $0x90,%rsi
add    $0x90,%r9
cmp    $0xfffffffffffffca0,%rcx
je     19b0 <main+0x880>
xorps  %xmm13,%xmm13
cvtsi2sd %r8d,%xmm13
mulsd  %xmm8,%xmm13
addsd  %xmm9,%xmm13
mov    %r13d,%eax
mov    $0x1,%r13d
cmp    $0xfffffff1,%ebp
ja     1819 <main+0x6e9>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%r13d
cmp    $0xc,%eax
jg     17b0 <main+0x680>
lea    -0x1(%r13),%eax
xorps  %xmm6,%xmm6
cvtsi2sd %eax,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm9,%xmm6
mov    %r14d,%eax
sub    %r13d,%eax
add    $0xfffffff9,%eax
cmp    $0xfffffff2,%eax
jae    1850 <main+0x720>
mov    %r13d,%eax
jmp    1810 <main+0x6e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%eax
sub    %r13d,%eax
mov    0x100(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
movsd  (%rcx,%rdx,1),%xmm14
mov    0x108(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
movsd  (%rcx,%rdx,1),%xmm8
movslq %r13d,%rdx
movsd  (%rsi,%rdx,8),%xmm0
movsd  (%r9,%rdx,8),%xmm7
movsd  (%rdi,%rdx,8),%xmm9
movsd  (%rbx,%rdx,8),%xmm10
mov    0x110(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
movsd  (%rcx,%rdx,1),%xmm12
mov    0x118(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
movsd  (%rcx,%rax,1),%xmm15
movapd 0x60(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movapd 0x70(%rsp),%xmm4
mulsd  %xmm4,%xmm7
addsd  %xmm0,%xmm7
movapd %xmm6,%xmm0
mulsd  %xmm8,%xmm0
movapd %xmm13,%xmm3
mulsd  %xmm14,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm1,%xmm0
unpcklpd %xmm8,%xmm0
movapd %xmm14,%xmm1
movapd %xmm15,%xmm11
unpcklpd %xmm12,%xmm15
mulsd  %xmm7,%xmm12
mulsd  %xmm7,%xmm11
mulsd  %xmm7,%xmm14
mulsd  %xmm8,%xmm7
unpcklpd %xmm10,%xmm8
mulpd  %xmm0,%xmm8
unpcklpd %xmm9,%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm8,%xmm1
movsd  0x16c8(%rip),%xmm8
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
mulsd  %xmm3,%xmm9
addsd  %xmm9,%xmm12
movsd  0x16b1(%rip),%xmm9
mulsd  %xmm10,%xmm3
addsd  %xmm3,%xmm11
unpcklpd %xmm12,%xmm11
mulpd  %xmm0,%xmm15
unpcklpd %xmm13,%xmm6
mulpd  %xmm1,%xmm6
subpd  %xmm6,%xmm11
unpcklpd %xmm14,%xmm7
subpd  %xmm15,%xmm7
addpd  %xmm7,%xmm2
addpd  %xmm11,%xmm5
movhpd %xmm5,(%r12,%r14,8)
mov    0xd8(%rsp),%rax
movlpd %xmm5,(%rax,%r14,8)
mov    %r13d,%eax
jmp    1810 <main+0x6e0>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movapd 0x280(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movapd 0x1e0(%rsp),%xmm7
movsd  0x240(%rsp),%xmm11
mulsd  %xmm11,%xmm7
addsd  %xmm0,%xmm7
movapd 0x1f0(%rsp),%xmm4
addsd  %xmm0,%xmm4
movapd 0x1b0(%rsp),%xmm10
addsd  %xmm0,%xmm10
movapd 0xe0(%rsp),%xmm6
addsd  %xmm0,%xmm6
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
jne    1a12 <main+0x8e2>
jnp    1a70 <main+0x940>
movsd  0x35f0(%rsp),%xmm0
movapd 0x270(%rsp),%xmm3
mulsd  %xmm3,%xmm0
movsd  0x4010(%rsp),%xmm1
movapd 0x260(%rsp),%xmm5
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm5
movsd  %xmm5,0x4010(%rsp)
mulsd  %xmm3,%xmm1
movsd  %xmm1,0x35f0(%rsp)
movsd  (%r12,%r14,8),%xmm0
mov    0xd8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm5
addsd  %xmm5,%xmm6
addsd  %xmm0,%xmm10
movsd  0x15a7(%rip),%xmm3
mulsd  %xmm3,%xmm10
addsd  0x230(%rsp),%xmm10
mov    0xb8(%rsp),%rax
movsd  %xmm10,(%rax,%r14,8)
mulsd  %xmm3,%xmm6
addsd  0x238(%rsp),%xmm6
mov    0xc0(%rsp),%rax
movsd  %xmm6,(%rax,%r14,8)
addsd  %xmm2,%xmm4
unpckhpd %xmm2,%xmm2
addsd  %xmm2,%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm11,%xmm7
mov    0xd0(%rsp),%rax
movsd  %xmm7,(%rax,%r14,8)
mulsd  %xmm3,%xmm4
addsd  0x248(%rsp),%xmm4
mov    0xc8(%rsp),%rax
movsd  %xmm4,(%rax,%r14,8)
movapd %xmm6,0xe0(%rsp)
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm10,%xmm12
mulsd  %xmm10,%xmm12
addsd  %xmm0,%xmm12
movapd %xmm7,0x1e0(%rsp)
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm4,0x1f0(%rsp)
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
movapd 0x60(%rsp),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x70(%rsp),%xmm0
movapd %xmm0,0x60(%rsp)
mov    %r11,%rbp
cmp    $0x1,%r11
mov    %r10,%rbx
movapd 0x1d0(%rsp),%xmm14
movsd  0xa8(%rsp),%xmm11
movsd  0xa0(%rsp),%xmm13
movapd 0x1c0(%rsp),%xmm15
movapd %xmm4,0x1b0(%rsp)
jne    1c00 <main+0xad0>
movupd 0x128(%rsp),%xmm14
movupd 0x138(%rsp),%xmm0
movapd %xmm14,(%rsp)
movapd %xmm0,0x10(%rsp)
movsd  0x350(%rsp,%r14,8),%xmm11
movsd  0x3e0(%rsp,%r14,8),%xmm10
movsd  0x470(%rsp,%r14,8),%xmm13
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
xor    %eax,%eax
lea    0x500(%rsp),%rsi
xor    %edx,%edx
jmp    1da0 <main+0xc70>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0xb,%rbp
ja     1c80 <main+0xb50>
movsd  0x118(%rsp,%rbp,8),%xmm14
movsd  %xmm14,(%rsp)
movapd 0x70(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
mov    0x50(%rsp),%rax
movupd 0x120(%rsp,%rax,8),%xmm0
movapd %xmm0,0x10(%rsp)
mov    0xb8(%rsp),%rax
movsd  -0x90(%rax,%r14,8),%xmm11
ff ff ff
movsd  0x90(%rax,%r14,8),%xmm13
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
mov    $0x1,%dl
xor    %eax,%eax
mov    0x208(%rsp),%rsi
movapd %xmm2,%xmm15
jmp    1da0 <main+0xc70>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
cmp    $0xd,%ebp
je     1d23 <main+0xbf3>
mov    $0x0,%edx
mov    $0x0,%ecx
cmp    $0xc,%ebp
movsd  0x90(%rsp),%xmm5
movsd  0xf8(%rsp),%xmm10
movsd  0x98(%rsp),%xmm7
jne    1dad <main+0xc7d>
movapd 0x180(%rsp),%xmm14
movapd %xmm14,(%rsp)
movlpd %xmm14,0x10(%rsp)
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
movsd  %xmm0,0x18(%rsp)
movsd  0x980(%rsp,%r14,8),%xmm13
movsd  0xa10(%rsp,%r14,8),%xmm10
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
mov    $0x1,%cl
xor    %eax,%eax
lea    0x8f0(%rsp),%rsi
movapd %xmm14,0x40(%rsp)
movapd %xmm13,%xmm11
xor    %edx,%edx
jmp    1da2 <main+0xc72>
movsd  0x188(%rsp),%xmm14
movsd  %xmm14,(%rsp)
movsd  0x180(%rsp),%xmm15
movsd  %xmm15,0x8(%rsp)
movsd  0x170(%rsp),%xmm1
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
movsd  %xmm0,0x10(%rsp)
movapd %xmm1,0x30(%rsp)
movsd  %xmm1,0x18(%rsp)
movsd  0xa10(%rsp,%r14,8),%xmm11
movsd  0x8f0(%rsp,%r14,8),%xmm13
movsd  0x980(%rsp,%r14,8),%xmm10
mov    $0x1,%al
xor    %edx,%edx
lea    0x860(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
movsd  (%rsi,%r14,8),%xmm5
movapd %xmm11,%xmm7
movapd %xmm14,%xmm6
movapd 0x60(%rsp),%xmm2
subsd  %xmm2,%xmm6
movapd %xmm15,%xmm3
subsd  %xmm2,%xmm3
movapd %xmm7,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm10
subsd  %xmm0,%xmm10
movapd %xmm6,%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm0,%xmm10
movapd 0x40(%rsp),%xmm4
subsd  %xmm2,%xmm4
movapd %xmm7,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm6,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm6,%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm0,%xmm13
movapd 0x30(%rsp),%xmm1
subsd  %xmm2,%xmm1
movapd %xmm7,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm6
divsd  %xmm6,%xmm5
movapd %xmm10,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm3,%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm0,%xmm13
movapd %xmm10,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm3
divsd  %xmm3,%xmm5
movapd %xmm13,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm4
divsd  %xmm4,%xmm5
mov    0x228(%rsp),%rsi
movsd  %xmm5,(%rsi,%r14,8)
cmp    $0x1,%rbp
movapd %xmm10,%xmm2
movapd %xmm7,%xmm10
je     21c0 <main+0x1090>
test   %dl,%dl
jne    222e <main+0x10fe>
test   %cl,%cl
jne    22af <main+0x117f>
test   %al,%al
je     1f2f <main+0xdff>
movsd  0x188(%rsp),%xmm14
movsd  %xmm14,(%rsp)
movsd  0x180(%rsp),%xmm15
movsd  %xmm15,0x8(%rsp)
movsd  0x170(%rsp),%xmm1
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
movsd  %xmm0,0x10(%rsp)
movapd %xmm1,0x30(%rsp)
movsd  %xmm1,0x18(%rsp)
movsd  0x1e50(%rsp,%r14,8),%xmm11
movsd  0x1dc0(%rsp,%r14,8),%xmm2
movsd  0x1ca0(%rsp,%r14,8),%xmm5
movsd  0x1d30(%rsp,%r14,8),%xmm13
movapd %xmm11,%xmm10
movapd %xmm14,%xmm6
movapd 0x60(%rsp),%xmm7
subsd  %xmm7,%xmm6
movapd %xmm15,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm10,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm6,%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm0,%xmm2
movapd 0x40(%rsp),%xmm4
subsd  %xmm7,%xmm4
movapd %xmm10,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm6,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm6,%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm0,%xmm13
movapd 0x30(%rsp),%xmm1
subsd  %xmm7,%xmm1
movapd %xmm10,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm6
divsd  %xmm6,%xmm5
movapd %xmm2,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm3,%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm0,%xmm13
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm3
divsd  %xmm3,%xmm5
movapd %xmm13,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm4
divsd  %xmm4,%xmm5
mov    0x220(%rsp),%rsi
movsd  %xmm5,(%rsi,%r14,8)
cmp    $0x1,%rbp
je     2330 <main+0x1200>
test   %dl,%dl
jne    239e <main+0x126e>
test   %cl,%cl
jne    241f <main+0x12ef>
test   %al,%al
je     20a5 <main+0xf75>
movsd  0x188(%rsp),%xmm14
movsd  %xmm14,(%rsp)
movsd  0x180(%rsp),%xmm15
movsd  %xmm15,0x8(%rsp)
movsd  0x170(%rsp),%xmm1
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
movsd  %xmm0,0x10(%rsp)
movapd %xmm1,0x30(%rsp)
movsd  %xmm1,0x18(%rsp)
movsd  0x2870(%rsp,%r14,8),%xmm11
movsd  0x27e0(%rsp,%r14,8),%xmm2
movsd  0x26c0(%rsp,%r14,8),%xmm5
movsd  0x2750(%rsp,%r14,8),%xmm13
movapd %xmm11,%xmm10
movapd %xmm14,%xmm4
movapd 0x60(%rsp),%xmm6
subsd  %xmm6,%xmm4
movapd %xmm2,%xmm1
movapd %xmm15,%xmm3
subsd  %xmm6,%xmm3
movapd %xmm10,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm0,%xmm1
movapd 0x40(%rsp),%xmm2
subsd  %xmm6,%xmm2
movapd %xmm10,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm4,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm4,%xmm0
subsd  %xmm2,%xmm0
divsd  %xmm0,%xmm13
movapd %xmm10,%xmm0
movapd 0x30(%rsp),%xmm10
subsd  %xmm6,%xmm10
mulsd  %xmm10,%xmm0
mulsd  %xmm4,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm10,%xmm4
divsd  %xmm4,%xmm5
movapd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm13
subsd  %xmm0,%xmm13
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
divsd  %xmm0,%xmm13
movapd %xmm1,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm3,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm10,%xmm3
divsd  %xmm3,%xmm5
movapd %xmm1,%xmm6
movapd %xmm13,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm2,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm10,%xmm2
divsd  %xmm2,%xmm5
mov    0x218(%rsp),%rsi
movsd  %xmm5,(%rsi,%r14,8)
cmp    $0x1,%rbp
je     24a0 <main+0x1370>
test   %dl,%dl
jne    24f9 <main+0x13c9>
test   %cl,%cl
jne    2565 <main+0x1435>
test   %al,%al
je     13f0 <main+0x2c0>
jmp    25c0 <main+0x1490>
nopl   0x0(%rax)
movupd 0x128(%rsp),%xmm14
movupd 0x138(%rsp),%xmm0
movapd %xmm14,(%rsp)
movapd %xmm0,0x10(%rsp)
movsd  0x1790(%rsp,%r14,8),%xmm11
movsd  0x1820(%rsp,%r14,8),%xmm2
movsd  0x18b0(%rsp,%r14,8),%xmm13
movsd  0x1940(%rsp,%r14,8),%xmm5
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm11,%xmm10
test   %dl,%dl
je     1eab <main+0xd7b>
movsd  0x118(%rsp,%rbp,8),%xmm14
movsd  %xmm14,(%rsp)
movapd 0x70(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
mov    0x50(%rsp),%rsi
movupd 0x120(%rsp,%rsi,8),%xmm0
movapd %xmm0,0x10(%rsp)
mov    0xd0(%rsp),%rsi
movsd  -0x90(%rsi,%r14,8),%xmm11
ff ff ff
movsd  0x90(%rsi,%r14,8),%xmm13
movsd  0x120(%rsi,%r14,8),%xmm5
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm2,%xmm15
movapd 0x1e0(%rsp),%xmm2
movapd %xmm11,%xmm10
test   %cl,%cl
je     1eb3 <main+0xd83>
movapd 0x180(%rsp),%xmm14
movapd %xmm14,(%rsp)
movlpd %xmm14,0x10(%rsp)
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
movsd  %xmm0,0x18(%rsp)
movsd  0x1d30(%rsp,%r14,8),%xmm5
movsd  0x1dc0(%rsp,%r14,8),%xmm11
movsd  0x1e50(%rsp,%r14,8),%xmm2
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm11,%xmm13
movapd %xmm14,0x40(%rsp)
movapd %xmm11,%xmm10
test   %al,%al
jne    1eb7 <main+0xd87>
jmp    1f2f <main+0xdff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x128(%rsp),%xmm14
movupd 0x138(%rsp),%xmm0
movapd %xmm14,(%rsp)
movapd %xmm0,0x10(%rsp)
movsd  0x21b0(%rsp,%r14,8),%xmm11
movsd  0x2240(%rsp,%r14,8),%xmm2
movsd  0x22d0(%rsp,%r14,8),%xmm13
movsd  0x2360(%rsp,%r14,8),%xmm5
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm11,%xmm10
test   %dl,%dl
je     2021 <main+0xef1>
movsd  0x118(%rsp,%rbp,8),%xmm14
movsd  %xmm14,(%rsp)
movapd 0x70(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
mov    0x50(%rsp),%rsi
movupd 0x120(%rsp,%rsi,8),%xmm0
movapd %xmm0,0x10(%rsp)
mov    0xc0(%rsp),%rsi
movsd  -0x90(%rsi,%r14,8),%xmm11
ff ff ff
movsd  0x90(%rsi,%r14,8),%xmm13
movsd  0x120(%rsi,%r14,8),%xmm5
movapd %xmm0,0x40(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm2,%xmm15
movapd 0xe0(%rsp),%xmm2
movapd %xmm11,%xmm10
test   %cl,%cl
je     2029 <main+0xef9>
movapd 0x180(%rsp),%xmm14
movapd %xmm14,(%rsp)
movlpd %xmm14,0x10(%rsp)
movsd  0x178(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
movsd  %xmm0,0x18(%rsp)
movsd  0x2750(%rsp,%r14,8),%xmm5
movsd  0x27e0(%rsp,%r14,8),%xmm11
movsd  0x2870(%rsp,%r14,8),%xmm2
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm11,%xmm13
movapd %xmm14,0x40(%rsp)
movapd %xmm11,%xmm10
test   %al,%al
jne    202d <main+0xefd>
jmp    20a5 <main+0xf75>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x128(%rsp),%xmm14
movupd 0x138(%rsp),%xmm0
movapd %xmm14,(%rsp)
movapd %xmm0,0x10(%rsp)
movsd  0xd70(%rsp,%r14,8),%xmm11
movsd  0xe00(%rsp,%r14,8),%xmm6
movsd  0xe90(%rsp,%r14,8),%xmm13
movsd  0xf20(%rsp,%r14,8),%xmm5
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
test   %dl,%dl
je     21a7 <main+0x1077>
movsd  0x118(%rsp,%rbp,8),%xmm14
movsd  %xmm14,(%rsp)
movapd 0x70(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
mov    0x50(%rsp),%rdx
movupd 0x120(%rsp,%rdx,8),%xmm0
movapd %xmm0,0x10(%rsp)
mov    0xc8(%rsp),%rdx
movsd  -0x90(%rdx,%r14,8),%xmm11
ff ff ff
movsd  0x90(%rdx,%r14,8),%xmm13
movsd  0x120(%rdx,%r14,8),%xmm5
movapd %xmm2,%xmm15
movapd 0x1f0(%rsp),%xmm6
test   %cl,%cl
je     21af <main+0x107f>
movapd 0x180(%rsp),%xmm14
movapd %xmm14,(%rsp)
movlpd %xmm14,0x10(%rsp)
movsd  0x178(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x1310(%rsp,%r14,8),%xmm5
movsd  0x13a0(%rsp,%r14,8),%xmm13
movsd  0x1430(%rsp,%r14,8),%xmm6
movapd %xmm14,%xmm15
unpckhpd %xmm14,%xmm15
movapd %xmm13,%xmm11
test   %al,%al
je     13f0 <main+0x2c0>
movsd  0x188(%rsp),%xmm14
movsd  %xmm14,(%rsp)
movsd  0x180(%rsp),%xmm15
movsd  %xmm15,0x8(%rsp)
movapd 0x170(%rsp),%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x1430(%rsp,%r14,8),%xmm11
movsd  0x13a0(%rsp,%r14,8),%xmm6
movsd  0x1280(%rsp,%r14,8),%xmm5
movsd  0x1310(%rsp,%r14,8),%xmm13
jmp    13f0 <main+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm5,0x90(%rsp)
movapd %xmm10,0x1c0(%rsp)
movsd  %xmm13,0xa0(%rsp)
movsd  %xmm11,0xa8(%rsp)
movapd %xmm14,0x1d0(%rsp)
xor    %eax,%eax
lea    0x8f0(%rsp),%rdx
lea    0x5e78(%rsp),%rdi
lea    0x5458(%rsp),%rbp
lea    0x4a38(%rsp),%r8
lea    0x4018(%rsp),%r9
nopl   0x0(%rax,%rax,1)
mov    0x60(%rdi,%rax,1),%rcx
mov    %rcx,-0x538(%rdx,%rax,1)
ff
movups 0x50(%rdi,%rax,1),%xmm0
movups %xmm0,-0x548(%rdx,%rax,1)
ff
movups 0x40(%rdi,%rax,1),%xmm0
movups %xmm0,-0x558(%rdx,%rax,1)
ff
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups 0x20(%rdi,%rax,1),%xmm2
movups 0x30(%rdi,%rax,1),%xmm3
movups %xmm3,-0x568(%rdx,%rax,1)
ff
movups %xmm2,-0x578(%rdx,%rax,1)
ff
movups %xmm1,-0x588(%rdx,%rax,1)
ff
movups %xmm0,-0x598(%rdx,%rax,1)
ff
mov    0x60(%rbp,%rax,1),%rcx
mov    %rcx,0x68(%rbx,%rax,1)
movups 0x50(%rbp,%rax,1),%xmm0
movups %xmm0,0x58(%rbx,%rax,1)
movups 0x40(%rbp,%rax,1),%xmm0
movups %xmm0,0x48(%rbx,%rax,1)
movups 0x0(%rbp,%rax,1),%xmm0
movups 0x10(%rbp,%rax,1),%xmm1
movups 0x20(%rbp,%rax,1),%xmm2
movups 0x30(%rbp,%rax,1),%xmm3
movups %xmm3,0x38(%rbx,%rax,1)
movups %xmm2,0x28(%rbx,%rax,1)
movups %xmm1,0x18(%rbx,%rax,1)
movups %xmm0,0x8(%rbx,%rax,1)
mov    0x60(%r8,%rax,1),%rcx
lea    0x1790(%rsp),%rsi
mov    %rcx,0x68(%rsi,%rax,1)
movups 0x50(%r8,%rax,1),%xmm0
movups %xmm0,0x58(%rsi,%rax,1)
movups 0x40(%r8,%rax,1),%xmm0
movups %xmm0,0x48(%rsi,%rax,1)
movups (%r8,%rax,1),%xmm0
movups 0x10(%r8,%rax,1),%xmm1
movups 0x20(%r8,%rax,1),%xmm2
movups 0x30(%r8,%rax,1),%xmm3
movups %xmm3,0x38(%rsi,%rax,1)
movups %xmm2,0x28(%rsi,%rax,1)
movups %xmm1,0x18(%rsi,%rax,1)
movups %xmm0,0x8(%rsi,%rax,1)
mov    0x60(%r9,%rax,1),%rcx
lea    0xd70(%rsp),%rsi
mov    %rcx,0x68(%rsi,%rax,1)
movups 0x50(%r9,%rax,1),%xmm0
movups %xmm0,0x58(%rsi,%rax,1)
movups 0x40(%r9,%rax,1),%xmm0
movups %xmm0,0x48(%rsi,%rax,1)
movupd (%r9,%rax,1),%xmm0
movupd 0x10(%r9,%rax,1),%xmm1
movupd 0x20(%r9,%rax,1),%xmm2
movupd 0x30(%r9,%rax,1),%xmm3
movupd %xmm3,0x38(%rsi,%rax,1)
movupd %xmm2,0x28(%rsi,%rax,1)
movupd %xmm1,0x18(%rsi,%rax,1)
movupd %xmm0,0x8(%rsi,%rax,1)
add    $0x90,%rax
cmp    $0x750,%rax
jne    2690 <main+0x1560>
movsd  0xb0(%rsp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
lea    0x830(%rip),%rdi
movsd  0x88(%rsp),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x88(%rsp),%xmm1
addsd  0x7ff(%rip),%xmm1
movsd  0x7ff(%rip),%xmm0
movsd  %xmm1,0x88(%rsp)
ucomisd %xmm1,%xmm0
xorpd  %xmm12,%xmm12
movsd  0x7b4(%rip),%xmm8
movsd  0x7b3(%rip),%xmm9
movsd  0xa8(%rsp),%xmm11
movsd  0xa0(%rsp),%xmm13
movsd  0x90(%rsp),%xmm5
jae    1220 <main+0xf0>
movsd  %xmm11,0x290(%rsp)
movsd  0xf8(%rsp),%xmm0
movsd  %xmm0,0x298(%rsp)
movsd  %xmm13,0x2a0(%rsp)
movsd  %xmm5,0x2a8(%rsp)
mov    0x200(%rsp),%rsp
xor    %eax,%eax
add    $0x6808,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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