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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
void findNURBSbasisFunIso(int ii, int jj, int iters, double *us,
                          double oldFunVal, double stepU, double stepV,
                          int degU, int degV, double *cp, int ncp, int kcp,
                          double *knotU, double *knotV, double *leftU,
                          double *rightU, double *NU, double *leftV,
                          double *rightV, double *NV) {
  int itr, i, j, spanU, spanV, ind, ind2, fourncp, myint, cpInd;
  double wgh, u, v, funVal;
  fourncp = 4 * ncp;
  cpInd = ii * fourncp + 4 * jj + 3;
  v = us[1];
  spanV = FindSpan(kcp, degV, v, knotV);
  BasisFuns(spanV, v, degV, knotV, NV, leftV, rightV);
  ind2 = spanV - degV;
  for (itr = 0; itr < iters; itr++) {
    u = us[0] - 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
    if (funVal > oldFunVal) {
      us[0] = u;
      oldFunVal = funVal;
      v = us[1] - 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
      if (funVal > oldFunVal) {
        us[1] = v;
        oldFunVal = funVal;
      } else {
        v += 2 * 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
        if (funVal > oldFunVal) {
          us[1] = v;
          oldFunVal = funVal;
        } else {
          v = us[1];
          spanV = FindSpan(kcp, degV, v, knotV);
          BasisFuns(spanV, v, degV, knotV, NV, leftV, rightV);
          ind2 = spanV - degV;
        }
      }
    } else {
      u += 2 * 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
      if (funVal > oldFunVal) {
        us[0] = u;
        oldFunVal = funVal;
      } else {
        u = us[0];
        spanU = FindSpan(ncp, degU, u, knotU);
        BasisFuns(spanU, u, degU, knotU, NU, leftU, rightU);
        ind = spanU - degU;
      }
      v = us[1] - 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
      if (funVal > oldFunVal) {
        us[1] = v;
        oldFunVal = funVal;
      } else {
        v += 2 * 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 = NV[ii - ind2] * NU[jj - ind] * cp[cpInd] / wgh;
        if (funVal > oldFunVal) {
          us[1] = v;
          oldFunVal = funVal;
        } else {
          v = us[1];
          spanV = FindSpan(kcp, degV, v, knotV);
          BasisFuns(spanV, v, degV, knotV, NV, leftV, rightV);
          ind2 = spanV - degV;
        }
      }
    }
    stepU = 0.5 * stepU;
    stepV = 0.5 * stepV;
  }
  if (us[0] < knotU[0]) {
    us[0] = knotU[0];
  } else if (us[0] > knotU[ncp]) {
    us[0] = knotU[ncp];
  }
  if (us[1] < knotV[0]) {
    us[1] = knotV[0];
  } else if (us[1] > knotV[kcp]) {
    us[1] = knotV[kcp];
  }
  return;
}


x86 assembly (clang, -O0):
<findNURBSbasisFunIso>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
mov    0x18(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ba1 <findNURBSbasisFunIso+0xa81>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%edi
mov    -0x34(%rbp),%esi
movsd  -0x70(%rbp),%xmm0
mov    0x28(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
movsd  -0x70(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x48(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     12f8 <findNURBSbasisFunIso+0x1d8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     12e5 <findNURBSbasisFunIso+0x1c5>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1281 <findNURBSbasisFunIso+0x161>
jmp    12ea <findNURBSbasisFunIso+0x1ca>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    126e <findNURBSbasisFunIso+0x14e>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    1688 <findNURBSbasisFunIso+0x568>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     145b <findNURBSbasisFunIso+0x33b>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1448 <findNURBSbasisFunIso+0x328>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13e4 <findNURBSbasisFunIso+0x2c4>
jmp    144d <findNURBSbasisFunIso+0x32d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13d1 <findNURBSbasisFunIso+0x2b1>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    14c3 <findNURBSbasisFunIso+0x3a3>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1683 <findNURBSbasisFunIso+0x563>
movsd  -0x30(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     15c8 <findNURBSbasisFunIso+0x4a8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     15b5 <findNURBSbasisFunIso+0x495>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1551 <findNURBSbasisFunIso+0x431>
jmp    15ba <findNURBSbasisFunIso+0x49a>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    153e <findNURBSbasisFunIso+0x41e>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    1630 <findNURBSbasisFunIso+0x510>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    167e <findNURBSbasisFunIso+0x55e>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1683 <findNURBSbasisFunIso+0x563>
jmp    1b6f <findNURBSbasisFunIso+0xa4f>
movsd  -0x28(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%edi
mov    -0x34(%rbp),%esi
movsd  -0x70(%rbp),%xmm0
mov    0x28(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
movsd  -0x70(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x48(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     178d <findNURBSbasisFunIso+0x66d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     177a <findNURBSbasisFunIso+0x65a>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1716 <findNURBSbasisFunIso+0x5f6>
jmp    177f <findNURBSbasisFunIso+0x65f>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1703 <findNURBSbasisFunIso+0x5e3>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    17f4 <findNURBSbasisFunIso+0x6d4>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1841 <findNURBSbasisFunIso+0x721>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%edi
mov    -0x34(%rbp),%esi
movsd  -0x70(%rbp),%xmm0
mov    0x28(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
movsd  -0x70(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x48(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1942 <findNURBSbasisFunIso+0x822>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     192f <findNURBSbasisFunIso+0x80f>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18cb <findNURBSbasisFunIso+0x7ab>
jmp    1934 <findNURBSbasisFunIso+0x814>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18b8 <findNURBSbasisFunIso+0x798>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    19aa <findNURBSbasisFunIso+0x88a>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1b6a <findNURBSbasisFunIso+0xa4a>
movsd  -0x30(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1aaf <findNURBSbasisFunIso+0x98f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1a9c <findNURBSbasisFunIso+0x97c>
mov    0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a38 <findNURBSbasisFunIso+0x918>
jmp    1aa1 <findNURBSbasisFunIso+0x981>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a25 <findNURBSbasisFunIso+0x905>
mov    0x60(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    1b17 <findNURBSbasisFunIso+0x9f7>
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1b65 <findNURBSbasisFunIso+0xa45>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%edi
mov    -0x38(%rbp),%esi
movsd  -0x78(%rbp),%xmm0
mov    0x30(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%esi
mov    0x30(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x4c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1b6a <findNURBSbasisFunIso+0xa4a>
jmp    1b6f <findNURBSbasisFunIso+0xa4f>
movsd  0x489(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0x477(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ec <findNURBSbasisFunIso+0xcc>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bd0 <findNURBSbasisFunIso+0xab0>
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1c05 <findNURBSbasisFunIso+0xae5>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movslq 0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1c00 <findNURBSbasisFunIso+0xae0>
mov    0x28(%rbp),%rax
movslq 0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1c05 <findNURBSbasisFunIso+0xae5>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c36 <findNURBSbasisFunIso+0xb16>
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1c6d <findNURBSbasisFunIso+0xb4d>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    0x30(%rbp),%rax
movslq 0x20(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1c68 <findNURBSbasisFunIso+0xb48>
mov    0x30(%rbp),%rax
movslq 0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1c6d <findNURBSbasisFunIso+0xb4d>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<findNURBSbasisFunIso>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9d,%ebp
mov    %r8d,%ebx
movsd  %xmm2,0x88(%rsp)
movsd  %xmm1,0x48(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %rcx,%r15
mov    %edx,%r12d
mov    %rsi,0x98(%rsp)
mov    %edi,0x24(%rsp)
mov    0x130(%rsp),%r13
mov    0x110(%rsp),%r14
mov    0x100(%rsp),%edi
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    %r9d,%esi
mov    %r14,%rdx
call   1040 <FindSpan@plt>
mov    %rax,(%rsp)
mov    %eax,%edi
movsd  0x58(%rsp),%xmm0
mov    %rbp,0x18(%rsp)
mov    %ebp,%esi
mov    %r14,%rdx
mov    0x140(%rsp),%rcx
mov    %r13,%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
movsd  0x48(%rsp),%xmm2
mov    0xf8(%rsp),%edi
mov    %r15,%rbp
mov    %r12d,0xa4(%rsp)
test   %r12d,%r12d
jle    1f6e <findNURBSbasisFunIso+0xe4e>
mov    %rbx,%r11
mov    0x128(%rsp),%r15
mov    0xf0(%rsp),%r14
lea    0x0(,%rdi,4),%r12d
mov    0x18(%rsp),%rcx
mov    (%rsp),%rax
sub    %ecx,%eax
mov    %rax,(%rsp)
mov    %r12d,%eax
imul   0x24(%rsp),%eax
mov    0x98(%rsp),%rdx
lea    (%rax,%rdx,4),%eax
or     $0x3,%eax
cltq
mov    %rax,0x80(%rsp)
lea    0x1(%rbx),%r13d
lea    0x1(%rcx),%r9d
lea    -0x1(%r13),%r10
mov    %r13,0x58(%rsp)
and    $0xfffffffe,%r13d
lea    0x0(,%rbx,4),%eax
mov    $0x7,%edx
sub    %eax,%edx
mov    %rdx,0x90(%rsp)
mov    $0x3,%edx
sub    %eax,%edx
mov    %rdx,0xb0(%rsp)
mov    %ecx,%eax
neg    %eax
mov    %eax,0x54(%rsp)
xor    %eax,%eax
mov    %rbx,0x38(%rsp)
mov    %rbp,0x30(%rsp)
mov    %r9,0x70(%rsp)
mov    %r10,0x68(%rsp)
jmp    12de <findNURBSbasisFunIso+0x1be>
xchg   %ax,%ax
movsd  %xmm1,0x10(%rsp)
mov    0x30(%rsp),%rbp
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x48(%rsp),%xmm0
mov    0xf8(%rsp),%edi
mov    0x78(%rsp),%rax
movsd  0xd50(%rip),%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
movsd  0x88(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x88(%rsp)
add    $0x1,%eax
cmp    0xa4(%rsp),%eax
je     1f6e <findNURBSbasisFunIso+0xe4e>
mov    %rax,0x78(%rsp)
movsd  0x0(%rbp),%xmm0
movsd  %xmm2,0x48(%rsp)
subsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r11d,%esi
mov    0x108(%rsp),%rdx
mov    %r12d,%ebp
mov    %r11,%r12
call   1040 <FindSpan@plt>
mov    %eax,%ebx
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %r12d,%esi
mov    0x108(%rsp),%rdx
mov    %r15,%rcx
mov    0x118(%rsp),%r8
mov    0x120(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %rbx,%rcx
mov    %r12,%rax
mov    %ecx,%esi
sub    %eax,%esi
mov    (%rsp),%rax
mov    %eax,%edx
mov    %ebp,%ebx
imul   %ebp,%edx
lea    0x0(,%rsi,4),%eax
cmpl   $0x0,0x18(%rsp)
mov    %eax,0x60(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x28(%rsp)
js     1470 <findNURBSbasisFunIso+0x350>
mov    %edx,%r9d
or     $0x3,%r9d
add    %eax,%r9d
mov    0x90(%rsp),%rax
add    %eax,%edx
lea    (%rdx,%rcx,4),%edx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x140(%rsp),%r10
mov    0x58(%rsp),%r11
mov    0x70(%rsp),%rcx
mov    0x68(%rsp),%r8
movsd  0x10(%rsp),%xmm3
jmp    13cf <findNURBSbasisFunIso+0x2af>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
add    %ebx,%edx
cmp    %rcx,%rsi
je     1482 <findNURBSbasisFunIso+0x362>
test   %r12d,%r12d
js     13c0 <findNURBSbasisFunIso+0x2a0>
movsd  (%r10,%rsi,8),%xmm1
test   %r8,%r8
je     1440 <findNURBSbasisFunIso+0x320>
mov    %edx,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rbp),%eax
cltq
mulsd  (%r14,%rax,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rdi,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %ebp,%rbp
mulsd  (%r14,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdi
add    $0x8,%ebp
cmp    %rdi,%r13
jne    13f0 <findNURBSbasisFunIso+0x2d0>
test   $0x1,%r11b
je     13c0 <findNURBSbasisFunIso+0x2a0>
jmp    144c <findNURBSbasisFunIso+0x32c>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edi,%edi
test   $0x1,%r11b
je     13c0 <findNURBSbasisFunIso+0x2a0>
mov    %ebx,%eax
imul   %esi,%eax
add    %r9d,%eax
mulsd  (%r15,%rdi,8),%xmm1
lea    (%rax,%rdi,4),%eax
cltq
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm1,%xmm0
jmp    13c0 <findNURBSbasisFunIso+0x2a0>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
mov    0x140(%rsp),%r10
movsd  0x10(%rsp),%xmm3
mov    0x24(%rsp),%eax
sub    (%rsp),%eax
movslq %eax,%rdx
movsd  (%r10,%rdx,8),%xmm1
mov    0x98(%rsp),%rax
sub    0x28(%rsp),%eax
movslq %eax,%rcx
mulsd  (%r15,%rcx,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
jbe    1660 <findNURBSbasisFunIso+0x540>
mov    %rcx,0x40(%rsp)
movsd  %xmm1,0x28(%rsp)
mov    0x30(%rsp),%rax
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%rax)
movsd  0x8(%rax),%xmm0
subsd  0x88(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%r12
mov    %r12d,%esi
mov    0x110(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %r12d,%esi
mov    0x110(%rsp),%rdx
mov    0x140(%rsp),%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %ebp,%eax
sub    %r12d,%eax
mov    %rax,(%rsp)
test   %r12d,%r12d
js     17f5 <findNURBSbasisFunIso+0x6d5>
mov    0x60(%rsp),%eax
or     $0x3,%eax
add    0x54(%rsp),%ebp
mov    %ebx,%r12d
imul   %ebx,%ebp
add    0x90(%rsp),%ebp
mov    0xa8(%rsp),%rcx
lea    0x0(%rbp,%rcx,4),%ecx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%r8
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%r10
mov    (%rsp),%rbx
movsd  0x28(%rsp),%xmm3
jmp    15b0 <findNURBSbasisFunIso+0x490>
xchg   %ax,%ax
add    $0x1,%rdx
add    %r12d,%ecx
cmp    %r9,%rdx
je     1813 <findNURBSbasisFunIso+0x6f3>
test   %r11d,%r11d
js     15a0 <findNURBSbasisFunIso+0x480>
movsd  (%r8,%rdx,8),%xmm1
test   %r10,%r10
je     1620 <findNURBSbasisFunIso+0x500>
mov    %ecx,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rdi),%ebp
movslq %ebp,%rbp
mulsd  (%r14,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x8,%edi
cmp    %rsi,%r13
jne    15d0 <findNURBSbasisFunIso+0x4b0>
testb  $0x1,0x58(%rsp)
je     15a0 <findNURBSbasisFunIso+0x480>
jmp    162d <findNURBSbasisFunIso+0x50d>
nopw   0x0(%rax,%rax,1)
xor    %esi,%esi
testb  $0x1,0x58(%rsp)
je     15a0 <findNURBSbasisFunIso+0x480>
lea    (%rbx,%rdx,1),%edi
imul   %r12d,%edi
add    %eax,%edi
mulsd  (%r15,%rsi,8),%xmm1
lea    (%rdi,%rsi,4),%esi
movslq %esi,%rsi
mulsd  (%r14,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    15a0 <findNURBSbasisFunIso+0x480>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,0x60(%rsp)
movsd  0x48(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0xf8(%rsp),%eax
mov    %rax,%rdi
mov    %r12d,%esi
mov    0x108(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x28(%rsp),%xmm0
mov    %r12d,%esi
mov    0x108(%rsp),%rdx
mov    %r15,%rcx
mov    0x118(%rsp),%r8
mov    0x120(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %r12,%rsi
mov    %ebp,%eax
sub    %esi,%eax
cmpl   $0x0,0x18(%rsp)
mov    %rax,0x8(%rsp)
js     19c2 <findNURBSbasisFunIso+0x8a2>
mov    (%rsp),%rcx
mov    0xf8(%rsp),%eax
imul   %eax,%ecx
add    %ebp,%ecx
mov    0x90(%rsp),%rax
lea    (%rax,%rcx,4),%eax
mov    0xb0(%rsp),%rcx
mov    0x40(%rsp),%rdx
add    %edx,%ecx
or     $0x3,%edx
mov    %rdx,0x40(%rsp)
lea    (%rcx,%rbp,4),%ecx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x140(%rsp),%r8
mov    0x58(%rsp),%r9
mov    0x70(%rsp),%r11
mov    0x68(%rsp),%r10
mov    %ebx,%r12d
movsd  0x10(%rsp),%xmm3
jmp    1753 <findNURBSbasisFunIso+0x633>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %r12d,%eax
add    %r12d,%ecx
cmp    %r11,%rdx
je     19d7 <findNURBSbasisFunIso+0x8b7>
test   %esi,%esi
js     1740 <findNURBSbasisFunIso+0x620>
movsd  (%r8,%rdx,8),%xmm1
test   %r10,%r10
je     17c0 <findNURBSbasisFunIso+0x6a0>
mov    %ecx,%edi
mov    %eax,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rbx,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %ebp,%rbp
mulsd  (%r14,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rbx
add    $0x8,%ebp
add    $0x8,%edi
cmp    %rbx,%r13
jne    1770 <findNURBSbasisFunIso+0x650>
test   $0x1,%r9b
je     1740 <findNURBSbasisFunIso+0x620>
jmp    17cc <findNURBSbasisFunIso+0x6ac>
cs nopw 0x0(%rax,%rax,1)
xor    %ebx,%ebx
test   $0x1,%r9b
je     1740 <findNURBSbasisFunIso+0x620>
mov    %r12d,%edi
imul   %edx,%edi
add    0x40(%rsp),%edi
mulsd  (%r15,%rbx,8),%xmm1
add    0x8(%rsp),%ebx
lea    (%rdi,%rbx,4),%edi
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1740 <findNURBSbasisFunIso+0x620>
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%r8
mov    %ebx,%r12d
mov    (%rsp),%rbx
movsd  0x28(%rsp),%xmm3
mov    0x24(%rsp),%eax
sub    %ebx,%eax
cltq
movsd  (%r8,%rax,8),%xmm1
mov    0x40(%rsp),%rax
mulsd  (%r15,%rax,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
ja     1280 <findNURBSbasisFunIso+0x160>
movsd  0x88(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
mov    0x140(%rsp),%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %ebp,%eax
sub    %ebx,%eax
mov    %rax,(%rsp)
test   %ebx,%ebx
js     1de2 <findNURBSbasisFunIso+0xcc2>
mov    0x60(%rsp),%r8d
or     $0x3,%r8d
add    0x54(%rsp),%ebp
imul   %r12d,%ebp
add    0x90(%rsp),%ebp
mov    0xa8(%rsp),%rax
lea    0x0(%rbp,%rax,4),%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbp
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%r10
mov    (%rsp),%rbx
movsd  0x28(%rsp),%xmm3
jmp    1920 <findNURBSbasisFunIso+0x800>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %r12d,%eax
cmp    %r9,%rcx
je     1dfd <findNURBSbasisFunIso+0xcdd>
test   %r11d,%r11d
js     1910 <findNURBSbasisFunIso+0x7f0>
movsd  0x0(%rbp,%rcx,8),%xmm1
test   %r10,%r10
je     1990 <findNURBSbasisFunIso+0x870>
mov    %eax,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rsi),%edi
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %esi,%rsi
mulsd  (%r14,%rsi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    $0x8,%esi
cmp    %rdx,%r13
jne    1940 <findNURBSbasisFunIso+0x820>
testb  $0x1,0x58(%rsp)
je     1910 <findNURBSbasisFunIso+0x7f0>
jmp    199d <findNURBSbasisFunIso+0x87d>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
testb  $0x1,0x58(%rsp)
je     1910 <findNURBSbasisFunIso+0x7f0>
lea    (%rbx,%rcx,1),%esi
imul   %r12d,%esi
add    %r8d,%esi
mulsd  (%r15,%rdx,8),%xmm1
lea    (%rsi,%rdx,4),%edx
movslq %edx,%rdx
mulsd  (%r14,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1910 <findNURBSbasisFunIso+0x7f0>
xorpd  %xmm0,%xmm0
mov    0x140(%rsp),%r8
mov    %ebx,%r12d
movsd  0x10(%rsp),%xmm3
mov    0x60(%rsp),%rax
movsd  (%r8,%rax,8),%xmm1
mov    0x98(%rsp),%rax
mov    0x8(%rsp),%rcx
sub    %ecx,%eax
cltq
mulsd  (%r15,%rax,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
jbe    1a30 <findNURBSbasisFunIso+0x910>
movsd  %xmm1,0x10(%rsp)
mov    0x30(%rsp),%rax
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,(%rax)
jmp    1a92 <findNURBSbasisFunIso+0x972>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%rsp)
mov    0xf8(%rsp),%edi
mov    0x108(%rsp),%rdx
mov    %rsi,%rbx
movsd  %xmm3,0x10(%rsp)
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    %ebx,%esi
mov    0x108(%rsp),%rdx
mov    %r15,%rcx
mov    0x118(%rsp),%r8
mov    0x120(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x30(%rsp),%rax
sub    %ebx,%ebp
mov    %rbp,0x8(%rsp)
movsd  0x8(%rax),%xmm0
subsd  0x88(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x40(%rsp),%xmm0
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
mov    0x140(%rsp),%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %ebp,%eax
sub    %ebx,%eax
mov    %rax,(%rsp)
mov    0x8(%rsp),%rax
lea    0x0(,%rax,4),%ecx
test   %ebx,%ebx
mov    %rcx,0x28(%rsp)
js     1c02 <findNURBSbasisFunIso+0xae2>
mov    %ecx,%eax
or     $0x3,%eax
add    0x54(%rsp),%ebp
imul   %r12d,%ebp
add    %ebp,%ecx
add    $0x7,%ecx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbx
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%r10
mov    (%rsp),%r8
movsd  0x10(%rsp),%xmm3
jmp    1b60 <findNURBSbasisFunIso+0xa40>
xchg   %ax,%ax
add    $0x1,%rdx
add    %r12d,%ecx
cmp    %r9,%rdx
je     1c1d <findNURBSbasisFunIso+0xafd>
test   %r11d,%r11d
js     1b50 <findNURBSbasisFunIso+0xa30>
movsd  (%rbx,%rdx,8),%xmm1
test   %r10,%r10
je     1bd0 <findNURBSbasisFunIso+0xab0>
mov    %ecx,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rdi),%ebp
movslq %ebp,%rbp
mulsd  (%r14,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x8,%edi
cmp    %rsi,%r13
jne    1b80 <findNURBSbasisFunIso+0xa60>
testb  $0x1,0x58(%rsp)
je     1b50 <findNURBSbasisFunIso+0xa30>
jmp    1bdd <findNURBSbasisFunIso+0xabd>
nopw   0x0(%rax,%rax,1)
xor    %esi,%esi
testb  $0x1,0x58(%rsp)
je     1b50 <findNURBSbasisFunIso+0xa30>
lea    (%r8,%rdx,1),%edi
imul   %r12d,%edi
add    %eax,%edi
mulsd  (%r15,%rsi,8),%xmm1
lea    (%rdi,%rsi,4),%esi
movslq %esi,%rsi
mulsd  (%r14,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1b50 <findNURBSbasisFunIso+0xa30>
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbx
mov    (%rsp),%r8
movsd  0x10(%rsp),%xmm3
mov    0x24(%rsp),%eax
sub    %r8d,%eax
cltq
movsd  (%rbx,%rax,8),%xmm1
mov    0x98(%rsp),%rax
sub    0x8(%rsp),%eax
movslq %eax,%rcx
mulsd  (%r15,%rcx,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
jbe    1c70 <findNURBSbasisFunIso+0xb50>
movsd  %xmm1,0x10(%rsp)
mov    0x30(%rsp),%rbp
movsd  0x40(%rsp),%xmm0
jmp    1291 <findNURBSbasisFunIso+0x171>
xchg   %ax,%ax
mov    %rcx,0x60(%rsp)
movsd  0x88(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%rbx
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebp
mov    %eax,%edi
movsd  0x8(%rsp),%xmm0
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
mov    0x140(%rsp),%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    %ebp,%eax
sub    %ebx,%eax
mov    %rax,(%rsp)
test   %ebx,%ebx
js     1eab <findNURBSbasisFunIso+0xd8b>
add    0x54(%rsp),%ebp
imul   %r12d,%ebp
mov    0x28(%rsp),%r8
mov    %r8d,%eax
or     $0x3,%r8d
add    %ebp,%eax
add    $0x7,%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbp
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%r10
mov    (%rsp),%rbx
movsd  0x10(%rsp),%xmm3
jmp    1d40 <findNURBSbasisFunIso+0xc20>
nopl   0x0(%rax)
add    $0x1,%rcx
add    %r12d,%eax
cmp    %r9,%rcx
je     1ec6 <findNURBSbasisFunIso+0xda6>
test   %r11d,%r11d
js     1d30 <findNURBSbasisFunIso+0xc10>
movsd  0x0(%rbp,%rcx,8),%xmm1
test   %r10,%r10
je     1db0 <findNURBSbasisFunIso+0xc90>
mov    %eax,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
lea    -0x4(%rsi),%edi
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movslq %esi,%rsi
mulsd  (%r14,%rsi,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    $0x8,%esi
cmp    %rdx,%r13
jne    1d60 <findNURBSbasisFunIso+0xc40>
testb  $0x1,0x58(%rsp)
je     1d30 <findNURBSbasisFunIso+0xc10>
jmp    1dbd <findNURBSbasisFunIso+0xc9d>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
testb  $0x1,0x58(%rsp)
je     1d30 <findNURBSbasisFunIso+0xc10>
lea    (%rbx,%rcx,1),%esi
imul   %r12d,%esi
add    %r8d,%esi
mulsd  (%r15,%rdx,8),%xmm1
lea    (%rsi,%rdx,4),%edx
movslq %edx,%rdx
mulsd  (%r14,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1d30 <findNURBSbasisFunIso+0xc10>
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbp
mov    (%rsp),%rbx
movsd  0x28(%rsp),%xmm3
mov    0x24(%rsp),%eax
sub    %ebx,%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm1
mov    0x40(%rsp),%rax
mulsd  (%r15,%rax,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
ja     1280 <findNURBSbasisFunIso+0x160>
mov    0x30(%rsp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%rsi
mov    0x110(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,%ebx
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    0x18(%rsp),%rsi
mov    0x110(%rsp),%rdx
mov    %rbp,%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x30(%rsp),%rbp
sub    0x18(%rsp),%ebx
mov    %rbx,(%rsp)
mov    0x38(%rsp),%r11
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
jmp    1296 <findNURBSbasisFunIso+0x176>
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r11
mov    0x140(%rsp),%rbp
mov    (%rsp),%rbx
movsd  0x10(%rsp),%xmm3
mov    0x24(%rsp),%eax
sub    %ebx,%eax
cltq
movsd  0x0(%rbp,%rax,8),%xmm1
mov    0x60(%rsp),%rax
mulsd  (%r15,%rax,8),%xmm1
mov    0x80(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm1
divsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
ja     1280 <findNURBSbasisFunIso+0x160>
mov    0x30(%rsp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,(%rsp)
mov    0x100(%rsp),%edi
mov    0x18(%rsp),%rsi
mov    0x110(%rsp),%rdx
movsd  %xmm3,0x10(%rsp)
call   1040 <FindSpan@plt>
mov    %eax,%ebx
mov    %eax,%edi
movsd  (%rsp),%xmm0
mov    0x18(%rsp),%rsi
mov    0x110(%rsp),%rdx
mov    %rbp,%rcx
mov    0x130(%rsp),%r8
mov    0x138(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x30(%rsp),%rbp
sub    0x18(%rsp),%ebx
mov    %rbx,(%rsp)
mov    0x38(%rsp),%r11
jmp    1296 <findNURBSbasisFunIso+0x176>
movsd  0x0(%rbp),%xmm1
mov    0x108(%rsp),%rcx
movsd  (%rcx),%xmm0
ucomisd %xmm1,%xmm0
ja     1f93 <findNURBSbasisFunIso+0xe73>
movslq %edi,%rax
movsd  (%rcx,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    1f98 <findNURBSbasisFunIso+0xe78>
movsd  %xmm0,0x0(%rbp)
movsd  0x8(%rbp),%xmm1
mov    0x110(%rsp),%rcx
movsd  (%rcx),%xmm0
ucomisd %xmm1,%xmm0
ja     1fc2 <findNURBSbasisFunIso+0xea2>
movslq 0x100(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
jbe    1fc7 <findNURBSbasisFunIso+0xea7>
movsd  %xmm0,0x8(%rbp)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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