#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 *);
int fabs(double);
void findNURBSbasisFunIso4xScCP(int ii, int jj, double a1, double b1, int iters,
                                double *us, double stepU, double stepV,
                                int degU, int degV, double *cp, int ncp,
                                int kcp, double *knotU, double *knotV,
                                double *usX1max, double *basisVals,
                                double *leftU, double *rightU, double *NU,
                                double *leftV, double *rightV, double *NV) {
  int itr, itr2, i, j, spanU, spanV, ind, ind2, fourncp, myint, numCP, cpInd1,
      cpInd2, cpInd3, cpInd4, uvInd1, uvInd2, uvInd3, uvInd4, bvind1, bvind2,
      bvind3, bvind4;
  double wgh, u, v, funVal, oldFunVal, a2, b2, p1, p2, f1, f2;
  a2 = 1.0 - a1;
  b2 = 1.0 - b1;
  bvind1 = ii * ncp + jj;
  bvind2 = bvind1 + 1;
  bvind3 = bvind1 + ncp;
  bvind4 = bvind3 + 1;
  uvInd1 = ii * 2 * ncp + 2 * jj;
  uvInd2 = uvInd1 + 2;
  uvInd3 = uvInd1 + 2 * ncp;
  uvInd4 = uvInd3 + 2;
  fourncp = 4 * ncp;
  numCP = ncp * kcp;
  cpInd1 = ii * fourncp + 4 * jj + 3;
  cpInd2 = cpInd1 + 4;
  cpInd3 = cpInd1 + fourncp;
  cpInd4 = cpInd3 + 4;
  for (itr2 = 0; itr2 < 2; itr2++) {
    v = us[1];
    spanV = FindSpan(kcp, degV, v, knotV);
    BasisFuns(spanV, v, degV, knotV, NV, leftV, rightV);
    ind2 = spanV - degV;
    u = us[0];
    spanU = FindSpan(ncp, degU, u, knotU);
    BasisFuns(spanU, u, degU, knotU, NU, leftU, rightU);
    ind = spanU - degU;
    myint = ind2 * fourncp + ind * 4 + 3;
    p1 = ((v - usX1max[uvInd1 + 1]) * usX1max[uvInd3] +
          (usX1max[uvInd3 + 1] - v) * usX1max[uvInd1]) /
         (usX1max[uvInd3 + 1] - usX1max[uvInd1 + 1]);
    p2 = ((v - usX1max[uvInd2 + 1]) * usX1max[uvInd4] +
          (usX1max[uvInd4 + 1] - v) * usX1max[uvInd2]) /
         (usX1max[uvInd4 + 1] - usX1max[uvInd2 + 1]);
    f1 = b2 * (a2 * basisVals[numCP * bvind1 + bvind2] +
               a1 * basisVals[numCP * bvind3 + bvind4]);
    f2 = b1 * (a2 * basisVals[numCP * bvind2 + bvind1] +
               a1 * basisVals[numCP * bvind4 + bvind3]);
    wgh = 0.0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        wgh += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint];
      }
    }
    oldFunVal =
        (b2 * (a2 * NV[ii - ind2] * NU[jj - ind] * cp[cpInd1] +
               a1 * NV[ii + 1 - ind2] * NU[jj - ind] * cp[cpInd3]) -
         b1 * (a2 * NV[ii - ind2] * NU[jj + 1 - ind] * cp[cpInd2] +
               a1 * NV[ii + 1 - ind2] * NU[jj + 1 - ind] * cp[cpInd4])) /
            wgh -
        ((u - p1) * f1 - (p2 - u) * f2) / (p2 - p1);
    for (itr = 0; itr < iters; itr++) {
      if (fabs(oldFunVal) < 1e-6) {
        break;
      }
      if (oldFunVal > 0) {
        u += stepU;
      } else {
        u -= stepU;
      }
      stepU = 0.5 * stepU;
      spanU = FindSpan(ncp, degU, u, knotU);
      BasisFuns(spanU, u, degU, knotU, NU, leftU, rightU);
      ind = spanU - degU;
      myint = ind2 * fourncp + ind * 4 + 3;
      wgh = 0.0;
      for (i = 0; i <= degV; i++) {
        for (j = 0; j <= degU; j++) {
          wgh += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint];
        }
      }
      funVal = (b2 * (a2 * NV[ii - ind2] * NU[jj - ind] * cp[cpInd1] +
                      a1 * NV[ii + 1 - ind2] * NU[jj - ind] * cp[cpInd3]) -
                b1 * (a2 * NV[ii - ind2] * NU[jj + 1 - ind] * cp[cpInd2] +
                      a1 * NV[ii + 1 - ind2] * NU[jj + 1 - ind] * cp[cpInd4])) /
                   wgh -
               ((u - p1) * f1 - (p2 - u) * f2) / (p2 - p1);
      if (fabs(funVal) < fabs(oldFunVal)) {
        oldFunVal = funVal;
        us[0] = u;
      } else {
        u = us[0];
      }
    }
    spanU = FindSpan(ncp, degU, u, knotU);
    BasisFuns(spanU, u, degU, knotU, NU, leftU, rightU);
    ind = spanU - degU;
    myint = ind2 * fourncp + ind * 4 + 3;
    p1 = ((u - usX1max[uvInd1]) * usX1max[uvInd2 + 1] +
          (usX1max[uvInd2] - u) * usX1max[uvInd1 + 1]) /
         (usX1max[uvInd2] - usX1max[uvInd1]);
    p2 = ((u - usX1max[uvInd3]) * usX1max[uvInd4 + 1] +
          (usX1max[uvInd4] - u) * usX1max[uvInd3 + 1]) /
         (usX1max[uvInd4] - usX1max[uvInd3]);
    f1 = a2 * (b2 * basisVals[numCP * bvind1 + bvind3] +
               b1 * basisVals[numCP * bvind2 + bvind4]);
    f2 = a1 * (b2 * basisVals[numCP * bvind3 + bvind1] +
               b1 * basisVals[numCP * bvind4 + bvind2]);
    wgh = 0.0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        wgh += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint];
      }
    }
    oldFunVal =
        (a2 * (b2 * NV[ii - ind2] * NU[jj - ind] * cp[cpInd1] +
               b1 * NV[ii - ind2] * NU[jj + 1 - ind] * cp[cpInd2]) -
         a1 * (b2 * NV[ii + 1 - ind2] * NU[jj - ind] * cp[cpInd3] +
               b1 * NV[ii + 1 - ind2] * NU[jj + 1 - ind] * cp[cpInd4])) /
            wgh -
        ((v - p1) * f1 - (p2 - v) * f2) / (p2 - p1);
    for (itr = 0; itr < iters; itr++) {
      if (fabs(oldFunVal) < 1e-6) {
        break;
      }
      if (oldFunVal > 0) {
        v += stepV;
      } else {
        v -= stepV;
      }
      stepV = 0.5 * stepV;
      spanV = FindSpan(kcp, degV, v, knotV);
      BasisFuns(spanV, v, degV, knotV, NV, leftV, rightV);
      ind2 = spanV - degV;
      myint = ind2 * fourncp + ind * 4 + 3;
      wgh = 0.0;
      for (i = 0; i <= degV; i++) {
        for (j = 0; j <= degU; j++) {
          wgh += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint];
        }
      }
      funVal = (a2 * (b2 * NV[ii - ind2] * NU[jj - ind] * cp[cpInd1] +
                      b1 * NV[ii - ind2] * NU[jj + 1 - ind] * cp[cpInd2]) -
                a1 * (b2 * NV[ii + 1 - ind2] * NU[jj - ind] * cp[cpInd3] +
                      b1 * NV[ii + 1 - ind2] * NU[jj + 1 - ind] * cp[cpInd4])) /
                   wgh -
               ((v - p1) * f1 - (p2 - v) * f2) / (p2 - p1);
      if (fabs(funVal) < fabs(oldFunVal)) {
        oldFunVal = funVal;
        us[1] = v;
      } else {
        v = us[1];
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<findNURBSbasisFunIso4xScCP>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
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),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
movsd  %xmm3,-0x38(%rbp)
mov    %r8d,-0x3c(%rbp)
mov    %r9d,-0x40(%rbp)
movsd  0x1e62(%rip),%xmm0
subsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x1e4d(%rip),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x4(%rbp),%eax
imul   0x18(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x90(%rbp),%eax
add    0x18(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
imul   0x18(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
mov    0x18(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x8c(%rbp)
mov    0x18(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    0x18(%rbp),%eax
imul   0x20(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x2,-0x48(%rbp)
jge    2358 <findNURBSbasisFunIso4xScCP+0x1228>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x20(%rbp),%edi
mov    -0x40(%rbp),%esi
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%edi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x40(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x60(%rbp),%r8
mov    0x68(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x58(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x18(%rbp),%edi
mov    -0x3c(%rbp),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x3c(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x54(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xb8(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xb8(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x10(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x98(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x10(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     15dc <findNURBSbasisFunIso4xScCP+0x4ac>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     15c9 <findNURBSbasisFunIso4xScCP+0x499>
mov    0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x50(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    155f <findNURBSbasisFunIso4xScCP+0x42f>
jmp    15ce <findNURBSbasisFunIso4xScCP+0x49e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    154c <findNURBSbasisFunIso4xScCP+0x41c>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x10(%rbp),%xmm1
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x18(%rbp),%xmm1
movsd  -0xd0(%rbp),%xmm3
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  -0x10(%rbp),%xmm4
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xb0(%rbp),%xmm2
ff
mulsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xe0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b28 <findNURBSbasisFunIso4xScCP+0x9f8>
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x185f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    17b8 <findNURBSbasisFunIso4xScCP+0x688>
jmp    1b28 <findNURBSbasisFunIso4xScCP+0x9f8>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17e7 <findNURBSbasisFunIso4xScCP+0x6b7>
movsd  -0x30(%rbp),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1800 <findNURBSbasisFunIso4xScCP+0x6d0>
movsd  -0x30(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x1808(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    0x18(%rbp),%edi
mov    -0x3c(%rbp),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x3c(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x54(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     190f <findNURBSbasisFunIso4xScCP+0x7df>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     18fc <findNURBSbasisFunIso4xScCP+0x7cc>
mov    0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x50(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1892 <findNURBSbasisFunIso4xScCP+0x762>
jmp    1901 <findNURBSbasisFunIso4xScCP+0x7d1>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    187f <findNURBSbasisFunIso4xScCP+0x74f>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x10(%rbp),%xmm1
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x18(%rbp),%xmm1
movsd  -0xd0(%rbp),%xmm3
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  -0x10(%rbp),%xmm4
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xb0(%rbp),%xmm2
ff
mulsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xe0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <fabs@plt>
mov    %eax,-0xfc(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <fabs@plt>
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
cmp    %ecx,%eax
jge    1b05 <findNURBSbasisFunIso4xScCP+0x9d5>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1b15 <findNURBSbasisFunIso4xScCP+0x9e5>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1b1a <findNURBSbasisFunIso4xScCP+0x9ea>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1784 <findNURBSbasisFunIso4xScCP+0x654>
mov    0x18(%rbp),%edi
mov    -0x3c(%rbp),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x3c(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x54(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xb0(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xb0(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x18(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x94(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x98(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x18(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1df7 <findNURBSbasisFunIso4xScCP+0xcc7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1de4 <findNURBSbasisFunIso4xScCP+0xcb4>
mov    0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x50(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1d7a <findNURBSbasisFunIso4xScCP+0xc4a>
jmp    1de9 <findNURBSbasisFunIso4xScCP+0xcb9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d67 <findNURBSbasisFunIso4xScCP+0xc37>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x18(%rbp),%xmm1
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x10(%rbp),%xmm1
movsd  -0xd8(%rbp),%xmm3
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  -0x18(%rbp),%xmm4
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xb8(%rbp),%xmm2
ff
mulsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xe0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2345 <findNURBSbasisFunIso4xScCP+0x1215>
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x1044(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1fd3 <findNURBSbasisFunIso4xScCP+0xea3>
jmp    2345 <findNURBSbasisFunIso4xScCP+0x1215>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2002 <findNURBSbasisFunIso4xScCP+0xed2>
movsd  -0x38(%rbp),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    201b <findNURBSbasisFunIso4xScCP+0xeeb>
movsd  -0x38(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xfed(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    0x20(%rbp),%edi
mov    -0x40(%rbp),%esi
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%edi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x40(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x60(%rbp),%r8
mov    0x68(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x58(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0x5c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     212a <findNURBSbasisFunIso4xScCP+0xffa>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2117 <findNURBSbasisFunIso4xScCP+0xfe7>
mov    0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x64(%rbp),%ecx
mov    -0x50(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    20ad <findNURBSbasisFunIso4xScCP+0xf7d>
jmp    211c <findNURBSbasisFunIso4xScCP+0xfec>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    209a <findNURBSbasisFunIso4xScCP+0xf6a>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x18(%rbp),%xmm1
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x10(%rbp),%xmm1
movsd  -0xd8(%rbp),%xmm3
ff
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm3
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  -0x18(%rbp),%xmm4
mov    0x70(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm4
mov    0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xb8(%rbp),%xmm2
ff
mulsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0xe0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <fabs@plt>
mov    %eax,-0x100(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <fabs@plt>
mov    %eax,%ecx
mov    -0x100(%rbp),%eax
cmp    %ecx,%eax
jge    2321 <findNURBSbasisFunIso4xScCP+0x11f1>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    2332 <findNURBSbasisFunIso4xScCP+0x1202>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    2337 <findNURBSbasisFunIso4xScCP+0x1207>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f9f <findNURBSbasisFunIso4xScCP+0xe6f>
jmp    234a <findNURBSbasisFunIso4xScCP+0x121a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1288 <findNURBSbasisFunIso4xScCP+0x158>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<findNURBSbasisFunIso4xScCP>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %r9,0x60(%rsp)
mov    %r8d,%r10d
movaps %xmm3,0x1c0(%rsp)
movaps %xmm2,0x1b0(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,0x28(%rsp)
mov    %esi,%r11d
mov    %edi,%r9d
mov    0x260(%rsp),%ecx
mov    0x258(%rsp),%r15d
mov    %r15d,%edx
imul   %edi,%edx
lea    (%rdx,%r11,1),%edi
add    $0x1,%edi
lea    (%r11,%r11,1),%eax
lea    (%rax,%rdx,2),%r13d
lea    0x2(%rax,%rdx,2),%esi
mov    %esi,0x18(%rsp)
lea    0x1(%rax,%rdx,2),%esi
mov    %esi,(%rsp)
lea    (%rax,%rdx,2),%eax
add    $0x3,%eax
mov    %eax,0x8(%rsp)
add    %r11d,%edx
mov    %ecx,%ebx
imul   %r15d,%ebx
lea    (%rdx,%r15,1),%ebp
mov    %ebp,%eax
imul   %ebx,%eax
imul   %ebx,%edi
lea    (%r15,%rdx,1),%ecx
add    $0x1,%ecx
mov    %ebx,%esi
imul   %ecx,%ebx
imul   %edx,%esi
lea    (%rsi,%rdx,1),%ecx
add    $0x1,%ecx
mov    %ecx,0x68(%rsp)
add    %ebp,%esi
lea    (%rdi,%rdx,1),%ecx
mov    %ecx,0x50(%rsp)
lea    (%rdi,%rbp,1),%ecx
add    $0x1,%ecx
mov    %ecx,0x48(%rsp)
lea    (%rax,%rbp,1),%r12d
add    $0x1,%r12d
lea    (%rbx,%rbp,1),%ecx
mov    %ecx,0x30(%rsp)
add    %edx,%eax
lea    (%rbx,%rdx,1),%r14d
add    $0x1,%r14d
mov    %r10,%rdi
lea    0x0(,%r10,4),%ecx
mov    $0x7,%edx
sub    %ecx,%edx
mov    %rdx,0x78(%rsp)
movsd  0x1de2(%rip),%xmm2
movapd %xmm2,%xmm3
movapd %xmm0,0x190(%rsp)
subsd  %xmm0,%xmm3
movapd %xmm3,0x140(%rsp)
movapd %xmm1,0x130(%rsp)
subsd  %xmm1,%xmm2
movapd %xmm2,0xd0(%rsp)
lea    0x0(,%r15,4),%ecx
mov    %ecx,0x24(%rsp)
imul   %r9d,%ecx
lea    (%rcx,%r11,4),%ebx
lea    (%rcx,%r11,4),%edx
add    $0x3,%edx
lea    0x7(%rcx,%r11,4),%r8d
lea    0x3(%rbx,%r15,4),%ecx
lea    0x7(%rbx,%r15,4),%ebx
movslq (%rsp),%rbp
mov    %rbp,0x118(%rsp)
lea    0x0(%r13,%r15,2),%r10d
movslq %r10d,%rbp
mov    %rbp,0x110(%rsp)
lea    0x1(%r13,%r15,2),%ebp
movslq %ebp,%rbp
mov    %rbp,0x108(%rsp)
movslq 0x8(%rsp),%rbp
mov    %rbp,0x100(%rsp)
lea    0x2(%r13,%r15,2),%ebp
movslq %ebp,%rbp
mov    %rbp,0xf8(%rsp)
movslq %r13d,%rbp
mov    %rbp,0xf0(%rsp)
lea    0x3(%r13,%r15,2),%ebp
movslq %ebp,%rbp
mov    %rbp,0xe8(%rsp)
movslq 0x18(%rsp),%rbp
mov    %rbp,0xe0(%rsp)
movslq 0x68(%rsp),%rbp
mov    %rbp,0x1e8(%rsp)
movslq %r12d,%rbp
mov    %rbp,0x1e0(%rsp)
movslq 0x50(%rsp),%rbp
mov    %rbp,0x1d8(%rsp)
movslq 0x30(%rsp),%rbp
mov    %rbp,0x1d0(%rsp)
movslq %edx,%rdx
mov    %rdx,0x50(%rsp)
movslq %ecx,%rcx
mov    %rcx,0xb0(%rsp)
movslq %r8d,%rcx
mov    %rcx,0xa8(%rsp)
movslq %ebx,%rcx
mov    %rcx,0xa0(%rsp)
movslq %esi,%rcx
mov    %rcx,0x208(%rsp)
movslq 0x48(%rsp),%rcx
mov    %rcx,0x200(%rsp)
cltq
mov    %rax,0x1f8(%rsp)
movslq %r14d,%rax
mov    %rax,0x1f0(%rsp)
mov    %rdi,%rax
mov    %rdi,0x18(%rsp)
lea    0x1(%rdi),%r8d
mov    %r8d,%r14d
and    $0xfffffffe,%r14d
mov    0x60(%rsp),%rcx
mov    %ecx,%eax
neg    %eax
mov    %eax,0xcc(%rsp)
mov    0x298(%rsp),%r12
mov    0x250(%rsp),%r13
mov    %r9,0x128(%rsp)
lea    0x1(%r9),%eax
mov    %eax,0x74(%rsp)
mov    %r11,0xc0(%rsp)
lea    0x1(%r11),%eax
mov    %eax,0x2c(%rsp)
mov    %rcx,%rax
lea    0x1(%rcx),%ebx
lea    -0x1(%r8),%r11
mov    $0x1,%al
mov    %r8,0x48(%rsp)
mov    %r11,0x98(%rsp)
mov    %rbx,0x68(%rsp)
jmp    1403 <findNURBSbasisFunIso4xScCP+0x2d3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
testb  $0x1,0xc8(%rsp)
01
mov    $0x0,%eax
je     2399 <findNURBSbasisFunIso4xScCP+0x1269>
mov    %eax,0xc8(%rsp)
mov    0x58(%rsp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x260(%rsp),%edi
mov    0x60(%rsp),%rbp
mov    %ebp,%esi
mov    0x270(%rsp),%r15
mov    %r15,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%ebx
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %ebp,%esi
mov    %r15,%rdx
mov    0x2b0(%rsp),%rcx
mov    0x2a0(%rsp),%r8
mov    0x2a8(%rsp),%r9
call   1040 <BasisFuns@plt>
sub    %ebp,%ebx
mov    %ebx,0x30(%rsp)
mov    0x58(%rsp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%rsp)
mov    0x258(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x268(%rsp),%rbp
mov    %rbp,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%r15d
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    %ebx,%esi
mov    %rbp,%rdx
mov    0x30(%rsp),%ebp
mov    %r12,%rcx
mov    0x288(%rsp),%r8
mov    0x290(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    %r15,%rsi
mov    %esi,%r8d
sub    %ebx,%r8d
mov    %ebp,%r15d
mov    %ebp,%edx
mov    0x24(%rsp),%ecx
imul   %ecx,%edx
cmpl   $0x0,0x60(%rsp)
mov    %rdx,0x120(%rsp)
js     15f0 <findNURBSbasisFunIso4xScCP+0x4c0>
mov    %edx,%r10d
or     $0x3,%r10d
mov    0x78(%rsp),%rax
add    %eax,%edx
lea    (%rdx,%rsi,4),%edx
xorpd  %xmm6,%xmm6
xor    %esi,%esi
mov    0x48(%rsp),%r11
mov    0x2b0(%rsp),%r9
mov    0x98(%rsp),%rbx
movsd  0x8(%rsp),%xmm4
movsd  (%rsp),%xmm0
jmp    1541 <findNURBSbasisFunIso4xScCP+0x411>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    %ecx,%edx
cmp    0x68(%rsp),%rsi
je     1607 <findNURBSbasisFunIso4xScCP+0x4d7>
cmpl   $0x0,0x18(%rsp)
js     1530 <findNURBSbasisFunIso4xScCP+0x400>
movsd  (%r9,%rsi,8),%xmm1
test   %rbx,%rbx
je     15b0 <findNURBSbasisFunIso4xScCP+0x480>
mov    %edx,%ebp
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rbp),%eax
cltq
mulsd  0x0(%r13,%rax,8),%xmm2
addsd  %xmm6,%xmm2
movsd  0x8(%r12,%rdi,8),%xmm6
mulsd  %xmm1,%xmm6
movslq %ebp,%rbp
mulsd  0x0(%r13,%rbp,8),%xmm6
addsd  %xmm2,%xmm6
add    $0x2,%rdi
add    $0x8,%ebp
cmp    %rdi,%r14
jne    1560 <findNURBSbasisFunIso4xScCP+0x430>
test   $0x1,%r11b
je     1530 <findNURBSbasisFunIso4xScCP+0x400>
jmp    15bc <findNURBSbasisFunIso4xScCP+0x48c>
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
test   $0x1,%r11b
je     1530 <findNURBSbasisFunIso4xScCP+0x400>
mov    %ecx,%eax
imul   %esi,%eax
add    %r10d,%eax
mulsd  (%r12,%rdi,8),%xmm1
add    %r8d,%edi
lea    (%rax,%rdi,4),%eax
cltq
mulsd  0x0(%r13,%rax,8),%xmm1
addsd  %xmm1,%xmm6
jmp    1530 <findNURBSbasisFunIso4xScCP+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm6,%xmm6
mov    0x2b0(%rsp),%r9
movsd  0x8(%rsp),%xmm4
movsd  (%rsp),%xmm0
mov    0x128(%rsp),%rax
sub    %r15d,%eax
mov    0x74(%rsp),%ecx
sub    %r15d,%ecx
movslq %eax,%rsi
movslq %ecx,%rdx
cmpl   $0x0,0x28(%rsp)
mov    %rdx,0x90(%rsp)
mov    %rsi,0x88(%rsp)
jle    1bf5 <findNURBSbasisFunIso4xScCP+0xac5>
mov    0x118(%rsp),%rax
mov    0x278(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
movapd %xmm4,%xmm11
mov    0x108(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm4,%xmm3
mov    0xf0(%rsp),%rax
mulsd  (%rcx,%rax,8),%xmm3
subsd  %xmm1,%xmm11
mov    0x110(%rsp),%rax
mulsd  (%rcx,%rax,8),%xmm11
addsd  %xmm3,%xmm11
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm11
mov    0x100(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm5
movapd %xmm4,%xmm1
subsd  %xmm5,%xmm1
mov    0xe8(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm4,%xmm3
mov    0xe0(%rsp),%rax
mulsd  (%rcx,%rax,8),%xmm3
mov    0xf8(%rsp),%rax
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm3,%xmm1
subsd  %xmm5,%xmm2
divsd  %xmm2,%xmm1
mov    0x1e0(%rsp),%rax
mov    0x280(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
movapd 0x190(%rsp),%xmm9
mulsd  %xmm9,%xmm2
mov    0x1e8(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm10
movapd 0x140(%rsp),%xmm4
mulsd  %xmm4,%xmm10
addsd  %xmm2,%xmm10
mov    0x1d0(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm9,%xmm3
mov    0x1d8(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movapd 0x130(%rsp),%xmm8
mulsd  %xmm8,%xmm2
mov    0xc0(%rsp),%rax
sub    %r8d,%eax
mov    0x2c(%rsp),%ecx
sub    %r8d,%ecx
movsd  (%r9,%rsi,8),%xmm3
mulsd  %xmm4,%xmm3
cltq
movsd  (%r12,%rax,8),%xmm4
movsd  (%r9,%rdx,8),%xmm5
mulsd  %xmm9,%xmm5
movapd %xmm3,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm5,%xmm4
mov    0xb0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm4
movslq %ecx,%rax
mov    0x50(%rsp),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm7
addsd  %xmm4,%xmm7
movsd  (%r12,%rax,8),%xmm4
mulsd  %xmm4,%xmm5
mov    0xa0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm5
mulsd  %xmm4,%xmm3
mov    0xa8(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm3
addsd  %xmm5,%xmm3
movapd %xmm0,%xmm4
subsd  %xmm11,%xmm4
movapd %xmm1,%xmm5
subsd  %xmm0,%xmm5
unpcklpd %xmm5,%xmm3
unpcklpd %xmm2,%xmm8
movapd 0xd0(%rsp),%xmm5
movapd %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
mulsd  %xmm5,%xmm10
unpcklpd %xmm10,%xmm7
mulpd  %xmm2,%xmm7
movapd %xmm8,0x180(%rsp)
mulpd  %xmm8,%xmm3
subpd  %xmm3,%xmm7
movsd  %xmm1,0xb8(%rsp)
movapd %xmm1,%xmm2
movsd  %xmm11,0x80(%rsp)
subsd  %xmm11,%xmm2
unpcklpd %xmm2,%xmm6
divpd  %xmm6,%xmm7
movapd %xmm7,%xmm3
unpckhpd %xmm7,%xmm3
subsd  %xmm3,%xmm7
mov    0x120(%rsp),%rcx
mov    %ecx,%r15d
or     $0x3,%r15d
unpcklpd %xmm10,%xmm1
movapd %xmm1,0x160(%rsp)
unpcklpd %xmm2,%xmm1
movapd %xmm1,0x150(%rsp)
mov    0x78(%rsp),%rax
add    %ecx,%eax
mov    %rax,0x210(%rsp)
xor    %ebx,%ebx
mov    %r15d,0x170(%rsp)
jmp    18d0 <findNURBSbasisFunIso4xScCP+0x7a0>
mov    0x58(%rsp),%rax
movsd  (%rax),%xmm0
movapd 0x30(%rsp),%xmm7
mov    0x14(%rsp),%ebx
add    $0x1,%ebx
cmp    0x28(%rsp),%ebx
je     1bf5 <findNURBSbasisFunIso4xScCP+0xac5>
movapd %xmm7,0x30(%rsp)
movsd  %xmm0,(%rsp)
movapd %xmm7,%xmm0
call   1030 <fabs@plt>
test   %eax,%eax
jle    1bf0 <findNURBSbasisFunIso4xScCP+0xac0>
mov    %ebx,0x14(%rsp)
movapd 0x1b0(%rsp),%xmm3
movapd %xmm3,%xmm0
xorpd  0x170b(%rip),%xmm0
xorpd  %xmm1,%xmm1
cmpltsd 0x30(%rsp),%xmm1
movapd %xmm1,%xmm2
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movsd  (%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
mov    0x258(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x268(%rsp),%r15
mov    %r15,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    %ebx,%esi
mov    %r15,%rdx
mov    0x170(%rsp),%r15d
mov    %r12,%rcx
mov    0x288(%rsp),%r8
mov    0x290(%rsp),%r9
call   1040 <BasisFuns@plt>
xorpd  %xmm4,%xmm4
mov    %ebp,%r9d
sub    %ebx,%r9d
movapd 0x1b0(%rsp),%xmm0
mulsd  0x1673(%rip),%xmm0
movapd %xmm0,0x1b0(%rsp)
cmpl   $0x0,0x60(%rsp)
mov    0x48(%rsp),%r10
mov    0x2b0(%rsp),%r8
mov    0x24(%rsp),%eax
mov    0x98(%rsp),%r11
mov    0x68(%rsp),%rbx
js     1aa0 <findNURBSbasisFunIso4xScCP+0x970>
mov    0x210(%rsp),%rcx
lea    (%rcx,%rbp,4),%ecx
xorpd  %xmm4,%xmm4
xor    %edx,%edx
jmp    19ef <findNURBSbasisFunIso4xScCP+0x8bf>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %eax,%ecx
cmp    %rbx,%rdx
je     1aa0 <findNURBSbasisFunIso4xScCP+0x970>
cmpl   $0x0,0x18(%rsp)
js     19e0 <findNURBSbasisFunIso4xScCP+0x8b0>
movsd  (%r8,%rdx,8),%xmm0
test   %r11,%r11
je     1a60 <findNURBSbasisFunIso4xScCP+0x930>
mov    %ecx,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
lea    -0x4(%rdi),%ebp
movslq %ebp,%rbp
mulsd  0x0(%r13,%rbp,8),%xmm1
addsd  %xmm4,%xmm1
movsd  0x8(%r12,%rsi,8),%xmm4
mulsd  %xmm0,%xmm4
movslq %edi,%rdi
mulsd  0x0(%r13,%rdi,8),%xmm4
addsd  %xmm1,%xmm4
add    $0x2,%rsi
add    $0x8,%edi
cmp    %rsi,%r14
jne    1a10 <findNURBSbasisFunIso4xScCP+0x8e0>
test   $0x1,%r10b
je     19e0 <findNURBSbasisFunIso4xScCP+0x8b0>
jmp    1a6c <findNURBSbasisFunIso4xScCP+0x93c>
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
test   $0x1,%r10b
je     19e0 <findNURBSbasisFunIso4xScCP+0x8b0>
mov    %eax,%edi
imul   %edx,%edi
add    %r15d,%edi
mulsd  (%r12,%rsi,8),%xmm0
add    %r9d,%esi
lea    (%rdi,%rsi,4),%esi
movslq %esi,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm0
addsd  %xmm0,%xmm4
jmp    19e0 <findNURBSbasisFunIso4xScCP+0x8b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
shufpd $0x2,0x150(%rsp),%xmm4
mov    0x88(%rsp),%rax
movsd  (%r8,%rax,8),%xmm6
mulsd  0x140(%rsp),%xmm6
mov    0xc0(%rsp),%rcx
sub    %r9d,%ecx
movslq %ecx,%rcx
movsd  (%r12,%rcx,8),%xmm2
movapd %xmm6,%xmm1
mulsd  %xmm2,%xmm1
mov    0x90(%rsp),%rax
movsd  (%r8,%rax,8),%xmm3
mulsd  0x190(%rsp),%xmm3
mulsd  %xmm3,%xmm2
mov    0xb0(%rsp),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm2
mov    0x50(%rsp),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
mov    0x2c(%rsp),%ecx
sub    %r9d,%ecx
movslq %ecx,%rax
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm2,%xmm6
mulsd  %xmm2,%xmm3
mov    0xa0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm3
mov    0xa8(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm6
shufpd $0x2,0x160(%rsp),%xmm1
addsd  %xmm3,%xmm6
movsd  (%rsp),%xmm5
movapd %xmm5,%xmm2
subsd  0x80(%rsp),%xmm2
movsd  0xb8(%rsp),%xmm3
subsd  %xmm5,%xmm3
unpcklpd %xmm3,%xmm6
mulpd  0x180(%rsp),%xmm6
movapd 0xd0(%rsp),%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm1,%xmm0
subpd  %xmm6,%xmm0
divpd  %xmm4,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
subsd  %xmm1,%xmm0
movapd %xmm0,0x1a0(%rsp)
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x30(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jge    18b0 <findNURBSbasisFunIso4xScCP+0x780>
mov    0x58(%rsp),%rax
movsd  (%rsp),%xmm0
movsd  %xmm0,(%rax)
movapd 0x1a0(%rsp),%xmm7
jmp    18bf <findNURBSbasisFunIso4xScCP+0x78f>
nopw   0x0(%rax,%rax,1)
movsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x258(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x268(%rsp),%r15
mov    %r15,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    %ebx,%esi
mov    %r15,%rdx
mov    %r12,%rcx
mov    0x288(%rsp),%r8
mov    0x290(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    %ebp,%r9d
sub    %ebx,%r9d
lea    0x0(,%r9,4),%edx
mov    0xf0(%rsp),%rcx
mov    0x278(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm9
movsd  (%rsp),%xmm1
movapd %xmm1,%xmm0
mov    0xe0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm6
movapd %xmm6,%xmm3
subsd  %xmm1,%xmm3
mov    0x118(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
subsd  %xmm9,%xmm0
mov    0x100(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x110(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm8
mov    0xf8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm12
movapd %xmm12,%xmm5
subsd  %xmm1,%xmm5
mov    0x108(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm5
subsd  %xmm8,%xmm1
mov    0xe8(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rsp)
mov    0x200(%rsp),%rcx
mov    0x280(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm10
movapd 0x130(%rsp),%xmm1
mulsd  %xmm1,%xmm10
mov    0x208(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm13
movapd 0xd0(%rsp),%xmm2
mulsd  %xmm2,%xmm13
mov    0x1f0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm11
mulsd  %xmm1,%xmm11
mov    0x1f8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm14
mulsd  %xmm2,%xmm14
cmpl   $0x0,0x60(%rsp)
mov    %edx,0x80(%rsp)
mov    %rbp,0x30(%rsp)
js     1e60 <findNURBSbasisFunIso4xScCP+0xd30>
mov    0x78(%rsp),%rcx
mov    0x120(%rsp),%r15
add    %r15d,%ecx
or     $0x3,%r15d
add    %edx,%r15d
lea    (%rcx,%rbp,4),%ecx
xorpd  %xmm2,%xmm2
xor    %edx,%edx
mov    0x48(%rsp),%r8
mov    0x2b0(%rsp),%r10
mov    0x24(%rsp),%eax
mov    0x98(%rsp),%r11
mov    0x68(%rsp),%rbx
jmp    1dbf <findNURBSbasisFunIso4xScCP+0xc8f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
add    %eax,%ecx
cmp    %rbx,%rdx
je     1e6c <findNURBSbasisFunIso4xScCP+0xd3c>
cmpl   $0x0,0x18(%rsp)
js     1db0 <findNURBSbasisFunIso4xScCP+0xc80>
movsd  (%r10,%rdx,8),%xmm7
test   %r11,%r11
je     1e30 <findNURBSbasisFunIso4xScCP+0xd00>
mov    %ecx,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rsi,8),%xmm4
mulsd  %xmm7,%xmm4
lea    -0x4(%rdi),%ebp
movslq %ebp,%rbp
mulsd  0x0(%r13,%rbp,8),%xmm4
addsd  %xmm2,%xmm4
movsd  0x8(%r12,%rsi,8),%xmm2
mulsd  %xmm7,%xmm2
movslq %edi,%rdi
mulsd  0x0(%r13,%rdi,8),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rsi
add    $0x8,%edi
cmp    %rsi,%r14
jne    1de0 <findNURBSbasisFunIso4xScCP+0xcb0>
test   $0x1,%r8b
je     1db0 <findNURBSbasisFunIso4xScCP+0xc80>
jmp    1e3c <findNURBSbasisFunIso4xScCP+0xd0c>
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
test   $0x1,%r8b
je     1db0 <findNURBSbasisFunIso4xScCP+0xc80>
mov    %eax,%edi
imul   %edx,%edi
add    %r15d,%edi
mulsd  (%r12,%rsi,8),%xmm7
lea    (%rdi,%rsi,4),%esi
movslq %esi,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm7
addsd  %xmm7,%xmm2
jmp    1db0 <findNURBSbasisFunIso4xScCP+0xc80>
xorpd  %xmm2,%xmm2
mov    0x2b0(%rsp),%r10
cmpl   $0x0,0x28(%rsp)
jle    13f0 <findNURBSbasisFunIso4xScCP+0x2c0>
movapd %xmm0,%xmm15
addsd  %xmm3,%xmm15
subsd  %xmm9,%xmm6
divsd  %xmm6,%xmm15
mov    0xc0(%rsp),%rcx
sub    %r9d,%ecx
mov    0x2c(%rsp),%edx
sub    %r9d,%edx
movsd  (%rsp),%xmm9
addsd  %xmm5,%xmm9
mov    0x88(%rsp),%rax
movsd  (%r10,%rax,8),%xmm3
subsd  %xmm8,%xmm12
divsd  %xmm12,%xmm9
addsd  %xmm10,%xmm13
addsd  %xmm11,%xmm14
movslq %ecx,%rax
mov    %rax,0x88(%rsp)
movsd  (%r12,%rax,8),%xmm8
movslq %edx,%rax
mov    %rax,0xb8(%rsp)
movsd  (%r12,%rax,8),%xmm5
movapd 0xd0(%rsp),%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm8,%xmm0
movapd 0x130(%rsp),%xmm1
mulsd  %xmm1,%xmm3
mulsd  %xmm5,%xmm3
mov    0xa8(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm3
mov    0x50(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm0
mov    0x90(%rsp),%rax
movsd  (%r10,%rax,8),%xmm6
addsd  %xmm3,%xmm0
movapd %xmm4,%xmm3
mulsd  %xmm6,%xmm3
mulsd  %xmm1,%xmm6
mulsd  %xmm5,%xmm6
movapd 0x190(%rsp),%xmm1
mulsd  %xmm1,%xmm14
mov    0xa0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm6
mulsd  %xmm8,%xmm3
mov    0xb0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm3
addsd  %xmm6,%xmm3
movsd  0x8(%rsp),%xmm6
movapd %xmm6,%xmm4
subsd  %xmm15,%xmm4
movapd %xmm9,%xmm5
subsd  %xmm6,%xmm5
unpcklpd %xmm5,%xmm3
unpcklpd %xmm14,%xmm1
movapd 0x140(%rsp),%xmm5
movapd %xmm5,%xmm7
unpcklpd %xmm4,%xmm7
mulsd  %xmm5,%xmm13
unpcklpd %xmm13,%xmm0
mulpd  %xmm7,%xmm0
movapd %xmm1,0x180(%rsp)
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm0
movsd  %xmm9,(%rsp)
movapd %xmm9,%xmm1
movsd  %xmm15,0x90(%rsp)
subsd  %xmm15,%xmm1
unpcklpd %xmm1,%xmm2
divpd  %xmm2,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
subsd  %xmm2,%xmm0
orl    $0x3,0x80(%rsp)
unpcklpd %xmm13,%xmm2
movapd %xmm2,0x170(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x160(%rsp)
mov    0x78(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,4),%eax
mov    %eax,0x150(%rsp)
xor    %ebp,%ebp
jmp    2061 <findNURBSbasisFunIso4xScCP+0xf31>
nop
mov    0x58(%rsp),%rax
movsd  0x8(%rax),%xmm6
movapd 0x30(%rsp),%xmm0
mov    0x14(%rsp),%ebp
add    $0x1,%ebp
cmp    0x28(%rsp),%ebp
je     13f0 <findNURBSbasisFunIso4xScCP+0x2c0>
movapd %xmm0,0x30(%rsp)
movsd  %xmm6,0x8(%rsp)
call   1030 <fabs@plt>
test   %eax,%eax
jle    13f0 <findNURBSbasisFunIso4xScCP+0x2c0>
mov    %ebp,0x14(%rsp)
movapd 0x1c0(%rsp),%xmm3
movapd %xmm3,%xmm0
xorpd  0xf7d(%rip),%xmm0
xorpd  %xmm1,%xmm1
cmpltsd 0x30(%rsp),%xmm1
movapd %xmm1,%xmm2
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x260(%rsp),%edi
mov    0x60(%rsp),%rbx
mov    %ebx,%esi
mov    0x270(%rsp),%r15
mov    %r15,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %ebx,%esi
mov    %r15,%rdx
mov    0x2b0(%rsp),%r15
mov    %r15,%rcx
mov    0x2a0(%rsp),%r8
mov    0x2a8(%rsp),%r9
call   1040 <BasisFuns@plt>
xorpd  %xmm7,%xmm7
mov    %ebp,%r8d
sub    %ebx,%r8d
movapd 0x1c0(%rsp),%xmm0
mulsd  0xee2(%rip),%xmm0
movapd %xmm0,0x1c0(%rsp)
test   %ebx,%ebx
mov    0x48(%rsp),%r9
mov    0x24(%rsp),%eax
mov    0x98(%rsp),%r10
mov    0x68(%rsp),%rbx
movsd  (%rsp),%xmm8
mov    0x80(%rsp),%r11d
js     2240 <findNURBSbasisFunIso4xScCP+0x1110>
add    0xcc(%rsp),%ebp
imul   %eax,%ebp
add    0x150(%rsp),%ebp
xorpd  %xmm7,%xmm7
xor    %ecx,%ecx
jmp    218f <findNURBSbasisFunIso4xScCP+0x105f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    %eax,%ebp
cmp    %rbx,%rcx
je     2240 <findNURBSbasisFunIso4xScCP+0x1110>
cmpl   $0x0,0x18(%rsp)
js     2180 <findNURBSbasisFunIso4xScCP+0x1050>
movsd  (%r15,%rcx,8),%xmm0
test   %r10,%r10
je     2200 <findNURBSbasisFunIso4xScCP+0x10d0>
mov    %ebp,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
lea    -0x4(%rsi),%edi
movslq %edi,%rdi
mulsd  0x0(%r13,%rdi,8),%xmm1
addsd  %xmm7,%xmm1
movsd  0x8(%r12,%rdx,8),%xmm7
mulsd  %xmm0,%xmm7
movslq %esi,%rsi
mulsd  0x0(%r13,%rsi,8),%xmm7
addsd  %xmm1,%xmm7
add    $0x2,%rdx
add    $0x8,%esi
cmp    %rdx,%r14
jne    21b0 <findNURBSbasisFunIso4xScCP+0x1080>
test   $0x1,%r9b
je     2180 <findNURBSbasisFunIso4xScCP+0x1050>
jmp    220c <findNURBSbasisFunIso4xScCP+0x10dc>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
test   $0x1,%r9b
je     2180 <findNURBSbasisFunIso4xScCP+0x1050>
lea    (%r8,%rcx,1),%esi
imul   %eax,%esi
add    %r11d,%esi
mulsd  (%r12,%rdx,8),%xmm0
lea    (%rsi,%rdx,4),%edx
movslq %edx,%rdx
mulsd  0x0(%r13,%rdx,8),%xmm0
addsd  %xmm0,%xmm7
jmp    2180 <findNURBSbasisFunIso4xScCP+0x1050>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
shufpd $0x2,0x160(%rsp),%xmm7
mov    0x128(%rsp),%rcx
sub    %r8d,%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm1
movapd 0xd0(%rsp),%xmm4
movapd %xmm4,%xmm6
mulsd  %xmm1,%xmm6
mov    0x88(%rsp),%rax
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm2,%xmm6
movapd 0x130(%rsp),%xmm5
mulsd  %xmm5,%xmm1
mov    0xb8(%rsp),%rax
movsd  (%r12,%rax,8),%xmm3
mulsd  %xmm3,%xmm1
mov    0xa8(%rsp),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm1
mov    0x50(%rsp),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm6
addsd  %xmm1,%xmm6
mov    0x74(%rsp),%ecx
sub    %r8d,%ecx
movslq %ecx,%rax
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm5,%xmm1
mulsd  %xmm3,%xmm1
mov    0xa0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm1
mov    0xb0(%rsp),%rax
mulsd  0x0(%r13,%rax,8),%xmm4
shufpd $0x2,0x170(%rsp),%xmm6
addsd  %xmm1,%xmm4
movsd  0x8(%rsp),%xmm3
movapd %xmm3,%xmm1
subsd  0x90(%rsp),%xmm1
movapd %xmm8,%xmm2
subsd  %xmm3,%xmm2
unpcklpd %xmm2,%xmm4
mulpd  0x180(%rsp),%xmm4
movapd 0x140(%rsp),%xmm0
unpcklpd %xmm1,%xmm0
mulpd  %xmm6,%xmm0
subpd  %xmm4,%xmm0
divpd  %xmm7,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
subsd  %xmm1,%xmm0
movapd %xmm0,0x1a0(%rsp)
call   1030 <fabs@plt>
mov    %eax,%ebp
movaps 0x30(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %eax,%ebp
jge    2040 <findNURBSbasisFunIso4xScCP+0xf10>
mov    0x58(%rsp),%rax
movsd  0x8(%rsp),%xmm6
movsd  %xmm6,0x8(%rax)
movapd 0x1a0(%rsp),%xmm0
jmp    2050 <findNURBSbasisFunIso4xScCP+0xf20>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @findNURBSbasisFunIso4xScCP(i32 %0, i32 %1, double %2, double %3, i32 %4, double* nocapture %5, double %6, double %7, i32 %8, i32 %9, double* nocapture %10, i32 %11, i32 %12, double* %13, double* %14, double* nocapture %15, double* nocapture %16, double* %17, double* %18, double* %19, double* %20, double* %21, double* %22) {
%24 = fsub double 1.000000e+00, %2
%25 = fsub double 1.000000e+00, %3
%26 = mul nsw i32 %11, %0
%27 = add nsw i32 %26, %1
%28 = add nsw i32 %27, 1
%29 = add nsw i32 %27, %11
%30 = add nsw i32 %29, 1
%31 = shl nsw i32 %0, 1
%32 = mul nsw i32 %31, %11
%33 = shl nsw i32 %1, 1
%34 = add nsw i32 %32, %33
%35 = add nsw i32 %34, 2
%36 = shl nsw i32 %11, 1
%37 = add nsw i32 %34, %36
%38 = add nsw i32 %37, 2
%39 = shl nsw i32 %11, 2
%40 = mul nsw i32 %12, %11
%41 = mul nsw i32 %39, %0
%42 = shl nsw i32 %1, 2
%43 = add nsw i32 %41, %42
%44 = or i32 %43, 3
%45 = add i32 %43, 7
%46 = add nsw i32 %44, %39
%47 = add nsw i32 %46, 4
%48 = getelementptr inbounds double, double* %5, i64 1
%49 = or i32 %34, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %15, i64 %50
%52 = sext i32 %37 to i64
%53 = getelementptr inbounds double, double* %15, i64 %52
%54 = or i32 %37, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %15, i64 %55
%57 = sext i32 %34 to i64
%58 = getelementptr inbounds double, double* %15, i64 %57
%59 = add nsw i32 %34, 3
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %15, i64 %60
%62 = sext i32 %38 to i64
%63 = getelementptr inbounds double, double* %15, i64 %62
%64 = add nsw i32 %37, 3
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %15, i64 %65
%67 = sext i32 %35 to i64
%68 = getelementptr inbounds double, double* %15, i64 %67
%69 = mul nsw i32 %40, %27
%70 = add nsw i32 %69, %28
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %16, i64 %71
%73 = mul nsw i32 %29, %40
%74 = add nsw i32 %73, %30
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %16, i64 %75
%77 = mul nsw i32 %28, %40
%78 = add nsw i32 %77, %27
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %16, i64 %79
%81 = mul nsw i32 %30, %40
%82 = add nsw i32 %81, %29
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %16, i64 %83
%85 = icmp slt i32 %9, 0
%86 = icmp slt i32 %8, 0
%87 = sext i32 %44 to i64
%88 = getelementptr inbounds double, double* %10, i64 %87
%89 = add nsw i32 %0, 1
%90 = sext i32 %46 to i64
%91 = getelementptr inbounds double, double* %10, i64 %90
%92 = add nsw i32 %1, 1
%93 = sext i32 %45 to i64
%94 = getelementptr inbounds double, double* %10, i64 %93
%95 = sext i32 %47 to i64
%96 = getelementptr inbounds double, double* %10, i64 %95
%97 = icmp sgt i32 %4, 0
%98 = add nsw i32 %69, %29
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %16, i64 %99
%101 = add nsw i32 %77, %30
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %16, i64 %102
%104 = add nsw i32 %73, %27
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %16, i64 %105
%107 = add nsw i32 %81, %28
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %16, i64 %108
%110 = add i32 %8, 1
%111 = add i32 %9, 1
%112 = zext i32 %111 to i64
%113 = zext i32 %110 to i64
%114 = zext i32 %111 to i64
%115 = zext i32 %111 to i64
%116 = zext i32 %111 to i64
%117 = insertelement <2 x double> poison, double %24, i64 0
%118 = insertelement <2 x double> poison, double %2, i64 0
%119 = insertelement <2 x double> poison, double %25, i64 0
%120 = insertelement <2 x double> poison, double %3, i64 0
%121 = add nsw i64 %113, -1
%122 = and i64 %113, 1
%123 = icmp eq i64 %121, 0
%124 = and i64 %113, 4294967294
%125 = icmp eq i64 %122, 0
%126 = insertelement <2 x double> poison, double %25, i64 0
%127 = insertelement <2 x double> poison, double %3, i64 0
%128 = and i64 %113, 1
%129 = icmp eq i64 %121, 0
%130 = and i64 %113, 4294967294
%131 = icmp eq i64 %128, 0
%132 = and i64 %113, 1
%133 = icmp eq i64 %121, 0
%134 = and i64 %113, 4294967294
%135 = icmp eq i64 %132, 0
%136 = insertelement <2 x double> poison, double %24, i64 0
%137 = insertelement <2 x double> poison, double %2, i64 0
%138 = and i64 %113, 1
%139 = icmp eq i64 %121, 0
%140 = and i64 %113, 4294967294
%141 = icmp eq i64 %138, 0
br label %142
142: ; preds = %23, %700
%143 = phi double [ %6, %23 ], [ %429, %700 ]
%144 = phi double [ %7, %23 ], [ %701, %700 ]
%145 = phi i1 [ true, %23 ], [ false, %700 ]
%146 = load double, double* %48
%147 = tail call i32 @FindSpan(i32 %12, i32 %9, double %146, double* %14)
%148 = tail call i32 @BasisFuns(i32 %147, double %146, i32 %9, double* %14, double* %22, double* %20, double* %21)
%149 = sub nsw i32 %147, %9
%150 = load double, double* %5
%151 = tail call i32 @FindSpan(i32 %11, i32 %8, double %150, double* %13)
%152 = tail call i32 @BasisFuns(i32 %151, double %150, i32 %8, double* %13, double* %19, double* %17, double* %18)
%153 = sub nsw i32 %151, %8
%154 = mul nsw i32 %149, %39
%155 = load double, double* %51
%156 = fsub double %146, %155
%157 = load double, double* %53
%158 = load double, double* %56
%159 = fsub double %158, %146
%160 = load double, double* %58
%161 = fmul double %159, %160
%162 = tail call double @llvm.fmuladd.f64(double %156, double %157, double %161)
%163 = fsub double %158, %155
%164 = fdiv double %162, %163
%165 = load double, double* %61
%166 = fsub double %146, %165
%167 = load double, double* %63
%168 = load double, double* %66
%169 = fsub double %168, %146
%170 = load double, double* %68
%171 = fmul double %169, %170
%172 = tail call double @llvm.fmuladd.f64(double %166, double %167, double %171)
%173 = fsub double %168, %165
%174 = fdiv double %172, %173
%175 = load double, double* %72
%176 = load double, double* %76
%177 = fmul double %176, %2
%178 = tail call double @llvm.fmuladd.f64(double %24, double %175, double %177)
%179 = fmul double %25, %178
%180 = load double, double* %80
%181 = load double, double* %84
%182 = fmul double %181, %2
%183 = tail call double @llvm.fmuladd.f64(double %24, double %180, double %182)
%184 = fmul double %183, %3
br i1 %85, label %246, label %185
185: ; preds = %142
%186 = or i32 %154, 3
br label %187
187: ; preds = %185, %242
%188 = phi i64 [ 0, %185 ], [ %244, %242 ]
%189 = phi double [ 0.000000e+00, %185 ], [ %243, %242 ]
br i1 %86, label %242, label %190
190: ; preds = %187
%191 = getelementptr inbounds double, double* %22, i64 %188
%192 = load double, double* %191
%193 = trunc i64 %188 to i32
%194 = mul nsw i32 %39, %193
%195 = add i32 %186, %194
br i1 %123, label %226, label %196
196: ; preds = %190, %196
%197 = phi i64 [ %223, %196 ], [ 0, %190 ]
%198 = phi double [ %222, %196 ], [ %189, %190 ]
%199 = phi i64 [ %224, %196 ], [ 0, %190 ]
%200 = getelementptr inbounds double, double* %19, i64 %197
%201 = load double, double* %200
%202 = fmul double %192, %201
%203 = trunc i64 %197 to i32
%204 = add i32 %153, %203
%205 = shl i32 %204, 2
%206 = add i32 %195, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %10, i64 %207
%209 = load double, double* %208
%210 = tail call double @llvm.fmuladd.f64(double %202, double %209, double %198)
%211 = or i64 %197, 1
%212 = getelementptr inbounds double, double* %19, i64 %211
%213 = load double, double* %212
%214 = fmul double %192, %213
%215 = trunc i64 %211 to i32
%216 = add i32 %153, %215
%217 = shl i32 %216, 2
%218 = add i32 %195, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %10, i64 %219
%221 = load double, double* %220
%222 = tail call double @llvm.fmuladd.f64(double %214, double %221, double %210)
%223 = add nuw nsw i64 %197, 2
%224 = add i64 %199, 2
%225 = icmp eq i64 %224, %124
br i1 %225, label %226, label %196
226: ; preds = %196, %190
%227 = phi double [ undef, %190 ], [ %222, %196 ]
%228 = phi i64 [ 0, %190 ], [ %223, %196 ]
%229 = phi double [ %189, %190 ], [ %222, %196 ]
br i1 %125, label %242, label %230
230: ; preds = %226
%231 = getelementptr inbounds double, double* %19, i64 %228
%232 = load double, double* %231
%233 = fmul double %192, %232
%234 = trunc i64 %228 to i32
%235 = add i32 %153, %234
%236 = shl i32 %235, 2
%237 = add i32 %195, %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %10, i64 %238
%240 = load double, double* %239
%241 = tail call double @llvm.fmuladd.f64(double %233, double %240, double %229)
br label %242
242: ; preds = %230, %226, %187
%243 = phi double [ %189, %187 ], [ %227, %226 ], [ %241, %230 ]
%244 = add nuw nsw i64 %188, 1
%245 = icmp eq i64 %244, %112
br i1 %245, label %246, label %187
246: ; preds = %242, %142
%247 = phi double [ 0.000000e+00, %142 ], [ %243, %242 ]
%248 = sub nsw i32 %0, %149
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %22, i64 %249
%251 = load double, double* %250
%252 = fmul double %24, %251
%253 = sub nsw i32 %1, %153
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %19, i64 %254
%256 = load double, double* %255
%257 = sub nsw i32 %89, %149
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %22, i64 %258
%260 = load double, double* %259
%261 = fmul double %260, %2
%262 = sub nsw i32 %92, %153
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %19, i64 %263
%265 = load double, double* %264
%266 = fsub double %174, %164
br i1 %97, label %267, label %427
267: ; preds = %246
%268 = fmul double %252, %256
%269 = load double, double* %88
%270 = load double, double* %91
%271 = fmul double %256, %261
%272 = fmul double %270, %271
%273 = tail call double @llvm.fmuladd.f64(double %268, double %269, double %272)
%274 = fmul double %252, %265
%275 = load double, double* %94
%276 = fmul double %261, %265
%277 = load double, double* %96
%278 = fmul double %276, %277
%279 = tail call double @llvm.fmuladd.f64(double %274, double %275, double %278)
%280 = fsub double %150, %164
%281 = fsub double %174, %150
%282 = insertelement <2 x double> poison, double %279, i64 0
%283 = insertelement <2 x double> %282, double %281, i64 1
%284 = fneg <2 x double> %283
%285 = insertelement <2 x double> %120, double %184, i64 1
%286 = fmul <2 x double> %285, %284
%287 = insertelement <2 x double> %119, double %280, i64 1
%288 = insertelement <2 x double> poison, double %273, i64 0
%289 = insertelement <2 x double> %288, double %179, i64 1
%290 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %287, <2 x double> %289, <2 x double> %286)
%291 = insertelement <2 x double> poison, double %247, i64 0
%292 = insertelement <2 x double> %291, double %266, i64 1
%293 = fdiv <2 x double> %290, %292
%294 = shufflevector <2 x double> %293, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%295 = fsub <2 x double> %293, %294
%296 = extractelement <2 x double> %295, i64 0
%297 = or i32 %154, 3
%298 = insertelement <2 x double> poison, double %179, i64 1
%299 = insertelement <2 x double> %127, double %184, i64 1
%300 = insertelement <2 x double> poison, double %266, i64 1
br label %301
301: ; preds = %267, %422
%302 = phi double [ %143, %267 ], [ %313, %422 ]
%303 = phi double [ %296, %267 ], [ %424, %422 ]
%304 = phi double [ %150, %267 ], [ %423, %422 ]
%305 = phi i32 [ 0, %267 ], [ %425, %422 ]
%306 = tail call i32 @fabs(double %303)
%307 = icmp slt i32 %306, 1
br i1 %307, label %427, label %308
308: ; preds = %301
%309 = fcmp ogt double %303, 0.000000e+00
%310 = fneg double %302
%311 = select i1 %309, double %302, double %310
%312 = fadd double %304, %311
%313 = fmul double %302, 5.000000e-01
%314 = tail call i32 @FindSpan(i32 %11, i32 %8, double %312, double* %13)
%315 = tail call i32 @BasisFuns(i32 %314, double %312, i32 %8, double* %13, double* %19, double* %17, double* %18)
%316 = sub nsw i32 %314, %8
br i1 %85, label %376, label %317
317: ; preds = %308, %372
%318 = phi i64 [ %374, %372 ], [ 0, %308 ]
%319 = phi double [ %373, %372 ], [ 0.000000e+00, %308 ]
br i1 %86, label %372, label %320
320: ; preds = %317
%321 = getelementptr inbounds double, double* %22, i64 %318
%322 = load double, double* %321
%323 = trunc i64 %318 to i32
%324 = mul nsw i32 %39, %323
%325 = add i32 %297, %324
br i1 %129, label %356, label %326
326: ; preds = %320, %326
%327 = phi i64 [ %353, %326 ], [ 0, %320 ]
%328 = phi double [ %352, %326 ], [ %319, %320 ]
%329 = phi i64 [ %354, %326 ], [ 0, %320 ]
%330 = getelementptr inbounds double, double* %19, i64 %327
%331 = load double, double* %330
%332 = fmul double %322, %331
%333 = trunc i64 %327 to i32
%334 = add i32 %316, %333
%335 = shl i32 %334, 2
%336 = add i32 %325, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %10, i64 %337
%339 = load double, double* %338
%340 = tail call double @llvm.fmuladd.f64(double %332, double %339, double %328)
%341 = or i64 %327, 1
%342 = getelementptr inbounds double, double* %19, i64 %341
%343 = load double, double* %342
%344 = fmul double %322, %343
%345 = trunc i64 %341 to i32
%346 = add i32 %316, %345
%347 = shl i32 %346, 2
%348 = add i32 %325, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %10, i64 %349
%351 = load double, double* %350
%352 = tail call double @llvm.fmuladd.f64(double %344, double %351, double %340)
%353 = add nuw nsw i64 %327, 2
%354 = add i64 %329, 2
%355 = icmp eq i64 %354, %130
br i1 %355, label %356, label %326
356: ; preds = %326, %320
%357 = phi double [ undef, %320 ], [ %352, %326 ]
%358 = phi i64 [ 0, %320 ], [ %353, %326 ]
%359 = phi double [ %319, %320 ], [ %352, %326 ]
br i1 %131, label %372, label %360
360: ; preds = %356
%361 = getelementptr inbounds double, double* %19, i64 %358
%362 = load double, double* %361
%363 = fmul double %322, %362
%364 = trunc i64 %358 to i32
%365 = add i32 %316, %364
%366 = shl i32 %365, 2
%367 = add i32 %325, %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double, double* %10, i64 %368
%370 = load double, double* %369
%371 = tail call double @llvm.fmuladd.f64(double %363, double %370, double %359)
br label %372
372: ; preds = %360, %356, %317
%373 = phi double [ %319, %317 ], [ %357, %356 ], [ %371, %360 ]
%374 = add nuw nsw i64 %318, 1
%375 = icmp eq i64 %374, %114
br i1 %375, label %376, label %317
376: ; preds = %372, %308
%377 = phi double [ 0.000000e+00, %308 ], [ %373, %372 ]
%378 = load double, double* %250
%379 = fmul double %24, %378
%380 = sub nsw i32 %1, %316
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double, double* %19, i64 %381
%383 = load double, double* %382
%384 = fmul double %379, %383
%385 = load double, double* %88
%386 = load double, double* %259
%387 = fmul double %386, %2
%388 = fmul double %383, %387
%389 = load double, double* %91
%390 = fmul double %389, %388
%391 = tail call double @llvm.fmuladd.f64(double %384, double %385, double %390)
%392 = sub nsw i32 %92, %316
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %19, i64 %393
%395 = load double, double* %394
%396 = fmul double %379, %395
%397 = load double, double* %94
%398 = fmul double %387, %395
%399 = load double, double* %96
%400 = fmul double %398, %399
%401 = tail call double @llvm.fmuladd.f64(double %396, double %397, double %400)
%402 = fsub double %312, %164
%403 = fsub double %174, %312
%404 = insertelement <2 x double> poison, double %401, i64 0
%405 = insertelement <2 x double> %404, double %403, i64 1
%406 = fneg <2 x double> %405
%407 = fmul <2 x double> %299, %406
%408 = insertelement <2 x double> %126, double %402, i64 1
%409 = insertelement <2 x double> %298, double %391, i64 0
%410 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %408, <2 x double> %409, <2 x double> %407)
%411 = insertelement <2 x double> %300, double %377, i64 0
%412 = fdiv <2 x double> %410, %411
%413 = shufflevector <2 x double> %412, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%414 = fsub <2 x double> %412, %413
%415 = extractelement <2 x double> %414, i64 0
%416 = tail call i32 @fabs(double %415)
%417 = tail call i32 @fabs(double %303)
%418 = icmp slt i32 %416, %417
br i1 %418, label %419, label %420
419: ; preds = %376
store double %312, double* %5
br label %422
420: ; preds = %376
%421 = load double, double* %5
br label %422
422: ; preds = %419, %420
%423 = phi double [ %312, %419 ], [ %421, %420 ]
%424 = phi double [ %415, %419 ], [ %303, %420 ]
%425 = add nuw nsw i32 %305, 1
%426 = icmp eq i32 %425, %4
br i1 %426, label %427, label %301
427: ; preds = %422, %301, %246
%428 = phi double [ %150, %246 ], [ %304, %301 ], [ %423, %422 ]
%429 = phi double [ %143, %246 ], [ %302, %301 ], [ %313, %422 ]
%430 = tail call i32 @FindSpan(i32 %11, i32 %8, double %428, double* %13)
%431 = tail call i32 @BasisFuns(i32 %430, double %428, i32 %8, double* %13, double* %19, double* %17, double* %18)
%432 = sub nsw i32 %430, %8
%433 = shl nsw i32 %432, 2
%434 = load double, double* %58
%435 = fsub double %428, %434
%436 = load double, double* %61
%437 = load double, double* %68
%438 = fsub double %437, %428
%439 = load double, double* %51
%440 = fmul double %438, %439
%441 = tail call double @llvm.fmuladd.f64(double %435, double %436, double %440)
%442 = fsub double %437, %434
%443 = fdiv double %441, %442
%444 = load double, double* %53
%445 = fsub double %428, %444
%446 = load double, double* %66
%447 = load double, double* %63
%448 = fsub double %447, %428
%449 = load double, double* %56
%450 = fmul double %448, %449
%451 = tail call double @llvm.fmuladd.f64(double %445, double %446, double %450)
%452 = fsub double %447, %444
%453 = fdiv double %451, %452
%454 = load double, double* %100
%455 = load double, double* %103
%456 = fmul double %455, %3
%457 = tail call double @llvm.fmuladd.f64(double %25, double %454, double %456)
%458 = fmul double %24, %457
%459 = load double, double* %106
%460 = load double, double* %109
%461 = fmul double %460, %3
%462 = tail call double @llvm.fmuladd.f64(double %25, double %459, double %461)
%463 = fmul double %462, %2
br i1 %85, label %523, label %464
464: ; preds = %427
%465 = or i32 %154, 3
%466 = add i32 %465, %433
br label %467
467: ; preds = %464, %519
%468 = phi i64 [ 0, %464 ], [ %521, %519 ]
%469 = phi double [ 0.000000e+00, %464 ], [ %520, %519 ]
br i1 %86, label %519, label %470
470: ; preds = %467
%471 = getelementptr inbounds double, double* %22, i64 %468
%472 = load double, double* %471
%473 = trunc i64 %468 to i32
%474 = mul nsw i32 %39, %473
%475 = add i32 %466, %474
br i1 %133, label %504, label %476
476: ; preds = %470, %476
%477 = phi i64 [ %501, %476 ], [ 0, %470 ]
%478 = phi double [ %500, %476 ], [ %469, %470 ]
%479 = phi i64 [ %502, %476 ], [ 0, %470 ]
%480 = getelementptr inbounds double, double* %19, i64 %477
%481 = load double, double* %480
%482 = fmul double %472, %481
%483 = trunc i64 %477 to i32
%484 = shl i32 %483, 2
%485 = add i32 %475, %484
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %10, i64 %486
%488 = load double, double* %487
%489 = tail call double @llvm.fmuladd.f64(double %482, double %488, double %478)
%490 = or i64 %477, 1
%491 = getelementptr inbounds double, double* %19, i64 %490
%492 = load double, double* %491
%493 = fmul double %472, %492
%494 = trunc i64 %490 to i32
%495 = shl i32 %494, 2
%496 = add i32 %475, %495
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %10, i64 %497
%499 = load double, double* %498
%500 = tail call double @llvm.fmuladd.f64(double %493, double %499, double %489)
%501 = add nuw nsw i64 %477, 2
%502 = add i64 %479, 2
%503 = icmp eq i64 %502, %134
br i1 %503, label %504, label %476
504: ; preds = %476, %470
%505 = phi double [ undef, %470 ], [ %500, %476 ]
%506 = phi i64 [ 0, %470 ], [ %501, %476 ]
%507 = phi double [ %469, %470 ], [ %500, %476 ]
br i1 %135, label %519, label %508
508: ; preds = %504
%509 = getelementptr inbounds double, double* %19, i64 %506
%510 = load double, double* %509
%511 = fmul double %472, %510
%512 = trunc i64 %506 to i32
%513 = shl i32 %512, 2
%514 = add i32 %475, %513
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %10, i64 %515
%517 = load double, double* %516
%518 = tail call double @llvm.fmuladd.f64(double %511, double %517, double %507)
br label %519
519: ; preds = %508, %504, %467
%520 = phi double [ %469, %467 ], [ %505, %504 ], [ %518, %508 ]
%521 = add nuw nsw i64 %468, 1
%522 = icmp eq i64 %521, %115
br i1 %522, label %523, label %467
523: ; preds = %519, %427
%524 = phi double [ 0.000000e+00, %427 ], [ %520, %519 ]
%525 = load double, double* %250
%526 = sub nsw i32 %1, %432
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double, double* %19, i64 %527
%529 = load double, double* %528
%530 = sub nsw i32 %92, %432
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %19, i64 %531
%533 = load double, double* %532
%534 = load double, double* %259
%535 = fsub double %453, %443
br i1 %97, label %536, label %700
536: ; preds = %523
%537 = fmul double %25, %525
%538 = fmul double %537, %529
%539 = load double, double* %88
%540 = fmul double %525, %3
%541 = fmul double %540, %533
%542 = load double, double* %94
%543 = fmul double %541, %542
%544 = tail call double @llvm.fmuladd.f64(double %538, double %539, double %543)
%545 = fmul double %25, %534
%546 = fmul double %529, %545
%547 = load double, double* %91
%548 = fmul double %534, %3
%549 = fmul double %533, %548
%550 = load double, double* %96
%551 = fmul double %549, %550
%552 = tail call double @llvm.fmuladd.f64(double %546, double %547, double %551)
%553 = fsub double %146, %443
%554 = fsub double %453, %146
%555 = insertelement <2 x double> poison, double %552, i64 0
%556 = insertelement <2 x double> %555, double %554, i64 1
%557 = fneg <2 x double> %556
%558 = insertelement <2 x double> %118, double %463, i64 1
%559 = fmul <2 x double> %558, %557
%560 = insertelement <2 x double> %117, double %553, i64 1
%561 = insertelement <2 x double> poison, double %544, i64 0
%562 = insertelement <2 x double> %561, double %458, i64 1
%563 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %560, <2 x double> %562, <2 x double> %559)
%564 = insertelement <2 x double> poison, double %524, i64 0
%565 = insertelement <2 x double> %564, double %535, i64 1
%566 = fdiv <2 x double> %563, %565
%567 = shufflevector <2 x double> %566, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%568 = fsub <2 x double> %566, %567
%569 = extractelement <2 x double> %568, i64 0
%570 = or i32 %433, 3
%571 = insertelement <2 x double> poison, double %458, i64 1
%572 = insertelement <2 x double> %137, double %463, i64 1
%573 = insertelement <2 x double> poison, double %535, i64 1
br label %574
574: ; preds = %536, %695
%575 = phi double [ %144, %536 ], [ %586, %695 ]
%576 = phi double [ %569, %536 ], [ %697, %695 ]
%577 = phi double [ %146, %536 ], [ %696, %695 ]
%578 = phi i32 [ 0, %536 ], [ %698, %695 ]
%579 = tail call i32 @fabs(double %576)
%580 = icmp slt i32 %579, 1
br i1 %580, label %700, label %581
581: ; preds = %574
%582 = fcmp ogt double %576, 0.000000e+00
%583 = fneg double %575
%584 = select i1 %582, double %575, double %583
%585 = fadd double %577, %584
%586 = fmul double %575, 5.000000e-01
%587 = tail call i32 @FindSpan(i32 %12, i32 %9, double %585, double* %14)
%588 = tail call i32 @BasisFuns(i32 %587, double %585, i32 %9, double* %14, double* %22, double* %20, double* %21)
%589 = sub nsw i32 %587, %9
br i1 %85, label %647, label %590
590: ; preds = %581, %643
%591 = phi i64 [ %645, %643 ], [ 0, %581 ]
%592 = phi double [ %644, %643 ], [ 0.000000e+00, %581 ]
br i1 %86, label %643, label %593
593: ; preds = %590
%594 = getelementptr inbounds double, double* %22, i64 %591
%595 = load double, double* %594
%596 = trunc i64 %591 to i32
%597 = add i32 %589, %596
%598 = mul i32 %597, %39
%599 = add i32 %570, %598
br i1 %139, label %628, label %600
600: ; preds = %593, %600
%601 = phi i64 [ %625, %600 ], [ 0, %593 ]
%602 = phi double [ %624, %600 ], [ %592, %593 ]
%603 = phi i64 [ %626, %600 ], [ 0, %593 ]
%604 = getelementptr inbounds double, double* %19, i64 %601
%605 = load double, double* %604
%606 = fmul double %595, %605
%607 = trunc i64 %601 to i32
%608 = shl i32 %607, 2
%609 = add i32 %599, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds double, double* %10, i64 %610
%612 = load double, double* %611
%613 = tail call double @llvm.fmuladd.f64(double %606, double %612, double %602)
%614 = or i64 %601, 1
%615 = getelementptr inbounds double, double* %19, i64 %614
%616 = load double, double* %615
%617 = fmul double %595, %616
%618 = trunc i64 %614 to i32
%619 = shl i32 %618, 2
%620 = add i32 %599, %619
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %10, i64 %621
%623 = load double, double* %622
%624 = tail call double @llvm.fmuladd.f64(double %617, double %623, double %613)
%625 = add nuw nsw i64 %601, 2
%626 = add i64 %603, 2
%627 = icmp eq i64 %626, %140
br i1 %627, label %628, label %600
628: ; preds = %600, %593
%629 = phi double [ undef, %593 ], [ %624, %600 ]
%630 = phi i64 [ 0, %593 ], [ %625, %600 ]
%631 = phi double [ %592, %593 ], [ %624, %600 ]
br i1 %141, label %643, label %632
632: ; preds = %628
%633 = getelementptr inbounds double, double* %19, i64 %630
%634 = load double, double* %633
%635 = fmul double %595, %634
%636 = trunc i64 %630 to i32
%637 = shl i32 %636, 2
%638 = add i32 %599, %637
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds double, double* %10, i64 %639
%641 = load double, double* %640
%642 = tail call double @llvm.fmuladd.f64(double %635, double %641, double %631)
br label %643
643: ; preds = %632, %628, %590
%644 = phi double [ %592, %590 ], [ %629, %628 ], [ %642, %632 ]
%645 = add nuw nsw i64 %591, 1
%646 = icmp eq i64 %645, %116
br i1 %646, label %647, label %590
647: ; preds = %643, %581
%648 = phi double [ 0.000000e+00, %581 ], [ %644, %643 ]
%649 = sub nsw i32 %0, %589
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %22, i64 %650
%652 = load double, double* %651
%653 = fmul double %25, %652
%654 = load double, double* %528
%655 = fmul double %653, %654
%656 = load double, double* %88
%657 = fmul double %652, %3
%658 = load double, double* %532
%659 = fmul double %657, %658
%660 = load double, double* %94
%661 = fmul double %659, %660
%662 = tail call double @llvm.fmuladd.f64(double %655, double %656, double %661)
%663 = sub nsw i32 %89, %589
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds double, double* %22, i64 %664
%666 = load double, double* %665
%667 = fmul double %25, %666
%668 = fmul double %654, %667
%669 = load double, double* %91
%670 = fmul double %666, %3
%671 = fmul double %658, %670
%672 = load double, double* %96
%673 = fmul double %671, %672
%674 = tail call double @llvm.fmuladd.f64(double %668, double %669, double %673)
%675 = fsub double %585, %443
%676 = fsub double %453, %585
%677 = insertelement <2 x double> poison, double %674, i64 0
%678 = insertelement <2 x double> %677, double %676, i64 1
%679 = fneg <2 x double> %678
%680 = fmul <2 x double> %572, %679
%681 = insertelement <2 x double> %136, double %675, i64 1
%682 = insertelement <2 x double> %571, double %662, i64 0
%683 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %681, <2 x double> %682, <2 x double> %680)
%684 = insertelement <2 x double> %573, double %648, i64 0
%685 = fdiv <2 x double> %683, %684
%686 = shufflevector <2 x double> %685, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%687 = fsub <2 x double> %685, %686
%688 = extractelement <2 x double> %687, i64 0
%689 = tail call i32 @fabs(double %688)
%690 = tail call i32 @fabs(double %576)
%691 = icmp slt i32 %689, %690
br i1 %691, label %692, label %693
692: ; preds = %647
store double %585, double* %48
br label %695
693: ; preds = %647
%694 = load double, double* %48
br label %695
695: ; preds = %692, %693
%696 = phi double [ %585, %692 ], [ %694, %693 ]
%697 = phi double [ %688, %692 ], [ %576, %693 ]
%698 = add nuw nsw i32 %578, 1
%699 = icmp eq i32 %698, %4
br i1 %699, label %700, label %574
700: ; preds = %574, %695, %523
%701 = phi double [ %144, %523 ], [ %586, %695 ], [ %575, %574 ]
br i1 %145, label %142, label %702
702: ; preds = %700
ret void
}