void cu_compute_matrix(int dp, int ds, int db, int nx, int ny, 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;
  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 (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            pBj1 = &tex0[kernelRadius + nx * j];
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp +=
                  (*ppx++) * pyj * (*pBi1++) * (*pBj1++) * (*pt3++) * (*pt4++);
            }
          }
        } else if (kj < nkernel) {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            pBj1 = &tex0[kernelRadius + nx * j];
            if (ext_basis[kj]) {
              pBj2 = &tex1[kernelRadius + c + nx * (j + d)];
            } else {
              pBj2 = &tex0[kernelRadius + c + nx * (j + d)];
            }
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * (*pBi1++) * ((*pBj2++) - (*pBj1++)) *
                      (*pt3++) * (*pt4++);
            }
          }
        } else {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * (*pBi1++) * (*pt3++) * (*pt4++);
            }
          }
        }
      } else if (ki < nkernel) {
        if (kj == 0) {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            if (ext_basis[ki]) {
              pBi2 = &tex1[kernelRadius + a + nx * (j + b)];
            } else {
              pBi2 = &tex0[kernelRadius + a + nx * (j + b)];
            }
            pBj1 = &tex0[kernelRadius + nx * j];
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) * (*pBj1++) *
                      (*pt3++) * (*pt4++);
            }
          }
        } else if (kj < nkernel) {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            pBj1 = &tex0[kernelRadius + nx * j];
            if (ext_basis[ki]) {
              pBi2 = &tex1[kernelRadius + a + nx * (j + b)];
            } else {
              pBi2 = &tex0[kernelRadius + a + nx * (j + b)];
            }
            if (ext_basis[kj]) {
              pBj2 = &tex1[kernelRadius + c + nx * (j + d)];
            } else {
              pBj2 = &tex0[kernelRadius + c + nx * (j + d)];
            }
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) *
                      ((*pBj2++) - (*pBj1++)) * (*pt3++) * (*pt4++);
            }
          }
        } else {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBi1 = &tex0[kernelRadius + nx * j];
            if (ext_basis[ki]) {
              pBi2 = &tex1[kernelRadius + a + nx * (j + b)];
            } else {
              pBi2 = &tex0[kernelRadius + a + nx * (j + b)];
            }
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * ((*pBi2++) - (*pBi1++)) * (*pt3++) *
                      (*pt4++);
            }
          }
        }
      } else {
        if (kj == 0) {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBj1 = &tex0[kernelRadius + nx * j];
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * (*pBj1++) * (*pt3++) * (*pt4++);
            }
          }
        } else if (kj < nkernel) {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pBj1 = &tex0[kernelRadius + nx * j];
            if (ext_basis[kj]) {
              pBj2 = &tex1[kernelRadius + c + nx * (j + d)];
            } else {
              pBj2 = &tex0[kernelRadius + c + nx * (j + d)];
            }
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; i++) {
              temp += (*ppx++) * pyj * ((*pBj2++) - (*pBj1++)) * (*pt3++) *
                      (*pt4++);
            }
          }
        } else {
          for (j = kernelRadius; j < ny - kernelRadius; j++) {
            pt3 = &tex3[kernelRadius + nx * j];
            pt4 = &tex4[kernelRadius + nx * j];
            ppx = &px[kernelRadius];
            pyj = py[j];
            for (i = kernelRadius; i < nx - kernelRadius; 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>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9,-0x20(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1218 <cu_compute_matrix+0xf8>
cvtsi2sdl -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x1e24(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    11c1 <cu_compute_matrix+0xa1>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1276 <cu_compute_matrix+0x156>
cvtsi2sdl -0x68(%rbp),%xmm1
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x1dc6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    121f <cu_compute_matrix+0xff>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    12f6 <cu_compute_matrix+0x1d6>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    12dd <cu_compute_matrix+0x1bd>
mov    0x30(%rbp),%rax
mov    -0xfc(%rbp),%ecx
mov    0x40(%rbp),%edx
imul   -0x100(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1299 <cu_compute_matrix+0x179>
jmp    12e2 <cu_compute_matrix+0x1c2>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1280 <cu_compute_matrix+0x160>
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,-0x3c(%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,-0x40(%rbp)
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    2946 <cu_compute_matrix+0x1826>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x100(%rbp),%eax
jg     292d <cu_compute_matrix+0x180d>
mov    -0xfc(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    137b <cu_compute_matrix+0x25b>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    1391 <cu_compute_matrix+0x271>
mov    -0xfc(%rbp),%eax
sub    -0x3c(%rbp),%eax
cltd
idivl  -0x40(%rbp)
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13b6 <cu_compute_matrix+0x296>
xor    %eax,%eax
mov    %eax,-0x108(%rbp)
jmp    13cc <cu_compute_matrix+0x2ac>
mov    -0x100(%rbp),%eax
sub    -0x3c(%rbp),%eax
cltd
idivl  -0x40(%rbp)
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    140b <cu_compute_matrix+0x2eb>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1433 <cu_compute_matrix+0x313>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x44(%rbp)
jne    1451 <cu_compute_matrix+0x331>
mov    -0x4(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    14a3 <cu_compute_matrix+0x383>
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1480 <cu_compute_matrix+0x360>
mov    -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xfc(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    149e <cu_compute_matrix+0x37e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xfc(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    14a3 <cu_compute_matrix+0x383>
cmpl   $0x0,-0x48(%rbp)
jne    14c1 <cu_compute_matrix+0x3a1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x100(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    1513 <cu_compute_matrix+0x3f3>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    14f0 <cu_compute_matrix+0x3d0>
mov    -0x8(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x100(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
jmp    150e <cu_compute_matrix+0x3ee>
mov    -0xc(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x100(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
jmp    1513 <cu_compute_matrix+0x3f3>
cmpl   $0x0,-0x44(%rbp)
jle    1550 <cu_compute_matrix+0x430>
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1550 <cu_compute_matrix+0x430>
cmpl   $0x0,-0x48(%rbp)
jle    1550 <cu_compute_matrix+0x430>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1550 <cu_compute_matrix+0x430>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    1550 <cu_compute_matrix+0x430>
jmp    2919 <cu_compute_matrix+0x17f9>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jg     15d0 <cu_compute_matrix+0x4b0>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    -0x6c(%rbp),%ecx
cmp    %ecx,%eax
jg     15bd <cu_compute_matrix+0x49d>
mov    -0x64(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    15a6 <cu_compute_matrix+0x486>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    157d <cu_compute_matrix+0x45d>
jmp    15c2 <cu_compute_matrix+0x4a2>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    156a <cu_compute_matrix+0x44a>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jg     1644 <cu_compute_matrix+0x524>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x60(%rbp),%ecx
sub    -0x6c(%rbp),%ecx
cmp    %ecx,%eax
jg     1631 <cu_compute_matrix+0x511>
mov    -0x64(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    161a <cu_compute_matrix+0x4fa>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    15f1 <cu_compute_matrix+0x4d1>
jmp    1636 <cu_compute_matrix+0x516>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15de <cu_compute_matrix+0x4be>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1694 <cu_compute_matrix+0x574>
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x74(%rbp),%eax
add    -0x7c(%rbp),%eax
cvtsi2sd %eax,%xmm1
call   1040 <pow@plt>
mov    -0x88(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    164b <cu_compute_matrix+0x52b>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16e4 <cu_compute_matrix+0x5c4>
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%eax
add    -0x80(%rbp),%eax
cvtsi2sd %eax,%xmm1
call   1040 <pow@plt>
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    169b <cu_compute_matrix+0x57b>
movsd  0x1914(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x1904(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
cmpl   $0x0,-0x44(%rbp)
jne    1c77 <cu_compute_matrix+0xb57>
cmpl   $0x0,-0x48(%rbp)
jne    18c9 <cu_compute_matrix+0x7a9>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    18c4 <cu_compute_matrix+0x7a4>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    18b1 <cu_compute_matrix+0x791>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17f5 <cu_compute_matrix+0x6d5>
jmp    18b6 <cu_compute_matrix+0x796>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1729 <cu_compute_matrix+0x609>
jmp    1c72 <cu_compute_matrix+0xb52>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1b01 <cu_compute_matrix+0x9e1>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1afc <cu_compute_matrix+0x9dc>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     196e <cu_compute_matrix+0x84e>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
jmp    1997 <cu_compute_matrix+0x877>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1ae9 <cu_compute_matrix+0x9c9>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm1
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1a10 <cu_compute_matrix+0x8f0>
jmp    1aee <cu_compute_matrix+0x9ce>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    18db <cu_compute_matrix+0x7bb>
jmp    1c6d <cu_compute_matrix+0xb4d>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1c68 <cu_compute_matrix+0xb48>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1c55 <cu_compute_matrix+0xb35>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1bb2 <cu_compute_matrix+0xa92>
jmp    1c5a <cu_compute_matrix+0xb3a>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b07 <cu_compute_matrix+0x9e7>
jmp    1c6d <cu_compute_matrix+0xb4d>
jmp    1c72 <cu_compute_matrix+0xb52>
jmp    2828 <cu_compute_matrix+0x1708>
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2373 <cu_compute_matrix+0x1253>
cmpl   $0x0,-0x48(%rbp)
jne    1eb9 <cu_compute_matrix+0xd99>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1eb4 <cu_compute_matrix+0xd94>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1d05 <cu_compute_matrix+0xbe5>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
jmp    1d2e <cu_compute_matrix+0xc0e>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1ea1 <cu_compute_matrix+0xd81>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm1
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1dc8 <cu_compute_matrix+0xca8>
jmp    1ea6 <cu_compute_matrix+0xd86>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1c93 <cu_compute_matrix+0xb73>
jmp    236e <cu_compute_matrix+0x124e>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2177 <cu_compute_matrix+0x1057>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    2172 <cu_compute_matrix+0x1052>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1f5e <cu_compute_matrix+0xe3e>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
jmp    1f87 <cu_compute_matrix+0xe67>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1fc7 <cu_compute_matrix+0xea7>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
jmp    1ff0 <cu_compute_matrix+0xed0>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    215f <cu_compute_matrix+0x103f>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm1
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm1
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2069 <cu_compute_matrix+0xf49>
jmp    2164 <cu_compute_matrix+0x1044>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1ecb <cu_compute_matrix+0xdab>
jmp    2369 <cu_compute_matrix+0x1249>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    2364 <cu_compute_matrix+0x1244>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     21ef <cu_compute_matrix+0x10cf>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
jmp    2218 <cu_compute_matrix+0x10f8>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x50(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    2351 <cu_compute_matrix+0x1231>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm1
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2291 <cu_compute_matrix+0x1171>
jmp    2356 <cu_compute_matrix+0x1236>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    217d <cu_compute_matrix+0x105d>
jmp    2369 <cu_compute_matrix+0x1249>
jmp    236e <cu_compute_matrix+0x124e>
jmp    2823 <cu_compute_matrix+0x1703>
cmpl   $0x0,-0x48(%rbp)
jne    24e9 <cu_compute_matrix+0x13c9>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    24e4 <cu_compute_matrix+0x13c4>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    24d1 <cu_compute_matrix+0x13b1>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    242e <cu_compute_matrix+0x130e>
jmp    24d6 <cu_compute_matrix+0x13b6>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    2383 <cu_compute_matrix+0x1263>
jmp    281e <cu_compute_matrix+0x16fe>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    26e7 <cu_compute_matrix+0x15c7>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    26e2 <cu_compute_matrix+0x15c2>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     256d <cu_compute_matrix+0x144d>
mov    0x58(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
jmp    2596 <cu_compute_matrix+0x1476>
mov    0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
add    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%edx
mov    -0x68(%rbp),%esi
add    -0x58(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    26cf <cu_compute_matrix+0x15af>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm1
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    260f <cu_compute_matrix+0x14ef>
jmp    26d4 <cu_compute_matrix+0x15b4>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    24fb <cu_compute_matrix+0x13db>
jmp    2819 <cu_compute_matrix+0x16f9>
mov    0x28(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    2814 <cu_compute_matrix+0x16f4>
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x88(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    2801 <cu_compute_matrix+0x16e1>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xc8(%rbp)
movsd  (%rax),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
mulsd  (%rax),%xmm0
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2777 <cu_compute_matrix+0x1657>
jmp    2806 <cu_compute_matrix+0x16e6>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    26ed <cu_compute_matrix+0x15cd>
jmp    2819 <cu_compute_matrix+0x16f9>
jmp    281e <cu_compute_matrix+0x16fe>
jmp    2823 <cu_compute_matrix+0x1703>
jmp    2828 <cu_compute_matrix+0x1708>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0xfc(%rbp),%ecx
mov    0x40(%rbp),%edx
imul   -0x100(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x100(%rbp),%ecx
mov    0x40(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x44(%rbp)
jle    2914 <cu_compute_matrix+0x17f4>
mov    -0x44(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2914 <cu_compute_matrix+0x17f4>
cmpl   $0x0,-0x48(%rbp)
jle    2914 <cu_compute_matrix+0x17f4>
mov    -0x48(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2914 <cu_compute_matrix+0x17f4>
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%esi
add    -0x2c(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    0x40(%rbp),%edx
mov    -0x34(%rbp),%esi
add    -0x30(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2919 <cu_compute_matrix+0x17f9>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    134d <cu_compute_matrix+0x22d>
jmp    2932 <cu_compute_matrix+0x1812>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1334 <cu_compute_matrix+0x214>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cu_compute_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,0x128(%rsp)
mov    %r8d,%ebx
mov    %ecx,%r14d
mov    %edx,0x38(%rsp)
mov    %rsi,0xa0(%rsp)
mov    %rdi,0x98(%rsp)
movslq %ecx,%r15
lea    0x0(,%r15,8),%rbp
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,%r12
mov    %rbx,0xd0(%rsp)
movslq %ebx,%rbx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %rbp,0x188(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %r14,0xf8(%rsp)
mov    %r14d,%esi
mov    %r15,0x40(%rsp)
test   %r15d,%r15d
mov    %rsi,0xe8(%rsp)
jle    12de <cu_compute_matrix+0x1ae>
mov    0xf8(%rsp),%rcx
lea    -0x1(%rcx),%edx
cvtsi2sd %edx,%xmm0
cmp    $0x1,%ecx
jne    11ef <cu_compute_matrix+0xbf>
xor    %edi,%edi
jmp    12ab <cu_compute_matrix+0x17b>
mov    %esi,%edi
and    $0xfffffffe,%edi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rdi),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     13df <cu_compute_matrix+0x2af>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0x1dde(%rip),%xmm2
xor    %edx,%edx
movapd 0x1de4(%rip),%xmm3
mulpd  %xmm1,%xmm3
movdqa 0x1de8(%rip),%xmm4
movdqa 0x1df0(%rip),%xmm5
cvtdq2pd %xmm2,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,(%r12,%rdx,8)
movdqa %xmm2,%xmm6
paddd  %xmm4,%xmm6
cvtdq2pd %xmm6,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,0x10(%r12,%rdx,8)
add    $0x4,%rdx
paddd  %xmm5,%xmm2
add    $0xfffffffffffffffe,%rsi
jne    1240 <cu_compute_matrix+0x110>
test   $0x1,%cl
je     129e <cu_compute_matrix+0x16e>
cvtdq2pd %xmm2,%xmm2
movapd 0x1d84(%rip),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,(%r12,%rdx,8)
mov    0xe8(%rsp),%rsi
cmp    %rsi,%rdi
je     12de <cu_compute_matrix+0x1ae>
movsd  0x1d8d(%rip),%xmm1
mulsd  %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
xorps  %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,(%r12,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    12c0 <cu_compute_matrix+0x190>
mov    %rbp,0xf0(%rsp)
mov    %r12,0x118(%rsp)
mov    0x208(%rsp),%ebp
mov    0xd0(%rsp),%rcx
mov    %ecx,%edi
test   %ecx,%ecx
mov    0x38(%rsp),%r10d
mov    0xa0(%rsp),%r9
mov    0x98(%rsp),%r11
mov    0x90(%rsp),%rcx
jle    145d <cu_compute_matrix+0x32d>
mov    0xd0(%rsp),%rdx
lea    -0x1(%rdx),%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
cmp    $0x1,%edx
jne    1342 <cu_compute_matrix+0x212>
xor    %ebx,%ebx
jmp    1431 <cu_compute_matrix+0x301>
mov    %edi,%ebx
and    $0xfffffffe,%ebx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rbx),%rdx
mov    %rdx,%r8
shr    %r8
add    $0x1,%r8
test   %rdx,%rdx
je     13f7 <cu_compute_matrix+0x2c7>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
movdqa 0x1c8b(%rip),%xmm2
xor    %edx,%edx
movapd 0x1c91(%rip),%xmm3
mulpd  %xmm1,%xmm3
movdqa 0x1c95(%rip),%xmm4
movdqa 0x1c9d(%rip),%xmm5
mov    0x90(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
cvtdq2pd %xmm2,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,(%rsi,%rdx,8)
movdqa %xmm2,%xmm6
paddd  %xmm4,%xmm6
cvtdq2pd %xmm6,%xmm6
addpd  %xmm3,%xmm6
divpd  %xmm1,%xmm6
movupd %xmm6,0x10(%rsi,%rdx,8)
add    $0x4,%rdx
paddd  %xmm5,%xmm2
add    $0xfffffffffffffffe,%rcx
jne    13a0 <cu_compute_matrix+0x270>
cvtdq2pd %xmm2,%xmm2
jmp    1405 <cu_compute_matrix+0x2d5>
movdqa 0x1c19(%rip),%xmm2
xor    %edx,%edx
test   $0x1,%cl
jne    1280 <cu_compute_matrix+0x150>
jmp    129e <cu_compute_matrix+0x16e>
pxor   %xmm2,%xmm2
movhpd 0x1c45(%rip),%xmm2
xor    %edx,%edx
test   $0x1,%r8b
mov    0x90(%rsp),%rcx
je     142c <cu_compute_matrix+0x2fc>
movapd 0x1bf5(%rip),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,(%rcx,%rdx,8)
cmp    %rdi,%rbx
je     145d <cu_compute_matrix+0x32d>
movsd  0x1c07(%rip),%xmm1
mulsd  %xmm0,%xmm1
nopl   (%rax)
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1440 <cu_compute_matrix+0x310>
mov    %rdi,0x108(%rsp)
mov    0x200(%rsp),%ecx
mov    %ebp,%edx
test   %ebp,%ebp
mov    %rax,0x88(%rsp)
mov    %rdx,0x140(%rsp)
jle    14fe <cu_compute_matrix+0x3ce>
mov    %rdx,%rax
mov    %ecx,%r15d
shl    $0x3,%r15
add    $0xffffffffffffffff,%rax
mov    %edx,%r12d
and    $0x3,%r12d
xor    %r14d,%r14d
cmp    $0x3,%rax
jae    2c16 <cu_compute_matrix+0x1ae6>
xor    %ebx,%ebx
test   %r12,%r12
mov    0x200(%rsp),%r14d
mov    0x208(%rsp),%ebp
je     14fe <cu_compute_matrix+0x3ce>
imul   %r14d,%ebx
jmp    14c9 <cu_compute_matrix+0x399>
add    %r14d,%ebx
add    $0xffffffffffffffff,%r12
je     14fe <cu_compute_matrix+0x3ce>
test   %r14d,%r14d
jle    14c0 <cu_compute_matrix+0x390>
movslq %ebx,%rax
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x98(%rsp),%r11
mov    0xa0(%rsp),%r9
mov    0x38(%rsp),%r10d
jmp    14c0 <cu_compute_matrix+0x390>
test   %ebp,%ebp
jle    2c04 <cu_compute_matrix+0x1ad4>
mov    0x228(%rsp),%rdi
mov    0x220(%rsp),%rsi
mov    0x1e8(%rsp),%edx
lea    0x1(%r11),%eax
lea    0x2(%r11),%ecx
imul   %eax,%ecx
mov    %ecx,%ebp
shr    $0x1f,%ebp
add    %ecx,%ebp
sar    %ebp
lea    0x1(%r9),%eax
lea    0x2(%r9),%ecx
imul   %eax,%ecx
mov    %ecx,%ebx
shr    $0x1f,%ebx
add    %ecx,%ebx
sar    %ebx
mov    0xd0(%rsp),%rax
mov    %eax,%r14d
sub    %edx,%r14d
movslq %edx,%r15
mov    0xf8(%rsp),%r12
mov    %r12d,%ecx
sub    %r15d,%ecx
mov    %ecx,0xc(%rsp)
mov    0xe8(%rsp),%rcx
lea    -0x1(%rcx),%rdx
mov    %rdx,0x178(%rsp)
mov    0x108(%rsp),%r13
lea    -0x1(%r13),%rax
mov    %rax,0x170(%rsp)
lea    (%r15,%r15,1),%eax
mov    %r12d,%edx
sub    %eax,%edx
mov    %rdx,0x50(%rsp)
not    %eax
add    %r12d,%eax
mov    %eax,0x24(%rsp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x168(%rsp)
and    $0xfffffffc,%ecx
mov    %rcx,0xe8(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x160(%rsp)
and    $0xfffffffc,%r13d
mov    %r13,0x108(%rsp)
mov    0x40(%rsp),%rax
add    $0x1,%rax
imul   %r15,%rax
mov    0x210(%rsp),%rcx
lea    (%rdi,%rax,8),%rdx
mov    %rdx,0x158(%rsp)
lea    (%rsi,%rax,8),%rdx
mov    %rdx,0x150(%rsp)
lea    (%rcx,%rax,8),%rax
mov    %rax,0x148(%rsp)
mov    0x1e0(%rsp),%ecx
mov    0xf0(%rsp),%rax
lea    (%rax,%r15,8),%rdx
mov    %rdx,0x28(%rsp)
mov    %ebp,0x64(%rsp)
movslq %ebp,%rdx
mov    %rdx,0x138(%rsp)
mov    %ecx,%ebp
mov    0x200(%rsp),%ecx
movslq %ecx,%rcx
mov    %rcx,0x120(%rsp)
mov    %r14d,0x114(%rsp)
movslq %r14d,%rcx
mov    %rcx,0x48(%rsp)
lea    0x8(%rax,%r15,8),%rax
mov    %rax,0x70(%rsp)
mov    %r15,0x18(%rsp)
lea    0x1(%r15),%eax
mov    %eax,0x20(%rsp)
mov    $0x1,%eax
mov    %rax,0x130(%rsp)
xor    %eax,%eax
mov    %rcx,0xc8(%rsp)
mov    %rcx,0xd8(%rsp)
mov    %ebx,0xbc(%rsp)
jmp    16c3 <cu_compute_matrix+0x593>
nopl   0x0(%rax)
mov    0xe0(%rsp),%rax
add    $0x1,%rax
addq   $0x1,0x130(%rsp)
cmp    0x140(%rsp),%rax
je     2c04 <cu_compute_matrix+0x1ad4>
mov    %eax,%ecx
sub    0x64(%rsp),%ecx
mov    %ecx,0xc0(%rsp)
mov    %rax,0xe0(%rsp)
imul   0x120(%rsp),%rax
mov    %rax,0x180(%rsp)
xor    %eax,%eax
jmp    172a <cu_compute_matrix+0x5fa>
nopl   (%rax)
mov    0x38(%rsp),%r10d
mov    0xa0(%rsp),%r9
mov    0x98(%rsp),%r11
mov    0xbc(%rsp),%ebx
mov    0x1e0(%rsp),%ebp
mov    0x78(%rsp),%rax
add    $0x1,%rax
cmp    0x130(%rsp),%rax
je     16a0 <cu_compute_matrix+0x570>
xor    %edi,%edi
mov    $0x0,%esi
mov    %rax,0x78(%rsp)
cmp    0x138(%rsp),%rax
jl     1751 <cu_compute_matrix+0x621>
mov    0x78(%rsp),%rax
sub    0x64(%rsp),%eax
cltd
idiv   %ebx
mov    %eax,%esi
add    $0x1,%esi
mov    0xe0(%rsp),%rax
cmp    0x138(%rsp),%rax
jl     1772 <cu_compute_matrix+0x642>
mov    0xc0(%rsp),%eax
cltd
idiv   %ebx
mov    %eax,%edi
add    $0x1,%edi
movl   $0x0,0x68(%rsp)
movl   $0x0,0x6c(%rsp)
cmp    %ebp,%esi
jl     17c0 <cu_compute_matrix+0x690>
cmp    %ebp,%edi
jl     17e5 <cu_compute_matrix+0x6b5>
test   %esi,%esi
je     1815 <cu_compute_matrix+0x6e5>
mov    $0x1,%eax
sub    %esi,%eax
imul   %ebx,%eax
mov    0x78(%rsp),%rcx
sub    0x64(%rsp),%ecx
add    %eax,%ecx
mov    %ecx,%eax
cmp    %ebp,%esi
mov    %r10d,%ecx
cmovl  %r9d,%ecx
mov    %rcx,0xa8(%rsp)
jmp    1825 <cu_compute_matrix+0x6f5>
nopl   0x0(%rax)
movslq %esi,%rax
mov    0x128(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    %ecx,0x6c(%rsp)
mov    0x1d0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x68(%rsp)
cmp    %ebp,%edi
jge    178a <cu_compute_matrix+0x65a>
movslq %edi,%rax
mov    0x128(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    %rcx,0xc8(%rsp)
mov    0x1d0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x84(%rsp)
test   %esi,%esi
jne    1792 <cu_compute_matrix+0x662>
mov    %r11d,%eax
mov    %rax,0xa8(%rsp)
mov    0x78(%rsp),%rax
mov    $0x1,%r8d
sub    %edi,%r8d
imul   %ebx,%r8d
add    0xc0(%rsp),%r8d
cmp    %ebp,%edi
mov    %r10d,%r13d
cmovl  %r9d,%r13d
test   %edi,%edi
cmove  %r11d,%r13d
cmove  0xe0(%rsp),%r8d
test   %esi,%esi
jle    186b <cu_compute_matrix+0x73b>
cmp    %ebp,%esi
jge    186b <cu_compute_matrix+0x73b>
test   %edi,%edi
jle    186b <cu_compute_matrix+0x73b>
cmp    %ebp,%edi
jge    186b <cu_compute_matrix+0x73b>
cmp    %r8d,%eax
jg     1713 <cu_compute_matrix+0x5e3>
mov    0xa8(%rsp),%r9
test   %r9d,%r9d
mov    %edi,0x34(%rsp)
mov    %esi,0x3c(%rsp)
mov    %eax,0xc4(%rsp)
mov    %r8d,0xb0(%rsp)
mov    %r13,0x10(%rsp)
js     19d0 <cu_compute_matrix+0x8a0>
lea    0x1(%r9),%ecx
mov    %eax,%r10d
neg    %r10d
xor    %esi,%esi
xor    %r11d,%r11d
mov    0xd8(%rsp),%rbx
mov    %r10,0x190(%rsp)
jmp    18d1 <cu_compute_matrix+0x7a1>
nopl   0x0(%rax)
lea    0x1(%rsi),%eax
add    $0xffffffff,%ecx
cmp    %esi,%r9d
mov    %eax,%esi
je     19d8 <cu_compute_matrix+0x8a8>
mov    %r9d,%edx
sub    %esi,%edx
jl     18c0 <cu_compute_matrix+0x790>
xor    %eax,%eax
cmp    $0x3,%edx
jb     198c <cu_compute_matrix+0x85c>
mov    %ecx,0x58(%rsp)
mov    %ecx,%r13d
and    $0xfffffffc,%r13d
add    %r11d,%r10d
xor    %eax,%eax
mov    %r11,0x100(%rsp)
mov    %r11d,%ebp
mov    0xc4(%rsp),%r11d
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rbp),%ecx
lea    0x1(%rax),%r8d
lea    0x2(%rbp),%r9d
mov    %r10d,%edi
add    %eax,%edi
cmove  %eax,%r12d
lea    0x2(%rax),%edi
cmove  %esi,%r15d
cmp    %r11d,%ecx
cmove  %r8d,%r12d
cmove  %esi,%r15d
lea    0x3(%rbp),%ecx
cmp    %r11d,%r9d
mov    %r12d,%edx
cmove  %edi,%edx
cmove  %esi,%r15d
lea    0x3(%rax),%r12d
cmp    %r11d,%ecx
cmove  %esi,%r15d
cmovne %edx,%r12d
add    $0x4,%ebp
add    $0x4,%eax
cmp    %r13d,%eax
jne    1910 <cu_compute_matrix+0x7e0>
mov    0x100(%rsp),%r11
add    %eax,%r11d
mov    0xb0(%rsp),%r8d
mov    0x10(%rsp),%r13
mov    0xa8(%rsp),%r9
mov    0x58(%rsp),%ecx
mov    0x190(%rsp),%r10
test   $0x3,%cl
je     18c0 <cu_compute_matrix+0x790>
mov    %ecx,%edx
and    $0x3,%edx
neg    %edx
lea    (%r10,%r11,1),%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %edi,%ebp
cmove  %esi,%r15d
cmove  %eax,%r12d
add    $0x1,%eax
add    $0xffffffff,%edi
cmp    %edi,%edx
jne    19b0 <cu_compute_matrix+0x880>
sub    %edi,%r11d
jmp    18c0 <cu_compute_matrix+0x790>
nopl   0x0(%rax)
mov    0xd8(%rsp),%rbx
test   %r13d,%r13d
js     1af0 <cu_compute_matrix+0x9c0>
lea    0x1(%r13),%edi
mov    %r8d,%edx
neg    %edx
xor    %r10d,%r10d
xor    %r9d,%r9d
mov    %rdx,0xa8(%rsp)
jmp    1a13 <cu_compute_matrix+0x8e3>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r10),%eax
add    $0xffffffff,%edi
cmp    %r10d,%r13d
mov    %eax,%r10d
je     1af0 <cu_compute_matrix+0x9c0>
mov    %r13d,%ecx
sub    %r10d,%ecx
jl     1a00 <cu_compute_matrix+0x8d0>
xor    %eax,%eax
cmp    $0x3,%ecx
jb     1ab6 <cu_compute_matrix+0x986>
mov    %edi,0x58(%rsp)
mov    %edi,%r13d
and    $0xfffffffc,%r13d
lea    (%rdx,%r9,1),%r8d
xor    %eax,%eax
mov    %r9,0x100(%rsp)
mov    %r9d,%ebp
mov    0xb0(%rsp),%r9d
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%edx
lea    0x1(%rax),%esi
lea    0x2(%rbp),%ecx
mov    %r8d,%r11d
add    %eax,%r11d
cmove  %eax,%ebx
lea    0x2(%rax),%edi
cmove  %r10d,%r14d
cmp    %r9d,%edx
cmove  %esi,%ebx
cmove  %r10d,%r14d
lea    0x3(%rbp),%edx
cmp    %r9d,%ecx
mov    %ebx,%ecx
cmove  %edi,%ecx
cmove  %r10d,%r14d
lea    0x3(%rax),%ebx
cmp    %r9d,%edx
cmove  %r10d,%r14d
cmovne %ecx,%ebx
add    $0x4,%ebp
add    $0x4,%eax
cmp    %r13d,%eax
jne    1a50 <cu_compute_matrix+0x920>
mov    0x100(%rsp),%r9
add    %eax,%r9d
mov    0x10(%rsp),%r13
mov    0x58(%rsp),%edi
mov    0xa8(%rsp),%rdx
test   $0x3,%dil
je     1a00 <cu_compute_matrix+0x8d0>
mov    %edi,%ecx
and    $0x3,%ecx
neg    %ecx
lea    (%rdx,%r9,1),%ebp
xor    %esi,%esi
nopl   (%rax)
cmp    %esi,%ebp
cmove  %r10d,%r14d
cmove  %eax,%ebx
add    $0x1,%eax
add    $0xffffffff,%esi
cmp    %esi,%ecx
jne    1ad0 <cu_compute_matrix+0x9a0>
sub    %esi,%r9d
jmp    1a00 <cu_compute_matrix+0x8d0>
nopl   0x0(%rax,%rax,1)
mov    %rbx,0xd8(%rsp)
cmpl   $0x0,0xf8(%rsp)
jle    1c15 <cu_compute_matrix+0xae5>
lea    (%r14,%r15,1),%eax
cvtsi2sd %eax,%xmm0
cmpq   $0x3,0x178(%rsp)
movsd  %xmm0,0x10(%rsp)
jae    1b30 <cu_compute_matrix+0xa00>
xor    %r13d,%r13d
jmp    1bc1 <cu_compute_matrix+0xa91>
nopw   0x0(%rax,%rax,1)
xor    %r13d,%r13d
mov    0x118(%rsp),%rbx
mov    0xf0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%r13,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x0(%rbp,%r13,8)
movsd  0x8(%rbx,%r13,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x8(%rbp,%r13,8)
movsd  0x10(%rbx,%r13,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x10(%rbp,%r13,8)
movsd  0x18(%rbx,%r13,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x18(%rbp,%r13,8)
add    $0x4,%r13
cmp    %r13,0xe8(%rsp)
jne    1b50 <cu_compute_matrix+0xa20>
mov    0x168(%rsp),%rbx
test   %rbx,%rbx
je     1c15 <cu_compute_matrix+0xae5>
mov    0xf0(%rsp),%rax
lea    (%rax,%r13,8),%rax
mov    %rax,0x58(%rsp)
mov    0x118(%rsp),%rax
lea    (%rax,%r13,8),%r13
xor    %ebp,%ebp
nopl   (%rax)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1bf0 <cu_compute_matrix+0xac0>
cmpl   $0x0,0xd0(%rsp)
jle    1d36 <cu_compute_matrix+0xc06>
mov    0xd8(%rsp),%rax
add    %r12d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmpq   $0x3,0x170(%rsp)
movsd  %xmm0,0x10(%rsp)
jae    1c50 <cu_compute_matrix+0xb20>
xor    %ebp,%ebp
jmp    1cdd <cu_compute_matrix+0xbad>
nopl   (%rax)
xor    %ebp,%ebp
mov    0x88(%rsp),%rbx
mov    0x90(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,(%rbx,%rbp,8)
movsd  0x8(%r13,%rbp,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
movsd  0x10(%r13,%rbp,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x10(%rbx,%rbp,8)
movsd  0x18(%r13,%rbp,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,0x18(%rbx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,0x108(%rsp)
jne    1c70 <cu_compute_matrix+0xb40>
mov    0x160(%rsp),%rbx
test   %rbx,%rbx
je     1d36 <cu_compute_matrix+0xc06>
mov    0x88(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x58(%rsp)
mov    0x90(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r13,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   1050 <pow@plt>
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%r13
cmp    %r13,%rbx
jne    1d10 <cu_compute_matrix+0xbe0>
mov    0x3c(%rsp),%ecx
test   %ecx,%ecx
je     1ee0 <cu_compute_matrix+0xdb0>
mov    0x1e0(%rsp),%eax
cmp    %eax,%ecx
mov    0x88(%rsp),%r13
mov    0x48(%rsp),%rbx
mov    0x34(%rsp),%ecx
xorpd  %xmm0,%xmm0
jge    20f0 <cu_compute_matrix+0xfc0>
test   %ecx,%ecx
je     2419 <cu_compute_matrix+0x12e9>
cmp    %eax,%ecx
jge    2859 <cu_compute_matrix+0x1729>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
movslq 0x3c(%rsp),%rax
mov    0x1e8(%rsp),%ecx
mov    %rcx,%rdx
mov    0x6c(%rsp),%ebx
add    %edx,%ebx
movslq 0x34(%rsp),%rcx
mov    0x1d8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
mov    0x218(%rsp),%rbp
mov    %rbp,%rcx
mov    0x210(%rsp),%rsi
cmove  %rsi,%rcx
cmpl   $0x0,(%rdi,%rax,4)
mov    0xc8(%rsp),%rax
lea    (%rax,%rdx,1),%eax
movslq 0x68(%rsp),%rdx
movslq %ebx,%r8
movslq 0x84(%rsp),%rdi
cltq
cmove  %rsi,%rbp
mov    0x18(%rsp),%r9
add    %r9,%rdi
mov    0x40(%rsp),%rsi
imul   %rsi,%rdi
add    %rax,%rdi
lea    (%rcx,%rdi,8),%r10
add    %r9,%rdx
imul   %rsi,%rdx
add    %r8,%rdx
lea    0x0(,%rdx,8),%rcx
add    %rbp,%rcx
xorpd  %xmm0,%xmm0
mov    0x148(%rsp),%rdx
mov    0x150(%rsp),%rsi
mov    0x158(%rsp),%rdi
mov    %r9,%r8
jmp    1e66 <cu_compute_matrix+0xd36>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
mov    0x188(%rsp),%rbp
add    %rbp,%rdi
add    %rbp,%rsi
add    %rbp,%r10
add    %rbp,%rdx
add    %rbp,%rcx
cmp    0x48(%rsp),%r8
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%ebp
cmp    %ebp,0xc(%rsp)
jle    1e40 <cu_compute_matrix+0xd10>
movsd  0x0(%r13,%r8,8),%xmm1
xor    %ebp,%ebp
mov    0x50(%rsp),%rbx
mov    0x28(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rcx,%rbp,8),%xmm3
movsd  (%rdx,%rbp,8),%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r10,%rbp,8),%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm2
mulsd  (%rsi,%rbp,8),%xmm2
mulsd  (%rdi,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %ebp,%ebx
jne    1e90 <cu_compute_matrix+0xd60>
jmp    1e40 <cu_compute_matrix+0xd10>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x34(%rsp),%ecx
test   %ecx,%ecx
mov    0x88(%rsp),%r13
mov    0x1e0(%rsp),%eax
mov    0x48(%rsp),%rbx
xorpd  %xmm0,%xmm0
je     22c1 <cu_compute_matrix+0x1191>
cmp    %eax,%ecx
jge    25e1 <cu_compute_matrix+0x14b1>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
movslq 0x34(%rsp),%rax
mov    0x1e8(%rsp),%ecx
mov    0xc8(%rsp),%rdx
add    %edx,%ecx
mov    0x1d8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rax,4)
movslq 0x84(%rsp),%rax
mov    %rax,0x10(%rsp)
movslq %ecx,%r9
mov    0x218(%rsp),%r10
cmove  0x210(%rsp),%r10
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%r11
jmp    1f85 <cu_compute_matrix+0xe55>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
add    $0x1,%r11
movapd %xmm0,%xmm1
cmp    %rbx,%r11
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    1f70 <cu_compute_matrix+0xe40>
mov    %r11,%rdx
mov    0x40(%rsp),%rcx
imul   %rcx,%rdx
add    0x18(%rsp),%rdx
movsd  0x0(%r13,%r11,8),%xmm2
mov    0x10(%rsp),%rax
add    %r11,%rax
imul   %rcx,%rax
add    %r9,%rax
lea    (%r10,%rax,8),%rdi
mov    0x210(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x228(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x220(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
testb  $0x1,0x50(%rsp)
jne    2000 <cu_compute_matrix+0xed0>
mov    0x28(%rsp),%rsi
mov    0x1e8(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
jne    2055 <cu_compute_matrix+0xf25>
jmp    1f74 <cu_compute_matrix+0xe44>
mov    0x28(%rsp),%rsi
movsd  (%rsi),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rax),%xmm4
add    $0x8,%rax
mulsd  %xmm4,%xmm3
movsd  (%rdi),%xmm0
add    $0x8,%rdi
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rsi
movapd %xmm0,%xmm1
mov    0x20(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
je     1f74 <cu_compute_matrix+0xe44>
mov    0xc(%rsp),%ebx
mov    %ebx,%r8d
mov    0x48(%rsp),%rbx
sub    %ebp,%r8d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rax,%rbp,8),%xmm3
movsd  0x8(%rax,%rbp,8),%xmm4
mulsd  %xmm3,%xmm0
movsd  (%rdi,%rbp,8),%xmm5
subsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
mulsd  (%rdx,%rbp,8),%xmm5
movsd  0x8(%rdi,%rbp,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm5
movsd  0x8(%rsi,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
addsd  %xmm1,%xmm5
addsd  %xmm5,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%r8d
jne    2070 <cu_compute_matrix+0xf40>
jmp    1f74 <cu_compute_matrix+0xe44>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %ecx,%ecx
je     2719 <cu_compute_matrix+0x15e9>
cmp    %eax,%ecx
jge    2a11 <cu_compute_matrix+0x18e1>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
movslq 0x34(%rsp),%rax
mov    0x1e8(%rsp),%ecx
mov    0xc8(%rsp),%rdx
add    %edx,%ecx
mov    0x1d8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rax,4)
movslq 0x84(%rsp),%r8
movslq %ecx,%r9
mov    0x218(%rsp),%r10
cmove  0x210(%rsp),%r10
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%r11
jmp    217d <cu_compute_matrix+0x104d>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
add    $0x1,%r11
movapd %xmm0,%xmm1
cmp    %rbx,%r11
mov    0x88(%rsp),%r13
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    2160 <cu_compute_matrix+0x1030>
mov    %r11,%rdx
mov    0x40(%rsp),%rcx
imul   %rcx,%rdx
add    0x18(%rsp),%rdx
movsd  0x0(%r13,%r11,8),%xmm2
lea    (%r11,%r8,1),%rax
imul   %rcx,%rax
add    %r9,%rax
lea    (%r10,%rax,8),%rdi
mov    0x210(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x228(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x220(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
testb  $0x1,0x50(%rsp)
jne    2200 <cu_compute_matrix+0x10d0>
mov    0x28(%rsp),%rsi
mov    0x1e8(%rsp),%ebx
mov    %ebx,%ebp
mov    0x48(%rsp),%rbx
cmpl   $0x0,0x24(%rsp)
jne    224d <cu_compute_matrix+0x111d>
jmp    2164 <cu_compute_matrix+0x1034>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rsi
movsd  (%rsi),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rdi),%xmm0
add    $0x8,%rdi
subsd  (%rax),%xmm0
add    $0x8,%rax
mulsd  %xmm3,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rsi
movapd %xmm0,%xmm1
mov    0x20(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
je     2164 <cu_compute_matrix+0x1034>
mov    0xc(%rsp),%ebx
mov    %ebx,%r13d
mov    0x48(%rsp),%rbx
sub    %ebp,%r13d
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rdi,%rbp,8),%xmm3
subsd  (%rax,%rbp,8),%xmm3
mulsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm3
mulsd  (%rdx,%rbp,8),%xmm3
movsd  0x8(%rdi,%rbp,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm3
movsd  0x8(%rsi,%rbp,8),%xmm4
mulsd  %xmm2,%xmm4
subsd  0x8(%rax,%rbp,8),%xmm0
mulsd  %xmm4,%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%r13d
jne    2260 <cu_compute_matrix+0x1130>
jmp    2164 <cu_compute_matrix+0x1034>
mov    0x1e8(%rsp),%eax
cmp    %eax,0x114(%rsp)
jle    2b30 <cu_compute_matrix+0x1a00>
pxor   %xmm2,%xmm2
mov    0x18(%rsp),%r8
jmp    22f5 <cu_compute_matrix+0x11c5>
movdqa %xmm2,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm2
cmp    %rbx,%r8
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    22e0 <cu_compute_matrix+0x11b0>
mov    %r8,%rax
imul   0x40(%rsp),%rax
add    0x18(%rsp),%rax
movsd  0x0(%r13,%r8,8),%xmm1
mov    0x228(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x220(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    0x210(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
testb  $0x1,0x50(%rsp)
jne    2360 <cu_compute_matrix+0x1230>
mov    0x28(%rsp),%rdi
mov    0x1e8(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
jne    23a9 <cu_compute_matrix+0x1279>
jmp    22e4 <cu_compute_matrix+0x11b4>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  %xmm1,%xmm0
movsd  (%rsi),%xmm3
add    $0x8,%rsi
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm2,%xmm0
mov    0x70(%rsp),%rdi
movapd %xmm0,%xmm2
mov    0x20(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
je     22e4 <cu_compute_matrix+0x11b4>
mov    0xc(%rsp),%ebp
sub    %eax,%ebp
xor    %eax,%eax
movapd %xmm2,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rsi,%rax,8),%xmm3
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  (%rdx,%rax,8),%xmm2
movsd  0x8(%rsi,%rax,8),%xmm3
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rax
cmp    %eax,%ebp
jne    23c0 <cu_compute_matrix+0x1290>
jmp    22e4 <cu_compute_matrix+0x11b4>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
movslq 0x3c(%rsp),%rax
mov    0x1e8(%rsp),%ecx
mov    0x6c(%rsp),%edx
add    %ecx,%edx
mov    0x1d8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
movslq 0x68(%rsp),%rax
mov    %rax,0x10(%rsp)
movslq %edx,%r9
mov    0x218(%rsp),%r10
cmove  0x210(%rsp),%r10
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%r11
jmp    2485 <cu_compute_matrix+0x1355>
nop
movapd %xmm1,%xmm0
add    $0x1,%r11
movapd %xmm0,%xmm1
cmp    %rbx,%r11
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    2470 <cu_compute_matrix+0x1340>
mov    %r11,%rdx
mov    0x40(%rsp),%rcx
imul   %rcx,%rdx
add    0x18(%rsp),%rdx
movsd  0x0(%r13,%r11,8),%xmm2
mov    0x10(%rsp),%rax
add    %r11,%rax
imul   %rcx,%rax
add    %r9,%rax
lea    (%r10,%rax,8),%rdi
mov    0x210(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x228(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x220(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
testb  $0x1,0x50(%rsp)
jne    2500 <cu_compute_matrix+0x13d0>
mov    0x28(%rsp),%rsi
mov    0x1e8(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
jne    2555 <cu_compute_matrix+0x1425>
jmp    2474 <cu_compute_matrix+0x1344>
mov    0x28(%rsp),%rsi
movsd  (%rsi),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rdi),%xmm0
add    $0x8,%rdi
movsd  (%rax),%xmm4
add    $0x8,%rax
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm4,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rsi
movapd %xmm0,%xmm1
mov    0x20(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
je     2474 <cu_compute_matrix+0x1344>
mov    0xc(%rsp),%ebx
mov    %ebx,%r8d
mov    0x48(%rsp),%rbx
sub    %ebp,%r8d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rdi,%rbp,8),%xmm4
movsd  0x8(%rdi,%rbp,8),%xmm0
movsd  (%rax,%rbp,8),%xmm5
subsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm5,%xmm4
mulsd  (%rdx,%rbp,8),%xmm4
movsd  0x8(%rax,%rbp,8),%xmm3
mulsd  (%rcx,%rbp,8),%xmm4
movsd  0x8(%rsi,%rbp,8),%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm3,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
addsd  %xmm1,%xmm4
addsd  %xmm4,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%r8d
jne    2570 <cu_compute_matrix+0x1440>
jmp    2474 <cu_compute_matrix+0x1344>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
pxor   %xmm2,%xmm2
mov    0x18(%rsp),%r8
jmp    2615 <cu_compute_matrix+0x14e5>
nopl   0x0(%rax,%rax,1)
movdqa %xmm2,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm2
cmp    %rbx,%r8
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    2600 <cu_compute_matrix+0x14d0>
mov    %r8,%rax
imul   0x40(%rsp),%rax
add    0x18(%rsp),%rax
movsd  0x0(%r13,%r8,8),%xmm1
mov    0x228(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x220(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    0x210(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
testb  $0x1,0x50(%rsp)
jne    2680 <cu_compute_matrix+0x1550>
mov    0x28(%rsp),%rdi
mov    0x1e8(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
jne    26c1 <cu_compute_matrix+0x1591>
jmp    2604 <cu_compute_matrix+0x14d4>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsi),%xmm0
add    $0x8,%rsi
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm2,%xmm0
mov    0x70(%rsp),%rdi
movapd %xmm0,%xmm2
mov    0x20(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
je     2604 <cu_compute_matrix+0x14d4>
mov    0xc(%rsp),%ebp
sub    %eax,%ebp
xor    %eax,%eax
movapd %xmm2,%xmm0
nopl   (%rax)
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rsi,%rax,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rax
cmp    %eax,%ebp
jne    26d0 <cu_compute_matrix+0x15a0>
jmp    2604 <cu_compute_matrix+0x14d4>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
pxor   %xmm2,%xmm2
mov    0x18(%rsp),%r8
jmp    2755 <cu_compute_matrix+0x1625>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm2,%xmm0
add    $0x1,%r8
movapd %xmm0,%xmm2
cmp    %rbx,%r8
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    2740 <cu_compute_matrix+0x1610>
mov    %r8,%rax
imul   0x40(%rsp),%rax
add    0x18(%rsp),%rax
movsd  0x0(%r13,%r8,8),%xmm1
mov    0x228(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x220(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    0x210(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
testb  $0x1,0x50(%rsp)
mov    0x28(%rsp),%rdi
jne    27c0 <cu_compute_matrix+0x1690>
mov    0x1e8(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
jne    27fc <cu_compute_matrix+0x16cc>
jmp    2744 <cu_compute_matrix+0x1614>
nopw   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsi),%xmm0
add    $0x8,%rsi
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm2,%xmm0
mov    0x70(%rsp),%rdi
movapd %xmm0,%xmm2
mov    0x20(%rsp),%eax
cmpl   $0x0,0x24(%rsp)
je     2744 <cu_compute_matrix+0x1614>
mov    0xc(%rsp),%ebp
sub    %eax,%ebp
xor    %eax,%eax
movapd %xmm2,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rsi,%rax,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rax
cmp    %eax,%ebp
jne    2810 <cu_compute_matrix+0x16e0>
jmp    2744 <cu_compute_matrix+0x1614>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
movslq 0x3c(%rsp),%rax
mov    0x1e8(%rsp),%ecx
mov    0x6c(%rsp),%edx
add    %ecx,%edx
mov    0x1d8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
movslq 0x68(%rsp),%r8
movslq %edx,%r9
mov    0x218(%rsp),%r10
cmove  0x210(%rsp),%r10
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%r11
jmp    28cd <cu_compute_matrix+0x179d>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
add    $0x1,%r11
movapd %xmm0,%xmm1
cmp    %rbx,%r11
mov    0x88(%rsp),%r13
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jle    28b0 <cu_compute_matrix+0x1780>
mov    %r11,%rdx
mov    0x40(%rsp),%rcx
imul   %rcx,%rdx
add    0x18(%rsp),%rdx
movsd  0x0(%r13,%r11,8),%xmm2
lea    (%r11,%r8,1),%rax
imul   %rcx,%rax
add    %r9,%rax
lea    (%r10,%rax,8),%rdi
mov    0x210(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x228(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x220(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
testb  $0x1,0x50(%rsp)
jne    2950 <cu_compute_matrix+0x1820>
mov    0x28(%rsp),%rsi
mov    0x1e8(%rsp),%ebx
mov    %ebx,%ebp
mov    0x48(%rsp),%rbx
cmpl   $0x0,0x24(%rsp)
jne    299d <cu_compute_matrix+0x186d>
jmp    28b4 <cu_compute_matrix+0x1784>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rsi
movsd  (%rsi),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rdi),%xmm0
add    $0x8,%rdi
subsd  (%rax),%xmm0
add    $0x8,%rax
mulsd  %xmm3,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rsi
movapd %xmm0,%xmm1
mov    0x20(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
je     28b4 <cu_compute_matrix+0x1784>
mov    0xc(%rsp),%ebx
mov    %ebx,%r13d
mov    0x48(%rsp),%rbx
sub    %ebp,%r13d
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rdi,%rbp,8),%xmm3
subsd  (%rax,%rbp,8),%xmm3
mulsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm3
mulsd  (%rdx,%rbp,8),%xmm3
movsd  0x8(%rdi,%rbp,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm3
movsd  0x8(%rsi,%rbp,8),%xmm4
mulsd  %xmm2,%xmm4
subsd  0x8(%rax,%rbp,8),%xmm0
mulsd  %xmm4,%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rbp
movapd %xmm0,%xmm1
cmp    %ebp,%r13d
jne    29b0 <cu_compute_matrix+0x1880>
jmp    28b4 <cu_compute_matrix+0x1784>
mov    0x1e8(%rsp),%eax
cmp    %eax,%ebx
jle    2b30 <cu_compute_matrix+0x1a00>
pxor   %xmm2,%xmm2
mov    0x18(%rsp),%rax
jmp    2a45 <cu_compute_matrix+0x1915>
nopl   0x0(%rax,%rax,1)
movdqa %xmm2,%xmm0
add    $0x1,%rax
movapd %xmm0,%xmm2
cmp    %rbx,%rax
je     2b30 <cu_compute_matrix+0x1a00>
mov    0x1e8(%rsp),%ecx
cmp    %ecx,0xc(%rsp)
jle    2a30 <cu_compute_matrix+0x1900>
mov    %rax,%rdx
imul   0x40(%rsp),%rdx
add    0x18(%rsp),%rdx
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x228(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x220(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
testb  $0x1,0x50(%rsp)
jne    2aa0 <cu_compute_matrix+0x1970>
mov    0x28(%rsp),%rsi
mov    0x1e8(%rsp),%edi
mov    %edi,%ebp
cmpl   $0x0,0x24(%rsp)
jne    2ad9 <cu_compute_matrix+0x19a9>
jmp    2a34 <cu_compute_matrix+0x1904>
nopl   (%rax)
mov    0x28(%rsp),%rsi
movsd  (%rsi),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rdx),%xmm0
add    $0x8,%rdx
mulsd  (%rcx),%xmm0
add    $0x8,%rcx
addsd  %xmm2,%xmm0
mov    0x70(%rsp),%rsi
movapd %xmm0,%xmm2
mov    0x20(%rsp),%ebp
cmpl   $0x0,0x24(%rsp)
je     2a34 <cu_compute_matrix+0x1904>
mov    0xc(%rsp),%edi
sub    %ebp,%edi
xor    %ebp,%ebp
movapd %xmm2,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  (%rdx,%rbp,8),%xmm2
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rsi,%rbp,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rbp
cmp    %ebp,%edi
jne    2af0 <cu_compute_matrix+0x19c0>
jmp    2a34 <cu_compute_matrix+0x1904>
xchg   %ax,%ax
mov    0x180(%rsp),%rax
mov    0x78(%rsp),%rcx
add    %rcx,%rax
imul   0x120(%rsp),%rcx
add    0xe0(%rsp),%rcx
mov    0x1f0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
mov    0x3c(%rsp),%esi
test   %esi,%esi
jle    16f0 <cu_compute_matrix+0x5c0>
mov    0x1e0(%rsp),%ebp
cmp    %ebp,%esi
mov    0x38(%rsp),%r10d
mov    0xa0(%rsp),%r9
mov    0x98(%rsp),%r11
mov    0xbc(%rsp),%ebx
mov    0x78(%rsp),%rax
jge    1718 <cu_compute_matrix+0x5e8>
mov    0x34(%rsp),%edi
test   %edi,%edi
jle    1718 <cu_compute_matrix+0x5e8>
cmp    %ebp,%edi
jge    1718 <cu_compute_matrix+0x5e8>
add    $0xffffffff,%esi
imul   %ebx,%esi
mov    0x64(%rsp),%eax
add    %eax,%esi
add    $0xffffffff,%edi
imul   %ebx,%edi
add    %eax,%edi
add    0xb0(%rsp),%esi
add    0xc4(%rsp),%edi
mov    %edi,%eax
mov    0x200(%rsp),%ecx
imul   %ecx,%eax
add    %esi,%eax
cltq
mov    0x1f0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
imul   %ecx,%esi
add    %edi,%esi
movslq %esi,%rax
movsd  %xmm0,(%rdx,%rax,8)
jmp    1713 <cu_compute_matrix+0x5e3>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x10(%rsp)
lea    0x0(,%rcx,4),%eax
mov    %eax,0xc(%rsp)
lea    (%rcx,%rcx,1),%eax
mov    %rax,0x58(%rsp)
lea    (%rcx,%rcx,2),%eax
mov    %rax,0xb0(%rsp)
xor    %ebx,%ebx
jmp    2c64 <cu_compute_matrix+0x1b34>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x4,%rbx
add    0xc(%rsp),%r14d
cmp    %rbx,0x10(%rsp)
je     14a6 <cu_compute_matrix+0x376>
mov    0x200(%rsp),%r13d
test   %r13d,%r13d
jle    2c50 <cu_compute_matrix+0x1b20>
movslq %r14d,%rax
mov    0x1f0(%rsp),%rbp
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    (%r14,%r13,1),%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x58(%rsp),%rax
add    %r14d,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0xb0(%rsp),%rax
add    %r14d,%eax
cltq
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x98(%rsp),%r11
mov    0xa0(%rsp),%r9
mov    0x38(%rsp),%r10d
jmp    2c50 <cu_compute_matrix+0x1b20>

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

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