#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 NURBSsurfaceEval(int degU, int degV, double *cp, int ncp, int kcp,
                      double *knotU, double *knotV, double *us, int nus,
                      double *ep, double *leftU, double *rightU, double *NU,
                      double *leftV, double *rightV, double *NV) {
  int i, j, jj, spanU, spanV, ind, ind2, fourncp, threejj, myint;
  double wgh, NN;
  fourncp = 4 * ncp;
  for (jj = 0; jj < nus; jj++) {
    threejj = 3 * jj;
    if (us[2 * jj] <= knotU[degU]) {
      if (us[2 * jj + 1] <= knotV[degV]) {
        ep[threejj] = cp[0] / cp[3];
        ep[threejj + 1] = cp[1] / cp[3];
        ep[threejj + 2] = cp[2] / cp[3];
      } else if (us[2 * jj + 1] >= knotV[kcp]) {
        myint = fourncp * (kcp - 1);
        ep[threejj] = cp[myint] / cp[myint + 3];
        ep[threejj + 1] = cp[myint + 1] / cp[myint + 3];
        ep[threejj + 2] = cp[myint + 2] / cp[myint + 3];
      } else {
        ep[threejj] = 0.0;
        ep[threejj + 1] = 0.0;
        ep[threejj + 2] = 0.0;
        wgh = 0.0;
        spanV = FindSpan(kcp, degV, us[2 * jj + 1], knotV);
        BasisFuns(spanV, us[2 * jj + 1], degV, knotV, NV, leftV, rightV);
        ind = spanV - degV;
        for (i = 0; i <= degV; i++) {
          myint = (ind + i) * fourncp;
          ep[threejj] += NV[i] * cp[myint];
          ep[threejj + 1] += NV[i] * cp[myint + 1];
          ep[threejj + 2] += NV[i] * cp[myint + 2];
          wgh += NV[i] * cp[myint + 3];
        }
        ep[threejj] = ep[threejj] / wgh;
        ep[threejj + 1] = ep[threejj + 1] / wgh;
        ep[threejj + 2] = ep[threejj + 2] / wgh;
      }
    } else if (us[2 * jj] >= knotU[ncp]) {
      if (us[2 * jj + 1] <= knotV[degV]) {
        ep[threejj] = cp[fourncp - 4] / cp[fourncp - 1];
        ep[threejj + 1] = cp[fourncp - 3] / cp[fourncp - 1];
        ep[threejj + 2] = cp[fourncp - 2] / cp[fourncp - 1];
      } else if (us[2 * jj + 1] >= knotV[kcp]) {
        myint = fourncp * kcp;
        ep[threejj] = cp[myint - 4] / cp[myint - 1];
        ep[threejj + 1] = cp[myint - 3] / cp[myint - 1];
        ep[threejj + 2] = cp[myint - 2] / cp[myint - 1];
      } else {
        ep[threejj] = 0.0;
        ep[threejj + 1] = 0.0;
        ep[threejj + 2] = 0.0;
        wgh = 0.0;
        spanV = FindSpan(kcp, degV, us[2 * jj + 1], knotV);
        BasisFuns(spanV, us[2 * jj + 1], degV, knotV, NV, leftV, rightV);
        ind = spanV - degV;
        myint = (ind + 1) * fourncp;
        for (i = 0; i <= degV; i++) {
          ep[threejj] += NV[i] * cp[i * fourncp + myint - 4];
          ep[threejj + 1] += NV[i] * cp[i * fourncp + myint - 3];
          ep[threejj + 2] += NV[i] * cp[i * fourncp + myint - 2];
          wgh += NV[i] * cp[i * fourncp + myint - 1];
        }
        ep[threejj] = ep[threejj] / wgh;
        ep[threejj + 1] = ep[threejj + 1] / wgh;
        ep[threejj + 2] = ep[threejj + 2] / wgh;
      }
    } else {
      ep[threejj] = 0.0;
      ep[threejj + 1] = 0.0;
      ep[threejj + 2] = 0.0;
      wgh = 0.0;
      if (us[2 * jj + 1] <= knotV[degV]) {
        spanU = FindSpan(ncp, degU, us[2 * jj], knotU);
        BasisFuns(spanU, us[2 * jj], degU, knotU, NU, leftU, rightU);
        ind = spanU - degU;
        for (i = 0; i <= degU; i++) {
          ep[threejj] += NU[i] * cp[(ind + i) * 4];
          ep[threejj + 1] += NU[i] * cp[(ind + i) * 4 + 1];
          ep[threejj + 2] += NU[i] * cp[(ind + i) * 4 + 2];
          wgh += NU[i] * cp[(ind + i) * 4 + 3];
        }
        ep[threejj] = ep[threejj] / wgh;
        ep[threejj + 1] = ep[threejj + 1] / wgh;
        ep[threejj + 2] = ep[threejj + 2] / wgh;
      } else if (us[2 * jj + 1] >= knotV[kcp]) {
        spanU = FindSpan(ncp, degU, us[2 * jj], knotU);
        BasisFuns(spanU, us[2 * jj], degU, knotU, NU, leftU, rightU);
        ind = spanU - degU;
        myint = ind * 4 + (kcp - 1) * fourncp;
        for (i = 0; i <= degU; i++) {
          ep[threejj] += NU[i] * cp[i * 4 + myint];
          ep[threejj + 1] += NU[i] * cp[i * 4 + myint + 1];
          ep[threejj + 2] += NU[i] * cp[i * 4 + myint + 2];
          wgh += NU[i] * cp[i * 4 + myint + 3];
        }
        ep[threejj] = ep[threejj] / wgh;
        ep[threejj + 1] = ep[threejj + 1] / wgh;
        ep[threejj + 2] = ep[threejj + 2] / wgh;
      } else {
        spanU = FindSpan(ncp, degU, us[2 * jj], knotU);
        BasisFuns(spanU, us[2 * jj], degU, knotU, NU, leftU, rightU);
        spanV = FindSpan(kcp, degV, us[2 * jj + 1], knotV);
        BasisFuns(spanV, us[2 * jj + 1], degV, knotV, NV, leftV, rightV);
        ind = spanU - degU;
        ind2 = spanV - degV;
        myint = ind2 * fourncp + ind * 4;
        for (i = 0; i <= degV; i++) {
          for (j = 0; j <= degU; j++) {
            NN = NV[i] * NU[j];
            ep[threejj] += NN * cp[i * fourncp + j * 4 + myint];
            ep[threejj + 1] += NN * cp[i * fourncp + j * 4 + myint + 1];
            ep[threejj + 2] += NN * cp[i * fourncp + j * 4 + myint + 2];
            wgh += NN * cp[i * fourncp + j * 4 + myint + 3];
          }
        }
        ep[threejj] = ep[threejj] / wgh;
        ep[threejj + 1] = ep[threejj + 1] / wgh;
        ep[threejj + 2] = ep[threejj + 2] / wgh;
      }
    }
  }
}


x86 assembly (clang, -O0):
<NURBSsurfaceEval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
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),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    20a2 <NURBSsurfaceEval+0xf82>
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1547 <NURBSsurfaceEval+0x427>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1247 <NURBSsurfaceEval+0x127>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x18(%rax),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x18(%rax),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x18(%rax),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1542 <NURBSsurfaceEval+0x422>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     131b <NURBSsurfaceEval+0x1fb>
mov    -0x40(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    153d <NURBSsurfaceEval+0x41d>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     14cc <NURBSsurfaceEval+0x3ac>
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
imul   -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c4 <NURBSsurfaceEval+0x2a4>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1542 <NURBSsurfaceEval+0x422>
jmp    208f <NURBSsurfaceEval+0xf6f>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     195b <NURBSsurfaceEval+0x83b>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     163a <NURBSsurfaceEval+0x51a>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1956 <NURBSsurfaceEval+0x836>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     170e <NURBSsurfaceEval+0x5ee>
mov    -0x40(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1951 <NURBSsurfaceEval+0x831>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
imul   -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     18e0 <NURBSsurfaceEval+0x7c0>
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17c4 <NURBSsurfaceEval+0x6a4>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1956 <NURBSsurfaceEval+0x836>
jmp    208a <NURBSsurfaceEval+0xf6a>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1bb5 <NURBSsurfaceEval+0xa95>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x40(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    0x38(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1b3f <NURBSsurfaceEval+0xa1f>
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a2a <NURBSsurfaceEval+0x90a>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2085 <NURBSsurfaceEval+0xf65>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1dde <NURBSsurfaceEval+0xcbe>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x40(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    0x38(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x2,%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1d68 <NURBSsurfaceEval+0xc48>
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c53 <NURBSsurfaceEval+0xb33>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2080 <NURBSsurfaceEval+0xf60>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x40(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    0x38(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x40(%rbp),%eax
mov    -0x38(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     200f <NURBSsurfaceEval+0xeef>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1ffc <NURBSsurfaceEval+0xedc>
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1ec4 <NURBSsurfaceEval+0xda4>
jmp    2001 <NURBSsurfaceEval+0xee1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1eb1 <NURBSsurfaceEval+0xd91>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2085 <NURBSsurfaceEval+0xf65>
jmp    208a <NURBSsurfaceEval+0xf6a>
jmp    208f <NURBSsurfaceEval+0xf6f>
jmp    2094 <NURBSsurfaceEval+0xf74>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1174 <NURBSsurfaceEval+0x54>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NURBSsurfaceEval>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r8d,0x24(%rsp)
mov    %rcx,0x48(%rsp)
mov    %esi,0x4(%rsp)
mov    0x170(%rsp),%eax
test   %eax,%eax
jle    1e20 <NURBSsurfaceEval+0xd00>
mov    %r9,%r11
mov    %rdx,%rbp
mov    %edi,%esi
mov    0x48(%rsp),%r8
lea    0x0(,%r8,4),%edi
mov    %rdi,0x68(%rsp)
mov    0x24(%rsp),%edx
movslq %edx,%rbx
mov    %rbx,%rcx
mov    %rbx,0x50(%rsp)
lea    -0x1(%rbx),%ecx
imul   %edi,%ecx
mov    %rcx,0x90(%rsp)
movslq %ecx,%rbx
mov    %ebx,%ecx
or     $0x3,%ecx
movslq %ecx,%rcx
mov    %rcx,0x100(%rsp)
mov    %ebx,%ecx
or     $0x1,%ecx
movslq %ecx,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rbx,%rcx
mov    %rbx,0x108(%rsp)
or     $0x2,%ecx
movslq %ecx,%rcx
mov    %rcx,0xf0(%rsp)
lea    -0x4(%rdi),%ecx
movslq %ecx,%rcx
mov    %rcx,0xe8(%rsp)
lea    -0x1(%rdi),%ecx
movslq %ecx,%rcx
mov    %rcx,0xe0(%rsp)
lea    -0x3(%rdi),%ecx
movslq %ecx,%rcx
mov    %rcx,0xd8(%rsp)
lea    -0x2(%rdi),%ecx
movslq %ecx,%rcx
mov    %rcx,0xd0(%rsp)
mov    %edi,%ecx
imul   %edx,%ecx
lea    -0x4(%rcx),%edx
movslq %edx,%rdx
mov    %rdx,0xb0(%rsp)
lea    -0x1(%rcx),%edx
movslq %edx,%rdx
mov    %rdx,0xa8(%rsp)
lea    -0x3(%rcx),%edx
movslq %edx,%rdx
mov    %rdx,0xa0(%rsp)
add    $0xfffffffe,%ecx
movslq %ecx,%rcx
mov    %rcx,0x98(%rsp)
mov    %eax,%r14d
movslq %edi,%rax
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0xc0(%rsp)
movslq 0x4(%rsp),%r15
mov    $0x1,%ecx
sub    %r15d,%ecx
mov    %ecx,0x64(%rsp)
movslq %esi,%rdi
lea    0x0(,%rdi,4),%ecx
neg    %ecx
mov    %rcx,0x78(%rsp)
lea    0x1(%rdi),%ecx
lea    0x0(,%rcx,4),%rdx
mov    %rdx,0x70(%rsp)
shl    $0x3,%rcx
mov    %rcx,0x88(%rsp)
mov    %r15d,%ecx
neg    %ecx
mov    %ecx,0x60(%rsp)
mov    0x190(%rsp),%rbx
mov    0x178(%rsp),%r13
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
movslq %r8d,%rcx
mov    %rcx,0x120(%rsp)
lea    0x1(%r15),%ecx
mov    %rcx,0x58(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0xb8(%rsp)
mov    %rax,0xc8(%rsp)
mov    %eax,%eax
mov    %rax,0x80(%rsp)
xor    %r8d,%r8d
mov    %r11,0x10(%rsp)
mov    %esi,(%rsp)
mov    %r14,0x40(%rsp)
mov    %r15,0x38(%rsp)
mov    %rdi,0x30(%rsp)
jmp    1352 <NURBSsurfaceEval+0x232>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp),%xmm0
divsd  0x18(%rbp),%xmm0
mov    %eax,%eax
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rbp),%xmm0
divsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rbp),%xmm0
divsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
add    $0x1,%r8
cmp    %r14,%r8
je     1e20 <NURBSsurfaceEval+0xd00>
lea    (%r8,%r8,2),%eax
lea    (%r8,%r8,1),%rdx
mov    %r8,%rcx
shl    $0x4,%rcx
movsd  (%r12,%rcx,1),%xmm0
movsd  (%r11,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jae    15d0 <NURBSsurfaceEval+0x4b0>
mov    0x120(%rsp),%rcx
ucomisd (%r11,%rcx,8),%xmm0
jae    1770 <NURBSsurfaceEval+0x650>
mov    %r15,%rcx
mov    %eax,%r15d
movq   $0x0,0x0(%r13,%r15,8)
lea    0x1(%r15),%r14
movq   $0x0,0x8(%r13,%r15,8)
mov    %r12,%rdi
lea    0x2(%r15),%r12
movq   $0x0,0x10(%r13,%r15,8)
mov    %rdx,%rax
or     $0x1,%rax
movsd  (%rdi,%rax,8),%xmm1
movsd  (%r9,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
mov    %r8,0x18(%rsp)
mov    %rdx,0x8(%rsp)
jae    1901 <NURBSsurfaceEval+0x7e1>
mov    %rax,0x28(%rsp)
mov    0x50(%rsp),%rax
movsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,0x118(%rsp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0x48(%rsp),%rdi
mov    %r11,%rdx
movsd  %xmm1,0x110(%rsp)
call   1040 <FindSpan@plt>
mov    0x168(%rsp),%rcx
mov    0x8(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    %rax,0x8(%rsp)
mov    %eax,%edi
mov    (%rsp),%esi
mov    0x10(%rsp),%rdx
mov    %rbx,%rcx
mov    0x180(%rsp),%r8
mov    0x188(%rsp),%r9
call   1030 <BasisFuns@plt>
movsd  0x110(%rsp),%xmm0
ucomisd 0x118(%rsp),%xmm0
jae    1ab2 <NURBSsurfaceEval+0x992>
mov    0x168(%rsp),%rbx
mov    0x28(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
mov    0x24(%rsp),%edi
mov    0x4(%rsp),%esi
mov    0x160(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    0x28(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    %rax,%rbx
mov    %ebx,%edi
mov    0x4(%rsp),%esi
mov    0x160(%rsp),%rdx
mov    0x1a8(%rsp),%rcx
mov    0x198(%rsp),%r8
mov    0x1a0(%rsp),%r9
call   1030 <BasisFuns@plt>
cmpl   $0x0,0x4(%rsp)
js     1ce2 <NURBSsurfaceEval+0xbc2>
add    0x60(%rsp),%ebx
imul   0x68(%rsp),%ebx
add    0x78(%rsp),%ebx
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,4),%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    (%rsp),%r11d
mov    0x1a8(%rsp),%r10
mov    0x70(%rsp),%rbx
mov    0x80(%rsp),%r9
jmp    1522 <NURBSsurfaceEval+0x402>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
add    %r9,%rax
cmp    0x58(%rsp),%rcx
je     1cea <NURBSsurfaceEval+0xbca>
test   %r11d,%r11d
js     1510 <NURBSsurfaceEval+0x3f0>
movsd  0x0(%r13,%r15,8),%xmm1
movsd  0x0(%r13,%r14,8),%xmm2
movsd  0x0(%r13,%r12,8),%xmm3
xor    %edx,%edx
mov    0x190(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
movsd  (%r10,%rcx,8),%xmm4
mulsd  (%r8,%rdx,2),%xmm4
lea    (%rax,%rdx,1),%rsi
movslq %esi,%rsi
movsd  0x0(%rbp,%rsi,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm1
movsd  %xmm1,0x0(%r13,%r15,8)
lea    0x1(%rsi),%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm2
lea    0x2(%rsi),%edi
movslq %edi,%rdi
movsd  %xmm2,0x0(%r13,%r14,8)
movsd  0x0(%rbp,%rdi,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm5,%xmm3
movsd  %xmm3,0x0(%r13,%r12,8)
add    $0x3,%esi
movslq %esi,%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm4
addsd  %xmm4,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1550 <NURBSsurfaceEval+0x430>
jmp    1510 <NURBSsurfaceEval+0x3f0>
nopl   0x0(%rax)
or     $0x1,%rdx
movsd  (%r12,%rdx,8),%xmm0
movsd  (%r9,%r15,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1310 <NURBSsurfaceEval+0x1f0>
mov    0x50(%rsp),%rcx
ucomisd (%r9,%rcx,8),%xmm0
jae    1a18 <NURBSsurfaceEval+0x8f8>
mov    %r8,0x18(%rsp)
mov    %eax,%r15d
movq   $0x0,0x0(%r13,%r15,8)
mov    %r12,%rbx
lea    0x1(%r15),%r12
movq   $0x0,0x8(%r13,%r15,8)
lea    0x2(%r15),%r14
movq   $0x0,0x10(%r13,%r15,8)
movsd  (%rbx,%rdx,8),%xmm0
mov    0x24(%rsp),%edi
mov    0x4(%rsp),%esi
mov    %rdx,0x8(%rsp)
mov    %r9,%rdx
call   1040 <FindSpan@plt>
mov    0x8(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    %eax,%ebx
mov    %eax,%edi
mov    0x4(%rsp),%esi
mov    0x160(%rsp),%rdx
mov    0x1a8(%rsp),%rcx
mov    0x198(%rsp),%r8
mov    0x1a0(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
js     1c01 <NURBSsurfaceEval+0xae1>
sub    %eax,%ebx
movslq %ebx,%rcx
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r12,8),%xmm1
movsd  0x0(%r13,%r14,8),%xmm0
mov    0xc0(%rsp),%r11
mov    %r11,%rax
imul   %rcx,%rax
imul   0xc8(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xorpd  %xmm3,%xmm3
xor    %edx,%edx
mov    0x1a8(%rsp),%r10
mov    0x190(%rsp),%rbx
mov    0x58(%rsp),%r8
mov    0xb8(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
movsd  (%r10,%rdx,8),%xmm4
mulsd  (%rcx),%xmm4
addsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
movsd  (%r10,%rdx,8),%xmm4
mov    %rax,%rsi
sar    $0x1d,%rsi
mov    %rsi,%rdi
or     $0x8,%rdi
mulsd  0x0(%rbp,%rdi,1),%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%r13,%r12,8)
movsd  (%r10,%rdx,8),%xmm4
mov    %rsi,%rdi
or     $0x10,%rdi
mulsd  0x0(%rbp,%rdi,1),%xmm4
addsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%r13,%r14,8)
movsd  (%r10,%rdx,8),%xmm4
or     $0x18,%rsi
mulsd  0x0(%rbp,%rsi,1),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rdx
add    %r11,%rax
add    %r9,%rcx
cmp    %rdx,%r8
jne    16f0 <NURBSsurfaceEval+0x5d0>
jmp    1c22 <NURBSsurfaceEval+0xb02>
or     $0x1,%rdx
movsd  (%r12,%rdx,8),%xmm0
movsd  (%r9,%r15,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1a65 <NURBSsurfaceEval+0x945>
mov    0x50(%rsp),%rcx
ucomisd (%r9,%rcx,8),%xmm0
jae    1b9a <NURBSsurfaceEval+0xa7a>
mov    %r8,0x18(%rsp)
mov    %eax,%r15d
movq   $0x0,0x0(%r13,%r15,8)
lea    0x1(%r15),%r14
movq   $0x0,0x8(%r13,%r15,8)
lea    0x2(%r15),%rax
mov    %rax,0x28(%rsp)
movq   $0x0,0x10(%r13,%r15,8)
movsd  (%r12,%rdx,8),%xmm0
mov    0x24(%rsp),%edi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
mov    %rdx,0x8(%rsp)
mov    %r9,%rdx
call   1040 <FindSpan@plt>
mov    %r12,%rcx
mov    %eax,%r12d
mov    0x8(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm0
mov    %r12d,%edi
mov    %ebx,%esi
mov    0x160(%rsp),%rdx
mov    0x1a8(%rsp),%rcx
mov    0x198(%rsp),%r8
mov    0x1a0(%rsp),%r9
call   1030 <BasisFuns@plt>
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x8(%r13,%r15,8),%xmm1
movsd  0x10(%r13,%r15,8),%xmm0
test   %ebx,%ebx
js     1d4f <NURBSsurfaceEval+0xc2f>
add    0x64(%rsp),%r12d
mov    0x68(%rsp),%rdx
imul   %edx,%r12d
add    $0xfffffffe,%r12d
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0x10(%rsp),%r11
mov    0x1a8(%rsp),%rbx
mov    0x58(%rsp),%rsi
mov    0x18(%rsp),%r8
mov    0x28(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm4
lea    -0x2(%r12),%ecx
movslq %ecx,%rcx
mulsd  0x0(%rbp,%rcx,8),%xmm4
addsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
movsd  (%rbx,%rax,8),%xmm4
lea    -0x1(%r12),%ecx
movslq %ecx,%rcx
mulsd  0x0(%rbp,%rcx,8),%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
movsd  (%rbx,%rax,8),%xmm4
movslq %r12d,%r12
mulsd  0x0(%rbp,%r12,8),%xmm4
addsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
movsd  (%rbx,%rax,8),%xmm4
lea    0x1(%r12),%ecx
movslq %ecx,%rcx
mulsd  0x0(%rbp,%rcx,8),%xmm4
lea    0x1(%rax),%rcx
addsd  %xmm4,%xmm3
add    %edx,%r12d
mov    %rcx,%rax
cmp    %rcx,%rsi
jne    1880 <NURBSsurfaceEval+0x760>
jmp    1d62 <NURBSsurfaceEval+0xc42>
movsd  (%rdi,%rdx,8),%xmm0
mov    0x48(%rsp),%rdi
mov    %r11,%rdx
call   1040 <FindSpan@plt>
mov    0x168(%rsp),%rcx
mov    0x8(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    %rax,0x8(%rsp)
mov    %eax,%edi
mov    (%rsp),%esi
mov    0x10(%rsp),%rdx
mov    %rbx,%rcx
mov    0x180(%rsp),%r8
mov    0x188(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    (%rsp),%eax
test   %eax,%eax
js     1c74 <NURBSsurfaceEval+0xb54>
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r14,8),%xmm1
movsd  0x0(%r13,%r12,8),%xmm0
mov    0x78(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%eax
xorpd  %xmm3,%xmm3
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
mov    0x190(%rsp),%rbx
mov    0x70(%rsp),%rdi
mov    0x18(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,2),%xmm4
lea    (%rax,%rcx,1),%rdx
movslq %edx,%rdx
mulsd  0x0(%rbp,%rdx,8),%xmm4
addsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
movsd  (%rbx,%rcx,2),%xmm4
lea    0x1(%rdx),%esi
movslq %esi,%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
movsd  (%rbx,%rcx,2),%xmm4
lea    0x2(%rdx),%esi
movslq %esi,%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm4
addsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
movsd  (%rbx,%rcx,2),%xmm4
add    $0x3,%edx
movslq %edx,%rdx
mulsd  0x0(%rbp,%rdx,8),%xmm4
addsd  %xmm4,%xmm3
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    19a0 <NURBSsurfaceEval+0x880>
jmp    1c9f <NURBSsurfaceEval+0xb7f>
mov    0x108(%rsp),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0x100(%rsp),%rcx
divsd  0x0(%rbp,%rcx,8),%xmm0
mov    %eax,%eax
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0xf8(%rsp),%rdx
movsd  0x0(%rbp,%rdx,8),%xmm0
divsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
mov    0xf0(%rsp),%rdx
jmp    1bf0 <NURBSsurfaceEval+0xad0>
mov    0xe8(%rsp),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0xe0(%rsp),%rcx
divsd  0x0(%rbp,%rcx,8),%xmm0
mov    %eax,%eax
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0xd8(%rsp),%rdx
movsd  0x0(%rbp,%rdx,8),%xmm0
divsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
mov    0xd0(%rsp),%rdx
jmp    1bf0 <NURBSsurfaceEval+0xad0>
mov    (%rsp),%eax
test   %eax,%eax
mov    0x18(%rsp),%r8
js     1db2 <NURBSsurfaceEval+0xc92>
mov    0x8(%rsp),%rcx
sub    %eax,%ecx
mov    0x90(%rsp),%rax
lea    (%rax,%rcx,4),%eax
cltq
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r14,8),%xmm1
movsd  0x0(%r13,%r12,8),%xmm0
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
shl    $0x20,%rax
xorpd  %xmm3,%xmm3
xor    %edx,%edx
mov    0x10(%rsp),%r11
mov    0x88(%rsp),%r10
movabs $0x400000000,%r9
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,1),%xmm4
mulsd  (%rcx,%rdx,4),%xmm4
addsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
movsd  (%rbx,%rdx,1),%xmm4
mov    %rax,%rsi
sar    $0x1d,%rsi
mov    %rsi,%rdi
or     $0x8,%rdi
mulsd  0x0(%rbp,%rdi,1),%xmm4
addsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
movsd  (%rbx,%rdx,1),%xmm4
mov    %rsi,%rdi
or     $0x10,%rdi
mulsd  0x0(%rbp,%rdi,1),%xmm4
addsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
movsd  (%rbx,%rdx,1),%xmm4
or     $0x18,%rsi
mulsd  0x0(%rbp,%rsi,1),%xmm4
addsd  %xmm4,%xmm3
add    $0x8,%rdx
add    %r9,%rax
cmp    %rdx,%r10
jne    1b20 <NURBSsurfaceEval+0xa00>
jmp    1dd0 <NURBSsurfaceEval+0xcb0>
mov    0xb0(%rsp),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0xa8(%rsp),%rcx
divsd  0x0(%rbp,%rcx,8),%xmm0
mov    %eax,%eax
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0xa0(%rsp),%rdx
movsd  0x0(%rbp,%rdx,8),%xmm0
divsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
mov    0x98(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,8),%xmm0
divsd  0x0(%rbp,%rcx,8),%xmm0
jmp    133e <NURBSsurfaceEval+0x21e>
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r12,8),%xmm1
movsd  0x0(%r13,%r14,8),%xmm0
xorpd  %xmm3,%xmm3
mov    0x190(%rsp),%rbx
divsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
divsd  %xmm3,%xmm1
movsd  %xmm1,0x0(%r13,%r12,8)
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%r14,8)
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%rdi
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
mov    0x18(%rsp),%r8
mov    (%rsp),%esi
mov    0x10(%rsp),%r11
mov    0x40(%rsp),%r14
jmp    1345 <NURBSsurfaceEval+0x225>
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r14,8),%xmm1
movsd  0x0(%r13,%r12,8),%xmm0
xorpd  %xmm3,%xmm3
mov    0x10(%rsp),%r11
mov    0x190(%rsp),%rbx
mov    0x18(%rsp),%r8
divsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
divsd  %xmm3,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
mov    0x30(%rsp),%rdi
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
mov    0x40(%rsp),%r14
mov    (%rsp),%esi
jmp    1e16 <NURBSsurfaceEval+0xcf6>
xorpd  %xmm0,%xmm0
mov    (%rsp),%r11d
movsd  0x0(%r13,%r15,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r15,8)
movsd  0x0(%r13,%r14,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
movsd  0x0(%r13,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r12,8)
mov    0x30(%rsp),%rdi
mov    0x190(%rsp),%rbx
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
mov    0x18(%rsp),%r8
mov    %r11d,%esi
mov    0x10(%rsp),%r11
jmp    1e11 <NURBSsurfaceEval+0xcf1>
xorpd  %xmm3,%xmm3
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%r8
mov    0x28(%rsp),%rdi
divsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
divsd  %xmm3,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%rdi
mov    0x190(%rsp),%rbx
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
mov    0x40(%rsp),%r14
mov    (%rsp),%esi
jmp    1345 <NURBSsurfaceEval+0x225>
movsd  0x0(%r13,%r15,8),%xmm2
movsd  0x0(%r13,%r14,8),%xmm1
movsd  0x0(%r13,%r12,8),%xmm0
xorpd  %xmm3,%xmm3
mov    0x10(%rsp),%r11
divsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%r15,8)
divsd  %xmm3,%xmm1
movsd  %xmm1,0x0(%r13,%r14,8)
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%r12,8)
mov    0x30(%rsp),%rdi
mov    0x190(%rsp),%rbx
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r9
mov    (%rsp),%esi
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%r15
jmp    1345 <NURBSsurfaceEval+0x225>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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