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


x86 assembly (clang, -O0):
<NURBSsurfaceBasisValues>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
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),%rax
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,-0x44(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x54(%rbp),%ecx
imul   -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    11bd <NURBSsurfaceBasisValues+0x9d>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118d <NURBSsurfaceBasisValues+0x6d>
mov    0x20(%rbp),%rax
movsd  0xe37(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x3,-0x40(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1339 <NURBSsurfaceBasisValues+0x219>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x38(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    0x30(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     12bc <NURBSsurfaceBasisValues+0x19c>
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    126e <NURBSsurfaceBasisValues+0x14e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1319 <NURBSsurfaceBasisValues+0x1f9>
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12c3 <NURBSsurfaceBasisValues+0x1a3>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e8 <NURBSsurfaceBasisValues+0xc8>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xcaf(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     185e <NURBSsurfaceBasisValues+0x73e>
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%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,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%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    0x50(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x38(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x44(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     144b <NURBSsurfaceBasisValues+0x32b>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13fc <NURBSsurfaceBasisValues+0x2dc>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     14af <NURBSsurfaceBasisValues+0x38f>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x40(%rbp),%edx
add    -0x24(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1452 <NURBSsurfaceBasisValues+0x332>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1706 <NURBSsurfaceBasisValues+0x5e6>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x38(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    0x30(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%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,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%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    0x50(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x38(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1641 <NURBSsurfaceBasisValues+0x521>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     162e <NURBSsurfaceBasisValues+0x50e>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15ca <NURBSsurfaceBasisValues+0x4aa>
jmp    1633 <NURBSsurfaceBasisValues+0x513>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15b7 <NURBSsurfaceBasisValues+0x497>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     16e6 <NURBSsurfaceBasisValues+0x5c6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16d3 <NURBSsurfaceBasisValues+0x5b3>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x40(%rbp),%edx
add    -0x24(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x3c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    165b <NURBSsurfaceBasisValues+0x53b>
jmp    16d8 <NURBSsurfaceBasisValues+0x5b8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1648 <NURBSsurfaceBasisValues+0x528>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14c8 <NURBSsurfaceBasisValues+0x3a8>
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%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,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%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    0x50(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x38(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
imul   -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     17d4 <NURBSsurfaceBasisValues+0x6b4>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1785 <NURBSsurfaceBasisValues+0x665>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     183e <NURBSsurfaceBasisValues+0x71e>
mov    0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x40(%rbp),%edx
add    -0x24(%rbp),%edx
add    $0x1,%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17db <NURBSsurfaceBasisValues+0x6bb>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    136f <NURBSsurfaceBasisValues+0x24f>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x782(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1a0d <NURBSsurfaceBasisValues+0x8ed>
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x38(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    0x30(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1982 <NURBSsurfaceBasisValues+0x862>
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1934 <NURBSsurfaceBasisValues+0x814>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     19ed <NURBSsurfaceBasisValues+0x8cd>
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
shl    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
add    -0x3c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1989 <NURBSsurfaceBasisValues+0x869>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18ae <NURBSsurfaceBasisValues+0x78e>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x5db(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NURBSsurfaceBasisValues>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x68(%rsp)
mov    %r8d,%r14d
mov    %ecx,%r8d
mov    %rdx,%r15
mov    %rsi,(%rsp)
mov    %edi,%esi
mov    0x120(%rsp),%rdi
mov    %r14d,%ecx
imul   %r8d,%ecx
mov    %ecx,%eax
imul   %ecx,%eax
test   %eax,%eax
mov    %rcx,0x50(%rsp)
mov    %r8,0x48(%rsp)
mov    %rsi,0x20(%rsp)
je     11a0 <NURBSsurfaceBasisValues+0x70>
mov    %eax,%edx
shl    $0x3,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%rsi
mov    0x48(%rsp),%r8
mov    0x50(%rsp),%rcx
mov    0x120(%rsp),%rdi
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rdi)
cmp    $0x2,%r8d
mov    %r14,0x58(%rsp)
jg     11c9 <NURBSsurfaceBasisValues+0x99>
lea    -0x1(%r8),%eax
mov    $0x1,%ebx
mov    %ecx,%r9d
jmp    1410 <NURBSsurfaceBasisValues+0x2e0>
lea    0x1(%rsi),%r13d
lea    -0x1(%r8),%eax
lea    -0x1(%r13),%rdx
mov    %rdx,0x30(%rsp)
mov    %r13,0x10(%rsp)
and    $0xfffffffe,%r13d
lea    0x38(%r15),%rdx
mov    %rdx,0x28(%rsp)
lea    0x8(%rdi),%rdx
mov    %rdx,0x8(%rsp)
mov    %ecx,%r10d
sub    %esi,%r10d
mov    $0x1,%ebp
mov    %ecx,%r9d
mov    %rax,0x60(%rsp)
mov    0x68(%rsp),%r12
jmp    1237 <NURBSsurfaceBasisValues+0x107>
nop
mov    0x18(%rsp),%rbp
add    $0x1,%rbp
mov    0x50(%rsp),%rcx
add    %ecx,%r9d
add    %ecx,%r10d
mov    0x60(%rsp),%rax
cmp    %rax,%rbp
mov    0x48(%rsp),%r8
je     1409 <NURBSsurfaceBasisValues+0x2d9>
mov    %rbp,0x18(%rsp)
shl    $0x4,%rbp
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,1),%xmm0
mov    %r8d,%edi
mov    %r12,%rdx
mov    %r9,%r14
mov    %r10d,%ebx
call   1050 <FindSpan@plt>
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rbp,1),%xmm0
mov    %eax,0x38(%rsp)
mov    %eax,%edi
mov    0x20(%rsp),%rsi
mov    %r12,%rdx
mov    0x138(%rsp),%rcx
mov    0x128(%rsp),%r8
mov    0x130(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    %ebx,%r10d
mov    %r14,%r9
mov    0x138(%rsp),%rax
mov    0x20(%rsp),%rsi
mov    0x120(%rsp),%rdi
test   %esi,%esi
js     1210 <NURBSsurfaceBasisValues+0xe0>
mov    0x38(%rsp),%ecx
mov    %ecx,%r8d
sub    %esi,%r8d
lea    0x3(,%r8,4),%ecx
movslq %ecx,%rcx
cmpq   $0x0,0x30(%rsp)
je     13c0 <NURBSsurfaceBasisValues+0x290>
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbp
add    $0xffffffffffffffe8,%rbp
xorpd  %xmm1,%xmm1
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm2
mulsd  -0x20(%rbp),%xmm2
movsd  0x8(%rax,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x0(%rbp),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    $0x40,%rbp
movapd %xmm0,%xmm1
cmp    %rdx,%r13
jne    12f0 <NURBSsurfaceBasisValues+0x1c0>
testb  $0x1,0x10(%rsp)
je     1338 <NURBSsurfaceBasisValues+0x208>
movsd  (%rax,%rdx,8),%xmm1
lea    (%rcx,%rdx,4),%rdx
mulsd  (%r15,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
test   %esi,%esi
js     1210 <NURBSsurfaceBasisValues+0xe0>
cmpq   $0x0,0x30(%rsp)
je     13d6 <NURBSsurfaceBasisValues+0x2a6>
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
add    $0xffffffffffffffe8,%rbx
mov    0x38(%rsp),%edx
add    %r10d,%edx
movslq %edx,%rdx
mov    0x8(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
xor    %edx,%edx
nop
movsd  (%rax,%rdx,8),%xmm1
mulsd  -0x20(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbp,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  (%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
add    $0x40,%rbx
cmp    %rdx,%r13
jne    1370 <NURBSsurfaceBasisValues+0x240>
testb  $0x1,0x10(%rsp)
je     1210 <NURBSsurfaceBasisValues+0xe0>
jmp    13e3 <NURBSsurfaceBasisValues+0x2b3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
jne    1325 <NURBSsurfaceBasisValues+0x1f5>
jmp    1338 <NURBSsurfaceBasisValues+0x208>
xor    %edx,%edx
testb  $0x1,0x10(%rsp)
je     1210 <NURBSsurfaceBasisValues+0xe0>
add    %r9d,%r8d
movsd  (%rax,%rdx,8),%xmm1
lea    (%rcx,%rdx,4),%rcx
mulsd  (%r15,%rcx,8),%xmm1
movslq %r8d,%rax
divsd  %xmm0,%xmm1
add    %rdx,%rax
movsd  %xmm1,(%rdi,%rax,8)
jmp    1210 <NURBSsurfaceBasisValues+0xe0>
mov    %eax,%ebx
mov    0x58(%rsp),%r14
lea    0x0(,%r8,4),%r10d
mov    %rax,0x60(%rsp)
add    %r9d,%eax
cltq
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rdi,%rax,8)
add    %ecx,%r9d
cmp    $0x2,%r14d
jg     1442 <NURBSsurfaceBasisValues+0x312>
lea    -0x1(%r14),%ebp
jmp    1bbb <NURBSsurfaceBasisValues+0xa8b>
mov    %r10,0x10(%rsp)
movslq %r10d,%rcx
mov    (%rsp),%rax
lea    0x1(%rax),%edx
lea    0x1(%rsi),%r13d
lea    -0x1(%r14),%ebp
lea    -0x1(%rdx),%rdi
mov    %rdi,0xa8(%rsp)
mov    %rdx,0x18(%rsp)
mov    %edx,%r10d
and    $0xfffffffe,%r10d
lea    (%r15,%rcx,8),%rdx
mov    %rdx,0xa0(%rsp)
lea    0x0(,%r13,4),%r12
and    $0xfffffffffffffff8,%r12
mov    %esi,%edx
neg    %edx
mov    %edx,0x78(%rsp)
mov    %r14d,%edx
sub    %eax,%edx
mov    %edx,0x84(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
mov    %rax,0xc0(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    %rax,0xc8(%rsp)
lea    0x18(%r15),%rax
mov    %rax,0x98(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0xb8(%rsp)
mov    %rcx,0x90(%rsp)
mov    %ecx,%eax
mov    %rax,0x38(%rsp)
mov    %r8d,%eax
mov    %rax,0x30(%rsp)
mov    $0x1,%eax
mov    %ebp,0x7c(%rsp)
mov    %r10,0xb0(%rsp)
jmp    1528 <NURBSsurfaceBasisValues+0x3f8>
xchg   %ax,%ax
mov    0x80(%rsp),%eax
add    $0x1,%eax
mov    0x50(%rsp),%rcx
add    %ecx,%r9d
mov    0x7c(%rsp),%ebp
cmp    %ebp,%eax
mov    0x58(%rsp),%r14
mov    0x40(%rsp),%rbx
je     1bb6 <NURBSsurfaceBasisValues+0xa86>
mov    %r9,0x8(%rsp)
mov    %eax,0x80(%rsp)
mov    %rbx,0x40(%rsp)
lea    (%rbx,%rbx,1),%eax
add    $0x3,%eax
movslq %eax,%rbp
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14d,%edi
mov    (%rsp),%rbx
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,%r14d
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14d,%edi
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
mov    0x150(%rsp),%rbp
mov    %rbp,%rcx
mov    0x140(%rsp),%r8
mov    0x148(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    0x8(%rsp),%r11
mov    0x48(%rsp),%rdi
mov    0x120(%rsp),%r9
test   %ebx,%ebx
mov    0xc8(%rsp),%rsi
mov    0xb8(%rsp),%r10
js     16b6 <NURBSsurfaceBasisValues+0x586>
sub    (%rsp),%r14d
mov    %r14d,%eax
imul   0x10(%rsp),%eax
or     $0x3,%eax
movslq %eax,%r8
cmpq   $0x0,0xa8(%rsp)
je     1b80 <NURBSsurfaceBasisValues+0xa50>
xorpd  %xmm1,%xmm1
mov    %r8,%rdx
xor    %ecx,%ecx
mov    0xb0(%rsp),%rbx
mov    0xa0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  (%r15,%rdx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rax,%rdx,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rcx
add    %rsi,%rdx
movapd %xmm0,%xmm1
cmp    %rcx,%rbx
jne    1610 <NURBSsurfaceBasisValues+0x4e0>
testb  $0x1,0x18(%rsp)
je     1662 <NURBSsurfaceBasisValues+0x532>
movsd  0x0(%rbp,%rcx,8),%xmm1
imul   0x90(%rsp),%rcx
add    %r8,%rcx
mulsd  (%r15,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
cmpl   $0x0,(%rsp)
mov    0x18(%rsp),%rdx
js     16b6 <NURBSsurfaceBasisValues+0x586>
imul   %edi,%r14d
add    %r11d,%r14d
mov    0x98(%rsp),%rax
lea    (%rax,%r8,8),%rax
add    $0xffffffffffffffe8,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  (%rax),%xmm1
divsd  %xmm0,%xmm1
movslq %r14d,%r14
movsd  %xmm1,(%r9,%r14,8)
add    $0x1,%rcx
add    %edi,%r14d
add    %r10,%rax
cmp    %rcx,%rdx
jne    1690 <NURBSsurfaceBasisValues+0x560>
mov    0x40(%rsp),%rax
add    $0x2,%eax
mov    0x50(%rsp),%rcx
lea    (%r11,%rcx,1),%edx
cmp    $0x3,%edi
jge    16e0 <NURBSsurfaceBasisValues+0x5b0>
mov    %eax,%ecx
jmp    19d7 <NURBSsurfaceBasisValues+0x8a7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%ecx
add    0x78(%rsp),%r11d
mov    $0x1,%ebp
mov    0x20(%rsp),%rsi
jmp    172b <NURBSsurfaceBasisValues+0x5fb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    0x8c(%rsp),%ebp
add    $0x1,%ebp
mov    0x50(%rsp),%rax
mov    0x70(%rsp),%edx
add    %eax,%edx
add    %eax,%r11d
cmp    0x60(%rsp),%ebp
je     19d0 <NURBSsurfaceBasisValues+0x8a0>
mov    %rcx,0x28(%rsp)
mov    %ebp,0x8c(%rsp)
mov    %edx,0x70(%rsp)
mov    %r11,0x8(%rsp)
lea    (%rcx,%rcx,1),%eax
movslq %eax,%r14
mov    0x118(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mov    %rax,%rbx
mov    0x68(%rsp),%rbp
mov    %rbp,%rdx
call   1050 <FindSpan@plt>
mov    %eax,0x88(%rsp)
movsd  (%rbx,%r14,8),%xmm0
mov    %rbx,%r14
mov    %eax,%edi
mov    0x20(%rsp),%rsi
mov    %rbp,%rdx
mov    0x138(%rsp),%rcx
mov    0x128(%rsp),%r8
mov    0x130(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    0x28(%rsp),%rax
add    %eax,%eax
add    $0x1,%eax
cltq
mov    %rax,0xd0(%rsp)
movsd  (%rbx,%rax,8),%xmm0
mov    0x58(%rsp),%rdi
mov    (%rsp),%rbp
mov    %ebp,%esi
mov    0x110(%rsp),%rbx
mov    %rbx,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%r14d
mov    0xd0(%rsp),%rax
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    %r14d,%edi
mov    %ebp,%esi
mov    %rbx,%rdx
mov    0x150(%rsp),%rbx
mov    %rbx,%rcx
mov    0x140(%rsp),%r8
mov    0x148(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    0x8(%rsp),%r11
mov    0x138(%rsp),%r10
mov    0x20(%rsp),%rsi
mov    0x48(%rsp),%rdi
test   %ebp,%ebp
mov    0x120(%rsp),%r9
mov    0x88(%rsp),%eax
mov    0x18(%rsp),%rbp
js     1700 <NURBSsurfaceBasisValues+0x5d0>
mov    %eax,%edx
sub    %esi,%edx
mov    %r14d,%ecx
sub    (%rsp),%ecx
imul   0x10(%rsp),%ecx
lea    (%rcx,%rdx,4),%r8d
mov    %r8d,%ecx
or     $0x3,%r8d
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    %eax,%r11d
jmp    188a <NURBSsurfaceBasisValues+0x75a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    0x38(%rsp),%rcx
cmp    %rbp,%rdx
mov    0x150(%rsp),%rbx
je     1930 <NURBSsurfaceBasisValues+0x800>
test   %esi,%esi
js     1870 <NURBSsurfaceBasisValues+0x740>
movsd  (%rbx,%rdx,8),%xmm1
je     18f0 <NURBSsurfaceBasisValues+0x7c0>
xor    %eax,%eax
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%r10,%rax,2),%xmm2
mulsd  %xmm1,%xmm2
lea    (%rcx,%rax,1),%ebp
add    $0x3,%ebp
movslq %ebp,%rbp
mulsd  (%r15,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r10,%rax,2),%xmm0
mulsd  %xmm1,%xmm0
lea    0x7(%rcx,%rax,1),%ebp
movslq %ebp,%rbp
mulsd  (%r15,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rbx
add    $0x8,%rax
cmp    %rax,%r12
jne    18a0 <NURBSsurfaceBasisValues+0x770>
jmp    18f2 <NURBSsurfaceBasisValues+0x7c2>
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
test   $0x1,%r13b
mov    0x18(%rsp),%rbp
mov    %r11d,%eax
je     1870 <NURBSsurfaceBasisValues+0x740>
mov    0x10(%rsp),%rax
imul   %edx,%eax
add    %r8d,%eax
mulsd  (%r10,%rbx,8),%xmm1
lea    (%rax,%rbx,4),%eax
cltq
mulsd  (%r15,%rax,8),%xmm1
mov    %r11d,%eax
addsd  %xmm1,%xmm0
jmp    1870 <NURBSsurfaceBasisValues+0x740>
nopl   0x0(%rax)
cmpl   $0x0,(%rsp)
mov    0x8(%rsp),%r11
js     1700 <NURBSsurfaceBasisValues+0x5d0>
add    %r11d,%eax
add    0x84(%rsp),%r14d
imul   %edi,%r14d
add    %eax,%r14d
xor    %ecx,%ecx
jmp    1979 <NURBSsurfaceBasisValues+0x849>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
add    0x10(%rsp),%r8d
add    0x30(%rsp),%r14
cmp    0x18(%rsp),%rcx
je     1700 <NURBSsurfaceBasisValues+0x5d0>
test   %esi,%esi
js     1960 <NURBSsurfaceBasisValues+0x830>
mov    %r8d,%edx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  (%r10,%rbp,8),%xmm1
movslq %edx,%rdx
mulsd  (%r15,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
lea    (%r14,%rbp,1),%eax
cltq
movsd  %xmm1,(%r9,%rax,8)
add    $0x1,%rbp
add    $0x4,%edx
cmp    %rbp,%r13
jne    1990 <NURBSsurfaceBasisValues+0x860>
jmp    1960 <NURBSsurfaceBasisValues+0x830>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x40(%rsp),%rcx
add    %edi,%ecx
mov    %edx,%eax
mov    %rax,0x8(%rsp)
mov    0x58(%rsp),%rdi
mov    %rcx,0x40(%rsp)
lea    (%rcx,%rcx,1),%eax
add    $0x1,%eax
movslq %eax,%rbp
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    (%rsp),%rbx
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,%r14d
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r14d,%edi
mov    %ebx,%esi
mov    0x110(%rsp),%rdx
mov    0x150(%rsp),%rbp
mov    %rbp,%rcx
mov    0x140(%rsp),%r8
mov    0x148(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %ebx,%ebx
mov    0x120(%rsp),%rdi
mov    0x48(%rsp),%r8
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%r9
mov    0xb0(%rsp),%r10
js     1500 <NURBSsurfaceBasisValues+0x3d0>
sub    (%rsp),%r14d
add    $0x1,%r14d
mov    %r14d,%eax
imul   0x10(%rsp),%eax
add    $0xffffffff,%eax
cltq
cmpq   $0x0,0xa8(%rsp)
mov    0xa0(%rsp),%rbx
je     1ba0 <NURBSsurfaceBasisValues+0xa70>
lea    0x0(,%rax,8),%rdx
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0xc0(%rsp),%r11
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  (%r15,%rdx,1),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rbx,%rdx,1),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rcx
add    %r11,%rdx
movapd %xmm0,%xmm1
cmp    %rcx,%r10
jne    1ac0 <NURBSsurfaceBasisValues+0x990>
testb  $0x1,0x18(%rsp)
je     1b12 <NURBSsurfaceBasisValues+0x9e2>
movsd  0x0(%rbp,%rcx,8),%xmm1
imul   0x90(%rsp),%rcx
add    %rax,%rcx
mulsd  (%r15,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
cmpl   $0x0,(%rsp)
mov    0x18(%rsp),%r11
mov    0xb8(%rsp),%rbx
js     1500 <NURBSsurfaceBasisValues+0x3d0>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
add    $0xffffffffffffffe8,%rax
imul   %r8d,%r14d
lea    (%r9,%r14,1),%ecx
add    $0xffffffff,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  (%rax),%xmm1
divsd  %xmm0,%xmm1
movslq %ecx,%rcx
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x1,%rdx
add    %rbx,%rax
add    %r8d,%ecx
cmp    %rdx,%r11
jne    1b50 <NURBSsurfaceBasisValues+0xa20>
jmp    1500 <NURBSsurfaceBasisValues+0x3d0>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
testb  $0x1,0x18(%rsp)
jne    1646 <NURBSsurfaceBasisValues+0x516>
jmp    1662 <NURBSsurfaceBasisValues+0x532>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
testb  $0x1,0x18(%rsp)
jne    1af6 <NURBSsurfaceBasisValues+0x9c6>
jmp    1b12 <NURBSsurfaceBasisValues+0x9e2>
mov    0x10(%rsp),%r10
mov    %ebp,%eax
imul   %r8d,%eax
mov    %rax,0x70(%rsp)
add    %r9d,%eax
lea    (%r9,%rcx,1),%r11d
cltq
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rdi,%rax,8)
cmp    $0x3,%r8d
jge    1c0c <NURBSsurfaceBasisValues+0xadc>
lea    (%rcx,%r11,1),%eax
add    $0xffffffff,%eax
cltq
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rdi,%rax,8)
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
imul   %ebp,%r10d
or     $0x3,%r10d
mov    %r10,0x10(%rsp)
add    $0x2,%ebx
lea    0x1(%rsi),%r13d
lea    -0x1(%r13),%rax
mov    %rax,0x28(%rsp)
mov    %r13,0x30(%rsp)
and    $0xfffffffe,%r13d
lea    0x38(%r15),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,(%rsp)
add    %ebp,%r14d
imul   %r8d,%r14d
add    %r14d,%r9d
sub    %esi,%r9d
mov    $0x1,%eax
mov    0x68(%rsp),%r14
jmp    1c8a <NURBSsurfaceBasisValues+0xb5a>
nopl   0x0(%rax)
mov    0x40(%rsp),%rbx
add    $0x1,%rbx
mov    0x18(%rsp),%eax
add    $0x1,%eax
mov    0x50(%rsp),%rcx
add    %ecx,%r11d
add    %ecx,%r9d
cmp    0x60(%rsp),%eax
mov    0x48(%rsp),%r8
je     1be3 <NURBSsurfaceBasisValues+0xab3>
mov    %eax,0x18(%rsp)
mov    %rbx,0x40(%rsp)
lea    (%rbx,%rbx,1),%eax
movslq %eax,%rbp
mov    0x118(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    %r8d,%edi
mov    %r14,%rdx
mov    %r9,%r12
mov    %r11,%rbx
call   1050 <FindSpan@plt>
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
mov    %eax,0x38(%rsp)
mov    %eax,%edi
mov    0x20(%rsp),%rsi
mov    %r14,%rdx
mov    0x138(%rsp),%rcx
mov    0x128(%rsp),%r8
mov    0x130(%rsp),%r9
call   1040 <BasisFuns@plt>
mov    %rbx,%r11
mov    %r12,%r9
mov    0x138(%rsp),%rax
mov    0x20(%rsp),%rsi
mov    0x120(%rsp),%rdi
test   %esi,%esi
js     1c60 <NURBSsurfaceBasisValues+0xb30>
mov    0x38(%rsp),%ecx
mov    %ecx,%r8d
sub    %esi,%r8d
mov    0x10(%rsp),%rcx
lea    (%rcx,%r8,4),%ecx
movslq %ecx,%rcx
cmpq   $0x0,0x28(%rsp)
je     1e20 <NURBSsurfaceBasisValues+0xcf0>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbp
add    $0xffffffffffffffe8,%rbp
xorpd  %xmm1,%xmm1
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm2
mulsd  -0x20(%rbp),%xmm2
movsd  0x8(%rax,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x0(%rbp),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdx
add    $0x40,%rbp
movapd %xmm0,%xmm1
cmp    %rdx,%r13
jne    1d50 <NURBSsurfaceBasisValues+0xc20>
testb  $0x1,0x30(%rsp)
je     1d98 <NURBSsurfaceBasisValues+0xc68>
movsd  (%rax,%rdx,8),%xmm1
lea    (%rcx,%rdx,4),%rdx
mulsd  (%r15,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
test   %esi,%esi
js     1c60 <NURBSsurfaceBasisValues+0xb30>
cmpq   $0x0,0x28(%rsp)
je     1e36 <NURBSsurfaceBasisValues+0xd06>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
add    $0xffffffffffffffe8,%rbx
mov    0x38(%rsp),%edx
add    %r9d,%edx
movslq %edx,%rdx
mov    (%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
xor    %edx,%edx
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm1
mulsd  -0x20(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbp,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  (%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
add    $0x40,%rbx
cmp    %rdx,%r13
jne    1dd0 <NURBSsurfaceBasisValues+0xca0>
testb  $0x1,0x30(%rsp)
je     1c60 <NURBSsurfaceBasisValues+0xb30>
jmp    1e43 <NURBSsurfaceBasisValues+0xd13>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
testb  $0x1,0x30(%rsp)
jne    1d85 <NURBSsurfaceBasisValues+0xc55>
jmp    1d98 <NURBSsurfaceBasisValues+0xc68>
xor    %edx,%edx
testb  $0x1,0x30(%rsp)
je     1c60 <NURBSsurfaceBasisValues+0xb30>
mov    0x70(%rsp),%rbp
add    %r11d,%ebp
add    %ebp,%r8d
movsd  (%rax,%rdx,8),%xmm1
lea    (%rcx,%rdx,4),%rcx
mulsd  (%r15,%rcx,8),%xmm1
movslq %r8d,%rax
divsd  %xmm0,%xmm1
add    %rdx,%rax
movsd  %xmm1,(%rdi,%rax,8)
jmp    1c60 <NURBSsurfaceBasisValues+0xb30>

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

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