#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
void computeGNmatPnt2Pnt(int degU, int degV, double *cpw, double *cp, int ncp,
                         int kcp, double *knotU, double *knotV, double *us,
                         int nus, double *dirOffset, double *cpDir,
                         double *sgnDistDiff, double *HessApprx,
                         double *gradIent, int *matInds, int *derivInds,
                         double *derivVals, double *leftU, double *rightU,
                         double *NU, double *leftV, double *rightV,
                         double *NV) {
  int i, j, ii, twoii, threeii, spanU, spanV, ind, ind2, dind, fourncp, myint,
      numCP, numRows, orderU, orderV, nnz, rowInd, colInd, cpInd;
  double bspnt[4], doubleval;
  fourncp = 4 * ncp;
  orderU = degU + 1;
  orderV = degV + 1;
  nnz = orderU * orderV;
  numCP = ncp * kcp;
  numRows = 2 * (numCP - 4);
  for (ii = 0; ii < nus; ii++) {
    twoii = 2 * ii;
    threeii = 3 * ii;
    spanU = FindSpan(ncp, degU, us[twoii], knotU);
    BasisFuns(spanU, us[twoii], degU, knotU, NU, leftU, rightU);
    ind = spanU - degU;
    spanV = FindSpan(kcp, degV, us[twoii + 1], knotV);
    BasisFuns(spanV, us[twoii + 1], degV, knotV, NV, leftV, rightV);
    ind2 = spanV - degV;
    myint = ind2 * fourncp + ind * 4;
    bspnt[0] = 0.0;
    bspnt[1] = 0.0;
    bspnt[2] = 0.0;
    bspnt[3] = 0.0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        bspnt[0] += NV[i] * NU[j] * cpw[i * fourncp + j * 4 + myint];
        bspnt[1] += NV[i] * NU[j] * cpw[i * fourncp + j * 4 + myint + 1];
        bspnt[2] += NV[i] * NU[j] * cpw[i * fourncp + j * 4 + myint + 2];
        bspnt[3] += NV[i] * NU[j] * cpw[i * fourncp + j * 4 + myint + 3];
      }
    }
    dind = 0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        cpInd = (ind2 + i) * ncp + ind + j;
        derivInds[dind] = cpInd;
        doubleval = NV[i] * NU[j] * cpw[4 * cpInd + 3] / bspnt[3];
        derivVals[6 * dind] = doubleval * cpDir[3 * cpInd];
        derivVals[6 * dind + 1] = doubleval * cpDir[3 * cpInd + 1];
        derivVals[6 * dind + 2] = doubleval * cpDir[3 * cpInd + 2];
        doubleval = NV[i] * NU[j] / (bspnt[3] * bspnt[3]);
        derivVals[6 * dind + 3] =
            doubleval * (bspnt[3] * cp[3 * cpInd] - bspnt[0]);
        derivVals[6 * dind + 4] =
            doubleval * (bspnt[3] * cp[3 * cpInd + 1] - bspnt[1]);
        derivVals[6 * dind + 5] =
            doubleval * (bspnt[3] * cp[3 * cpInd + 2] - bspnt[2]);
        dind++;
      }
    }
    for (i = 0; i < nnz; i++) {
      colInd = matInds[derivInds[i]];
      if (colInd < numCP) {
        gradIent[2 * colInd] +=
            sgnDistDiff[ii] * (dirOffset[threeii] * derivVals[6 * i] +
                               dirOffset[threeii + 1] * derivVals[6 * i + 1] +
                               dirOffset[threeii + 2] * derivVals[6 * i + 2]);
        gradIent[2 * colInd + 1] +=
            sgnDistDiff[ii] * (dirOffset[threeii] * derivVals[6 * i + 3] +
                               dirOffset[threeii + 1] * derivVals[6 * i + 4] +
                               dirOffset[threeii + 2] * derivVals[6 * i + 5]);
        for (j = 0; j < nnz; j++) {
          rowInd = matInds[derivInds[j]];
          if (rowInd < numCP) {
            if (rowInd > colInd) {
              HessApprx[(2 * colInd) * numRows + 2 * rowInd] +=
                  derivVals[6 * i] * derivVals[6 * j] +
                  derivVals[6 * i + 1] * derivVals[6 * j + 1] +
                  derivVals[6 * i + 2] * derivVals[6 * j + 2];
              HessApprx[(2 * colInd) * numRows + 2 * rowInd + 1] +=
                  derivVals[6 * i] * derivVals[6 * j + 3] +
                  derivVals[6 * i + 1] * derivVals[6 * j + 4] +
                  derivVals[6 * i + 2] * derivVals[6 * j + 5];
              HessApprx[(2 * colInd + 1) * numRows + 2 * rowInd] +=
                  derivVals[6 * i + 3] * derivVals[6 * j] +
                  derivVals[6 * i + 4] * derivVals[6 * j + 1] +
                  derivVals[6 * i + 5] * derivVals[6 * j + 2];
              HessApprx[(2 * colInd + 1) * numRows + 2 * rowInd + 1] +=
                  derivVals[6 * i + 3] * derivVals[6 * j + 3] +
                  derivVals[6 * i + 4] * derivVals[6 * j + 4] +
                  derivVals[6 * i + 5] * derivVals[6 * j + 5];
            } else if (rowInd == colInd) {
              HessApprx[(2 * colInd) * numRows + 2 * rowInd] +=
                  derivVals[6 * i] * derivVals[6 * j] +
                  derivVals[6 * i + 1] * derivVals[6 * j + 1] +
                  derivVals[6 * i + 2] * derivVals[6 * j + 2];
              HessApprx[(2 * colInd) * numRows + 2 * rowInd + 1] +=
                  derivVals[6 * i] * derivVals[6 * j + 3] +
                  derivVals[6 * i + 1] * derivVals[6 * j + 4] +
                  derivVals[6 * i + 2] * derivVals[6 * j + 5];
              HessApprx[(2 * colInd + 1) * numRows + 2 * rowInd + 1] +=
                  derivVals[6 * i + 3] * derivVals[6 * j + 3] +
                  derivVals[6 * i + 4] * derivVals[6 * j + 4] +
                  derivVals[6 * i + 5] * derivVals[6 * j + 5];
            }
          }
        }
      }
    }
  }
  for (i = 1; i < numRows; i++) {
    for (j = 0; j < i; j++) {
      HessApprx[i * numRows + j] = HessApprx[j * numRows + i];
    }
  }
}


x86 assembly (clang, -O0):
<computeGNmatPnt2Pnt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
imul   -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x4,%eax
shl    $0x1,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1da2 <computeGNmatPnt2Pnt+0xc82>
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x80(%rbp),%rcx
mov    0x70(%rbp),%r8
mov    0x78(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x38(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edi
mov    0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x98(%rbp),%rcx
mov    0x88(%rbp),%r8
mov    0x90(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x3c(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     147c <computeGNmatPnt2Pnt+0x35c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1469 <computeGNmatPnt2Pnt+0x349>
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12fa <computeGNmatPnt2Pnt+0x1da>
jmp    146e <computeGNmatPnt2Pnt+0x34e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e7 <computeGNmatPnt2Pnt+0x1c7>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1704 <computeGNmatPnt2Pnt+0x5e4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16f1 <computeGNmatPnt2Pnt+0x5d1>
mov    -0x44(%rbp),%eax
add    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x40(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%edx
mov    0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
imul   $0x3,-0x70(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x80(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x48(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    149d <computeGNmatPnt2Pnt+0x37d>
jmp    16f6 <computeGNmatPnt2Pnt+0x5d6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    148a <computeGNmatPnt2Pnt+0x36a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1d8f <computeGNmatPnt2Pnt+0xc6f>
mov    0x58(%rbp),%rax
mov    0x60(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1d7c <computeGNmatPnt2Pnt+0xc5c>
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1d77 <computeGNmatPnt2Pnt+0xc57>
mov    0x58(%rbp),%rax
mov    0x60(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1d64 <computeGNmatPnt2Pnt+0xc44>
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jle    1b5f <computeGNmatPnt2Pnt+0xa3f>
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d5f <computeGNmatPnt2Pnt+0xc3f>
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jne    1d5a <computeGNmatPnt2Pnt+0xc3a>
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rbp),%rax
imul   $0x6,-0x24(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   -0x58(%rbp),%ecx
mov    -0x68(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d5f <computeGNmatPnt2Pnt+0xc3f>
jmp    1d64 <computeGNmatPnt2Pnt+0xc44>
jmp    1d69 <computeGNmatPnt2Pnt+0xc49>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    188c <computeGNmatPnt2Pnt+0x76c>
jmp    1d7c <computeGNmatPnt2Pnt+0xc5c>
jmp    1d81 <computeGNmatPnt2Pnt+0xc61>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    170b <computeGNmatPnt2Pnt+0x5eb>
jmp    1d94 <computeGNmatPnt2Pnt+0xc74>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d6 <computeGNmatPnt2Pnt+0xb6>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1e15 <computeGNmatPnt2Pnt+0xcf5>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e02 <computeGNmatPnt2Pnt+0xce2>
mov    0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1dbc <computeGNmatPnt2Pnt+0xc9c>
jmp    1e07 <computeGNmatPnt2Pnt+0xce7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1da9 <computeGNmatPnt2Pnt+0xc89>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeGNmatPnt2Pnt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rcx,0xc0(%rsp)
mov    %rdx,%r15
mov    %rsi,0x40(%rsp)
mov    0x168(%rsp),%eax
mov    %r9d,0x60(%rsp)
mov    %r9d,%ecx
mov    %r8,0x38(%rsp)
imul   %r8d,%ecx
mov    %rcx,0x90(%rsp)
lea    (%rcx,%rcx,1),%edx
add    $0xfffffff8,%edx
mov    %edx,0x18(%rsp)
test   %eax,%eax
jle    1a8b <computeGNmatPnt2Pnt+0x96b>
mov    %edi,%r13d
lea    0x1(%r13),%esi
mov    0x40(%rsp),%rdx
lea    0x1(%rdx),%edi
mov    %eax,%eax
mov    %rax,0xb0(%rsp)
mov    %edi,%eax
mov    %rax,0x70(%rsp)
imul   %esi,%edi
mov    %esi,%ebp
mov    %edi,0x5c(%rsp)
mov    %edi,%eax
lea    0x0(,%r13,4),%esi
neg    %esi
mov    %esi,0x58(%rsp)
neg    %edx
mov    %edx,0x54(%rsp)
mov    %r13d,%edx
neg    %edx
mov    %edx,0x50(%rsp)
mov    %rax,0xe8(%rsp)
add    %rax,%rax
lea    (%rax,%rax,2),%r8
mov    0x1a8(%rsp),%r14
mov    0x38(%rsp),%rax
lea    0x0(,%rax,4),%ecx
mov    %ecx,0x1c(%rsp)
mov    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
lea    0x0(,%rbp,4),%rcx
mov    %rcx,0x98(%rsp)
mov    %eax,%eax
mov    %rax,0xe0(%rsp)
xor    %ebx,%ebx
mov    %r13,0x68(%rsp)
mov    %rbp,0xb8(%rsp)
mov    %r8,0x80(%rsp)
mov    %r15,0xa8(%rsp)
jmp    1254 <computeGNmatPnt2Pnt+0x134>
nopw   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rbx
add    $0x1,%rbx
cmp    0xb0(%rsp),%rbx
mov    0x68(%rsp),%r13
mov    0xa8(%rsp),%r15
je     1a8b <computeGNmatPnt2Pnt+0x96b>
mov    %rbx,0x48(%rsp)
shl    $0x4,%rbx
mov    0x160(%rsp),%r12
movsd  (%r12,%rbx,1),%xmm0
mov    0x38(%rsp),%rdi
mov    %r13d,%esi
mov    0x150(%rsp),%rbp
mov    %rbp,%rdx
call   1040 <FindSpan@plt>
mov    %rax,0x8(%rsp)
movsd  (%r12,%rbx,1),%xmm0
mov    %eax,%edi
mov    %r13d,%esi
mov    %rbp,%rdx
mov    0x1c0(%rsp),%rcx
mov    0x1b0(%rsp),%r8
mov    0x1b8(%rsp),%r9
call   1030 <BasisFuns@plt>
movsd  0x8(%r12,%rbx,1),%xmm0
mov    0x60(%rsp),%edi
mov    0x40(%rsp),%rbp
mov    %ebp,%esi
mov    0x158(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%r12d
mov    0x160(%rsp),%rax
movsd  0x8(%rax,%rbx,1),%xmm0
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x158(%rsp),%rdx
mov    0x1d8(%rsp),%rcx
mov    0x1c8(%rsp),%r8
mov    0x1d0(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x8(%rsp),%r8
mov    %r12,%rcx
test   %ebp,%ebp
movabs $0x600000000,%r12
js     1620 <computeGNmatPnt2Pnt+0x500>
add    0x54(%rsp),%ecx
mov    0x1c(%rsp),%eax
mov    %rcx,0x10(%rsp)
imul   %ecx,%eax
add    0x58(%rsp),%eax
lea    (%rax,%r8,4),%eax
xorpd  %xmm0,%xmm0
xor    %r9d,%r9d
xorpd  %xmm1,%xmm1
mov    0x1c0(%rsp),%r11
mov    0xa0(%rsp),%r10
mov    0x98(%rsp),%rcx
jmp    1382 <computeGNmatPnt2Pnt+0x262>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9
add    %r10,%rax
cmp    0x70(%rsp),%r9
je     1420 <computeGNmatPnt2Pnt+0x300>
test   %r13d,%r13d
js     1370 <computeGNmatPnt2Pnt+0x250>
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm2
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm3
movapd %xmm0,%xmm4
movsd  (%r11,%rdx,2),%xmm0
mulsd  %xmm2,%xmm0
lea    (%rax,%rdx,1),%rsi
movslq %esi,%rsi
lea    0x1(%rsi),%edi
movslq %edi,%rdi
lea    0x2(%rsi),%ebp
movslq %ebp,%rbp
lea    0x3(%rsi),%ebx
movslq %ebx,%rbx
unpcklpd %xmm0,%xmm0
movsd  (%r15,%rbx,8),%xmm5
movhpd (%r15,%rbp,8),%xmm5
movsd  (%r15,%rdi,8),%xmm6
movhpd (%r15,%rsi,8),%xmm6
mulpd  %xmm0,%xmm6
movapd %xmm6,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm4,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    13a0 <computeGNmatPnt2Pnt+0x280>
addpd  %xmm4,%xmm5
addpd  %xmm3,%xmm6
movapd %xmm5,%xmm0
movapd %xmm6,%xmm1
jmp    1370 <computeGNmatPnt2Pnt+0x250>
nopl   (%rax)
cmpl   $0x0,0x40(%rsp)
mov    0x10(%rsp),%rcx
js     1620 <computeGNmatPnt2Pnt+0x500>
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
movapd 0xbb8(%rip),%xmm5
xorpd  %xmm5,%xmm3
xorpd  %xmm5,%xmm1
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
xorpd  %xmm5,%xmm4
add    0x50(%rsp),%r8d
imul   0x38(%rsp),%ecx
add    %r8d,%ecx
lea    0x3(,%rcx,4),%edi
xor    %r11d,%r11d
xor    %edx,%edx
jmp    149b <computeGNmatPnt2Pnt+0x37b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    0x1c(%rsp),%edi
add    0xe0(%rsp),%rcx
cmp    0x70(%rsp),%r11
je     1620 <computeGNmatPnt2Pnt+0x500>
test   %r13d,%r13d
js     1480 <computeGNmatPnt2Pnt+0x360>
movslq %ecx,%rax
shl    $0x3,%rax
lea    (%rax,%rax,2),%r10
mov    0x178(%rsp),%rax
lea    (%rax,%r10,1),%r13
add    0xc0(%rsp),%r10
mov    %edx,0x28(%rsp)
movslq %edx,%rbp
mov    0x1a0(%rsp),%rax
lea    (%rax,%rbp,4),%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
imul   %r12,%rbp
shl    $0x4,%rax
add    %r14,%rax
mov    $0x4,%edx
mov    %rcx,0x10(%rsp)
mov    %edi,0x30(%rsp)
mov    %edi,%ecx
xor    %ebx,%ebx
mov    %r14,%r9
mov    %r12,%r14
mov    0xb8(%rsp),%r12
nopl   (%rax)
mov    0x10(%rsp),%rdi
add    %ebx,%edi
mov    0x8(%rsp),%r8
mov    %edi,(%r8,%rbx,4)
mov    0x1d8(%rsp),%rsi
movsd  (%rsi,%r11,8),%xmm5
mov    0x1c0(%rsp),%r8
mulsd  (%r8,%rbx,8),%xmm5
movslq %ecx,%rcx
mulsd  (%r15,%rcx,8),%xmm5
divsd  %xmm0,%xmm5
movsd  -0x10(%r13,%rdx,4),%xmm6
mulsd  %xmm5,%xmm6
movsd  %xmm6,-0x20(%rax,%rdx,8)
movsd  -0x8(%r13,%rdx,4),%xmm6
mulsd  %xmm5,%xmm6
mov    %rbp,%rdi
sar    $0x1d,%rdi
or     $0x8,%rdi
movsd  %xmm6,(%r9,%rdi,1)
mulsd  0x0(%r13,%rdx,4),%xmm5
movsd  %xmm5,-0x10(%rax,%rdx,8)
movsd  (%rsi,%r11,8),%xmm5
mulsd  (%r8,%rbx,8),%xmm5
divsd  %xmm2,%xmm5
movsd  -0x10(%r10,%rdx,4),%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm5,%xmm6
movsd  %xmm6,-0x8(%rax,%rdx,8)
movsd  -0x8(%r10,%rdx,4),%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm1,%xmm6
mulsd  %xmm5,%xmm6
movsd  %xmm6,(%rax,%rdx,8)
movsd  (%r10,%rdx,4),%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm5,%xmm6
movsd  %xmm6,0x8(%rax,%rdx,8)
add    $0x1,%rbx
add    %r14,%rbp
add    $0x6,%rdx
add    $0x4,%ecx
cmp    %rbx,%r12
jne    1510 <computeGNmatPnt2Pnt+0x3f0>
mov    0x28(%rsp),%edx
add    %ebx,%edx
mov    0x68(%rsp),%r13
mov    %r14,%r12
mov    %r9,%r14
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%edi
jmp    1480 <computeGNmatPnt2Pnt+0x360>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x0,0x5c(%rsp)
mov    0x188(%rsp),%r15
mov    0x80(%rsp),%r8
mov    0x198(%rsp),%rcx
jle    1230 <computeGNmatPnt2Pnt+0x110>
mov    0x48(%rsp),%rax
lea    (%rax,%rax,2),%eax
mov    %eax,%edx
mov    %rdx,0xd0(%rsp)
lea    0x1(%rax),%edx
mov    %rdx,0xc8(%rsp)
add    $0x2,%eax
mov    %rax,0xd8(%rsp)
xor    %edx,%edx
jmp    1687 <computeGNmatPnt2Pnt+0x567>
nop
mov    0x78(%rsp),%rdx
add    $0x1,%rdx
cmp    0xe8(%rsp),%rdx
je     1230 <computeGNmatPnt2Pnt+0x110>
mov    0x1a0(%rsp),%rax
mov    %rdx,0x78(%rsp)
movslq (%rax,%rdx,4),%rax
movslq (%rcx,%rax,4),%rdx
cmp    0x90(%rsp),%edx
jge    1670 <computeGNmatPnt2Pnt+0x550>
mov    0x78(%rsp),%rax
add    %eax,%eax
lea    (%rax,%rax,2),%r11d
mov    0x170(%rsp),%r13
mov    %rdx,0x20(%rsp)
mov    0xc8(%rsp),%r9
movsd  0x0(%r13,%r9,8),%xmm0
mov    %r11d,%eax
or     $0x1,%eax
mov    %rax,0x8(%rsp)
mulsd  (%r14,%rax,8),%xmm0
mov    0xd0(%rsp),%rbx
movsd  0x0(%r13,%rbx,8),%xmm1
mulsd  (%r14,%r11,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xd8(%rsp),%r12
movsd  0x0(%r13,%r12,8),%xmm0
lea    0x2(%r11),%rax
mov    %rax,0x30(%rsp)
mulsd  0x10(%r14,%r11,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rsp),%rax
lea    (%rax,%rax,1),%rsi
mov    0x20(%rsp),%rax
mov    0x180(%rsp),%rdx
mov    0x48(%rsp),%rbp
mulsd  (%rdx,%rbp,8),%xmm0
shl    $0x4,%rax
mov    0x190(%rsp),%rdx
addsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,(%rdx,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
lea    0x3(%r11),%rbx
movsd  0x0(%r13,%r9,8),%xmm1
mov    0x20(%rsp),%r9
lea    0x4(%r11),%rax
mov    %rax,0x88(%rsp)
mulsd  0x20(%r14,%r11,8),%xmm1
mulsd  0x18(%r14,%r11,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x28(%r14,%r11,8),%xmm1
mov    %r11,0x28(%rsp)
lea    0x5(%r11),%r10
addsd  %xmm0,%xmm1
lea    0x1(%rsi),%eax
movslq %eax,%rdi
mov    0x180(%rsp),%rax
mulsd  (%rax,%rbp,8),%xmm1
addsd  (%rdx,%rdi,8),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
mov    %esi,%edx
mov    0x18(%rsp),%eax
imul   %eax,%edx
imul   %eax,%edi
lea    (%rsi,%rdx,1),%eax
cltq
mov    %rax,0xf0(%rsp)
mov    %rdx,0x108(%rsp)
lea    (%rsi,%rdx,1),%eax
add    $0x1,%eax
mov    %eax,0x64(%rsp)
mov    %rdi,0x110(%rsp)
add    %edi,%esi
mov    %rsi,0xf8(%rsp)
mov    0x1a0(%rsp),%r12
xor    %r13d,%r13d
mov    %r10,0x100(%rsp)
jmp    19b6 <computeGNmatPnt2Pnt+0x896>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdi
movsd  (%r14,%rdi,8),%xmm0
mov    %rbx,%r8
mov    %r13d,%eax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm1
lea    0x1(%r13),%r11d
mulsd  (%r14,%r11,8),%xmm1
mulsd  (%r14,%rax,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rsp),%rdx
movsd  (%r14,%rdx,8),%xmm1
lea    0x2(%r13),%r10d
mulsd  (%r14,%r10,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x108(%rsp),%rax
lea    (%rax,%rbp,2),%eax
movslq %eax,%rsi
addsd  (%r15,%rsi,8),%xmm1
movsd  %xmm1,(%r15,%rsi,8)
movsd  (%r14,%rdi,8),%xmm0
lea    0x3(%r13),%eax
movsd  (%r14,%rcx,8),%xmm1
lea    0x4(%r13),%r9d
mulsd  (%r14,%r9,8),%xmm1
mulsd  (%r14,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14,%rdx,8),%xmm1
lea    0x5(%r13),%edx
mulsd  (%r14,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
or     $0x1,%esi
movslq %esi,%rsi
mov    0x188(%rsp),%rdi
addsd  (%rdi,%rsi,8),%xmm1
mov    0x188(%rsp),%rdi
movsd  %xmm1,(%rdi,%rsi,8)
mov    0x88(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm0
mulsd  (%r14,%r11,8),%xmm0
movsd  (%r14,%rbx,8),%xmm1
mov    0x10(%rsp),%rsi
mulsd  (%r14,%rsi,8),%xmm1
lea    (%r14,%rax,8),%r11
lea    (%r14,%r9,8),%rsi
mov    0x20(%rsp),%r9
mov    0x188(%rsp),%r15
mov    %rcx,%rdi
lea    (%r14,%rdx,8),%rax
addsd  %xmm0,%xmm1
mov    0x100(%rsp),%rcx
movsd  (%r14,%rcx,8),%xmm0
mulsd  (%r14,%r10,8),%xmm0
mov    %rcx,%r10
mov    0x198(%rsp),%rcx
mov    0x80(%rsp),%r8
addsd  %xmm1,%xmm0
mov    0x110(%rsp),%rdx
lea    (%rdx,%rbp,2),%edx
mov    %edx,%ebp
movslq %edx,%rdx
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r14,%rbx,8),%xmm0
movsd  (%r14,%rdi,8),%xmm1
mulsd  (%rsi),%xmm1
mulsd  (%r11),%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14,%r10,8),%xmm1
mulsd  (%rax),%xmm1
addsd  %xmm0,%xmm1
or     $0x1,%ebp
movslq %ebp,%rax
addsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x6,%r13
add    $0x4,%r12
cmp    %r13,%r8
je     1670 <computeGNmatPnt2Pnt+0x550>
movslq (%r12),%rax
mov    (%rcx,%rax,4),%ebp
cmp    0x90(%rsp),%ebp
jge    19a5 <computeGNmatPnt2Pnt+0x885>
cmp    %r9d,%ebp
jg     1820 <computeGNmatPnt2Pnt+0x700>
cmp    %r9d,%ebp
jne    19a5 <computeGNmatPnt2Pnt+0x885>
mov    0x28(%rsp),%rdi
movsd  (%r14,%rdi,8),%xmm0
mov    %r13d,%eax
mov    0x8(%rsp),%rsi
movsd  (%r14,%rsi,8),%xmm1
lea    0x1(%r13),%edx
mulsd  (%r14,%rdx,8),%xmm1
mulsd  (%r14,%rax,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rsp),%rbp
movsd  (%r14,%rbp,8),%xmm1
lea    0x2(%r13),%eax
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xf0(%rsp),%rax
addsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  (%r14,%rdi,8),%xmm1
lea    0x3(%r13),%eax
lea    (%r14,%rax,8),%r11
movsd  (%r14,%rsi,8),%xmm0
lea    0x4(%r13),%edx
mulsd  (%r14,%rdx,8),%xmm0
mulsd  (%r14,%rax,8),%xmm1
lea    (%r14,%rdx,8),%rsi
addsd  %xmm0,%xmm1
movsd  (%r14,%rbp,8),%xmm0
lea    0x5(%r13),%edx
lea    (%r14,%rdx,8),%rax
mulsd  (%r14,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x64(%rsp),%edx
mov    0xf8(%rsp),%rbp
mov    0x88(%rsp),%rdi
jmp    195d <computeGNmatPnt2Pnt+0x83d>
mov    0x18(%rsp),%eax
cmp    $0x2,%eax
jl     1b65 <computeGNmatPnt2Pnt+0xa45>
mov    %eax,%r9d
mov    0x188(%rsp),%rax
lea    (%rax,%r9,8),%rcx
add    $0x8,%rcx
mov    %r9,%r14
shl    $0x4,%r14
lea    0x0(,%r9,8),%r8
lea    0x8(%rax),%rdi
mov    $0x1,%r11d
xor    %r10d,%r10d
mov    %rcx,%rsi
jmp    1ae8 <computeGNmatPnt2Pnt+0x9c8>
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x1,%r10
add    $0x8,%rsi
add    %r8,%rcx
add    $0x8,%rdi
cmp    %r9,%r11
je     1b65 <computeGNmatPnt2Pnt+0xa45>
test   %r10,%r10
je     1b30 <computeGNmatPnt2Pnt+0xa10>
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x2,%rdx
add    %r14,%rbx
cmp    %rdx,%rbp
jne    1b00 <computeGNmatPnt2Pnt+0x9e0>
test   $0x1,%r11b
je     1ad0 <computeGNmatPnt2Pnt+0x9b0>
jmp    1b38 <computeGNmatPnt2Pnt+0xa18>
nopl   0x0(%rax)
xor    %edx,%edx
test   $0x1,%r11b
je     1ad0 <computeGNmatPnt2Pnt+0x9b0>
mov    %r11,%rbx
imul   %r9,%rbx
mov    %rdx,%rax
imul   %r9,%rax
add    %r11,%rax
mov    0x188(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
add    %rdx,%rbx
movsd  %xmm0,0x0(%rbp,%rbx,8)
jmp    1ad0 <computeGNmatPnt2Pnt+0x9b0>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @computeGNmatPnt2Pnt(i32 %0, i32 %1, double* nocapture %2, double* nocapture %3, i32 %4, i32 %5, double* %6, double* %7, double* nocapture %8, i32 %9, double* nocapture %10, double* nocapture %11, double* nocapture %12, double* nocapture %13, double* nocapture %14, i32* nocapture %15, i32* nocapture %16, double* %17, double* %18, double* %19, double* %20, double* %21, double* %22, double* %23) {
%25 = shl nsw i32 %4, 2
%26 = add i32 %0, 1
%27 = add i32 %1, 1
%28 = mul i32 %27, %26
%29 = mul nsw i32 %5, %4
%30 = shl i32 %29, 1
%31 = add i32 %30, -8
%32 = icmp sgt i32 %9, 0
br i1 %32, label %33, label %43
33: ; preds = %24
%34 = icmp slt i32 %1, 0
%35 = icmp slt i32 %0, 0
%36 = icmp sgt i32 %28, 0
%37 = zext i32 %9 to i64
%38 = zext i32 %27 to i64
%39 = zext i32 %26 to i64
%40 = zext i32 %27 to i64
%41 = zext i32 %26 to i64
%42 = zext i32 %28 to i64
br label %48
43: ; preds = %424, %24
%44 = icmp sgt i32 %31, 1
br i1 %44, label %45, label %468
45: ; preds = %43
%46 = zext i32 %31 to i64
%47 = zext i32 %31 to i64
br label %427
48: ; preds = %33, %424
%49 = phi i64 [ 0, %33 ], [ %425, %424 ]
%50 = shl nuw nsw i64 %49, 1
%51 = trunc i64 %49 to i32
%52 = mul nsw i32 %51, 3
%53 = getelementptr inbounds double, double* %8, i64 %50
%54 = load double, double* %53
%55 = tail call i32 @FindSpan(i32 %4, i32 %0, double %54, double* %6)
%56 = load double, double* %53
%57 = tail call i32 @BasisFuns(i32 %55, double %56, i32 %0, double* %6, double* %20, double* %18, double* %19)
%58 = sub nsw i32 %55, %0
%59 = or i64 %50, 1
%60 = getelementptr inbounds double, double* %8, i64 %59
%61 = load double, double* %60
%62 = tail call i32 @FindSpan(i32 %5, i32 %1, double %61, double* %7)
%63 = load double, double* %60
%64 = tail call i32 @BasisFuns(i32 %62, double %63, i32 %1, double* %7, double* %23, double* %21, double* %22)
%65 = sub nsw i32 %62, %1
br i1 %34, label %125, label %76
66: ; preds = %121
br i1 %34, label %125, label %67
67: ; preds = %66
%68 = extractelement <4 x double> %122, i64 0
%69 = fmul double %68, %68
%70 = extractelement <4 x double> %122, i64 3
%71 = fneg double %70
%72 = extractelement <4 x double> %122, i64 2
%73 = fneg double %72
%74 = extractelement <4 x double> %122, i64 1
%75 = fneg double %74
br label %136
76: ; preds = %48, %121
%77 = phi i64 [ %123, %121 ], [ 0, %48 ]
%78 = phi <4 x double> [ %122, %121 ], [ zeroinitializer, %48 ]
br i1 %35, label %121, label %79
79: ; preds = %76
%80 = getelementptr inbounds double, double* %23, i64 %77
%81 = load double, double* %80
%82 = trunc i64 %77 to i32
%83 = add i32 %65, %82
%84 = mul i32 %83, %25
br label %85
85: ; preds = %79, %85
%86 = phi i64 [ 0, %79 ], [ %117, %85 ]
%87 = phi <4 x double> [ %78, %79 ], [ %116, %85 ]
%88 = getelementptr inbounds double, double* %20, i64 %86
%89 = load double, double* %88
%90 = fmul double %81, %89
%91 = trunc i64 %86 to i32
%92 = add i32 %58, %91
%93 = shl i32 %92, 2
%94 = add i32 %93, %84
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %2, i64 %95
%97 = load double, double* %96
%98 = or i32 %94, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %2, i64 %99
%101 = load double, double* %100
%102 = or i32 %94, 2
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %2, i64 %103
%105 = load double, double* %104
%106 = or i32 %94, 3
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %2, i64 %107
%109 = load double, double* %108
%110 = insertelement <4 x double> poison, double %90, i64 0
%111 = shufflevector <4 x double> %110, <4 x double> poison, <4 x i32> zeroinitializer
%112 = insertelement <4 x double> poison, double %109, i64 0
%113 = insertelement <4 x double> %112, double %105, i64 1
%114 = insertelement <4 x double> %113, double %101, i64 2
%115 = insertelement <4 x double> %114, double %97, i64 3
%116 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %111, <4 x double> %115, <4 x double> %87)
%117 = add nuw nsw i64 %86, 1
%118 = icmp eq i64 %117, %39
br i1 %118, label %119, label %85
119: ; preds = %85
%120 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %111, <4 x double> %115, <4 x double> %87)
br label %121
121: ; preds = %119, %76
%122 = phi <4 x double> [ %78, %76 ], [ %120, %119 ]
%123 = add nuw nsw i64 %77, 1
%124 = icmp eq i64 %123, %38
br i1 %124, label %66, label %76
125: ; preds = %213, %48, %66
br i1 %36, label %126, label %424
126: ; preds = %125
%127 = getelementptr inbounds double, double* %12, i64 %49
%128 = zext i32 %52 to i64
%129 = getelementptr inbounds double, double* %10, i64 %128
%130 = add nuw nsw i32 %52, 1
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds double, double* %10, i64 %131
%133 = add nuw nsw i32 %52, 2
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds double, double* %10, i64 %134
br label %217
136: ; preds = %67, %213
%137 = phi i64 [ 0, %67 ], [ %215, %213 ]
%138 = phi i32 [ 0, %67 ], [ %214, %213 ]
br i1 %35, label %213, label %139
139: ; preds = %136
%140 = trunc i64 %137 to i32
%141 = add nsw i32 %65, %140
%142 = mul nsw i32 %141, %4
%143 = add nsw i32 %142, %58
%144 = getelementptr inbounds double, double* %23, i64 %137
%145 = sext i32 %143 to i64
%146 = sext i32 %138 to i64
br label %147
147: ; preds = %139, %147
%148 = phi i64 [ %146, %139 ], [ %208, %147 ]
%149 = phi i64 [ 0, %139 ], [ %209, %147 ]
%150 = trunc i64 %149 to i32
%151 = add nsw i64 %149, %145
%152 = add nsw i32 %143, %150
%153 = getelementptr inbounds i32, i32* %16, i64 %148
%154 = trunc i64 %151 to i32
store i32 %154, i32* %153
%155 = load double, double* %144
%156 = getelementptr inbounds double, double* %20, i64 %149
%157 = load double, double* %156
%158 = fmul double %155, %157
%159 = shl nsw i32 %152, 2
%160 = or i32 %159, 3
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %2, i64 %161
%163 = load double, double* %162
%164 = fmul double %158, %163
%165 = fdiv double %164, %68
%166 = mul nsw i64 %151, 3
%167 = getelementptr inbounds double, double* %11, i64 %166
%168 = load double, double* %167
%169 = fmul double %168, %165
%170 = mul nsw i64 %148, 6
%171 = getelementptr inbounds double, double* %17, i64 %170
store double %169, double* %171
%172 = add nsw i64 %166, 1
%173 = getelementptr inbounds double, double* %11, i64 %172
%174 = load double, double* %173
%175 = fmul double %165, %174
%176 = mul i64 %148, 25769803776
%177 = ashr exact i64 %176, 32
%178 = or i64 %177, 1
%179 = getelementptr inbounds double, double* %17, i64 %178
store double %175, double* %179
%180 = add nsw i64 %166, 2
%181 = getelementptr inbounds double, double* %11, i64 %180
%182 = load double, double* %181
%183 = fmul double %165, %182
%184 = add nsw i64 %170, 2
%185 = getelementptr inbounds double, double* %17, i64 %184
store double %183, double* %185
%186 = load double, double* %144
%187 = load double, double* %156
%188 = fmul double %186, %187
%189 = fdiv double %188, %69
%190 = getelementptr inbounds double, double* %3, i64 %166
%191 = load double, double* %190
%192 = tail call double @llvm.fmuladd.f64(double %68, double %191, double %71)
%193 = fmul double %189, %192
%194 = add nsw i64 %170, 3
%195 = getelementptr inbounds double, double* %17, i64 %194
store double %193, double* %195
%196 = getelementptr inbounds double, double* %3, i64 %172
%197 = load double, double* %196
%198 = tail call double @llvm.fmuladd.f64(double %68, double %197, double %73)
%199 = fmul double %189, %198
%200 = add nsw i64 %170, 4
%201 = getelementptr inbounds double, double* %17, i64 %200
store double %199, double* %201
%202 = getelementptr inbounds double, double* %3, i64 %180
%203 = load double, double* %202
%204 = tail call double @llvm.fmuladd.f64(double %68, double %203, double %75)
%205 = fmul double %189, %204
%206 = add nsw i64 %170, 5
%207 = getelementptr inbounds double, double* %17, i64 %206
store double %205, double* %207
%208 = add nsw i64 %148, 1
%209 = add nuw nsw i64 %149, 1
%210 = icmp eq i64 %209, %41
br i1 %210, label %211, label %147
211: ; preds = %147
%212 = trunc i64 %208 to i32
br label %213
213: ; preds = %211, %136
%214 = phi i32 [ %138, %136 ], [ %212, %211 ]
%215 = add nuw nsw i64 %137, 1
%216 = icmp eq i64 %215, %40
br i1 %216, label %125, label %136
217: ; preds = %126, %421
%218 = phi i64 [ 0, %126 ], [ %422, %421 ]
%219 = getelementptr inbounds i32, i32* %16, i64 %218
%220 = load i32, i32* %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %15, i64 %221
%223 = load i32, i32* %222
%224 = icmp slt i32 %223, %29
br i1 %224, label %225, label %421
225: ; preds = %217
%226 = load double, double* %127
%227 = load double, double* %129
%228 = trunc i64 %218 to i32
%229 = mul nsw i32 %228, 6
%230 = zext i32 %229 to i64
%231 = getelementptr inbounds double, double* %17, i64 %230
%232 = load double, double* %231
%233 = load double, double* %132
%234 = or i32 %229, 1
%235 = zext i32 %234 to i64
%236 = getelementptr inbounds double, double* %17, i64 %235
%237 = load double, double* %236
%238 = fmul double %233, %237
%239 = tail call double @llvm.fmuladd.f64(double %227, double %232, double %238)
%240 = load double, double* %135
%241 = add nuw nsw i32 %229, 2
%242 = zext i32 %241 to i64
%243 = getelementptr inbounds double, double* %17, i64 %242
%244 = load double, double* %243
%245 = tail call double @llvm.fmuladd.f64(double %240, double %244, double %239)
%246 = shl nsw i32 %223, 1
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %14, i64 %247
%249 = load double, double* %248
%250 = tail call double @llvm.fmuladd.f64(double %226, double %245, double %249)
store double %250, double* %248
%251 = load double, double* %127
%252 = load double, double* %129
%253 = add nuw nsw i32 %229, 3
%254 = zext i32 %253 to i64
%255 = getelementptr inbounds double, double* %17, i64 %254
%256 = load double, double* %255
%257 = load double, double* %132
%258 = add nuw nsw i32 %229, 4
%259 = zext i32 %258 to i64
%260 = getelementptr inbounds double, double* %17, i64 %259
%261 = load double, double* %260
%262 = fmul double %257, %261
%263 = tail call double @llvm.fmuladd.f64(double %252, double %256, double %262)
%264 = load double, double* %135
%265 = add nuw nsw i32 %229, 5
%266 = zext i32 %265 to i64
%267 = getelementptr inbounds double, double* %17, i64 %266
%268 = load double, double* %267
%269 = tail call double @llvm.fmuladd.f64(double %264, double %268, double %263)
%270 = or i32 %246, 1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %14, i64 %271
%273 = load double, double* %272
%274 = tail call double @llvm.fmuladd.f64(double %251, double %269, double %273)
store double %274, double* %272
%275 = mul nsw i32 %246, %31
%276 = mul nsw i32 %270, %31
%277 = add nsw i32 %246, %275
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %13, i64 %278
%280 = or i32 %277, 1
%281 = add nsw i32 %246, %276
br label %282
282: ; preds = %225, %418
%283 = phi i64 [ 0, %225 ], [ %419, %418 ]
%284 = getelementptr inbounds i32, i32* %16, i64 %283
%285 = load i32, i32* %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i32, i32* %15, i64 %286
%288 = load i32, i32* %287
%289 = icmp slt i32 %288, %29
br i1 %289, label %290, label %418
290: ; preds = %282
%291 = icmp sgt i32 %288, %223
br i1 %291, label %292, label %351
292: ; preds = %290
%293 = load double, double* %231
%294 = trunc i64 %283 to i32
%295 = mul nsw i32 %294, 6
%296 = zext i32 %295 to i64
%297 = getelementptr inbounds double, double* %17, i64 %296
%298 = load double, double* %297
%299 = load double, double* %236
%300 = or i32 %295, 1
%301 = zext i32 %300 to i64
%302 = getelementptr inbounds double, double* %17, i64 %301
%303 = load double, double* %302
%304 = fmul double %299, %303
%305 = tail call double @llvm.fmuladd.f64(double %293, double %298, double %304)
%306 = load double, double* %243
%307 = add nuw nsw i32 %295, 2
%308 = zext i32 %307 to i64
%309 = getelementptr inbounds double, double* %17, i64 %308
%310 = load double, double* %309
%311 = tail call double @llvm.fmuladd.f64(double %306, double %310, double %305)
%312 = shl nsw i32 %288, 1
%313 = add nsw i32 %312, %275
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %13, i64 %314
%316 = load double, double* %315
%317 = fadd double %316, %311
store double %317, double* %315
%318 = load double, double* %231
%319 = add nuw nsw i32 %295, 3
%320 = zext i32 %319 to i64
%321 = getelementptr inbounds double, double* %17, i64 %320
%322 = load double, double* %321
%323 = load double, double* %236
%324 = add nuw nsw i32 %295, 4
%325 = zext i32 %324 to i64
%326 = getelementptr inbounds double, double* %17, i64 %325
%327 = load double, double* %326
%328 = fmul double %323, %327
%329 = tail call double @llvm.fmuladd.f64(double %318, double %322, double %328)
%330 = load double, double* %243
%331 = add nuw nsw i32 %295, 5
%332 = zext i32 %331 to i64
%333 = getelementptr inbounds double, double* %17, i64 %332
%334 = load double, double* %333
%335 = tail call double @llvm.fmuladd.f64(double %330, double %334, double %329)
%336 = or i32 %313, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %13, i64 %337
%339 = load double, double* %338
%340 = fadd double %339, %335
store double %340, double* %338
%341 = load double, double* %255
%342 = load double, double* %297
%343 = load double, double* %260
%344 = load double, double* %302
%345 = fmul double %343, %344
%346 = tail call double @llvm.fmuladd.f64(double %341, double %342, double %345)
%347 = load double, double* %267
%348 = load double, double* %309
%349 = tail call double @llvm.fmuladd.f64(double %347, double %348, double %346)
%350 = add nsw i32 %312, %276
br label %393
351: ; preds = %290
%352 = icmp eq i32 %288, %223
br i1 %352, label %353, label %418
353: ; preds = %351
%354 = load double, double* %231
%355 = trunc i64 %283 to i32
%356 = mul nsw i32 %355, 6
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds double, double* %17, i64 %357
%359 = load double, double* %358
%360 = load double, double* %236
%361 = or i32 %356, 1
%362 = zext i32 %361 to i64
%363 = getelementptr inbounds double, double* %17, i64 %362
%364 = load double, double* %363
%365 = fmul double %360, %364
%366 = tail call double @llvm.fmuladd.f64(double %354, double %359, double %365)
%367 = load double, double* %243
%368 = add nuw nsw i32 %356, 2
%369 = zext i32 %368 to i64
%370 = getelementptr inbounds double, double* %17, i64 %369
%371 = load double, double* %370
%372 = tail call double @llvm.fmuladd.f64(double %367, double %371, double %366)
%373 = load double, double* %279
%374 = fadd double %373, %372
store double %374, double* %279
%375 = load double, double* %231
%376 = add nuw nsw i32 %356, 3
%377 = zext i32 %376 to i64
%378 = getelementptr inbounds double, double* %17, i64 %377
%379 = load double, double* %378
%380 = load double, double* %236
%381 = add nuw nsw i32 %356, 4
%382 = zext i32 %381 to i64
%383 = getelementptr inbounds double, double* %17, i64 %382
%384 = load double, double* %383
%385 = fmul double %380, %384
%386 = tail call double @llvm.fmuladd.f64(double %375, double %379, double %385)
%387 = load double, double* %243
%388 = add nuw nsw i32 %356, 5
%389 = zext i32 %388 to i64
%390 = getelementptr inbounds double, double* %17, i64 %389
%391 = load double, double* %390
%392 = tail call double @llvm.fmuladd.f64(double %387, double %391, double %386)
br label %393
393: ; preds = %292, %353
%394 = phi i32 [ %350, %292 ], [ %280, %353 ]
%395 = phi double [ %349, %292 ], [ %392, %353 ]
%396 = phi double* [ %321, %292 ], [ %378, %353 ]
%397 = phi double* [ %326, %292 ], [ %383, %353 ]
%398 = phi double* [ %333, %292 ], [ %390, %353 ]
%399 = phi i32 [ %350, %292 ], [ %281, %353 ]
%400 = sext i32 %394 to i64
%401 = getelementptr inbounds double, double* %13, i64 %400
%402 = load double, double* %401
%403 = fadd double %402, %395
store double %403, double* %401
%404 = load double, double* %255
%405 = load double, double* %396
%406 = load double, double* %260
%407 = load double, double* %397
%408 = fmul double %406, %407
%409 = tail call double @llvm.fmuladd.f64(double %404, double %405, double %408)
%410 = load double, double* %267
%411 = load double, double* %398
%412 = tail call double @llvm.fmuladd.f64(double %410, double %411, double %409)
%413 = or i32 %399, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %13, i64 %414
%416 = load double, double* %415
%417 = fadd double %416, %412
store double %417, double* %415
br label %418
418: ; preds = %393, %282, %351
%419 = add nuw nsw i64 %283, 1
%420 = icmp eq i64 %419, %42
br i1 %420, label %421, label %282
421: ; preds = %418, %217
%422 = add nuw nsw i64 %218, 1
%423 = icmp eq i64 %422, %42
br i1 %423, label %424, label %217
424: ; preds = %421, %125
%425 = add nuw nsw i64 %49, 1
%426 = icmp eq i64 %425, %37
br i1 %426, label %43, label %48
427: ; preds = %45, %464
%428 = phi i64 [ 0, %45 ], [ %467, %464 ]
%429 = phi i64 [ 1, %45 ], [ %465, %464 ]
%430 = mul nsw i64 %429, %46
%431 = and i64 %429, 1
%432 = icmp eq i64 %428, 0
br i1 %432, label %454, label %433
433: ; preds = %427
%434 = and i64 %429, 9223372036854775806
br label %435
435: ; preds = %435, %433
%436 = phi i64 [ 0, %433 ], [ %451, %435 ]
%437 = phi i64 [ 0, %433 ], [ %452, %435 ]
%438 = mul nsw i64 %436, %46
%439 = add nuw nsw i64 %438, %429
%440 = getelementptr inbounds double, double* %13, i64 %439
%441 = load double, double* %440
%442 = add nuw nsw i64 %436, %430
%443 = getelementptr inbounds double, double* %13, i64 %442
store double %441, double* %443
%444 = or i64 %436, 1
%445 = mul nsw i64 %444, %46
%446 = add nuw nsw i64 %445, %429
%447 = getelementptr inbounds double, double* %13, i64 %446
%448 = load double, double* %447
%449 = add nuw nsw i64 %444, %430
%450 = getelementptr inbounds double, double* %13, i64 %449
store double %448, double* %450
%451 = add nuw nsw i64 %436, 2
%452 = add i64 %437, 2
%453 = icmp eq i64 %452, %434
br i1 %453, label %454, label %435
454: ; preds = %435, %427
%455 = phi i64 [ 0, %427 ], [ %451, %435 ]
%456 = icmp eq i64 %431, 0
br i1 %456, label %464, label %457
457: ; preds = %454
%458 = mul nsw i64 %455, %46
%459 = add nuw nsw i64 %458, %429
%460 = getelementptr inbounds double, double* %13, i64 %459
%461 = load double, double* %460
%462 = add nuw nsw i64 %455, %430
%463 = getelementptr inbounds double, double* %13, i64 %462
store double %461, double* %463
br label %464
464: ; preds = %454, %457
%465 = add nuw nsw i64 %429, 1
%466 = icmp eq i64 %465, %47
%467 = add i64 %428, 1
br i1 %466, label %468, label %427
468: ; preds = %464, %43
ret void
}