void nrbSrfDerivative(int degU, int degV, int ncp, int kcp, double *cp,
                      double *knotU, double *knotV, double *ducp,
                      double *duknotU, double *duknotV, double *dvcp,
                      double *dvknotV, double *duucp, double *duvcp,
                      double *dvvcp) {
  int i, j, fourncp, fourncpD;
  double doubleVal;
  fourncp = 4 * ncp;
  fourncpD = fourncp - 4;
  if (degU > 0) {
    for (j = 0; j < (ncp - 1); j++) {
      if ((knotU[j + degU + 1] - knotU[j + 1]) > 1e-12) {
        doubleVal = ((double)(degU)) / (knotU[j + degU + 1] - knotU[j + 1]);
        for (i = 0; i < kcp; i++) {
          ducp[i * fourncpD + 4 * j] =
              doubleVal *
              (cp[i * fourncp + 4 * (j + 1)] - cp[i * fourncp + 4 * j]);
          ducp[i * fourncpD + 4 * j + 1] =
              doubleVal *
              (cp[i * fourncp + 4 * (j + 1) + 1] - cp[i * fourncp + 4 * j + 1]);
          ducp[i * fourncpD + 4 * j + 2] =
              doubleVal *
              (cp[i * fourncp + 4 * (j + 1) + 2] - cp[i * fourncp + 4 * j + 2]);
          ducp[i * fourncpD + 4 * j + 3] =
              doubleVal *
              (cp[i * fourncp + 4 * (j + 1) + 3] - cp[i * fourncp + 4 * j + 3]);
        }
      } else {
        for (i = 0; i < kcp; i++) {
          ducp[i * fourncpD + 4 * j] = 0.0;
          ducp[i * fourncpD + 4 * j + 1] = 0.0;
          ducp[i * fourncpD + 4 * j + 2] = 0.0;
          ducp[i * fourncpD + 4 * j + 3] = 0.0;
        }
      }
    }
  }
  if (degV > 0) {
    for (i = 0; i < (kcp - 1); i++) {
      if ((knotV[i + degV + 1] - knotV[i + 1]) > 1e-12) {
        doubleVal = ((double)(degV)) / (knotV[i + degV + 1] - knotV[i + 1]);
        for (j = 0; j < ncp; j++) {
          dvcp[i * fourncp + 4 * j] =
              doubleVal *
              (cp[i * fourncp + fourncp + 4 * j] - cp[i * fourncp + 4 * j]);
          dvcp[i * fourncp + 4 * j + 1] =
              doubleVal * (cp[i * fourncp + fourncp + 4 * j + 1] -
                           cp[i * fourncp + 4 * j + 1]);
          dvcp[i * fourncp + 4 * j + 2] =
              doubleVal * (cp[i * fourncp + fourncp + 4 * j + 2] -
                           cp[i * fourncp + 4 * j + 2]);
          dvcp[i * fourncp + 4 * j + 3] =
              doubleVal * (cp[i * fourncp + fourncp + 4 * j + 3] -
                           cp[i * fourncp + 4 * j + 3]);
        }
      } else {
        for (j = 0; j < ncp; j++) {
          dvcp[i * fourncp + 4 * j] = 0.0;
          dvcp[i * fourncp + 4 * j + 1] = 0.0;
          dvcp[i * fourncp + 4 * j + 2] = 0.0;
          dvcp[i * fourncp + 4 * j + 3] = 0.0;
        }
      }
    }
  }
  fourncp -= 4;
  fourncpD -= 4;
  if (degU > 1) {
    for (j = 0; j < (ncp - 2); j++) {
      if ((duknotU[j + degU] - duknotU[j + 1]) > 1e-12) {
        doubleVal = ((double)(degU - 1)) / (duknotU[j + degU] - duknotU[j + 1]);
        for (i = 0; i < kcp; i++) {
          duucp[i * fourncpD + 4 * j] =
              doubleVal *
              (ducp[i * fourncp + 4 * (j + 1)] - ducp[i * fourncp + 4 * j]);
          duucp[i * fourncpD + 4 * j + 1] =
              doubleVal * (ducp[i * fourncp + 4 * (j + 1) + 1] -
                           ducp[i * fourncp + 4 * j + 1]);
          duucp[i * fourncpD + 4 * j + 2] =
              doubleVal * (ducp[i * fourncp + 4 * (j + 1) + 2] -
                           ducp[i * fourncp + 4 * j + 2]);
          duucp[i * fourncpD + 4 * j + 3] =
              doubleVal * (ducp[i * fourncp + 4 * (j + 1) + 3] -
                           ducp[i * fourncp + 4 * j + 3]);
        }
      } else {
        for (i = 0; i < kcp; i++) {
          duucp[i * fourncpD + 4 * j] = 0.0;
          duucp[i * fourncpD + 4 * j + 1] = 0.0;
          duucp[i * fourncpD + 4 * j + 2] = 0.0;
          duucp[i * fourncpD + 4 * j + 3] = 0.0;
        }
      }
    }
  }
  if (degU > 0 && degV > 0) {
    for (i = 0; i < (kcp - 1); i++) {
      if ((duknotV[i + degV + 1] - duknotV[i + 1]) > 1e-12) {
        doubleVal = ((double)(degV)) / (duknotV[i + degV + 1] - duknotV[i + 1]);
        for (j = 0; j < (ncp - 1); j++) {
          duvcp[i * fourncp + 4 * j] =
              doubleVal *
              (ducp[i * fourncp + fourncp + 4 * j] - ducp[i * fourncp + 4 * j]);
          duvcp[i * fourncp + 4 * j + 1] =
              doubleVal * (ducp[i * fourncp + fourncp + 4 * j + 1] -
                           ducp[i * fourncp + 4 * j + 1]);
          duvcp[i * fourncp + 4 * j + 2] =
              doubleVal * (ducp[i * fourncp + fourncp + 4 * j + 2] -
                           ducp[i * fourncp + 4 * j + 2]);
          duvcp[i * fourncp + 4 * j + 3] =
              doubleVal * (ducp[i * fourncp + fourncp + 4 * j + 3] -
                           ducp[i * fourncp + 4 * j + 3]);
        }
      } else {
        for (j = 0; j < (ncp - 1); j++) {
          duvcp[i * fourncp + 4 * j] = 0.0;
          duvcp[i * fourncp + 4 * j + 1] = 0.0;
          duvcp[i * fourncp + 4 * j + 2] = 0.0;
          duvcp[i * fourncp + 4 * j + 3] = 0.0;
        }
      }
    }
  }
  fourncp += 4;
  if (degV > 1) {
    for (i = 0; i < (kcp - 2); i++) {
      if ((dvknotV[i + degV] - dvknotV[i + 1]) > 1e-12) {
        doubleVal = ((double)(degV - 1)) / (dvknotV[i + degV] - dvknotV[i + 1]);
        for (j = 0; j < ncp; j++) {
          dvvcp[i * fourncp + 4 * j] =
              doubleVal *
              (dvcp[i * fourncp + fourncp + 4 * j] - dvcp[i * fourncp + 4 * j]);
          dvvcp[i * fourncp + 4 * j + 1] =
              doubleVal * (dvcp[i * fourncp + fourncp + 4 * j + 1] -
                           dvcp[i * fourncp + 4 * j + 1]);
          dvvcp[i * fourncp + 4 * j + 2] =
              doubleVal * (dvcp[i * fourncp + fourncp + 4 * j + 2] -
                           dvcp[i * fourncp + 4 * j + 2]);
          dvvcp[i * fourncp + 4 * j + 3] =
              doubleVal * (dvcp[i * fourncp + fourncp + 4 * j + 3] -
                           dvcp[i * fourncp + 4 * j + 3]);
        }
      } else {
        for (j = 0; j < ncp; j++) {
          dvvcp[i * fourncp + 4 * j] = 0.0;
          dvvcp[i * fourncp + 4 * j + 1] = 0.0;
          dvvcp[i * fourncp + 4 * j + 2] = 0.0;
          dvvcp[i * fourncp + 4 * j + 3] = 0.0;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<nrbSrfDerivative>:
push   %rbp
mov    %rsp,%rbp
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    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1452 <nrbSrfDerivative+0x352>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    144d <nrbSrfDerivative+0x34d>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x1e61(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1393 <nrbSrfDerivative+0x293>
cvtsi2sdl -0x4(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    138e <nrbSrfDerivative+0x28e>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e5 <nrbSrfDerivative+0xe5>
jmp    143a <nrbSrfDerivative+0x33a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1435 <nrbSrfDerivative+0x335>
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    139a <nrbSrfDerivative+0x29a>
jmp    143a <nrbSrfDerivative+0x33a>
jmp    143f <nrbSrfDerivative+0x33f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115f <nrbSrfDerivative+0x5f>
jmp    1452 <nrbSrfDerivative+0x352>
cmpl   $0x0,-0x8(%rbp)
jle    1756 <nrbSrfDerivative+0x656>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1751 <nrbSrfDerivative+0x651>
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x1b5d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1697 <nrbSrfDerivative+0x597>
cvtsi2sdl -0x8(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1692 <nrbSrfDerivative+0x592>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14e9 <nrbSrfDerivative+0x3e9>
jmp    173e <nrbSrfDerivative+0x63e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1739 <nrbSrfDerivative+0x639>
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    169e <nrbSrfDerivative+0x59e>
jmp    173e <nrbSrfDerivative+0x63e>
jmp    1743 <nrbSrfDerivative+0x643>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1463 <nrbSrfDerivative+0x363>
jmp    1756 <nrbSrfDerivative+0x656>
mov    -0x2c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x4(%rbp)
jle    1a6b <nrbSrfDerivative+0x96b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1a66 <nrbSrfDerivative+0x966>
mov    0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x184a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19ac <nrbSrfDerivative+0x8ac>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19a7 <nrbSrfDerivative+0x8a7>
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17fe <nrbSrfDerivative+0x6fe>
jmp    1a53 <nrbSrfDerivative+0x953>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a4e <nrbSrfDerivative+0x94e>
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19b3 <nrbSrfDerivative+0x8b3>
jmp    1a53 <nrbSrfDerivative+0x953>
jmp    1a58 <nrbSrfDerivative+0x958>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1779 <nrbSrfDerivative+0x679>
jmp    1a6b <nrbSrfDerivative+0x96b>
cmpl   $0x0,-0x4(%rbp)
jle    1d83 <nrbSrfDerivative+0xc83>
cmpl   $0x0,-0x8(%rbp)
jle    1d83 <nrbSrfDerivative+0xc83>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d7e <nrbSrfDerivative+0xc7e>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x153a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1cbf <nrbSrfDerivative+0xbbf>
cvtsi2sdl -0x8(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1cba <nrbSrfDerivative+0xbba>
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1b0c <nrbSrfDerivative+0xa0c>
jmp    1d6b <nrbSrfDerivative+0xc6b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d66 <nrbSrfDerivative+0xc66>
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1cc6 <nrbSrfDerivative+0xbc6>
jmp    1d6b <nrbSrfDerivative+0xc6b>
jmp    1d70 <nrbSrfDerivative+0xc70>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a86 <nrbSrfDerivative+0x986>
jmp    1d83 <nrbSrfDerivative+0xc83>
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x8(%rbp)
jle    208f <nrbSrfDerivative+0xf8f>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    208a <nrbSrfDerivative+0xf8a>
mov    0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0x1226(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1fd0 <nrbSrfDerivative+0xed0>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fcb <nrbSrfDerivative+0xecb>
movsd  -0x38(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e22 <nrbSrfDerivative+0xd22>
jmp    2077 <nrbSrfDerivative+0xf77>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2072 <nrbSrfDerivative+0xf72>
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1fd7 <nrbSrfDerivative+0xed7>
jmp    2077 <nrbSrfDerivative+0xf77>
jmp    207c <nrbSrfDerivative+0xf7c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1d9d <nrbSrfDerivative+0xc9d>
jmp    208f <nrbSrfDerivative+0xf8f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<nrbSrfDerivative>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,%r14
mov    %rsi,0x40(%rsp)
lea    0x0(,%rdx,4),%eax
mov    %rdx,0x10(%rsp)
lea    -0x4(,%rdx,4),%edx
mov    %edx,0x8c(%rsp)
movslq %edx,%rdx
mov    %eax,0x3c(%rsp)
cltq
mov    %rax,0x70(%rsp)
mov    %rcx,(%rsp)
mov    %ecx,%eax
mov    %rax,0x48(%rsp)
mov    %rdi,%rax
mov    %rdi,0x30(%rsp)
test   %edi,%edi
mov    %rdx,0x78(%rsp)
jle    1427 <nrbSrfDerivative+0x317>
cmpl   $0x2,0x10(%rsp)
jl     1427 <nrbSrfDerivative+0x317>
mov    0x10(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x68(%rsp)
cvtsi2sdl 0x30(%rsp),%xmm0
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x50(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x60(%rsp)
and    $0xfffffffc,%eax
mov    %rax,0x98(%rsp)
mov    %rdx,%rax
shl    $0x5,%rax
mov    %rax,0x90(%rsp)
lea    0x0(,%rdx,8),%rbp
mov    0xe8(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0xa0(%rsp)
add    $0x18,%rax
mov    %rax,0x80(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,%r8
shl    $0x20,%r8
lea    0x0(,%rax,8),%rcx
xor    %edi,%edi
movl   $0x4,0x20(%rsp)
movsd  0xdec(%rip),%xmm1
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    %rcx,0x58(%rsp)
jmp    124d <nrbSrfDerivative+0x13d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
add    $0x4,%edi
addl   $0x4,0x20(%rsp)
mov    0x8(%rsp),%rax
cmp    0x68(%rsp),%rax
je     1427 <nrbSrfDerivative+0x317>
movslq %edi,%r10
lea    0x1(%rax),%rbx
mov    0x30(%rsp),%rdx
lea    (%rbx,%rdx,1),%esi
movslq %esi,%rsi
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rsi,8),%xmm4
subsd  0x8(%rdx,%rax,8),%xmm4
ucomisd %xmm1,%xmm4
mov    %rdi,0x18(%rsp)
mov    %rbx,0x8(%rsp)
jbe    1360 <nrbSrfDerivative+0x250>
cmpl   $0x0,(%rsp)
jle    1230 <nrbSrfDerivative+0x120>
mov    0x80(%rsp),%rax
lea    (%rax,%r10,8),%rsi
mov    %r10,%r15
shl    $0x20,%r15
movslq 0x20(%rsp),%rdi
mov    %rdi,%r12
shl    $0x20,%r12
movapd %xmm0,%xmm3
divsd  %xmm4,%xmm3
mov    0x48(%rsp),%r9
mov    %r14,%rbx
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdi,8),%xmm4
subsd  (%rbx,%r10,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x18(%rsi)
mov    %r12,%r11
sar    $0x1d,%r11
mov    %r11,%r13
or     $0x8,%r13
movsd  (%r14,%r13,1),%xmm4
mov    %r15,%rdx
sar    $0x1d,%rdx
mov    %rdx,%rax
or     $0x8,%rax
subsd  (%r14,%rax,1),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x10(%rsi)
mov    %r11,%rax
or     $0x10,%rax
movsd  (%r14,%rax,1),%xmm4
mov    %rdx,%rax
or     $0x10,%rax
subsd  (%r14,%rax,1),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x8(%rsi)
or     $0x18,%r11
movsd  (%r14,%r11,1),%xmm4
or     $0x18,%rdx
subsd  (%r14,%rdx,1),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi)
add    %rbp,%rsi
add    %r8,%r15
add    %rcx,%rbx
add    %r8,%r12
add    $0xffffffffffffffff,%r9
jne    12c0 <nrbSrfDerivative+0x1b0>
jmp    1230 <nrbSrfDerivative+0x120>
nop
cmpl   $0x0,(%rsp)
jle    1230 <nrbSrfDerivative+0x120>
cmpq   $0x3,0x50(%rsp)
jae    1376 <nrbSrfDerivative+0x266>
xor    %eax,%eax
jmp    13de <nrbSrfDerivative+0x2ce>
mov    0xe8(%rsp),%rax
lea    (%rax,%r10,8),%rsi
xor    %eax,%eax
mov    0x78(%rsp),%rbx
mov    0x98(%rsp),%r9
mov    0x90(%rsp),%rcx
nopl   0x0(%rax)
movupd %xmm2,(%rsi)
movupd %xmm2,0x10(%rsi)
lea    (%rsi,%rbp,1),%rdx
movupd %xmm2,(%rsi,%rbx,8)
movupd %xmm2,0x10(%rsi,%rbx,8)
lea    (%rdx,%rbp,1),%rdi
movupd %xmm2,(%rdx,%rbx,8)
movupd %xmm2,0x10(%rdx,%rbx,8)
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm2,0x10(%rdi,%rbx,8)
add    $0x4,%rax
add    %rcx,%rsi
cmp    %rax,%r9
jne    13a0 <nrbSrfDerivative+0x290>
cmpq   $0x0,0x60(%rsp)
mov    0x58(%rsp),%rcx
je     1230 <nrbSrfDerivative+0x120>
imul   0x78(%rsp),%rax
add    %r10,%rax
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    0x58(%rsp),%rcx
mov    0x60(%rsp),%rsi
xchg   %ax,%ax
movupd %xmm2,-0x10(%rax)
movupd %xmm2,(%rax)
add    %rbp,%rax
add    $0xffffffffffffffff,%rsi
jne    1410 <nrbSrfDerivative+0x300>
jmp    1230 <nrbSrfDerivative+0x120>
mov    0x40(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x60(%rsp)
mov    0x100(%rsp),%r8
mov    0x10(%rsp),%rdi
mov    %edi,%ecx
mov    0x3c(%rsp),%esi
test   %eax,%eax
mov    %rcx,0x58(%rsp)
mov    %rsi,0x68(%rsp)
jle    1609 <nrbSrfDerivative+0x4f9>
cmpl   $0x2,(%rsp)
jl     1609 <nrbSrfDerivative+0x4f9>
mov    0xe0(%rsp),%rbx
mov    (%rsp),%rax
lea    -0x1(%rax),%r9d
mov    0x40(%rsp),%rax
lea    0x1(%rax),%r10d
mov    %rcx,%rax
shl    $0x5,%rax
mov    %rax,0x20(%rsp)
lea    0x18(%r8),%rbp
mov    0x70(%rsp),%rax
lea    0x0(,%rax,8),%r11
lea    0x18(%r14),%r12
lea    0x0(,%rcx,4),%r13
xor    %edx,%edx
movsd  0xb4c(%rip),%xmm2
mov    %rsi,%r15
mov    %r10,0x8(%rsp)
mov    %r11,0x28(%rsp)
jmp    14e7 <nrbSrfDerivative+0x3d7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r11,%rbp
add    %r11,%r12
add    %rsi,%r15
mov    0x18(%rsp),%rdx
cmp    %r9,%rdx
je     1609 <nrbSrfDerivative+0x4f9>
mov    %edx,%eax
lea    (%r10,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm1
subsd  0x8(%rbx,%rdx,8),%xmm1
add    $0x1,%rdx
ucomisd %xmm2,%xmm1
mov    %rdx,0x18(%rsp)
jbe    15b0 <nrbSrfDerivative+0x4a0>
test   %edi,%edi
jle    14d0 <nrbSrfDerivative+0x3c0>
movsd  0x60(%rsp),%xmm0
divsd  %xmm1,%xmm0
xor    %eax,%eax
xchg   %ax,%ax
lea    (%r15,%rax,1),%rcx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
subsd  -0x18(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%rbp,%rax,8)
lea    0x1(%rcx),%edx
movslq %edx,%rdx
movsd  (%r14,%rdx,8),%xmm1
subsd  -0x10(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rbp,%rax,8)
lea    0x2(%rcx),%edx
movslq %edx,%rdx
movsd  (%r14,%rdx,8),%xmm1
subsd  -0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
subsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    1520 <nrbSrfDerivative+0x410>
jmp    14d0 <nrbSrfDerivative+0x3c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %edi,%edi
jle    14d0 <nrbSrfDerivative+0x3c0>
mov    0x3c(%rsp),%ecx
imul   %eax,%ecx
movslq %ecx,%rax
lea    (%r8,%rax,8),%rdi
xor    %esi,%esi
mov    0x20(%rsp),%rdx
mov    %r9,%rbx
call   1030 <memset@plt>
movsd  0xa23(%rip),%xmm2
mov    0x28(%rsp),%r11
mov    0x8(%rsp),%r10
mov    %rbx,%r9
mov    0xe0(%rsp),%rbx
mov    0x68(%rsp),%rsi
mov    0x100(%rsp),%r8
mov    0x10(%rsp),%rdi
jmp    14d0 <nrbSrfDerivative+0x3c0>
cmpl   $0x2,0x30(%rsp)
jl     1867 <nrbSrfDerivative+0x757>
cmpl   $0x3,0x10(%rsp)
jl     1867 <nrbSrfDerivative+0x757>
mov    0x110(%rsp),%rdi
mov    0xf0(%rsp),%rbp
mov    0x70(%rsp),%rcx
lea    -0x8(%rcx),%rdx
mov    0x30(%rsp),%rsi
lea    -0x1(%rsi),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0x18(%rsp)
mov    %esi,%r14d
mov    %rbp,%rsi
mov    0x48(%rsp),%r15
lea    -0x1(%r15),%rax
mov    %rax,0x20(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x8(%rsp)
and    $0xfffffffc,%r15d
mov    %rdx,%r12
shl    $0x5,%r12
lea    -0x40(,%rcx,8),%rcx
ff
lea    0x10(%rdi),%rax
mov    %rax,0x80(%rsp)
lea    0x18(%rdi),%rax
mov    %rax,0x28(%rsp)
mov    0xe8(%rsp),%rax
add    $0x18,%rax
mov    %rax,0x50(%rsp)
mov    0x78(%rsp),%rax
lea    0x0(,%rax,8),%r8
xor    %r13d,%r13d
movsd  0x93c(%rip),%xmm1
xorpd  %xmm2,%xmm2
mov    $0x4,%r9d
xor    %r10d,%r10d
jmp    16f3 <nrbSrfDerivative+0x5e3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x4,%r13d
add    $0x4,%r9d
cmp    0x18(%rsp),%r10
je     1867 <nrbSrfDerivative+0x757>
lea    (%r10,%r14,1),%rax
movsd  (%rsi,%rax,8),%xmm4
subsd  0x8(%rsi,%r10,8),%xmm4
movslq %r13d,%rbp
add    $0x1,%r10
ucomisd %xmm1,%xmm4
jbe    17b0 <nrbSrfDerivative+0x6a0>
cmpl   $0x0,(%rsp)
jle    16e0 <nrbSrfDerivative+0x5d0>
mov    0x28(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
movslq %r9d,%rbx
movapd %xmm0,%xmm3
divsd  %xmm4,%xmm3
mov    0x48(%rsp),%rax
mov    0x50(%rsp),%r11
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%r11,%rbx,8),%xmm4
subsd  -0x18(%r11,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x18(%rdi)
movsd  -0x10(%r11,%rbx,8),%xmm4
subsd  -0x10(%r11,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x10(%rdi)
movsd  -0x8(%r11,%rbx,8),%xmm4
subsd  -0x8(%r11,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,-0x8(%rdi)
movsd  (%r11,%rbx,8),%xmm4
subsd  (%r11,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%rdi)
add    %rcx,%rdi
add    %r8,%r11
add    $0xffffffffffffffff,%rax
jne    1740 <nrbSrfDerivative+0x630>
jmp    16e0 <nrbSrfDerivative+0x5d0>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,(%rsp)
jle    16e0 <nrbSrfDerivative+0x5d0>
cmpq   $0x3,0x20(%rsp)
jae    17c6 <nrbSrfDerivative+0x6b6>
xor    %eax,%eax
jmp    181e <nrbSrfDerivative+0x70e>
mov    0x110(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm2,(%rdi)
movupd %xmm2,0x10(%rdi)
lea    (%rdi,%rcx,1),%rbx
movupd %xmm2,(%rdi,%rdx,8)
movupd %xmm2,0x10(%rdi,%rdx,8)
lea    (%rbx,%rcx,1),%rsi
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm2,0x10(%rbx,%rdx,8)
movupd %xmm2,(%rsi,%rdx,8)
movupd %xmm2,0x10(%rsi,%rdx,8)
add    $0x4,%rax
add    %r12,%rdi
cmp    %rax,%r15
jne    17e0 <nrbSrfDerivative+0x6d0>
cmpq   $0x0,0x8(%rsp)
mov    0xf0(%rsp),%rsi
je     16e0 <nrbSrfDerivative+0x5d0>
imul   %rdx,%rax
add    %rbp,%rax
mov    0x80(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
mov    0x8(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movupd %xmm2,-0x10(%rax)
movupd %xmm2,(%rax)
add    %rcx,%rax
add    $0xffffffffffffffff,%rdi
jne    1850 <nrbSrfDerivative+0x740>
jmp    16e0 <nrbSrfDerivative+0x5d0>
cmpl   $0x0,0x30(%rsp)
mov    0x10(%rsp),%r10
mov    0xe8(%rsp),%rdx
mov    0x100(%rsp),%rdi
mov    0x58(%rsp),%r8
jle    1a93 <nrbSrfDerivative+0x983>
cmpl   $0x0,0x40(%rsp)
jle    1a93 <nrbSrfDerivative+0x983>
cmpl   $0x2,(%rsp)
jl     1a93 <nrbSrfDerivative+0x983>
mov    0x118(%rsp),%rcx
mov    0xf8(%rsp),%rsi
mov    (%rsp),%rax
lea    -0x1(%rax),%r11d
mov    0x40(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
lea    -0x1(%r10),%eax
mov    %rax,%rbx
shl    $0x5,%rbx
mov    %rbx,0x50(%rsp)
lea    0x18(%rcx),%rbx
mov    %rax,%rcx
mov    0x78(%rsp),%rax
lea    0x0(,%rax,8),%rbp
mov    %rbp,0x30(%rsp)
lea    0x18(%rdx),%rbp
mov    %eax,%r13d
lea    0x3(%r13),%r14
lea    0x2(%r13),%r15
lea    0x1(%r13),%r12
shl    $0x2,%rcx
xor    %r9d,%r9d
movsd  0x6ef(%rip),%xmm2
mov    %r13,0x28(%rsp)
mov    %r11,0x48(%rsp)
mov    %rcx,0x18(%rsp)
jmp    195a <nrbSrfDerivative+0x84a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x30(%rsp),%rax
add    %rax,%rbx
add    %rax,%rbp
mov    0x28(%rsp),%rax
add    %rax,%r14
add    %rax,%r15
add    %rax,%r12
add    %rax,%r13
mov    0x8(%rsp),%r9
cmp    %r11,%r9
je     1a93 <nrbSrfDerivative+0x983>
mov    %r9d,%eax
mov    0x20(%rsp),%rcx
add    %eax,%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm1
subsd  0x8(%rsi,%r9,8),%xmm1
add    $0x1,%r9
mov    %r9,0x8(%rsp)
ucomisd %xmm2,%xmm1
jbe    1a30 <nrbSrfDerivative+0x920>
cmp    $0x2,%r10d
jl     1930 <nrbSrfDerivative+0x820>
movsd  0x60(%rsp),%xmm0
divsd  %xmm1,%xmm0
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%rax,%r13,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm1
subsd  -0x18(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%rbx,%rax,8)
lea    (%r12,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm1
subsd  -0x10(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rbx,%rax,8)
lea    (%r15,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm1
subsd  -0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
lea    (%r14,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm1
mov    0x18(%rsp),%rcx
subsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    19a0 <nrbSrfDerivative+0x890>
jmp    1930 <nrbSrfDerivative+0x820>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x2,%r10d
jl     1930 <nrbSrfDerivative+0x820>
mov    0x8c(%rsp),%ecx
imul   %eax,%ecx
movslq %ecx,%rax
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x50(%rsp),%rdx
call   1030 <memset@plt>
movsd  0x599(%rip),%xmm2
mov    0x48(%rsp),%r11
mov    0xf8(%rsp),%rsi
mov    0x58(%rsp),%r8
mov    0x100(%rsp),%rdi
mov    0xe8(%rsp),%rdx
mov    0x10(%rsp),%r10
jmp    1930 <nrbSrfDerivative+0x820>
cmpl   $0x2,0x40(%rsp)
mov    0x68(%rsp),%r9
jl     1c35 <nrbSrfDerivative+0xb25>
cmpl   $0x3,(%rsp)
jl     1c35 <nrbSrfDerivative+0xb25>
mov    0x120(%rsp),%rdx
mov    0x108(%rsp),%rsi
mov    (%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,(%rsp)
mov    0x40(%rsp),%rcx
lea    -0x1(%rcx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r8,%rax
shl    $0x5,%rax
mov    %rax,0x8(%rsp)
mov    %ecx,%r13d
lea    0x18(%rdx),%rbp
shlq   $0x3,0x70(%rsp)
lea    0x18(%rdi),%rbx
shl    $0x2,%r8
xor    %r15d,%r15d
movsd  0x4f7(%rip),%xmm2
mov    %r9,%r14
jmp    1b28 <nrbSrfDerivative+0xa18>
xchg   %ax,%ax
mov    0x70(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
add    %r9,%r14
cmp    (%rsp),%r15
je     1c35 <nrbSrfDerivative+0xb25>
mov    %r15,%rax
lea    (%r15,%r13,1),%rcx
movsd  (%rsi,%rcx,8),%xmm1
add    $0x1,%r15
subsd  0x8(%rsi,%rax,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1be0 <nrbSrfDerivative+0xad0>
test   %r10d,%r10d
jle    1b10 <nrbSrfDerivative+0xa00>
movsd  0x18(%rsp),%xmm0
divsd  %xmm1,%xmm0
xor    %eax,%eax
nopl   0x0(%rax)
lea    (%r14,%rax,1),%rcx
movslq %ecx,%rcx
movsd  (%rdi,%rcx,8),%xmm1
subsd  -0x18(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%rbp,%rax,8)
lea    0x1(%rcx),%edx
movslq %edx,%rdx
movsd  (%rdi,%rdx,8),%xmm1
subsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rbp,%rax,8)
lea    0x2(%rcx),%edx
movslq %edx,%rdx
movsd  (%rdi,%rdx,8),%xmm1
subsd  -0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rdi,%rcx,8),%xmm1
subsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r8
jne    1b60 <nrbSrfDerivative+0xa50>
jmp    1b10 <nrbSrfDerivative+0xa00>
nopw   0x0(%rax,%rax,1)
test   %r10d,%r10d
jle    1b10 <nrbSrfDerivative+0xa00>
imul   0x3c(%rsp),%eax
cltq
mov    0x120(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x8(%rsp),%rdx
mov    %r8,%r12
call   1030 <memset@plt>
movsd  0x3ed(%rip),%xmm2
mov    0x108(%rsp),%rsi
mov    0x68(%rsp),%r9
mov    %r12,%r8
mov    0x100(%rsp),%rdi
mov    0x10(%rsp),%r10
jmp    1b10 <nrbSrfDerivative+0xa00>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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