void cu_compute_matrix_stamps(int dp, int ds, int db, int nx, int ny,
                              int nstamps, int stamp_half_width,
                              double *stamp_xpos, double *stamp_ypos,
                              int *kxindex, int *kyindex, int *ext_basis,
                              int nkernel, int kernelRadius, double *H,
                              int BlockDimx, int gridDimx, int gridDimy,
                              double *tex0, double *tex1, double *tex3,
                              double *tex4) {
  int idx, idy, idx0, idy0, idx1, idy1;
  int np, ns, ki, kj, a, b, c, d, d1, d2, i, j, i1, i2, j1, j2;
  int l, m, l1, m1, l2, m2;
  double *px, *py, *x, *y, Bi, Bj, temp, pyj;
  double *ppx;
  double *pBi1, *pBi2, *pBj1, *pBj2, *pt3, *pt4;
  int blockIdx, blockIdy;
  x = (double *)malloc(nx * sizeof(double));
  y = (double *)malloc(ny * sizeof(double));
  px = (double *)malloc(nx * sizeof(double));
  py = (double *)malloc(ny * sizeof(double));
  for (j = 0; j < nx; j++) {
    x[j] = (j - 0.5 * (nx - 1)) / (nx - 1);
  }
  for (j = 0; j < ny; j++) {
    y[j] = (j - 0.5 * (ny - 1)) / (ny - 1);
  }
  for (blockIdy = 0; blockIdy < gridDimy; blockIdy++) {
    for (blockIdx = 0; blockIdx < gridDimx; blockIdx++) {
      H[blockIdx + gridDimx * blockIdy] = 0.0;
    }
  }
  np = (dp + 1) * (dp + 2) / 2;
  ns = (ds + 1) * (ds + 2) / 2;
  for (blockIdy = 0; blockIdy < gridDimy; blockIdy++) {
    for (blockIdx = 0; blockIdx <= blockIdy; blockIdx++) {
      ki = blockIdx < np ? 0 : (blockIdx - np) / ns + 1;
      kj = blockIdy < np ? 0 : (blockIdy - np) / ns + 1;
      a = b = 0;
      if (ki < nkernel) {
        a = kxindex[ki];
        b = kyindex[ki];
      }
      if (kj < nkernel) {
        c = kxindex[kj];
        d = kyindex[kj];
      }
      if (ki == 0) {
        d1 = dp;
        idx = blockIdx;
      } else if (ki < nkernel) {
        d1 = ds;
        idx = blockIdx - np - (ki - 1) * ns;
      } else {
        d1 = db;
        idx = blockIdx - np - (ki - 1) * ns;
      }
      if (kj == 0) {
        d2 = dp;
        idy = blockIdy;
      } else if (kj < nkernel) {
        d2 = ds;
        idy = blockIdy - np - (kj - 1) * ns;
      } else {
        d2 = db;
        idy = blockIdy - np - (kj - 1) * ns;
      }
      if ((ki > 0) && (ki < nkernel) && (kj > 0) && (kj < nkernel) &&
          (idx > idy)) {
        continue;
      }
      idx0 = idx;
      idy0 = idy;
      i = 0;
      for (l = 0; l <= d1; l++) {
        for (m = 0; m <= d1 - l; m++) {
          if (i == idx) {
            l1 = l;
            m1 = m;
          }
          i++;
        }
      }
      i = 0;
      for (l = 0; l <= d2; l++) {
        for (m = 0; m <= d2 - l; m++) {
          if (i == idy) {
            l2 = l;
            m2 = m;
          }
          i++;
        }
      }
      for (j = 0; j < nx; j++) {
        px[j] = pow(x[j], l1 + l2);
      }
      for (j = 0; j < ny; j++) {
        py[j] = pow(y[j], m1 + m2);
      }
      Bi = Bj = 1.0;
      temp = 0.0;
      if (ki == 0) {
        if (kj == 0) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              pBj1 = &tex0[i1 + nx * j];
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * (*pBi1++) * (*pBj1++) * (*pt3++) *
                        (*pt4++);
              }
            }
          }
        } else if (kj < nkernel) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              pBj1 = &tex0[i1 + nx * j];
              if (ext_basis[kj]) {
                pBj2 = &tex1[i1 + c + nx * (j + d)];
              } else {
                pBj2 = &tex0[i1 + c + nx * (j + d)];
              }
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * (*pBi1++) * ((*pBj2++) - (*pBj1++)) *
                        (*pt3++) * (*pt4++);
              }
            }
          }
        } else {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * (*pBi1++) * (*pt3++) * (*pt4++);
              }
            }
          }
        }
      } else if (ki < nkernel) {
        if (kj == 0) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              if (ext_basis[ki]) {
                pBi2 = &tex1[i1 + a + nx * (j + b)];
              } else {
                pBi2 = &tex0[i1 + a + nx * (j + b)];
              }
              pBj1 = &tex0[i1 + nx * j];
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) * (*pBj1++) *
                        (*pt3++) * (*pt4++);
              }
            }
          }
        } else if (kj < nkernel) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              pBj1 = &tex0[i1 + nx * j];
              if (ext_basis[ki]) {
                pBi2 = &tex1[i1 + a + nx * (j + b)];
              } else {
                pBi2 = &tex0[i1 + a + nx * (j + b)];
              }
              if (ext_basis[kj]) {
                pBj2 = &tex1[i1 + c + nx * (j + d)];
              } else {
                pBj2 = &tex0[i1 + c + nx * (j + d)];
              }
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) *
                        ((*pBj2++) - (*pBj1++)) * (*pt3++) * (*pt4++);
              }
            }
          }
        } else {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBi1 = &tex0[i1 + nx * j];
              if (ext_basis[ki]) {
                pBi2 = &tex1[i1 + a + nx * (j + b)];
              } else {
                pBi2 = &tex0[i1 + a + nx * (j + b)];
              }
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) * (*pt3++) *
                        (*pt4++);
              }
            }
          }
        }
      } else {
        if (kj == 0) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBj1 = &tex0[i1 + nx * j];
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * (*pBj1++) * (*pt3++) * (*pt4++);
              }
            }
          }
        } else if (kj < nkernel) {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pBj1 = &tex0[i1 + nx * j];
              if (ext_basis[kj]) {
                pBj2 = &tex1[i1 + c + nx * (j + d)];
              } else {
                pBj2 = &tex0[i1 + c + nx * (j + d)];
              }
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * ((*pBj2++) - (*pBj1++)) * (*pt3++) *
                        (*pt4++);
              }
            }
          }
        } else {
          for (idx = 0; idx < nstamps; idx++) {
            j1 = ((0) > ((int)stamp_ypos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_ypos[idx] - stamp_half_width));
            j2 = ((ny) < ((int)stamp_ypos[idx] + stamp_half_width)
                      ? (ny)
                      : ((int)stamp_ypos[idx] + stamp_half_width));
            i1 = ((0) > ((int)stamp_xpos[idx] - stamp_half_width)
                      ? (0)
                      : ((int)stamp_xpos[idx] - stamp_half_width));
            i2 = ((nx) < ((int)stamp_xpos[idx] + stamp_half_width)
                      ? (nx)
                      : ((int)stamp_xpos[idx] + stamp_half_width));
            for (j = j1; j < j2; j++) {
              pt3 = &tex3[i1 + nx * j];
              pt4 = &tex4[i1 + nx * j];
              ppx = &px[i1];
              pyj = py[j];
              for (i = i1; i < i2; i++) {
                temp += (*ppx++) * pyj * (*pt3++) * (*pt4++);
              }
            }
          }
        }
      }
      H[blockIdx + gridDimx * blockIdy] = temp;
      H[blockIdy + gridDimx * blockIdx] = temp;
      if ((ki > 0) && (ki < nkernel) && (kj > 0) && (kj < nkernel)) {
        idx1 = np + (ki - 1) * ns;
        idy1 = np + (kj - 1) * ns;
        H[(idx1 + idy0) + gridDimx * (idy1 + idx0)] = temp;
        H[(idy1 + idx0) + gridDimx * (idx1 + idy0)] = temp;
      }
    }
  }
}


x86 assembly (clang, -O0):
<cu_compute_matrix_stamps>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    122d <cu_compute_matrix_stamps+0x10d>
cvtsi2sdl -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x2e0f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11d6 <cu_compute_matrix_stamps+0xb6>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128b <cu_compute_matrix_stamps+0x16b>
cvtsi2sdl -0x60(%rbp),%xmm1
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x2db1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1234 <cu_compute_matrix_stamps+0x114>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    0x68(%rbp),%eax
jge    130b <cu_compute_matrix_stamps+0x1eb>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    0x60(%rbp),%eax
jge    12f2 <cu_compute_matrix_stamps+0x1d2>
mov    0x50(%rbp),%rax
mov    -0x104(%rbp),%ecx
mov    0x60(%rbp),%edx
imul   -0x108(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    12ae <cu_compute_matrix_stamps+0x18e>
jmp    12f7 <cu_compute_matrix_stamps+0x1d7>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    1295 <cu_compute_matrix_stamps+0x175>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    0x68(%rbp),%eax
jge    3495 <cu_compute_matrix_stamps+0x2375>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x108(%rbp),%eax
jg     347c <cu_compute_matrix_stamps+0x235c>
mov    -0x104(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1390 <cu_compute_matrix_stamps+0x270>
xor    %eax,%eax
mov    %eax,-0x10c(%rbp)
jmp    13a6 <cu_compute_matrix_stamps+0x286>
mov    -0x104(%rbp),%eax
sub    -0x34(%rbp),%eax
cltd
idivl  -0x38(%rbp)
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x108(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13cb <cu_compute_matrix_stamps+0x2ab>
xor    %eax,%eax
mov    %eax,-0x110(%rbp)
jmp    13e1 <cu_compute_matrix_stamps+0x2c1>
mov    -0x108(%rbp),%eax
sub    -0x34(%rbp),%eax
cltd
idivl  -0x38(%rbp)
add    $0x1,%eax
mov    %eax,-0x110(%rbp)
mov    -0x110(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1420 <cu_compute_matrix_stamps+0x300>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1448 <cu_compute_matrix_stamps+0x328>
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    1466 <cu_compute_matrix_stamps+0x346>
mov    -0x4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x104(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    14b8 <cu_compute_matrix_stamps+0x398>
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1495 <cu_compute_matrix_stamps+0x375>
mov    -0x8(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x104(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b3 <cu_compute_matrix_stamps+0x393>
mov    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x104(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b8 <cu_compute_matrix_stamps+0x398>
cmpl   $0x0,-0x40(%rbp)
jne    14d6 <cu_compute_matrix_stamps+0x3b6>
mov    -0x4(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x108(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1528 <cu_compute_matrix_stamps+0x408>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1505 <cu_compute_matrix_stamps+0x3e5>
mov    -0x8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x108(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
jmp    1523 <cu_compute_matrix_stamps+0x403>
mov    -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x108(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
jmp    1528 <cu_compute_matrix_stamps+0x408>
cmpl   $0x0,-0x3c(%rbp)
jle    1565 <cu_compute_matrix_stamps+0x445>
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1565 <cu_compute_matrix_stamps+0x445>
cmpl   $0x0,-0x40(%rbp)
jle    1565 <cu_compute_matrix_stamps+0x445>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1565 <cu_compute_matrix_stamps+0x445>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1565 <cu_compute_matrix_stamps+0x445>
jmp    3468 <cu_compute_matrix_stamps+0x2348>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     15e5 <cu_compute_matrix_stamps+0x4c5>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    -0x74(%rbp),%ecx
cmp    %ecx,%eax
jg     15d2 <cu_compute_matrix_stamps+0x4b2>
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    15bb <cu_compute_matrix_stamps+0x49b>
mov    -0x74(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1592 <cu_compute_matrix_stamps+0x472>
jmp    15d7 <cu_compute_matrix_stamps+0x4b7>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    157f <cu_compute_matrix_stamps+0x45f>
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     165f <cu_compute_matrix_stamps+0x53f>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    -0x74(%rbp),%ecx
cmp    %ecx,%eax
jg     164c <cu_compute_matrix_stamps+0x52c>
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    1635 <cu_compute_matrix_stamps+0x515>
mov    -0x74(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1606 <cu_compute_matrix_stamps+0x4e6>
jmp    1651 <cu_compute_matrix_stamps+0x531>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    15f3 <cu_compute_matrix_stamps+0x4d3>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16b2 <cu_compute_matrix_stamps+0x592>
mov    -0xa0(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x7c(%rbp),%eax
add    -0x84(%rbp),%eax
cvtsi2sd %eax,%xmm1
call   1040 <pow@plt>
mov    -0x90(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1666 <cu_compute_matrix_stamps+0x546>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1705 <cu_compute_matrix_stamps+0x5e5>
mov    -0xa8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%eax
add    -0x88(%rbp),%eax
cvtsi2sd %eax,%xmm1
call   1040 <pow@plt>
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    16b9 <cu_compute_matrix_stamps+0x599>
movsd  0x28f3(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0x28e3(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
cmpl   $0x0,-0x3c(%rbp)
jne    2052 <cu_compute_matrix_stamps+0xf32>
cmpl   $0x0,-0x40(%rbp)
jne    1a28 <cu_compute_matrix_stamps+0x908>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a23 <cu_compute_matrix_stamps+0x903>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    177e <cu_compute_matrix_stamps+0x65e>
xor    %eax,%eax
mov    %eax,-0x114(%rbp)
jmp    1794 <cu_compute_matrix_stamps+0x674>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    17c6 <cu_compute_matrix_stamps+0x6a6>
mov    -0x14(%rbp),%eax
mov    %eax,-0x118(%rbp)
jmp    17dc <cu_compute_matrix_stamps+0x6bc>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x118(%rbp)
mov    -0x118(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    180c <cu_compute_matrix_stamps+0x6ec>
xor    %eax,%eax
mov    %eax,-0x11c(%rbp)
jmp    1822 <cu_compute_matrix_stamps+0x702>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1854 <cu_compute_matrix_stamps+0x734>
mov    -0x10(%rbp),%eax
mov    %eax,-0x120(%rbp)
jmp    186a <cu_compute_matrix_stamps+0x74a>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1a10 <cu_compute_matrix_stamps+0x8f0>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    19fd <cu_compute_matrix_stamps+0x8dd>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1946 <cu_compute_matrix_stamps+0x826>
jmp    1a02 <cu_compute_matrix_stamps+0x8e2>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1879 <cu_compute_matrix_stamps+0x759>
jmp    1a15 <cu_compute_matrix_stamps+0x8f5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    174b <cu_compute_matrix_stamps+0x62b>
jmp    204d <cu_compute_matrix_stamps+0xf2d>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1d9e <cu_compute_matrix_stamps+0xc7e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d99 <cu_compute_matrix_stamps+0xc79>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1a6e <cu_compute_matrix_stamps+0x94e>
xor    %eax,%eax
mov    %eax,-0x124(%rbp)
jmp    1a84 <cu_compute_matrix_stamps+0x964>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1ab6 <cu_compute_matrix_stamps+0x996>
mov    -0x14(%rbp),%eax
mov    %eax,-0x128(%rbp)
jmp    1acc <cu_compute_matrix_stamps+0x9ac>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1afc <cu_compute_matrix_stamps+0x9dc>
xor    %eax,%eax
mov    %eax,-0x12c(%rbp)
jmp    1b12 <cu_compute_matrix_stamps+0x9f2>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1b44 <cu_compute_matrix_stamps+0xa24>
mov    -0x10(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    1b5a <cu_compute_matrix_stamps+0xa3a>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x130(%rbp)
mov    -0x130(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1d86 <cu_compute_matrix_stamps+0xc66>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1bf7 <cu_compute_matrix_stamps+0xad7>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
jmp    1c20 <cu_compute_matrix_stamps+0xb00>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1d73 <cu_compute_matrix_stamps+0xc53>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
movsd  (%rax),%xmm1
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1c9f <cu_compute_matrix_stamps+0xb7f>
jmp    1d78 <cu_compute_matrix_stamps+0xc58>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b69 <cu_compute_matrix_stamps+0xa49>
jmp    1d8b <cu_compute_matrix_stamps+0xc6b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1a3b <cu_compute_matrix_stamps+0x91b>
jmp    2048 <cu_compute_matrix_stamps+0xf28>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2043 <cu_compute_matrix_stamps+0xf23>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1dd8 <cu_compute_matrix_stamps+0xcb8>
xor    %eax,%eax
mov    %eax,-0x134(%rbp)
jmp    1dee <cu_compute_matrix_stamps+0xcce>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1e20 <cu_compute_matrix_stamps+0xd00>
mov    -0x14(%rbp),%eax
mov    %eax,-0x138(%rbp)
jmp    1e36 <cu_compute_matrix_stamps+0xd16>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1e66 <cu_compute_matrix_stamps+0xd46>
xor    %eax,%eax
mov    %eax,-0x13c(%rbp)
jmp    1e7c <cu_compute_matrix_stamps+0xd5c>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1eae <cu_compute_matrix_stamps+0xd8e>
mov    -0x10(%rbp),%eax
mov    %eax,-0x140(%rbp)
jmp    1ec4 <cu_compute_matrix_stamps+0xda4>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    2030 <cu_compute_matrix_stamps+0xf10>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    201d <cu_compute_matrix_stamps+0xefd>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1f7f <cu_compute_matrix_stamps+0xe5f>
jmp    2022 <cu_compute_matrix_stamps+0xf02>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1ed3 <cu_compute_matrix_stamps+0xdb3>
jmp    2035 <cu_compute_matrix_stamps+0xf15>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1da5 <cu_compute_matrix_stamps+0xc85>
jmp    2048 <cu_compute_matrix_stamps+0xf28>
jmp    204d <cu_compute_matrix_stamps+0xf2d>
jmp    3377 <cu_compute_matrix_stamps+0x2257>
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    2b08 <cu_compute_matrix_stamps+0x19e8>
cmpl   $0x0,-0x40(%rbp)
jne    23d2 <cu_compute_matrix_stamps+0x12b2>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    23cd <cu_compute_matrix_stamps+0x12ad>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    20a2 <cu_compute_matrix_stamps+0xf82>
xor    %eax,%eax
mov    %eax,-0x144(%rbp)
jmp    20b8 <cu_compute_matrix_stamps+0xf98>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    20ea <cu_compute_matrix_stamps+0xfca>
mov    -0x14(%rbp),%eax
mov    %eax,-0x148(%rbp)
jmp    2100 <cu_compute_matrix_stamps+0xfe0>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2130 <cu_compute_matrix_stamps+0x1010>
xor    %eax,%eax
mov    %eax,-0x14c(%rbp)
jmp    2146 <cu_compute_matrix_stamps+0x1026>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2178 <cu_compute_matrix_stamps+0x1058>
mov    -0x10(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    218e <cu_compute_matrix_stamps+0x106e>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    23ba <cu_compute_matrix_stamps+0x129a>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     220a <cu_compute_matrix_stamps+0x10ea>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
jmp    2233 <cu_compute_matrix_stamps+0x1113>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    23a7 <cu_compute_matrix_stamps+0x1287>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm1
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    22d3 <cu_compute_matrix_stamps+0x11b3>
jmp    23ac <cu_compute_matrix_stamps+0x128c>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    219d <cu_compute_matrix_stamps+0x107d>
jmp    23bf <cu_compute_matrix_stamps+0x129f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    206f <cu_compute_matrix_stamps+0xf4f>
jmp    2b03 <cu_compute_matrix_stamps+0x19e3>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    27ce <cu_compute_matrix_stamps+0x16ae>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    27c9 <cu_compute_matrix_stamps+0x16a9>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2418 <cu_compute_matrix_stamps+0x12f8>
xor    %eax,%eax
mov    %eax,-0x154(%rbp)
jmp    242e <cu_compute_matrix_stamps+0x130e>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2460 <cu_compute_matrix_stamps+0x1340>
mov    -0x14(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    2476 <cu_compute_matrix_stamps+0x1356>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    24a6 <cu_compute_matrix_stamps+0x1386>
xor    %eax,%eax
mov    %eax,-0x15c(%rbp)
jmp    24bc <cu_compute_matrix_stamps+0x139c>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    24ee <cu_compute_matrix_stamps+0x13ce>
mov    -0x10(%rbp),%eax
mov    %eax,-0x160(%rbp)
jmp    2504 <cu_compute_matrix_stamps+0x13e4>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    27b6 <cu_compute_matrix_stamps+0x1696>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     25a1 <cu_compute_matrix_stamps+0x1481>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
jmp    25ca <cu_compute_matrix_stamps+0x14aa>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     260a <cu_compute_matrix_stamps+0x14ea>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
jmp    2633 <cu_compute_matrix_stamps+0x1513>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    27a3 <cu_compute_matrix_stamps+0x1683>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm1
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
movsd  (%rax),%xmm1
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    26b2 <cu_compute_matrix_stamps+0x1592>
jmp    27a8 <cu_compute_matrix_stamps+0x1688>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2513 <cu_compute_matrix_stamps+0x13f3>
jmp    27bb <cu_compute_matrix_stamps+0x169b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    23e5 <cu_compute_matrix_stamps+0x12c5>
jmp    2afe <cu_compute_matrix_stamps+0x19de>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2af9 <cu_compute_matrix_stamps+0x19d9>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2808 <cu_compute_matrix_stamps+0x16e8>
xor    %eax,%eax
mov    %eax,-0x164(%rbp)
jmp    281e <cu_compute_matrix_stamps+0x16fe>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x164(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2850 <cu_compute_matrix_stamps+0x1730>
mov    -0x14(%rbp),%eax
mov    %eax,-0x168(%rbp)
jmp    2866 <cu_compute_matrix_stamps+0x1746>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2896 <cu_compute_matrix_stamps+0x1776>
xor    %eax,%eax
mov    %eax,-0x16c(%rbp)
jmp    28ac <cu_compute_matrix_stamps+0x178c>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    28de <cu_compute_matrix_stamps+0x17be>
mov    -0x10(%rbp),%eax
mov    %eax,-0x170(%rbp)
jmp    28f4 <cu_compute_matrix_stamps+0x17d4>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    2ae6 <cu_compute_matrix_stamps+0x19c6>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     2970 <cu_compute_matrix_stamps+0x1850>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
jmp    2999 <cu_compute_matrix_stamps+0x1879>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x48(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    2ad3 <cu_compute_matrix_stamps+0x19b3>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm1
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2a18 <cu_compute_matrix_stamps+0x18f8>
jmp    2ad8 <cu_compute_matrix_stamps+0x19b8>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2903 <cu_compute_matrix_stamps+0x17e3>
jmp    2aeb <cu_compute_matrix_stamps+0x19cb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    27d5 <cu_compute_matrix_stamps+0x16b5>
jmp    2afe <cu_compute_matrix_stamps+0x19de>
jmp    2b03 <cu_compute_matrix_stamps+0x19e3>
jmp    3372 <cu_compute_matrix_stamps+0x2252>
cmpl   $0x0,-0x40(%rbp)
jne    2dbc <cu_compute_matrix_stamps+0x1c9c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2db7 <cu_compute_matrix_stamps+0x1c97>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2b4c <cu_compute_matrix_stamps+0x1a2c>
xor    %eax,%eax
mov    %eax,-0x174(%rbp)
jmp    2b62 <cu_compute_matrix_stamps+0x1a42>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x174(%rbp)
mov    -0x174(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2b94 <cu_compute_matrix_stamps+0x1a74>
mov    -0x14(%rbp),%eax
mov    %eax,-0x178(%rbp)
jmp    2baa <cu_compute_matrix_stamps+0x1a8a>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x178(%rbp)
mov    -0x178(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2bda <cu_compute_matrix_stamps+0x1aba>
xor    %eax,%eax
mov    %eax,-0x17c(%rbp)
jmp    2bf0 <cu_compute_matrix_stamps+0x1ad0>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x17c(%rbp)
mov    -0x17c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2c22 <cu_compute_matrix_stamps+0x1b02>
mov    -0x10(%rbp),%eax
mov    %eax,-0x180(%rbp)
jmp    2c38 <cu_compute_matrix_stamps+0x1b18>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x180(%rbp)
mov    -0x180(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    2da4 <cu_compute_matrix_stamps+0x1c84>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    2d91 <cu_compute_matrix_stamps+0x1c71>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2cf3 <cu_compute_matrix_stamps+0x1bd3>
jmp    2d96 <cu_compute_matrix_stamps+0x1c76>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2c47 <cu_compute_matrix_stamps+0x1b27>
jmp    2da9 <cu_compute_matrix_stamps+0x1c89>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    2b19 <cu_compute_matrix_stamps+0x19f9>
jmp    336d <cu_compute_matrix_stamps+0x224d>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    30f8 <cu_compute_matrix_stamps+0x1fd8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    30f3 <cu_compute_matrix_stamps+0x1fd3>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2e02 <cu_compute_matrix_stamps+0x1ce2>
xor    %eax,%eax
mov    %eax,-0x184(%rbp)
jmp    2e18 <cu_compute_matrix_stamps+0x1cf8>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x184(%rbp)
mov    -0x184(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2e4a <cu_compute_matrix_stamps+0x1d2a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x188(%rbp)
jmp    2e60 <cu_compute_matrix_stamps+0x1d40>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x188(%rbp)
mov    -0x188(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    2e90 <cu_compute_matrix_stamps+0x1d70>
xor    %eax,%eax
mov    %eax,-0x18c(%rbp)
jmp    2ea6 <cu_compute_matrix_stamps+0x1d86>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x18c(%rbp)
mov    -0x18c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    2ed8 <cu_compute_matrix_stamps+0x1db8>
mov    -0x10(%rbp),%eax
mov    %eax,-0x190(%rbp)
jmp    2eee <cu_compute_matrix_stamps+0x1dce>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x190(%rbp)
mov    -0x190(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    30e0 <cu_compute_matrix_stamps+0x1fc0>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     2f6a <cu_compute_matrix_stamps+0x1e4a>
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
jmp    2f93 <cu_compute_matrix_stamps+0x1e73>
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x60(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    30cd <cu_compute_matrix_stamps+0x1fad>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
movsd  (%rax),%xmm1
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    3012 <cu_compute_matrix_stamps+0x1ef2>
jmp    30d2 <cu_compute_matrix_stamps+0x1fb2>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2efd <cu_compute_matrix_stamps+0x1ddd>
jmp    30e5 <cu_compute_matrix_stamps+0x1fc5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    2dcf <cu_compute_matrix_stamps+0x1caf>
jmp    3368 <cu_compute_matrix_stamps+0x2248>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    3363 <cu_compute_matrix_stamps+0x2243>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    3132 <cu_compute_matrix_stamps+0x2012>
xor    %eax,%eax
mov    %eax,-0x194(%rbp)
jmp    3148 <cu_compute_matrix_stamps+0x2028>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x194(%rbp)
mov    -0x194(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    317a <cu_compute_matrix_stamps+0x205a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x198(%rbp)
jmp    3190 <cu_compute_matrix_stamps+0x2070>
mov    0x20(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x198(%rbp)
mov    -0x198(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%ecx
sub    0x10(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    31c0 <cu_compute_matrix_stamps+0x20a0>
xor    %eax,%eax
mov    %eax,-0x19c(%rbp)
jmp    31d6 <cu_compute_matrix_stamps+0x20b6>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x19c(%rbp)
mov    -0x19c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cvttsd2si (%rcx,%rdx,8),%ecx
add    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    3208 <cu_compute_matrix_stamps+0x20e8>
mov    -0x10(%rbp),%eax
mov    %eax,-0x1a0(%rbp)
jmp    321e <cu_compute_matrix_stamps+0x20fe>
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
add    0x10(%rbp),%eax
mov    %eax,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    3350 <cu_compute_matrix_stamps+0x2230>
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    333d <cu_compute_matrix_stamps+0x221d>
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
mulsd  (%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    32b8 <cu_compute_matrix_stamps+0x2198>
jmp    3342 <cu_compute_matrix_stamps+0x2222>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    322d <cu_compute_matrix_stamps+0x210d>
jmp    3355 <cu_compute_matrix_stamps+0x2235>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    30ff <cu_compute_matrix_stamps+0x1fdf>
jmp    3368 <cu_compute_matrix_stamps+0x2248>
jmp    336d <cu_compute_matrix_stamps+0x224d>
jmp    3372 <cu_compute_matrix_stamps+0x2252>
jmp    3377 <cu_compute_matrix_stamps+0x2257>
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x104(%rbp),%ecx
mov    0x60(%rbp),%edx
imul   -0x108(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x108(%rbp),%ecx
mov    0x60(%rbp),%edx
imul   -0x104(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x3c(%rbp)
jle    3463 <cu_compute_matrix_stamps+0x2343>
mov    -0x3c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    3463 <cu_compute_matrix_stamps+0x2343>
cmpl   $0x0,-0x40(%rbp)
jle    3463 <cu_compute_matrix_stamps+0x2343>
mov    -0x40(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    3463 <cu_compute_matrix_stamps+0x2343>
mov    -0x34(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    0x60(%rbp),%edx
mov    -0x30(%rbp),%esi
add    -0x24(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    0x60(%rbp),%edx
mov    -0x2c(%rbp),%esi
add    -0x28(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    3468 <cu_compute_matrix_stamps+0x2348>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1362 <cu_compute_matrix_stamps+0x242>
jmp    3481 <cu_compute_matrix_stamps+0x2361>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    1349 <cu_compute_matrix_stamps+0x229>
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cu_compute_matrix_stamps>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9d,0x18(%rsp)
mov    %r8d,%r12d
mov    %ecx,%r15d
mov    %edx,0x34(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %rdi,0xe0(%rsp)
movslq %ecx,%rbx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %r12,0x38(%rsp)
movslq %r12d,%r13
shl    $0x3,%r13
mov    %r13,%rdi
call   1040 <malloc@plt>
mov    %rax,0xd0(%rsp)
mov    %rbp,0x150(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r13,%rdi
call   1040 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %r15,0x50(%rsp)
mov    %r15d,%r13d
test   %ebx,%ebx
jle    12be <cu_compute_matrix_stamps+0x18e>
mov    0x50(%rsp),%rcx
lea    -0x1(%rcx),%eax
cvtsi2sd %eax,%xmm0
cmp    $0x1,%ecx
jne    11dc <cu_compute_matrix_stamps+0xac>
xor    %eax,%eax
jmp    1293 <cu_compute_matrix_stamps+0x163>
mov    %r13d,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     3179 <cu_compute_matrix_stamps+0x2049>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0x2df0(%rip),%xmm2
xor    %edx,%edx
movapd 0x2df6(%rip),%xmm3
mulpd  %xmm1,%xmm3
movdqa 0x2dfa(%rip),%xmm4
movdqa 0x2e02(%rip),%xmm5
xchg   %ax,%ax
cvtdq2pd %xmm2,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,(%r14,%rdx,8)
movdqa %xmm2,%xmm6
paddd  %xmm4,%xmm6
cvtdq2pd %xmm6,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,0x10(%r14,%rdx,8)
add    $0x4,%rdx
paddd  %xmm5,%xmm2
add    $0xfffffffffffffffe,%rsi
jne    1230 <cu_compute_matrix_stamps+0x100>
test   $0x1,%cl
je     128e <cu_compute_matrix_stamps+0x15e>
cvtdq2pd %xmm2,%xmm2
movapd 0x2d94(%rip),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,(%r14,%rdx,8)
cmp    %r13,%rax
je     12be <cu_compute_matrix_stamps+0x18e>
movsd  0x2da5(%rip),%xmm1
mulsd  %xmm0,%xmm1
nop
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    12a0 <cu_compute_matrix_stamps+0x170>
mov    0x1e8(%rsp),%edi
mov    0x38(%rsp),%rax
mov    %eax,%r12d
test   %eax,%eax
mov    0x34(%rsp),%r11d
mov    0xa0(%rsp),%r9
mov    0xd0(%rsp),%rbp
jle    13fe <cu_compute_matrix_stamps+0x2ce>
mov    0x38(%rsp),%rcx
lea    -0x1(%rcx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    $0x1,%ecx
jne    1305 <cu_compute_matrix_stamps+0x1d5>
xor    %eax,%eax
jmp    13c7 <cu_compute_matrix_stamps+0x297>
mov    %r12d,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     3191 <cu_compute_matrix_stamps+0x2061>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0x2cc7(%rip),%xmm2
xor    %edx,%edx
movapd 0x2ccd(%rip),%xmm3
mulpd  %xmm1,%xmm3
movdqa 0x2cd1(%rip),%xmm4
movdqa 0x2cd9(%rip),%xmm5
nopw   0x0(%rax,%rax,1)
cvtdq2pd %xmm2,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,0x0(%rbp,%rdx,8)
movdqa %xmm2,%xmm6
paddd  %xmm4,%xmm6
cvtdq2pd %xmm6,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,0x10(%rbp,%rdx,8)
add    $0x4,%rdx
paddd  %xmm5,%xmm2
add    $0xfffffffffffffffe,%rsi
jne    1360 <cu_compute_matrix_stamps+0x230>
cvtdq2pd %xmm2,%xmm2
mov    0x34(%rsp),%r11d
test   $0x1,%cl
je     13c2 <cu_compute_matrix_stamps+0x292>
movapd 0x2c60(%rip),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,0x0(%rbp,%rdx,8)
cmp    %r12,%rax
je     13fe <cu_compute_matrix_stamps+0x2ce>
movsd  0x2c71(%rip),%xmm1
mulsd  %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    13e0 <cu_compute_matrix_stamps+0x2b0>
mov    %r14,0xf8(%rsp)
mov    %rbx,0x58(%rsp)
mov    0x1e0(%rsp),%ecx
mov    %edi,%eax
mov    %rax,0xf0(%rsp)
test   %edi,%edi
jle    14b5 <cu_compute_matrix_stamps+0x385>
mov    %r12,0xc0(%rsp)
mov    %r13,0xc8(%rsp)
mov    %ecx,%eax
shl    $0x3,%rax
mov    %rax,(%rsp)
mov    0xf0(%rsp),%rdx
lea    -0x1(%rdx),%rax
mov    %edx,%r15d
and    $0x3,%r15d
xor    %ebp,%ebp
cmp    $0x3,%rax
jae    3094 <cu_compute_matrix_stamps+0x1f64>
xor    %ebx,%ebx
test   %r15,%r15
mov    0xc8(%rsp),%r13
mov    0xc0(%rsp),%r12
mov    0x1e0(%rsp),%ebp
je     14b5 <cu_compute_matrix_stamps+0x385>
imul   %ebp,%ebx
jmp    1488 <cu_compute_matrix_stamps+0x358>
add    %ebp,%ebx
add    $0xffffffffffffffff,%r15
je     14b5 <cu_compute_matrix_stamps+0x385>
test   %ebp,%ebp
jle    1480 <cu_compute_matrix_stamps+0x350>
movslq %ebx,%rax
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    (%rsp),%rdx
call   1030 <memset@plt>
mov    0xa0(%rsp),%r9
mov    0x34(%rsp),%r11d
jmp    1480 <cu_compute_matrix_stamps+0x350>
cmpl   $0x0,0x1e8(%rsp)
jle    3082 <cu_compute_matrix_stamps+0x1f52>
mov    %r13,%rdi
mov    0x1c0(%rsp),%r13d
mov    0xe0(%rsp),%rcx
lea    0x1(%rcx),%eax
add    $0x2,%ecx
imul   %eax,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
lea    0x1(%r9),%eax
lea    0x2(%r9),%ecx
imul   %eax,%ecx
mov    %ecx,%r15d
shr    $0x1f,%r15d
add    %ecx,%r15d
sar    %r15d
lea    -0x1(%rdi),%rax
mov    %rax,0x130(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x128(%rsp)
mov    %edi,%eax
and    $0x3,%eax
mov    %rax,0x120(%rsp)
and    $0xfffffffc,%edi
mov    %rdi,0xc8(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x118(%rsp)
and    $0xfffffffc,%r12d
mov    %r12,0xc0(%rsp)
mov    %edx,0x68(%rsp)
movslq %edx,%rax
mov    %rax,0x110(%rsp)
mov    0x1e0(%rsp),%eax
cltq
mov    %rax,0x100(%rsp)
mov    0x18(%rsp),%eax
mov    %rax,0x48(%rsp)
mov    $0x1,%eax
mov    %rax,0x108(%rsp)
xor    %r10d,%r10d
mov    %rax,0xb8(%rsp)
mov    %r15d,0xb0(%rsp)
jmp    15bb <cu_compute_matrix_stamps+0x48b>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
addq   $0x1,0x108(%rsp)
cmp    0xf0(%rsp),%r10
je     3082 <cu_compute_matrix_stamps+0x1f52>
mov    %r10d,%eax
sub    0x68(%rsp),%eax
mov    %eax,0xb4(%rsp)
mov    %r10,%rax
imul   0x100(%rsp),%rax
mov    %rax,0x138(%rsp)
xor    %edi,%edi
mov    %r10,0x140(%rsp)
jmp    162f <cu_compute_matrix_stamps+0x4ff>
nopl   0x0(%rax)
mov    0x34(%rsp),%r11d
mov    0xa0(%rsp),%r9
mov    0x1c0(%rsp),%r13d
mov    0xb0(%rsp),%r15d
mov    0xa8(%rsp),%rbx
mov    0xe8(%rsp),%rsi
add    $0x1,%rdi
cmp    0x108(%rsp),%rdi
je     15a0 <cu_compute_matrix_stamps+0x470>
xor    %ebp,%ebp
mov    $0x0,%eax
cmp    0x110(%rsp),%rdi
jl     164d <cu_compute_matrix_stamps+0x51d>
mov    %edi,%eax
sub    0x68(%rsp),%eax
cltd
idiv   %r15d
add    $0x1,%eax
cmp    0x110(%rsp),%r10
mov    %eax,0x1c(%rsp)
jl     166f <cu_compute_matrix_stamps+0x53f>
mov    0xb4(%rsp),%eax
cltd
idiv   %r15d
mov    %eax,%ebp
mov    0x1c(%rsp),%eax
add    $0x1,%ebp
xor    %edx,%edx
mov    $0x0,%ecx
mov    %rcx,0x70(%rsp)
cmp    %r13d,%eax
jge    16a4 <cu_compute_matrix_stamps+0x574>
movslq 0x1c(%rsp),%rax
mov    0x1a8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    %rcx,0x70(%rsp)
mov    0x1b0(%rsp),%rcx
mov    (%rcx,%rax,4),%edx
mov    0x1c(%rsp),%eax
cmp    %r13d,%ebp
jge    16d5 <cu_compute_matrix_stamps+0x5a5>
movslq %ebp,%rax
mov    0x1a8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    %rcx,0xb8(%rsp)
mov    0x1b0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x94(%rsp)
mov    0x1c(%rsp),%eax
test   %eax,%eax
mov    %edx,0x20(%rsp)
mov    %eax,%ecx
je     1710 <cu_compute_matrix_stamps+0x5e0>
mov    $0x1,%eax
sub    %ecx,%eax
imul   %r15d,%eax
mov    %edi,%edx
sub    0x68(%rsp),%edx
add    %eax,%edx
mov    %edx,0x6c(%rsp)
cmp    %r13d,%ecx
mov    %r11d,%eax
cmovl  %r9d,%eax
mov    %rax,0x8(%rsp)
mov    0xe0(%rsp),%rax
jmp    1725 <cu_compute_matrix_stamps+0x5f5>
nop
mov    0xe0(%rsp),%rax
mov    %eax,%edx
mov    %rdx,0x8(%rsp)
mov    %edi,%edx
mov    %edi,0x6c(%rsp)
mov    $0x1,%r8d
sub    %ebp,%r8d
imul   %r15d,%r8d
add    0xb4(%rsp),%r8d
cmp    %r13d,%ebp
mov    %r11d,%edx
cmovl  %r9d,%edx
test   %ebp,%ebp
cmove  %eax,%edx
mov    %rdx,0x10(%rsp)
cmove  %r10d,%r8d
test   %ecx,%ecx
mov    0x6c(%rsp),%eax
jle    1771 <cu_compute_matrix_stamps+0x641>
cmp    %r13d,%ecx
jge    1771 <cu_compute_matrix_stamps+0x641>
test   %ebp,%ebp
jle    1771 <cu_compute_matrix_stamps+0x641>
cmp    %r13d,%ebp
jge    1771 <cu_compute_matrix_stamps+0x641>
cmp    %r8d,%eax
jg     161d <cu_compute_matrix_stamps+0x4ed>
mov    %rdi,0x148(%rsp)
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    %ebp,0x98(%rsp)
mov    %r8d,0x9c(%rsp)
js     18b0 <cu_compute_matrix_stamps+0x780>
lea    0x1(%rcx),%r9d
mov    %eax,%r11d
neg    %r11d
xor    %r10d,%r10d
xor    %r13d,%r13d
mov    %rbx,0xa8(%rsp)
mov    %r11,0x28(%rsp)
jmp    17d4 <cu_compute_matrix_stamps+0x6a4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r10),%eax
add    $0xffffffff,%r9d
cmp    %r10d,%ecx
mov    %eax,%r10d
je     18b0 <cu_compute_matrix_stamps+0x780>
mov    %ecx,%edx
sub    %r10d,%edx
jl     17c0 <cu_compute_matrix_stamps+0x690>
xor    %eax,%eax
cmp    $0x3,%edx
jb     186b <cu_compute_matrix_stamps+0x73b>
mov    %r9d,%r15d
and    $0xfffffffc,%r15d
lea    (%r11,%r13,1),%r8d
xor    %eax,%eax
mov    %r13,(%rsp)
mov    %r13d,%ebp
mov    0x6c(%rsp),%r11d
nop
lea    0x1(%rbp),%ecx
lea    0x1(%rax),%ebx
lea    0x2(%rbp),%edi
mov    %r8d,%r13d
add    %eax,%r13d
cmove  %eax,%esi
lea    0x2(%rax),%edx
cmove  %r10d,%r14d
cmp    %r11d,%ecx
cmove  %ebx,%esi
cmove  %r10d,%r14d
lea    0x3(%rbp),%ecx
cmp    %r11d,%edi
mov    %esi,%edi
cmove  %edx,%edi
cmove  %r10d,%r14d
lea    0x3(%rax),%esi
cmp    %r11d,%ecx
cmove  %r10d,%r14d
cmovne %edi,%esi
add    $0x4,%ebp
add    $0x4,%eax
cmp    %r15d,%eax
jne    1800 <cu_compute_matrix_stamps+0x6d0>
mov    (%rsp),%r13
add    %eax,%r13d
mov    0xa8(%rsp),%rbx
mov    0x9c(%rsp),%r8d
mov    0x8(%rsp),%rcx
mov    0x28(%rsp),%r11
test   $0x3,%r9b
je     17c0 <cu_compute_matrix_stamps+0x690>
mov    %r9d,%edx
and    $0x3,%edx
neg    %edx
lea    (%r11,%r13,1),%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %edi,%ebp
cmove  %r10d,%r14d
cmove  %eax,%esi
add    $0x1,%eax
add    $0xffffffff,%edi
cmp    %edi,%edx
jne    1890 <cu_compute_matrix_stamps+0x760>
sub    %edi,%r13d
jmp    17c0 <cu_compute_matrix_stamps+0x690>
nopl   0x0(%rax,%rax,1)
mov    %rsi,0xe8(%rsp)
mov    0x10(%rsp),%rdx
test   %edx,%edx
js     19b0 <cu_compute_matrix_stamps+0x880>
lea    0x1(%rdx),%r9d
mov    %r8d,%edi
neg    %edi
xor    %r13d,%r13d
xor    %r10d,%r10d
mov    %rdi,(%rsp)
jmp    18f4 <cu_compute_matrix_stamps+0x7c4>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r13),%eax
add    $0xffffffff,%r9d
cmp    %r13d,%edx
mov    %eax,%r13d
je     19b0 <cu_compute_matrix_stamps+0x880>
mov    %edx,%ecx
sub    %r13d,%ecx
jl     18e0 <cu_compute_matrix_stamps+0x7b0>
xor    %eax,%eax
cmp    $0x3,%ecx
jb     1975 <cu_compute_matrix_stamps+0x845>
mov    %r9d,%r15d
and    $0xfffffffc,%r15d
lea    (%rdi,%r10,1),%r11d
xor    %eax,%eax
mov    %r10d,%ebp
mov    0x9c(%rsp),%r8d
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%edi
lea    0x1(%rax),%edx
lea    0x2(%rbp),%esi
mov    %r11d,%ecx
add    %eax,%ecx
cmove  %eax,%ebx
lea    0x2(%rax),%ecx
cmove  %r13d,%r12d
cmp    %r8d,%edi
cmove  %edx,%ebx
cmove  %r13d,%r12d
lea    0x3(%rbp),%edx
cmp    %r8d,%esi
mov    %ebx,%esi
cmove  %ecx,%esi
cmove  %r13d,%r12d
lea    0x3(%rax),%ebx
cmp    %r8d,%edx
cmove  %r13d,%r12d
cmovne %esi,%ebx
add    $0x4,%ebp
add    $0x4,%eax
cmp    %r15d,%eax
jne    1920 <cu_compute_matrix_stamps+0x7f0>
add    %eax,%r10d
mov    0x10(%rsp),%rdx
mov    (%rsp),%rdi
test   $0x3,%r9b
je     18e0 <cu_compute_matrix_stamps+0x7b0>
mov    %r9d,%ecx
and    $0x3,%ecx
neg    %ecx
lea    (%rdi,%r10,1),%ebp
xor    %esi,%esi
nopl   (%rax)
cmp    %esi,%ebp
cmove  %r13d,%r12d
cmove  %eax,%ebx
add    $0x1,%eax
add    $0xffffffff,%esi
cmp    %esi,%ecx
jne    1990 <cu_compute_matrix_stamps+0x860>
sub    %esi,%r10d
jmp    18e0 <cu_compute_matrix_stamps+0x7b0>
nopl   0x0(%rax,%rax,1)
mov    %rbx,0xa8(%rsp)
cmpl   $0x0,0x50(%rsp)
jle    1ac0 <cu_compute_matrix_stamps+0x990>
lea    (%r12,%r14,1),%eax
cvtsi2sd %eax,%xmm0
cmpq   $0x3,0x130(%rsp)
movsd  %xmm0,(%rsp)
jae    19f0 <cu_compute_matrix_stamps+0x8c0>
xor    %ebp,%ebp
jmp    1a73 <cu_compute_matrix_stamps+0x943>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebp,%ebp
mov    0xf8(%rsp),%r15
mov    0x40(%rsp),%rbx
mov    0xc8(%rsp),%r13
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,(%rbx,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
movsd  0x10(%r15,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x10(%rbx,%rbp,8)
movsd  0x18(%r15,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x18(%rbx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1a10 <cu_compute_matrix_stamps+0x8e0>
mov    0x120(%rsp),%rbx
test   %rbx,%rbx
je     1ac0 <cu_compute_matrix_stamps+0x990>
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,8),%r15
mov    0xf8(%rsp),%rax
lea    (%rax,%rbp,8),%r13
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1aa0 <cu_compute_matrix_stamps+0x970>
cmpl   $0x0,0x38(%rsp)
jle    1bd0 <cu_compute_matrix_stamps+0xaa0>
mov    0xa8(%rsp),%rax
mov    0xe8(%rsp),%rcx
add    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmpq   $0x3,0x128(%rsp)
movsd  %xmm0,(%rsp)
jae    1b00 <cu_compute_matrix_stamps+0x9d0>
xor    %ebp,%ebp
jmp    1b83 <cu_compute_matrix_stamps+0xa53>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
mov    0x60(%rsp),%r15
mov    0xd0(%rsp),%rbx
mov    0xc0(%rsp),%r13
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,(%r15,%rbp,8)
movsd  0x8(%rbx,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x8(%r15,%rbp,8)
movsd  0x10(%rbx,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x10(%r15,%rbp,8)
movsd  0x18(%rbx,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x18(%r15,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1b20 <cu_compute_matrix_stamps+0x9f0>
mov    0x118(%rsp),%rbx
test   %rbx,%rbx
je     1bd0 <cu_compute_matrix_stamps+0xaa0>
mov    0x60(%rsp),%rax
lea    (%rax,%rbp,8),%r15
mov    0xd0(%rsp),%rax
lea    (%rax,%rbp,8),%r13
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  (%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1bb0 <cu_compute_matrix_stamps+0xa80>
mov    0x1c(%rsp),%ecx
test   %ecx,%ecx
je     1e10 <cu_compute_matrix_stamps+0xce0>
mov    0x1c0(%rsp),%eax
cmp    %eax,%ecx
mov    0x98(%rsp),%ecx
jge    20c0 <cu_compute_matrix_stamps+0xf90>
test   %ecx,%ecx
je     252f <cu_compute_matrix_stamps+0x13ff>
cmp    %eax,%ecx
mov    0x20(%rsp),%edx
jge    2b5f <cu_compute_matrix_stamps+0x1a2f>
cmpl   $0x0,0x18(%rsp)
mov    0x1c(%rsp),%eax
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
cltq
mov    %rax,0x10(%rsp)
movslq %ecx,%rax
mov    %rax,0x8(%rsp)
movslq %edx,%rax
mov    %rax,0x28(%rsp)
movslq 0x94(%rsp),%rax
mov    %rax,0x20(%rsp)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1c63 <cu_compute_matrix_stamps+0xb33>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rcx
add    $0x1,%rcx
cmp    0x48(%rsp),%rcx
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rcx,8),%esi
mov    %esi,%edx
mov    0x190(%rsp),%edi
sub    %edi,%edx
mov    $0x0,%ebp
cmovs  %ebp,%edx
add    %edi,%esi
mov    0x38(%rsp),%rax
cmp    %eax,%esi
cmovg  %eax,%esi
mov    0x198(%rsp),%rax
mov    %rcx,(%rsp)
cvttsd2si (%rax,%rcx,8),%eax
mov    %eax,%ecx
sub    %edi,%ecx
cmovs  %ebp,%ecx
add    %edi,%eax
mov    0x50(%rsp),%rdi
cmp    %edi,%eax
cmovg  %edi,%eax
cmp    %esi,%edx
jge    1c50 <cu_compute_matrix_stamps+0xb20>
mov    0x70(%rsp),%rdi
lea    (%rcx,%rdi,1),%r8d
mov    0xb8(%rsp),%rdi
add    %ecx,%edi
mov    0x1b8(%rsp),%r10
mov    0x8(%rsp),%rbp
cmpl   $0x0,(%r10,%rbp,4)
mov    0x1f8(%rsp),%r13
mov    %r13,%r9
mov    0x1f0(%rsp),%r11
cmove  %r11,%r9
mov    0x10(%rsp),%rbp
cmpl   $0x0,(%r10,%rbp,4)
mov    %edx,%edx
mov    %ecx,%r15d
movslq %r8d,%r10
movslq %edi,%r8
cmove  %r11,%r13
mov    %esi,%esi
mov    0x58(%rsp),%rbp
imul   %rdx,%rbp
add    %r15,%rbp
mov    0x20(%rsp),%rdi
lea    (%rdi,%rdx,1),%rbx
imul   0x58(%rsp),%rbx
add    %r8,%rbx
mov    0x208(%rsp),%rdi
lea    (%rdi,%rbp,8),%r8
lea    (%r9,%rbx,8),%r9
mov    0x28(%rsp),%rdi
lea    (%rdi,%rdx,1),%rbx
imul   0x58(%rsp),%rbx
add    %r10,%rbx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rbp,8),%r10
lea    (%r11,%rbp,8),%r11
lea    0x0(,%rbx,8),%rdi
add    %r13,%rdi
mov    0x40(%rsp),%rbx
lea    (%rbx,%r15,8),%r13
mov    %eax,%r15d
sub    %ecx,%r15d
jmp    1da4 <cu_compute_matrix_stamps+0xc74>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    0x150(%rsp),%rbp
add    %rbp,%r8
add    %rbp,%r10
add    %rbp,%r9
add    %rbp,%r11
add    %rbp,%rdi
cmp    %rsi,%rdx
je     1c50 <cu_compute_matrix_stamps+0xb20>
cmp    %eax,%ecx
jge    1d80 <cu_compute_matrix_stamps+0xc50>
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rdi,%rbp,8),%xmm3
movsd  (%r11,%rbp,8),%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r9,%rbp,8),%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm2
mulsd  (%r10,%rbp,8),%xmm2
mulsd  (%r8,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %ebp,%r15d
jne    1dc0 <cu_compute_matrix_stamps+0xc90>
jmp    1d80 <cu_compute_matrix_stamps+0xc50>
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%ecx
test   %ecx,%ecx
mov    0x1c0(%rsp),%eax
je     2344 <cu_compute_matrix_stamps+0x1214>
cmp    %eax,%ecx
jge    27b4 <cu_compute_matrix_stamps+0x1684>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
movslq %ecx,%rax
mov    %rax,0x78(%rsp)
movslq 0x94(%rsp),%rax
mov    %rax,0x88(%rsp)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    1e7c <cu_compute_matrix_stamps+0xd4c>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
mov    0x70(%rsp),%rsi
add    $0x1,%rsi
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rsi
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rsi,8),%eax
mov    %eax,%ecx
mov    0x190(%rsp),%edi
sub    %edi,%ecx
mov    $0x0,%ebp
cmovs  %ebp,%ecx
add    %edi,%eax
mov    0x38(%rsp),%rdx
cmp    %edx,%eax
cmovg  %edx,%eax
mov    0x198(%rsp),%rdx
mov    %rsi,0x70(%rsp)
cvttsd2si (%rdx,%rsi,8),%esi
mov    %esi,%r13d
sub    %edi,%r13d
cmovs  %ebp,%r13d
add    %edi,%esi
mov    0x50(%rsp),%rdx
cmp    %edx,%esi
cmovg  %edx,%esi
cmp    %eax,%ecx
jge    1e60 <cu_compute_matrix_stamps+0xd30>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%r13,1),%r9d
mov    %esi,%edi
sub    %r13d,%edi
mov    %edi,(%rsp)
lea    0x1(%r13),%r15d
mov    0x1b8(%rsp),%rdi
mov    0x78(%rsp),%rbp
cmpl   $0x0,(%rdi,%rbp,4)
mov    %r13d,%ebp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdx
mov    %rdx,0x8(%rsp)
mov    %ecx,%r8d
movslq %r9d,%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%r10d
mov    0x1f8(%rsp),%rax
cmove  0x1f0(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    %rbp,0x10(%rsp)
lea    (%rdi,%rbp,8),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
jmp    1f65 <cu_compute_matrix_stamps+0xe35>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm1
cmp    %r10,%r8
je     1e64 <cu_compute_matrix_stamps+0xd34>
cmp    %r13d,%esi
jle    1f50 <cu_compute_matrix_stamps+0xe20>
mov    %r8,%rcx
mov    0x58(%rsp),%rdx
imul   %rdx,%rcx
add    0x10(%rsp),%rcx
mov    0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm2
mov    0x88(%rsp),%rax
add    %r8,%rax
imul   %rdx,%rax
add    0x28(%rsp),%rax
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    0x208(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rcx,8),%r11
testb  $0x1,(%rsp)
jne    1fe0 <cu_compute_matrix_stamps+0xeb0>
mov    0x8(%rsp),%rcx
mov    %r13d,%ebp
cmp    %r15d,%esi
je     1f54 <cu_compute_matrix_stamps+0xe24>
jmp    2037 <cu_compute_matrix_stamps+0xf07>
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rax),%xmm4
add    $0x8,%rax
mulsd  %xmm4,%xmm3
movsd  (%r9),%xmm0
add    $0x8,%r9
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  (%r11),%xmm0
add    $0x8,%r11
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rcx
movapd %xmm0,%xmm1
mov    %r15d,%ebp
cmp    %r15d,%esi
je     1f54 <cu_compute_matrix_stamps+0xe24>
mov    %esi,%edi
sub    %ebp,%edi
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rax,%rbp,8),%xmm3
movsd  0x8(%rax,%rbp,8),%xmm4
mulsd  %xmm3,%xmm0
movsd  (%r9,%rbp,8),%xmm5
subsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
mulsd  (%r11,%rbp,8),%xmm5
movsd  0x8(%r9,%rbp,8),%xmm0
mulsd  (%rdx,%rbp,8),%xmm5
movsd  0x8(%rcx,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%r11,%rbp,8),%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
addsd  %xmm1,%xmm5
addsd  %xmm5,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%edi
jne    2040 <cu_compute_matrix_stamps+0xf10>
jmp    1f54 <cu_compute_matrix_stamps+0xe24>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %ecx,%ecx
je     298f <cu_compute_matrix_stamps+0x185f>
cmp    %eax,%ecx
jge    2dd4 <cu_compute_matrix_stamps+0x1ca4>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
movslq %ecx,%rax
mov    %rax,0x78(%rsp)
movslq 0x94(%rsp),%rax
mov    %rax,0x88(%rsp)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    211c <cu_compute_matrix_stamps+0xfec>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
mov    0x70(%rsp),%rsi
add    $0x1,%rsi
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rsi
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rsi,8),%eax
mov    %eax,%ecx
mov    0x190(%rsp),%edi
sub    %edi,%ecx
mov    $0x0,%ebp
cmovs  %ebp,%ecx
add    %edi,%eax
mov    0x38(%rsp),%rdx
cmp    %edx,%eax
cmovg  %edx,%eax
mov    0x198(%rsp),%rdx
mov    %rsi,0x70(%rsp)
cvttsd2si (%rdx,%rsi,8),%esi
mov    %esi,%r13d
sub    %edi,%r13d
cmovs  %ebp,%r13d
add    %edi,%esi
mov    0x50(%rsp),%rdx
cmp    %edx,%esi
cmovg  %edx,%esi
cmp    %eax,%ecx
jge    2100 <cu_compute_matrix_stamps+0xfd0>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%r13,1),%r9d
mov    %esi,%edi
sub    %r13d,%edi
mov    %edi,(%rsp)
lea    0x1(%r13),%r15d
mov    0x1b8(%rsp),%rdi
mov    0x78(%rsp),%rbp
cmpl   $0x0,(%rdi,%rbp,4)
mov    %r13d,%ebp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdx
mov    %rdx,0x20(%rsp)
mov    %ecx,%r8d
movslq %r9d,%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%r10d
mov    0x1f8(%rsp),%rax
cmove  0x1f0(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    %rbp,0x10(%rsp)
lea    (%rdi,%rbp,8),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
jmp    2205 <cu_compute_matrix_stamps+0x10d5>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm1
cmp    %r10,%r8
je     2104 <cu_compute_matrix_stamps+0xfd4>
cmp    %r13d,%esi
jle    21f0 <cu_compute_matrix_stamps+0x10c0>
mov    %r8,%rcx
mov    0x58(%rsp),%rdx
imul   %rdx,%rcx
add    0x10(%rsp),%rcx
mov    0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm2
mov    0x88(%rsp),%rax
add    %r8,%rax
imul   %rdx,%rax
add    0x8(%rsp),%rax
mov    0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    0x208(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rcx,8),%r11
testb  $0x1,(%rsp)
jne    2280 <cu_compute_matrix_stamps+0x1150>
mov    0x20(%rsp),%rcx
mov    %r13d,%edi
cmp    %r15d,%esi
je     21f4 <cu_compute_matrix_stamps+0x10c4>
jmp    22cf <cu_compute_matrix_stamps+0x119f>
mov    0x20(%rsp),%rcx
movsd  (%rcx),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r9),%xmm0
add    $0x8,%r9
subsd  (%rax),%xmm0
add    $0x8,%rax
mulsd  %xmm3,%xmm0
mulsd  (%r11),%xmm0
add    $0x8,%r11
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rcx
movapd %xmm0,%xmm1
mov    %r15d,%edi
cmp    %r15d,%esi
je     21f4 <cu_compute_matrix_stamps+0x10c4>
mov    %esi,%ebp
sub    %edi,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdi,8),%xmm0
movsd  (%r9,%rdi,8),%xmm3
subsd  (%rax,%rdi,8),%xmm3
mulsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm3
mulsd  (%r11,%rdi,8),%xmm3
movsd  0x8(%r9,%rdi,8),%xmm0
mulsd  (%rdx,%rdi,8),%xmm3
movsd  0x8(%rcx,%rdi,8),%xmm4
mulsd  %xmm2,%xmm4
subsd  0x8(%rax,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
mulsd  0x8(%r11,%rdi,8),%xmm0
mulsd  0x8(%rdx,%rdi,8),%xmm0
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rdi
movapd %xmm0,%xmm1
cmp    %edi,%ebp
jne    22e0 <cu_compute_matrix_stamps+0x11b0>
jmp    21f4 <cu_compute_matrix_stamps+0x10c4>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    237c <cu_compute_matrix_stamps+0x124c>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rdx
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rdx,8),%esi
mov    %esi,%eax
mov    0x190(%rsp),%edi
sub    %edi,%eax
mov    $0x0,%ebp
cmovs  %ebp,%eax
add    %edi,%esi
mov    0x38(%rsp),%rcx
cmp    %ecx,%esi
cmovg  %ecx,%esi
mov    0x198(%rsp),%rcx
mov    %rdx,0x8(%rsp)
cvttsd2si (%rcx,%rdx,8),%ecx
mov    %ecx,%edx
sub    %edi,%edx
cmovs  %ebp,%edx
add    %edi,%ecx
mov    0x50(%rsp),%rdi
cmp    %edi,%ecx
cmovg  %edi,%ecx
cmp    %esi,%eax
jge    2360 <cu_compute_matrix_stamps+0x1230>
mov    %edx,%ebx
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbp
mov    %rbp,0x10(%rsp)
mov    %eax,%eax
mov    %esi,%r13d
mov    %ecx,%r11d
sub    %edx,%r11d
lea    0x1(%rdx),%r15d
mov    %rbx,(%rsp)
lea    (%rdi,%rbx,8),%rbx
add    $0x8,%rbx
jmp    2415 <cu_compute_matrix_stamps+0x12e5>
xchg   %ax,%ax
movapd %xmm1,%xmm0
add    $0x1,%rax
movapd %xmm0,%xmm1
cmp    %r13,%rax
je     2364 <cu_compute_matrix_stamps+0x1234>
cmp    %edx,%ecx
jle    2400 <cu_compute_matrix_stamps+0x12d0>
mov    %rax,%rsi
imul   0x58(%rsp),%rsi
add    (%rsp),%rsi
mov    0x60(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm2
mov    0x208(%rsp),%rdi
lea    (%rdi,%rsi,8),%r8
mov    0x200(%rsp),%rdi
lea    (%rdi,%rsi,8),%r9
mov    0x1f0(%rsp),%rdi
lea    (%rdi,%rsi,8),%r10
test   $0x1,%r11b
jne    2470 <cu_compute_matrix_stamps+0x1340>
mov    0x10(%rsp),%rsi
mov    %edx,%edi
cmp    %r15d,%ecx
je     2404 <cu_compute_matrix_stamps+0x12d4>
jmp    24b7 <cu_compute_matrix_stamps+0x1387>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rsi
movsd  (%rsi),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%r10),%xmm3
add    $0x8,%r10
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  (%r9),%xmm0
add    $0x8,%r9
mulsd  (%r8),%xmm0
add    $0x8,%r8
addsd  %xmm1,%xmm0
mov    %rbx,%rsi
movapd %xmm0,%xmm1
mov    %r15d,%edi
cmp    %r15d,%ecx
je     2404 <cu_compute_matrix_stamps+0x12d4>
mov    %ecx,%ebp
sub    %edi,%ebp
xor    %edi,%edi
movapd %xmm1,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%r10,%rdi,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm1
mulsd  (%r9,%rdi,8),%xmm1
movsd  0x8(%r10,%rdi,8),%xmm3
mulsd  (%r8,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rsi,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%r9,%rdi,8),%xmm0
mulsd  0x8(%r8,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdi
cmp    %edi,%ebp
jne    24d0 <cu_compute_matrix_stamps+0x13a0>
jmp    2404 <cu_compute_matrix_stamps+0x12d4>
cmpl   $0x0,0x18(%rsp)
mov    0x20(%rsp),%eax
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
movslq 0x1c(%rsp),%rcx
mov    %rcx,0xd8(%rsp)
cltq
mov    %rax,0x88(%rsp)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    257c <cu_compute_matrix_stamps+0x144c>
nopl   (%rax)
movapd %xmm1,%xmm0
mov    0x78(%rsp),%rsi
add    $0x1,%rsi
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rsi
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rsi,8),%eax
mov    %eax,%ecx
mov    0x190(%rsp),%edi
sub    %edi,%ecx
mov    $0x0,%ebp
cmovs  %ebp,%ecx
add    %edi,%eax
mov    0x38(%rsp),%rdx
cmp    %edx,%eax
cmovg  %edx,%eax
mov    0x198(%rsp),%rdx
mov    %rsi,0x78(%rsp)
cvttsd2si (%rdx,%rsi,8),%esi
mov    %esi,%r13d
sub    %edi,%r13d
cmovs  %ebp,%r13d
add    %edi,%esi
mov    0x50(%rsp),%rdx
cmp    %edx,%esi
cmovg  %edx,%esi
cmp    %eax,%ecx
jge    2560 <cu_compute_matrix_stamps+0x1430>
mov    0x70(%rsp),%rdx
lea    (%rdx,%r13,1),%r9d
mov    %esi,%edi
sub    %r13d,%edi
mov    %edi,(%rsp)
lea    0x1(%r13),%r15d
mov    0x1b8(%rsp),%rdi
mov    0xd8(%rsp),%rbp
cmpl   $0x0,(%rdi,%rbp,4)
mov    %r13d,%ebp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdx
mov    %rdx,0x8(%rsp)
mov    %ecx,%r8d
movslq %r9d,%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%r10d
mov    0x1f8(%rsp),%rax
cmove  0x1f0(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    %rbp,0x10(%rsp)
lea    (%rdi,%rbp,8),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
jmp    2665 <cu_compute_matrix_stamps+0x1535>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm1
cmp    %r10,%r8
je     2564 <cu_compute_matrix_stamps+0x1434>
cmp    %r13d,%esi
jle    2650 <cu_compute_matrix_stamps+0x1520>
mov    %r8,%rcx
mov    0x58(%rsp),%rdx
imul   %rdx,%rcx
add    0x10(%rsp),%rcx
mov    0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm2
mov    0x88(%rsp),%rax
add    %r8,%rax
imul   %rdx,%rax
add    0x28(%rsp),%rax
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    0x208(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rcx,8),%r11
testb  $0x1,(%rsp)
jne    26e0 <cu_compute_matrix_stamps+0x15b0>
mov    0x8(%rsp),%rcx
mov    %r13d,%ebp
cmp    %r15d,%esi
je     2654 <cu_compute_matrix_stamps+0x1524>
jmp    2737 <cu_compute_matrix_stamps+0x1607>
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r9),%xmm0
add    $0x8,%r9
movsd  (%rax),%xmm4
add    $0x8,%rax
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm0
mulsd  (%r11),%xmm0
add    $0x8,%r11
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rcx
movapd %xmm0,%xmm1
mov    %r15d,%ebp
cmp    %r15d,%esi
je     2654 <cu_compute_matrix_stamps+0x1524>
mov    %esi,%edi
sub    %ebp,%edi
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r9,%rbp,8),%xmm4
movsd  0x8(%r9,%rbp,8),%xmm0
movsd  (%rax,%rbp,8),%xmm5
subsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm5,%xmm4
mulsd  (%r11,%rbp,8),%xmm4
movsd  0x8(%rax,%rbp,8),%xmm3
mulsd  (%rdx,%rbp,8),%xmm4
movsd  0x8(%rcx,%rbp,8),%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm3,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%r11,%rbp,8),%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
addsd  %xmm1,%xmm4
addsd  %xmm4,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%edi
jne    2740 <cu_compute_matrix_stamps+0x1610>
jmp    2654 <cu_compute_matrix_stamps+0x1524>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    27ec <cu_compute_matrix_stamps+0x16bc>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rdx
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rdx,8),%esi
mov    %esi,%eax
mov    0x190(%rsp),%edi
sub    %edi,%eax
mov    $0x0,%ebp
cmovs  %ebp,%eax
add    %edi,%esi
mov    0x38(%rsp),%rcx
cmp    %ecx,%esi
cmovg  %ecx,%esi
mov    0x198(%rsp),%rcx
mov    %rdx,0x8(%rsp)
cvttsd2si (%rcx,%rdx,8),%ecx
mov    %ecx,%edx
sub    %edi,%edx
cmovs  %ebp,%edx
add    %edi,%ecx
mov    0x50(%rsp),%rdi
cmp    %edi,%ecx
cmovg  %edi,%ecx
cmp    %esi,%eax
jge    27d0 <cu_compute_matrix_stamps+0x16a0>
mov    %edx,%ebp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,8),%rbx
mov    %rbx,(%rsp)
mov    %eax,%eax
mov    %esi,%r13d
mov    %ecx,%r11d
sub    %edx,%r11d
lea    0x1(%rdx),%r15d
mov    %rbp,%rbx
lea    (%rdi,%rbp,8),%rsi
add    $0x8,%rsi
mov    %rsi,0x10(%rsp)
jmp    2895 <cu_compute_matrix_stamps+0x1765>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
add    $0x1,%rax
movapd %xmm0,%xmm1
cmp    %r13,%rax
je     27d4 <cu_compute_matrix_stamps+0x16a4>
cmp    %edx,%ecx
jle    2880 <cu_compute_matrix_stamps+0x1750>
mov    %rax,%rsi
imul   0x58(%rsp),%rsi
add    %rbx,%rsi
mov    0x60(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm2
mov    0x208(%rsp),%rdi
lea    (%rdi,%rsi,8),%r8
mov    0x200(%rsp),%rdi
lea    (%rdi,%rsi,8),%r9
mov    0x1f0(%rsp),%rdi
lea    (%rdi,%rsi,8),%r10
test   $0x1,%r11b
jne    28f0 <cu_compute_matrix_stamps+0x17c0>
mov    (%rsp),%rsi
mov    %edx,%edi
cmp    %r15d,%ecx
je     2884 <cu_compute_matrix_stamps+0x1754>
jmp    2930 <cu_compute_matrix_stamps+0x1800>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rsi
movsd  (%rsi),%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%r10),%xmm0
add    $0x8,%r10
mulsd  (%r9),%xmm0
add    $0x8,%r9
mulsd  (%r8),%xmm0
add    $0x8,%r8
addsd  %xmm1,%xmm0
mov    0x10(%rsp),%rsi
movapd %xmm0,%xmm1
mov    %r15d,%edi
cmp    %r15d,%ecx
je     2884 <cu_compute_matrix_stamps+0x1754>
mov    %ecx,%ebp
sub    %edi,%ebp
xor    %edi,%edi
movapd %xmm1,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%r10,%rdi,8),%xmm1
mulsd  (%r9,%rdi,8),%xmm1
mulsd  (%r8,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rsi,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x8(%r10,%rdi,8),%xmm0
mulsd  0x8(%r9,%rdi,8),%xmm0
mulsd  0x8(%r8,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdi
cmp    %edi,%ebp
jne    2940 <cu_compute_matrix_stamps+0x1810>
jmp    2884 <cu_compute_matrix_stamps+0x1754>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    29cc <cu_compute_matrix_stamps+0x189c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm1,%xmm0
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rdx
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rdx,8),%esi
mov    %esi,%eax
mov    0x190(%rsp),%edi
sub    %edi,%eax
mov    $0x0,%ebp
cmovs  %ebp,%eax
add    %edi,%esi
mov    0x38(%rsp),%rcx
cmp    %ecx,%esi
cmovg  %ecx,%esi
mov    0x198(%rsp),%rcx
mov    %rdx,0x8(%rsp)
cvttsd2si (%rcx,%rdx,8),%ecx
mov    %ecx,%edx
sub    %edi,%edx
cmovs  %ebp,%edx
add    %edi,%ecx
mov    0x50(%rsp),%rdi
cmp    %edi,%ecx
cmovg  %edi,%ecx
cmp    %esi,%eax
jge    29b0 <cu_compute_matrix_stamps+0x1880>
mov    %edx,%ebx
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbp
mov    %rbp,(%rsp)
mov    %eax,%eax
mov    %esi,%r13d
mov    %ecx,%r11d
sub    %edx,%r11d
lea    0x1(%rdx),%r15d
lea    (%rdi,%rbx,8),%rsi
add    $0x8,%rsi
mov    %rsi,0x10(%rsp)
jmp    2a65 <cu_compute_matrix_stamps+0x1935>
xchg   %ax,%ax
movapd %xmm1,%xmm0
add    $0x1,%rax
movapd %xmm0,%xmm1
cmp    %r13,%rax
je     29b4 <cu_compute_matrix_stamps+0x1884>
cmp    %edx,%ecx
jle    2a50 <cu_compute_matrix_stamps+0x1920>
mov    %rax,%rsi
imul   0x58(%rsp),%rsi
add    %rbx,%rsi
mov    0x60(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm2
mov    0x208(%rsp),%rdi
lea    (%rdi,%rsi,8),%r8
mov    0x200(%rsp),%rdi
lea    (%rdi,%rsi,8),%r9
mov    0x1f0(%rsp),%rdi
lea    (%rdi,%rsi,8),%r10
test   $0x1,%r11b
jne    2ac0 <cu_compute_matrix_stamps+0x1990>
mov    (%rsp),%rsi
mov    %edx,%edi
cmp    %r15d,%ecx
je     2a54 <cu_compute_matrix_stamps+0x1924>
jmp    2b00 <cu_compute_matrix_stamps+0x19d0>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rsi
movsd  (%rsi),%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%r10),%xmm0
add    $0x8,%r10
mulsd  (%r9),%xmm0
add    $0x8,%r9
mulsd  (%r8),%xmm0
add    $0x8,%r8
addsd  %xmm1,%xmm0
mov    0x10(%rsp),%rsi
movapd %xmm0,%xmm1
mov    %r15d,%edi
cmp    %r15d,%ecx
je     2a54 <cu_compute_matrix_stamps+0x1924>
mov    %ecx,%ebp
sub    %edi,%ebp
xor    %edi,%edi
movapd %xmm1,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%r10,%rdi,8),%xmm1
mulsd  (%r9,%rdi,8),%xmm1
mulsd  (%r8,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rsi,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x8(%r10,%rdi,8),%xmm0
mulsd  0x8(%r9,%rdi,8),%xmm0
mulsd  0x8(%r8,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdi
cmp    %edi,%ebp
jne    2b10 <cu_compute_matrix_stamps+0x19e0>
jmp    2a54 <cu_compute_matrix_stamps+0x1924>
cmpl   $0x0,0x18(%rsp)
mov    0x1c(%rsp),%eax
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
cltq
mov    %rax,0xd8(%rsp)
movslq %edx,%rax
mov    %rax,0x88(%rsp)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    2bac <cu_compute_matrix_stamps+0x1a7c>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
mov    0x78(%rsp),%rsi
add    $0x1,%rsi
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rsi
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rsi,8),%eax
mov    %eax,%ecx
mov    0x190(%rsp),%edi
sub    %edi,%ecx
mov    $0x0,%ebp
cmovs  %ebp,%ecx
add    %edi,%eax
mov    0x38(%rsp),%rdx
cmp    %edx,%eax
cmovg  %edx,%eax
mov    0x198(%rsp),%rdx
mov    %rsi,0x78(%rsp)
cvttsd2si (%rdx,%rsi,8),%esi
mov    %esi,%r13d
sub    %edi,%r13d
cmovs  %ebp,%r13d
add    %edi,%esi
mov    0x50(%rsp),%rdx
cmp    %edx,%esi
cmovg  %edx,%esi
cmp    %eax,%ecx
jge    2b90 <cu_compute_matrix_stamps+0x1a60>
mov    0x70(%rsp),%rdx
lea    (%rdx,%r13,1),%r9d
mov    %esi,%edi
sub    %r13d,%edi
mov    %edi,(%rsp)
lea    0x1(%r13),%r15d
mov    0x1b8(%rsp),%rdi
mov    0xd8(%rsp),%rbp
cmpl   $0x0,(%rdi,%rbp,4)
mov    %r13d,%ebp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdx
mov    %rdx,0x20(%rsp)
mov    %ecx,%r8d
movslq %r9d,%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%r10d
mov    0x1f8(%rsp),%rax
cmove  0x1f0(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    %rbp,0x10(%rsp)
lea    (%rdi,%rbp,8),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
jmp    2c95 <cu_compute_matrix_stamps+0x1b65>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm1
cmp    %r10,%r8
je     2b94 <cu_compute_matrix_stamps+0x1a64>
cmp    %r13d,%esi
jle    2c80 <cu_compute_matrix_stamps+0x1b50>
mov    %r8,%rcx
mov    0x58(%rsp),%rdx
imul   %rdx,%rcx
add    0x10(%rsp),%rcx
mov    0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm2
mov    0x88(%rsp),%rax
add    %r8,%rax
imul   %rdx,%rax
add    0x8(%rsp),%rax
mov    0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    0x1f0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    0x208(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rcx,8),%r11
testb  $0x1,(%rsp)
jne    2d10 <cu_compute_matrix_stamps+0x1be0>
mov    0x20(%rsp),%rcx
mov    %r13d,%edi
cmp    %r15d,%esi
je     2c84 <cu_compute_matrix_stamps+0x1b54>
jmp    2d5f <cu_compute_matrix_stamps+0x1c2f>
mov    0x20(%rsp),%rcx
movsd  (%rcx),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r9),%xmm0
add    $0x8,%r9
subsd  (%rax),%xmm0
add    $0x8,%rax
mulsd  %xmm3,%xmm0
mulsd  (%r11),%xmm0
add    $0x8,%r11
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rcx
movapd %xmm0,%xmm1
mov    %r15d,%edi
cmp    %r15d,%esi
je     2c84 <cu_compute_matrix_stamps+0x1b54>
mov    %esi,%ebp
sub    %edi,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdi,8),%xmm0
movsd  (%r9,%rdi,8),%xmm3
subsd  (%rax,%rdi,8),%xmm3
mulsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm3
mulsd  (%r11,%rdi,8),%xmm3
movsd  0x8(%r9,%rdi,8),%xmm0
mulsd  (%rdx,%rdi,8),%xmm3
movsd  0x8(%rcx,%rdi,8),%xmm4
mulsd  %xmm2,%xmm4
subsd  0x8(%rax,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
mulsd  0x8(%r11,%rdi,8),%xmm0
mulsd  0x8(%rdx,%rdi,8),%xmm0
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rdi
movapd %xmm0,%xmm1
cmp    %edi,%ebp
jne    2d70 <cu_compute_matrix_stamps+0x1c40>
jmp    2c84 <cu_compute_matrix_stamps+0x1b54>
cmpl   $0x0,0x18(%rsp)
jle    2f90 <cu_compute_matrix_stamps+0x1e60>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    2e0c <cu_compute_matrix_stamps+0x1cdc>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
movapd %xmm0,%xmm1
cmp    0x48(%rsp),%rbp
je     2f94 <cu_compute_matrix_stamps+0x1e64>
mov    0x1a0(%rsp),%rax
cvttsd2si (%rax,%rbp,8),%esi
mov    %esi,%eax
mov    0x190(%rsp),%edx
sub    %edx,%eax
mov    $0x0,%edi
cmovs  %edi,%eax
add    %edx,%esi
mov    0x38(%rsp),%rcx
cmp    %ecx,%esi
cmovg  %ecx,%esi
mov    0x198(%rsp),%rcx
mov    %rbp,0x8(%rsp)
cvttsd2si (%rcx,%rbp,8),%ecx
mov    %ecx,%r10d
sub    %edx,%r10d
cmovs  %edi,%r10d
add    %edx,%ecx
mov    0x50(%rsp),%rdx
cmp    %edx,%ecx
cmovg  %edx,%ecx
cmp    %esi,%eax
jge    2df0 <cu_compute_matrix_stamps+0x1cc0>
mov    %r10d,%ebx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdi
mov    %rdi,(%rsp)
mov    %eax,%eax
mov    %esi,%r13d
mov    %ecx,%r11d
sub    %r10d,%r11d
lea    0x1(%r10),%r15d
lea    (%rdx,%rbx,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x10(%rsp)
jmp    2eb5 <cu_compute_matrix_stamps+0x1d85>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%rax
movapd %xmm0,%xmm1
cmp    %r13,%rax
je     2df4 <cu_compute_matrix_stamps+0x1cc4>
cmp    %r10d,%ecx
jle    2ea0 <cu_compute_matrix_stamps+0x1d70>
mov    %rax,%rdx
imul   0x58(%rsp),%rdx
add    %rbx,%rdx
mov    0x60(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm2
mov    0x208(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
mov    0x200(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
test   $0x1,%r11b
jne    2f00 <cu_compute_matrix_stamps+0x1dd0>
mov    (%rsp),%r9
mov    %r10d,%edx
cmp    %r15d,%ecx
je     2ea4 <cu_compute_matrix_stamps+0x1d74>
jmp    2f35 <cu_compute_matrix_stamps+0x1e05>
nopl   0x0(%rax)
mov    (%rsp),%rdx
movsd  (%rdx),%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%rdi),%xmm0
add    $0x8,%rdi
mulsd  (%rsi),%xmm0
add    $0x8,%rsi
addsd  %xmm1,%xmm0
mov    0x10(%rsp),%r9
movapd %xmm0,%xmm1
mov    %r15d,%edx
cmp    %r15d,%ecx
je     2ea4 <cu_compute_matrix_stamps+0x1d74>
mov    %ecx,%ebp
sub    %edx,%ebp
xor    %r8d,%r8d
movapd %xmm1,%xmm0
movsd  (%r9,%r8,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%rdi,%r8,8),%xmm1
mulsd  (%rsi,%r8,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%r9,%r8,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x8(%rdi,%r8,8),%xmm0
mulsd  0x8(%rsi,%r8,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%r8
cmp    %r8d,%ebp
jne    2f40 <cu_compute_matrix_stamps+0x1e10>
jmp    2ea4 <cu_compute_matrix_stamps+0x1d74>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
mov    0x138(%rsp),%rax
mov    0x148(%rsp),%rdi
add    %rdi,%rax
mov    %rdi,%rcx
imul   0x100(%rsp),%rcx
mov    0x140(%rsp),%r10
add    %r10,%rcx
mov    0x1d0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
mov    0x1c(%rsp),%r8d
test   %r8d,%r8d
jle    15f0 <cu_compute_matrix_stamps+0x4c0>
mov    0x1c0(%rsp),%r13d
cmp    %r13d,%r8d
mov    0x34(%rsp),%r11d
mov    0xa0(%rsp),%r9
mov    0xb0(%rsp),%r15d
mov    0xa8(%rsp),%rbx
mov    0xe8(%rsp),%rsi
jge    161d <cu_compute_matrix_stamps+0x4ed>
mov    0x98(%rsp),%ebp
test   %ebp,%ebp
jle    161d <cu_compute_matrix_stamps+0x4ed>
cmp    %r13d,%ebp
jge    161d <cu_compute_matrix_stamps+0x4ed>
add    $0xffffffff,%r8d
imul   %r15d,%r8d
mov    0x68(%rsp),%eax
add    %eax,%r8d
add    $0xffffffff,%ebp
imul   %r15d,%ebp
add    %eax,%ebp
add    0x9c(%rsp),%r8d
add    0x6c(%rsp),%ebp
mov    %ebp,%eax
mov    0x1e0(%rsp),%ecx
imul   %ecx,%eax
add    %r8d,%eax
cltq
mov    0x1d0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
imul   %ecx,%r8d
add    %ebp,%r8d
movslq %r8d,%rax
movsd  %xmm0,(%rdx,%rax,8)
jmp    161d <cu_compute_matrix_stamps+0x4ed>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rdx,%r12
and    $0xfffffffc,%r12d
mov    %r12,0x10(%rsp)
lea    0x0(,%rcx,4),%eax
mov    %eax,0x48(%rsp)
lea    (%rcx,%rcx,1),%eax
mov    %rax,0x8(%rsp)
lea    (%rcx,%rcx,2),%eax
mov    %rax,0x28(%rsp)
xor    %ebx,%ebx
mov    (%rsp),%r12
jmp    30e3 <cu_compute_matrix_stamps+0x1fb3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x4,%rbx
add    0x48(%rsp),%ebp
cmp    %rbx,0x10(%rsp)
je     145f <cu_compute_matrix_stamps+0x32f>
mov    0x1e0(%rsp),%r14d
test   %r14d,%r14d
jle    30d0 <cu_compute_matrix_stamps+0x1fa0>
movslq %ebp,%rax
mov    0x1d0(%rsp),%r13
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
lea    (%r14,%rbp,1),%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rax
add    %ebp,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x28(%rsp),%rax
add    %ebp,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0xa0(%rsp),%r9
mov    0x34(%rsp),%r11d
jmp    30d0 <cu_compute_matrix_stamps+0x1fa0>
movdqa 0xe7f(%rip),%xmm2
xor    %edx,%edx
test   $0x1,%cl
jne    1270 <cu_compute_matrix_stamps+0x140>
jmp    128e <cu_compute_matrix_stamps+0x15e>
pxor   %xmm2,%xmm2
movhpd 0xeab(%rip),%xmm2
xor    %edx,%edx
test   $0x1,%cl
jne    13a8 <cu_compute_matrix_stamps+0x278>
jmp    13c2 <cu_compute_matrix_stamps+0x292>

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

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