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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
scalar_t__ pwr2(double);
double lineSearchUpdateOffsetNURBS(int degU, int degV, double *cpw, double *cp,
                                   int ncp, int kcp, double *knotU,
                                   double *knotV, double *us, int nus,
                                   double *dirOffset, double *cpDir,
                                   double *sgnDistDiff, int *matInds,
                                   double *gnDir, double *gradIent,
                                   double *leftU, double *rightU, double *NU,
                                   double *leftV, double *rightV, double *NV) {
  int i, j, ii, itr, twoii, threeii, spanU, spanV, ind, ind2, fourncp, myint,
      numCP, numRows, orderU, orderV, cpInd;
  double bspnt[4], f0, scfp0, falpha, fdiff = 0.0, alpha = 1.0;
  fourncp = 4 * ncp;
  orderU = degU + 1;
  orderV = degV + 1;
  numCP = ncp * kcp;
  numRows = 2 * (numCP - 4);
  f0 = 0.0;
  for (ii = 0; ii < nus; ii++) {
    f0 += sgnDistDiff[ii] * sgnDistDiff[ii];
  }
  scfp0 = 0.0;
  for (ii = 0; ii < numRows; ii++) {
    scfp0 += gnDir[ii] * gradIent[ii];
  }
  scfp0 = 0.5 * scfp0;
  for (itr = 0; itr < 50; itr++) {
    falpha = 0.0;
    for (ii = 0; ii < nus; ii++) {
      twoii = 2 * ii;
      threeii = 3 * ii;
      spanU = FindSpan(ncp, degU, us[twoii], knotU);
      BasisFuns(spanU, us[twoii], degU, knotU, NU, leftU, rightU);
      ind = spanU - degU;
      spanV = FindSpan(kcp, degV, us[twoii + 1], knotV);
      BasisFuns(spanV, us[twoii + 1], degV, knotV, NV, leftV, rightV);
      ind2 = spanV - degV;
      myint = ind2 * fourncp + ind * 4;
      bspnt[0] = 0.0;
      bspnt[1] = 0.0;
      bspnt[2] = 0.0;
      bspnt[3] = 0.0;
      for (i = 0; i <= degV; i++) {
        for (j = 0; j <= degU; j++) {
          cpInd = (ind2 + i) * ncp + ind + j;
          if (matInds[cpInd] < numCP) {
            bspnt[0] +=
                NV[i] * NU[j] *
                (cpw[4 * cpInd + 3] + alpha * gnDir[2 * matInds[cpInd] + 1]) *
                (cp[3 * cpInd] +
                 alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd]);
            bspnt[1] +=
                NV[i] * NU[j] *
                (cpw[4 * cpInd + 3] + alpha * gnDir[2 * matInds[cpInd] + 1]) *
                (cp[3 * cpInd + 1] +
                 alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd + 1]);
            bspnt[2] +=
                NV[i] * NU[j] *
                (cpw[4 * cpInd + 3] + alpha * gnDir[2 * matInds[cpInd] + 1]) *
                (cp[3 * cpInd + 2] +
                 alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd + 2]);
            bspnt[3] +=
                NV[i] * NU[j] *
                (cpw[4 * cpInd + 3] + alpha * gnDir[2 * matInds[cpInd] + 1]);
          } else {
            bspnt[0] += NV[i] * NU[j] * cpw[4 * cpInd];
            bspnt[1] += NV[i] * NU[j] * cpw[4 * cpInd + 1];
            bspnt[2] += NV[i] * NU[j] * cpw[4 * cpInd + 2];
            bspnt[3] += NV[i] * NU[j] * cpw[4 * cpInd + 3];
          }
        }
      }
      falpha += pwr2((dirOffset[threeii] * bspnt[0] +
                      dirOffset[threeii + 1] * bspnt[1] +
                      dirOffset[threeii + 2] * bspnt[2]) /
                         bspnt[3] +
                     sgnDistDiff[ii + nus]);
    }
    if (falpha < (f0 + alpha * scfp0)) {
      fdiff = f0 - falpha;
      for (cpInd = 0; cpInd < numCP; cpInd++) {
        if (matInds[cpInd] < numCP) {
          cp[3 * cpInd] += alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd];
          cp[3 * cpInd + 1] +=
              alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd + 1];
          cp[3 * cpInd + 2] +=
              alpha * gnDir[2 * matInds[cpInd]] * cpDir[3 * cpInd + 2];
          cpw[4 * cpInd + 3] += alpha * gnDir[2 * matInds[cpInd] + 1];
          cpw[4 * cpInd] = cpw[4 * cpInd + 3] * cp[3 * cpInd];
          cpw[4 * cpInd + 1] = cpw[4 * cpInd + 3] * cp[3 * cpInd + 1];
          cpw[4 * cpInd + 2] = cpw[4 * cpInd + 3] * cp[3 * cpInd + 2];
        }
      }
      break;
    } else {
      alpha = 0.5 * alpha;
    }
  }
  return (fdiff);
}


x86 assembly (clang, -O0):
<lineSearchUpdateOffsetNURBS>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xe57(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x4,%eax
shl    $0x1,%eax
mov    %eax,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1240 <lineSearchUpdateOffsetNURBS+0x110>
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f4 <lineSearchUpdateOffsetNURBS+0xc4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    129e <lineSearchUpdateOffsetNURBS+0x16e>
mov    0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1252 <lineSearchUpdateOffsetNURBS+0x122>
movsd  0xd62(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x30(%rbp)
cmpl   $0x32,-0x30(%rbp)
jge    1b6e <lineSearchUpdateOffsetNURBS+0xa3e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    18c9 <lineSearchUpdateOffsetNURBS+0x799>
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edi
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x60(%rbp),%r8
mov    0x68(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x3c(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rdx
call   1050 <FindSpan@plt>
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edi
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x88(%rbp),%rcx
mov    0x78(%rbp),%r8
mov    0x80(%rbp),%r9
call   1040 <BasisFuns@plt>
mov    -0x40(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1834 <lineSearchUpdateOffsetNURBS+0x704>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1821 <lineSearchUpdateOffsetNURBS+0x6f1>
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jge    16f5 <lineSearchUpdateOffsetNURBS+0x5c5>
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    180e <lineSearchUpdateOffsetNURBS+0x6de>
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1813 <lineSearchUpdateOffsetNURBS+0x6e3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13f7 <lineSearchUpdateOffsetNURBS+0x2c7>
jmp    1826 <lineSearchUpdateOffsetNURBS+0x6f6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13e4 <lineSearchUpdateOffsetNURBS+0x2b4>
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
mov    0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
mov    0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    0x28(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
call   1030 <pwr2@plt>
cvtsi2sd %rax,%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d9 <lineSearchUpdateOffsetNURBS+0x1a9>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b43 <lineSearchUpdateOffsetNURBS+0xa13>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1b3e <lineSearchUpdateOffsetNURBS+0xa0e>
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
jge    1b2b <lineSearchUpdateOffsetNURBS+0x9fb>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b30 <lineSearchUpdateOffsetNURBS+0xa00>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    191a <lineSearchUpdateOffsetNURBS+0x7ea>
jmp    1b6e <lineSearchUpdateOffsetNURBS+0xa3e>
movsd  0x4bd(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1b60 <lineSearchUpdateOffsetNURBS+0xa30>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bd <lineSearchUpdateOffsetNURBS+0x18d>
movsd  -0xb0(%rbp),%xmm0
ff
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lineSearchUpdateOffsetNURBS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r13
mov    %edi,%r11d
mov    0x120(%rsp),%r10
mov    0x108(%rsp),%edx
mov    %r9d,0x1c(%rsp)
mov    %r9d,%r14d
mov    %r8d,0xc(%rsp)
imul   %r8d,%r14d
lea    (%r14,%r14,1),%r8d
add    $0xfffffff8,%r8d
xorpd  %xmm4,%xmm4
mov    %edx,%edi
xorpd  %xmm3,%xmm3
test   %edx,%edx
jle    1216 <lineSearchUpdateOffsetNURBS+0xe6>
lea    -0x1(%rdi),%rdx
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1198 <lineSearchUpdateOffsetNURBS+0x68>
xorpd  %xmm3,%xmm3
xor    %edx,%edx
jmp    11f4 <lineSearchUpdateOffsetNURBS+0xc4>
mov    %edi,%ebp
and    $0xfffffffc,%ebp
xorpd  %xmm3,%xmm3
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r10,%rdx,8),%xmm0
movsd  0x8(%r10,%rdx,8),%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r10,%rdx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%r10,%rdx,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    11b0 <lineSearchUpdateOffsetNURBS+0x80>
test   %rax,%rax
je     1216 <lineSearchUpdateOffsetNURBS+0xe6>
lea    (%r10,%rdx,8),%rdx
xor    %ebp,%ebp
nop
movsd  (%rdx,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1200 <lineSearchUpdateOffsetNURBS+0xd0>
mov    %rcx,0x20(%rsp)
mov    0x130(%rsp),%rbp
test   %r8d,%r8d
jle    12ef <lineSearchUpdateOffsetNURBS+0x1bf>
mov    0x138(%rsp),%rcx
mov    %r8d,%r8d
lea    -0x1(%r8),%rdx
cmp    $0x3,%rdx
jae    1249 <lineSearchUpdateOffsetNURBS+0x119>
xorpd  %xmm4,%xmm4
xor    %edx,%edx
jmp    12a8 <lineSearchUpdateOffsetNURBS+0x178>
mov    %r8d,%eax
and    $0xfffffffc,%eax
xorpd  %xmm4,%xmm4
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  0x8(%rbp,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm0
mulsd  0x8(%rcx,%rdx,8),%xmm1
addsd  %xmm4,%xmm0
movsd  0x10(%rbp,%rdx,8),%xmm2
mulsd  0x10(%rcx,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rbp,%rdx,8),%xmm4
mulsd  0x18(%rcx,%rdx,8),%xmm4
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm4
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1260 <lineSearchUpdateOffsetNURBS+0x130>
test   $0x2,%r8b
je     12e7 <lineSearchUpdateOffsetNURBS+0x1b7>
lea    (%rcx,%rdx,8),%rcx
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
shl    $0x3,%r8d
and    $0x10,%r8d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,1),%xmm0
mulsd  (%rcx,%rax,1),%xmm0
addsd  %xmm0,%xmm4
add    $0x8,%rax
cmp    %rax,%r8
jne    12d0 <lineSearchUpdateOffsetNURBS+0x1a0>
mulsd  0xd11(%rip),%xmm4
lea    0x1(%r11),%r12d
movslq 0xc(%rsp),%rcx
lea    0x0(,%r11,4),%eax
neg    %eax
mov    %eax,0x18(%rsp)
lea    0x0(,%rcx,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0xb0(%rsp)
shl    $0x2,%r12
movsd  0xce2(%rip),%xmm2
mov    %rsi,0x80(%rsp)
lea    0x1(%rsi),%eax
mov    %rax,0xa8(%rsp)
movslq 0x108(%rsp),%rax
mov    %rax,0x70(%rsp)
lea    0x0(,%rcx,4),%eax
mov    %rax,0x30(%rsp)
mov    0x20(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x60(%rsp)
lea    (%rcx,%rcx,2),%rax
mov    %rax,0x58(%rsp)
mov    0x118(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x50(%rsp)
mov    %rcx,0x68(%rsp)
lea    0x0(,%rcx,4),%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
movsd  %xmm3,0x40(%rsp)
mov    %rdi,0x78(%rsp)
movsd  %xmm4,0x38(%rsp)
mov    %r11,0x10(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rax,0x48(%rsp)
movsd  %xmm2,0x28(%rsp)
xorpd  %xmm1,%xmm1
cmpl   $0x0,0x108(%rsp)
jle    1730 <lineSearchUpdateOffsetNURBS+0x600>
xor    %ebp,%ebp
jmp    147c <lineSearchUpdateOffsetNURBS+0x34c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
xorpd  %xmm9,%xmm9
mov    0x90(%rsp),%rbp
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    %eax,%ecx
lea    0x1(%rax),%edx
mov    0x110(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  (%rsi,%rcx,8),%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%eax
unpckhpd %xmm0,%xmm0
mulsd  (%rsi,%rax,8),%xmm0
addsd  %xmm9,%xmm0
divsd  %xmm2,%xmm0
mov    0x70(%rsp),%rax
add    %rbp,%rax
mov    0x120(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
call   1030 <pwr2@plt>
mov    0x10(%rsp),%r11
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x98(%rsp),%xmm1
addsd  %xmm0,%xmm1
add    $0x1,%rbp
mov    0x78(%rsp),%rdi
cmp    %rdi,%rbp
je     1730 <lineSearchUpdateOffsetNURBS+0x600>
movsd  %xmm1,0x98(%rsp)
mov    %rbp,0x90(%rsp)
shl    $0x4,%rbp
mov    0x100(%rsp),%r15
movsd  (%r15,%rbp,1),%xmm0
mov    0xc(%rsp),%edi
mov    %r11d,%esi
mov    0xf0(%rsp),%rdx
mov    %r11,%rbx
call   1050 <FindSpan@plt>
movsd  (%r15,%rbp,1),%xmm0
mov    %rax,0x88(%rsp)
mov    %eax,%edi
mov    %ebx,%esi
mov    0xf0(%rsp),%rdx
mov    0x150(%rsp),%rcx
mov    0x140(%rsp),%r8
mov    0x148(%rsp),%r9
call   1040 <BasisFuns@plt>
movsd  0x8(%r15,%rbp,1),%xmm0
mov    0x1c(%rsp),%edi
mov    0x80(%rsp),%rbx
mov    %ebx,%esi
mov    0xf8(%rsp),%rdx
call   1050 <FindSpan@plt>
movsd  0x8(%r15,%rbp,1),%xmm0
mov    %eax,%ebp
mov    %eax,%edi
mov    %ebx,%esi
mov    0xf8(%rsp),%rdx
mov    0x168(%rsp),%rcx
mov    0x158(%rsp),%r8
mov    0x160(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %ebx,%ebx
js     13e0 <lineSearchUpdateOffsetNURBS+0x2b0>
sub    %ebx,%ebp
mov    0x88(%rsp),%rcx
mov    %ecx,%eax
sub    0x10(%rsp),%eax
movslq %ebp,%rsi
movslq %eax,%rdi
mov    %esi,%eax
imul   0x30(%rsp),%eax
add    0x18(%rsp),%eax
lea    (%rax,%rcx,4),%eax
mov    0x58(%rsp),%rcx
imul   %rsi,%rcx
lea    (%rdi,%rdi,2),%rdx
add    %rcx,%rdx
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdx,8),%r9
mov    0x50(%rsp),%rcx
lea    (%rcx,%rdx,8),%r10
imul   0x68(%rsp),%rsi
add    %rdi,%rsi
mov    0x128(%rsp),%rcx
lea    (%rcx,%rsi,4),%r15
xorpd  %xmm0,%xmm0
xorpd  %xmm9,%xmm9
xor    %r8d,%r8d
xorpd  %xmm2,%xmm2
movsd  0x28(%rsp),%xmm10
jmp    15ed <lineSearchUpdateOffsetNURBS+0x4bd>
nopl   (%rax)
add    $0x1,%r8
add    0x30(%rsp),%rax
mov    0xb0(%rsp),%rcx
add    %rcx,%r9
add    %rcx,%r10
add    0xa0(%rsp),%r15
cmp    0xa8(%rsp),%r8
je     13ed <lineSearchUpdateOffsetNURBS+0x2bd>
cmpl   $0x0,0x10(%rsp)
js     15c0 <lineSearchUpdateOffsetNURBS+0x490>
mov    0x168(%rsp),%rcx
movsd  (%rcx,%r8,8),%xmm8
xor    %ebp,%ebp
xor    %edi,%edi
jmp    167c <lineSearchUpdateOffsetNURBS+0x54c>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rdi,1),%rcx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm1,%xmm9
lea    0x1(%rax,%rdi,1),%ecx
movslq %ecx,%rcx
lea    0x2(%rax,%rdi,1),%edx
movslq %edx,%rdx
movapd %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
movsd  0x0(%r13,%rcx,8),%xmm3
movhpd 0x0(%r13,%rdx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm3,%xmm0
lea    (%rax,%rdi,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm4,%xmm2
add    $0x4,%rdi
add    $0x6,%rbp
cmp    %rdi,%r12
je     15c0 <lineSearchUpdateOffsetNURBS+0x490>
movslq (%r15,%rdi,1),%rbx
mov    0x150(%rsp),%rcx
movsd  (%rcx,%rdi,2),%xmm4
mulsd  %xmm8,%xmm4
cmp    %r14d,%ebx
jge    1610 <lineSearchUpdateOffsetNURBS+0x4e0>
lea    (%rax,%rdi,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
lea    (%rbx,%rbx,1),%rdx
shl    $0x4,%rbx
mov    0x130(%rsp),%r11
movsd  0x8(%r11,%rbx,1),%xmm5
mulsd  %xmm10,%xmm5
addsd  0x0(%r13,%rcx,8),%xmm5
movapd %xmm4,%xmm6
mulsd  %xmm5,%xmm6
movslq %edx,%rcx
movsd  (%r11,%rcx,8),%xmm7
mulsd  %xmm10,%xmm7
movsd  -0x8(%r10,%rbp,4),%xmm3
mulsd  %xmm7,%xmm3
addsd  -0x8(%r9,%rbp,4),%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm3,%xmm9
movupd (%r9,%rbp,4),%xmm3
movupd (%r10,%rbp,4),%xmm1
unpcklpd %xmm7,%xmm7
mulpd  %xmm1,%xmm7
addpd  %xmm3,%xmm7
unpcklpd %xmm6,%xmm6
mulpd  %xmm7,%xmm6
addpd  %xmm6,%xmm0
jmp    1663 <lineSearchUpdateOffsetNURBS+0x533>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x28(%rsp),%xmm2
movapd %xmm2,%xmm0
movsd  0x38(%rsp),%xmm4
mulsd  %xmm4,%xmm0
movsd  0x40(%rsp),%xmm3
addsd  %xmm3,%xmm0
ucomisd %xmm1,%xmm0
ja     1776 <lineSearchUpdateOffsetNURBS+0x646>
mulsd  0x8a4(%rip),%xmm2
mov    0x48(%rsp),%rax
add    $0x1,%eax
cmp    $0x32,%eax
jne    13b0 <lineSearchUpdateOffsetNURBS+0x280>
xorpd  %xmm3,%xmm3
jmp    1889 <lineSearchUpdateOffsetNURBS+0x759>
subsd  %xmm1,%xmm3
test   %r14d,%r14d
jle    1889 <lineSearchUpdateOffsetNURBS+0x759>
mov    %r14d,%r8d
shl    $0x2,%r8
xor    %ecx,%ecx
xor    %edx,%edx
mov    0x20(%rsp),%rdi
mov    0x130(%rsp),%r10
mov    0x118(%rsp),%r11
jmp    17c0 <lineSearchUpdateOffsetNURBS+0x690>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%rdx
add    $0x3,%ecx
cmp    %rdx,%r8
je     1889 <lineSearchUpdateOffsetNURBS+0x759>
mov    0x128(%rsp),%rax
movslq (%rax,%rdx,1),%rax
cmp    %r14d,%eax
jge    17b0 <lineSearchUpdateOffsetNURBS+0x680>
lea    (%rax,%rax,1),%rbx
shl    $0x4,%rax
movsd  (%r10,%rax,1),%xmm0
mulsd  %xmm2,%xmm0
mov    %ecx,%esi
mulsd  (%r11,%rsi,8),%xmm0
addsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
movsd  (%r10,%rax,1),%xmm0
mulsd  %xmm2,%xmm0
lea    0x1(%rcx),%ebp
mulsd  (%r11,%rbp,8),%xmm0
addsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
movsd  (%r10,%rax,1),%xmm0
mulsd  %xmm2,%xmm0
lea    0x2(%rcx),%eax
mulsd  (%r11,%rax,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
or     $0x1,%ebx
movslq %ebx,%r9
lea    0x3(%rdx),%ebx
movsd  (%r10,%r9,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x0(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
movsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %edx,%esi
movsd  %xmm1,0x0(%r13,%rsi,8)
movsd  (%rdi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
lea    0x1(%rdx),%esi
movsd  %xmm1,0x0(%r13,%rsi,8)
mulsd  (%rdi,%rax,8),%xmm0
lea    0x2(%rdx),%eax
movsd  %xmm0,0x0(%r13,%rax,8)
jmp    17b0 <lineSearchUpdateOffsetNURBS+0x680>
movapd %xmm3,%xmm0
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @lineSearchUpdateOffsetNURBS(i32 %0, i32 %1, double* nocapture %2, double* nocapture %3, i32 %4, i32 %5, double* %6, double* %7, double* nocapture %8, i32 %9, double* nocapture %10, double* nocapture %11, double* nocapture %12, i32* nocapture %13, double* nocapture %14, double* nocapture %15, double* %16, double* %17, double* %18, double* %19, double* %20, double* %21) {
%23 = mul i32 %5, %4
%24 = shl i32 %23, 1
%25 = add i32 %24, -8
%26 = icmp sgt i32 %9, 0
br i1 %26, label %27, label %49
27: ; preds = %22
%28 = zext i32 %9 to i64
%29 = add nsw i64 %28, -1
%30 = and i64 %28, 3
%31 = icmp ult i64 %29, 3
br i1 %31, label %34, label %32
32: ; preds = %27
%33 = and i64 %28, 4294967292
br label %59
34: ; preds = %59, %27
%35 = phi double [ undef, %27 ], [ %77, %59 ]
%36 = phi i64 [ 0, %27 ], [ %78, %59 ]
%37 = phi double [ 0.000000e+00, %27 ], [ %77, %59 ]
%38 = icmp eq i64 %30, 0
br i1 %38, label %49, label %39
39: ; preds = %34, %39
%40 = phi i64 [ %46, %39 ], [ %36, %34 ]
%41 = phi double [ %45, %39 ], [ %37, %34 ]
%42 = phi i64 [ %47, %39 ], [ 0, %34 ]
%43 = getelementptr inbounds double, double* %12, i64 %40
%44 = load double, double* %43
%45 = tail call double @llvm.fmuladd.f64(double %44, double %44, double %41)
%46 = add nuw nsw i64 %40, 1
%47 = add i64 %42, 1
%48 = icmp eq i64 %47, %30
br i1 %48, label %49, label %39
49: ; preds = %34, %39, %22
%50 = phi double [ 0.000000e+00, %22 ], [ %35, %34 ], [ %45, %39 ]
%51 = icmp sgt i32 %25, 0
br i1 %51, label %52, label %131
52: ; preds = %49
%53 = zext i32 %25 to i64
%54 = add nsw i64 %53, -1
%55 = and i64 %53, 2
%56 = icmp ult i64 %54, 3
br i1 %56, label %111, label %57
57: ; preds = %52
%58 = and i64 %53, 4294967292
br label %81
59: ; preds = %59, %32
%60 = phi i64 [ 0, %32 ], [ %78, %59 ]
%61 = phi double [ 0.000000e+00, %32 ], [ %77, %59 ]
%62 = phi i64 [ 0, %32 ], [ %79, %59 ]
%63 = getelementptr inbounds double, double* %12, i64 %60
%64 = load double, double* %63
%65 = tail call double @llvm.fmuladd.f64(double %64, double %64, double %61)
%66 = or i64 %60, 1
%67 = getelementptr inbounds double, double* %12, i64 %66
%68 = load double, double* %67
%69 = tail call double @llvm.fmuladd.f64(double %68, double %68, double %65)
%70 = or i64 %60, 2
%71 = getelementptr inbounds double, double* %12, i64 %70
%72 = load double, double* %71
%73 = tail call double @llvm.fmuladd.f64(double %72, double %72, double %69)
%74 = or i64 %60, 3
%75 = getelementptr inbounds double, double* %12, i64 %74
%76 = load double, double* %75
%77 = tail call double @llvm.fmuladd.f64(double %76, double %76, double %73)
%78 = add nuw nsw i64 %60, 4
%79 = add i64 %62, 4
%80 = icmp eq i64 %79, %33
br i1 %80, label %34, label %59
81: ; preds = %81, %57
%82 = phi i64 [ 0, %57 ], [ %108, %81 ]
%83 = phi double [ 0.000000e+00, %57 ], [ %107, %81 ]
%84 = phi i64 [ 0, %57 ], [ %109, %81 ]
%85 = getelementptr inbounds double, double* %14, i64 %82
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %15, i64 %82
%88 = load double, double* %87
%89 = tail call double @llvm.fmuladd.f64(double %86, double %88, double %83)
%90 = or i64 %82, 1
%91 = getelementptr inbounds double, double* %14, i64 %90
%92 = load double, double* %91
%93 = getelementptr inbounds double, double* %15, i64 %90
%94 = load double, double* %93
%95 = tail call double @llvm.fmuladd.f64(double %92, double %94, double %89)
%96 = or i64 %82, 2
%97 = getelementptr inbounds double, double* %14, i64 %96
%98 = load double, double* %97
%99 = getelementptr inbounds double, double* %15, i64 %96
%100 = load double, double* %99
%101 = tail call double @llvm.fmuladd.f64(double %98, double %100, double %95)
%102 = or i64 %82, 3
%103 = getelementptr inbounds double, double* %14, i64 %102
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %15, i64 %102
%106 = load double, double* %105
%107 = tail call double @llvm.fmuladd.f64(double %104, double %106, double %101)
%108 = add nuw nsw i64 %82, 4
%109 = add i64 %84, 4
%110 = icmp eq i64 %109, %58
br i1 %110, label %111, label %81
111: ; preds = %81, %52
%112 = phi double [ undef, %52 ], [ %107, %81 ]
%113 = phi i64 [ 0, %52 ], [ %108, %81 ]
%114 = phi double [ 0.000000e+00, %52 ], [ %107, %81 ]
%115 = icmp eq i64 %55, 0
br i1 %115, label %128, label %116
116: ; preds = %111, %116
%117 = phi i64 [ %125, %116 ], [ %113, %111 ]
%118 = phi double [ %124, %116 ], [ %114, %111 ]
%119 = phi i64 [ %126, %116 ], [ 0, %111 ]
%120 = getelementptr inbounds double, double* %14, i64 %117
%121 = load double, double* %120
%122 = getelementptr inbounds double, double* %15, i64 %117
%123 = load double, double* %122
%124 = tail call double @llvm.fmuladd.f64(double %121, double %123, double %118)
%125 = add nuw nsw i64 %117, 1
%126 = add i64 %119, 1
%127 = icmp eq i64 %126, %55
br i1 %127, label %128, label %116
128: ; preds = %116, %111
%129 = phi double [ %112, %111 ], [ %124, %116 ]
%130 = fmul double %129, 5.000000e-01
br label %131
131: ; preds = %128, %49
%132 = phi double [ 0.000000e+00, %49 ], [ %130, %128 ]
%133 = icmp slt i32 %1, 0
%134 = icmp slt i32 %0, 0
%135 = add i32 %0, 1
%136 = sext i32 %4 to i64
%137 = add i32 %1, 1
%138 = sext i32 %9 to i64
%139 = zext i32 %9 to i64
%140 = zext i32 %137 to i64
%141 = zext i32 %135 to i64
br label %142
142: ; preds = %131, %365
%143 = phi double [ 1.000000e+00, %131 ], [ %366, %365 ]
%144 = phi i32 [ 0, %131 ], [ %367, %365 ]
br i1 %26, label %145, label %292
145: ; preds = %142, %262
%146 = phi i64 [ %290, %262 ], [ 0, %142 ]
%147 = phi double [ %289, %262 ], [ 0.000000e+00, %142 ]
%148 = shl nuw nsw i64 %146, 1
%149 = mul nuw nsw i64 %146, 3
%150 = getelementptr inbounds double, double* %8, i64 %148
%151 = load double, double* %150
%152 = tail call i32 @FindSpan(i32 %4, i32 %0, double %151, double* %6)
%153 = load double, double* %150
%154 = tail call i32 @BasisFuns(i32 %152, double %153, i32 %0, double* %6, double* %18, double* %16, double* %17)
%155 = or i64 %148, 1
%156 = getelementptr inbounds double, double* %8, i64 %155
%157 = load double, double* %156
%158 = tail call i32 @FindSpan(i32 %5, i32 %1, double %157, double* %7)
%159 = load double, double* %156
%160 = tail call i32 @BasisFuns(i32 %158, double %159, i32 %1, double* %7, double* %21, double* %19, double* %20)
br i1 %133, label %262, label %161
161: ; preds = %145
%162 = sub i32 %158, %1
%163 = sub i32 %152, %0
%164 = sext i32 %162 to i64
%165 = sext i32 %163 to i64
br label %166
166: ; preds = %161, %256
%167 = phi i64 [ 0, %161 ], [ %260, %256 ]
%168 = phi double [ 0.000000e+00, %161 ], [ %258, %256 ]
%169 = phi double [ 0.000000e+00, %161 ], [ %257, %256 ]
%170 = phi <2 x double> [ zeroinitializer, %161 ], [ %259, %256 ]
br i1 %134, label %256, label %171
171: ; preds = %166
%172 = add nsw i64 %167, %164
%173 = mul nsw i64 %172, %136
%174 = add nsw i64 %173, %165
%175 = getelementptr inbounds double, double* %21, i64 %167
%176 = load double, double* %175
br label %177
177: ; preds = %171, %249
%178 = phi i64 [ 0, %171 ], [ %254, %249 ]
%179 = phi double [ %168, %171 ], [ %251, %249 ]
%180 = phi double [ %169, %171 ], [ %253, %249 ]
%181 = phi <2 x double> [ %170, %171 ], [ %252, %249 ]
%182 = add nsw i64 %174, %178
%183 = getelementptr inbounds i32, i32* %13, i64 %182
%184 = load i32, i32* %183
%185 = icmp slt i32 %184, %23
%186 = getelementptr inbounds double, double* %18, i64 %178
%187 = load double, double* %186
%188 = fmul double %176, %187
%189 = trunc i64 %182 to i32
%190 = shl nsw i32 %189, 2
br i1 %185, label %191, label %227
191: ; preds = %177
%192 = or i32 %190, 3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %2, i64 %193
%195 = load double, double* %194
%196 = shl nsw i32 %184, 1
%197 = or i32 %196, 1
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %14, i64 %198
%200 = load double, double* %199
%201 = tail call double @llvm.fmuladd.f64(double %143, double %200, double %195)
%202 = fmul double %188, %201
%203 = mul nsw i64 %182, 3
%204 = getelementptr inbounds double, double* %3, i64 %203
%205 = load double, double* %204
%206 = sext i32 %196 to i64
%207 = getelementptr inbounds double, double* %14, i64 %206
%208 = load double, double* %207
%209 = fmul double %143, %208
%210 = getelementptr inbounds double, double* %11, i64 %203
%211 = load double, double* %210
%212 = tail call double @llvm.fmuladd.f64(double %209, double %211, double %205)
%213 = tail call double @llvm.fmuladd.f64(double %202, double %212, double %179)
%214 = add nsw i64 %203, 1
%215 = getelementptr inbounds double, double* %3, i64 %214
%216 = getelementptr inbounds double, double* %11, i64 %214
%217 = bitcast double* %215 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = bitcast double* %216 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = insertelement <2 x double> poison, double %209, i64 0
%222 = shufflevector <2 x double> %221, <2 x double> poison, <2 x i32> zeroinitializer
%223 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %222, <2 x double> %220, <2 x double> %218)
%224 = insertelement <2 x double> poison, double %202, i64 0
%225 = shufflevector <2 x double> %224, <2 x double> poison, <2 x i32> zeroinitializer
%226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %225, <2 x double> %223, <2 x double> %181)
br label %249
227: ; preds = %177
%228 = sext i32 %190 to i64
%229 = getelementptr inbounds double, double* %2, i64 %228
%230 = load double, double* %229
%231 = tail call double @llvm.fmuladd.f64(double %188, double %230, double %179)
%232 = or i32 %190, 1
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %2, i64 %233
%235 = load double, double* %234
%236 = or i32 %190, 2
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds double, double* %2, i64 %237
%239 = load double, double* %238
%240 = insertelement <2 x double> poison, double %188, i64 0
%241 = shufflevector <2 x double> %240, <2 x double> poison, <2 x i32> zeroinitializer
%242 = insertelement <2 x double> poison, double %235, i64 0
%243 = insertelement <2 x double> %242, double %239, i64 1
%244 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %241, <2 x double> %243, <2 x double> %181)
%245 = or i32 %190, 3
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %2, i64 %246
%248 = load double, double* %247
br label %249
249: ; preds = %191, %227
%250 = phi double [ %201, %191 ], [ %248, %227 ]
%251 = phi double [ %213, %191 ], [ %231, %227 ]
%252 = phi <2 x double> [ %226, %191 ], [ %244, %227 ]
%253 = tail call double @llvm.fmuladd.f64(double %188, double %250, double %180)
%254 = add nuw nsw i64 %178, 1
%255 = icmp eq i64 %254, %141
br i1 %255, label %256, label %177
256: ; preds = %249, %166
%257 = phi double [ %169, %166 ], [ %253, %249 ]
%258 = phi double [ %168, %166 ], [ %251, %249 ]
%259 = phi <2 x double> [ %170, %166 ], [ %252, %249 ]
%260 = add nuw nsw i64 %167, 1
%261 = icmp eq i64 %260, %140
br i1 %261, label %262, label %166
262: ; preds = %256, %145
%263 = phi double [ 0.000000e+00, %145 ], [ %257, %256 ]
%264 = phi double [ 0.000000e+00, %145 ], [ %258, %256 ]
%265 = phi <2 x double> [ zeroinitializer, %145 ], [ %259, %256 ]
%266 = and i64 %149, 4294967295
%267 = getelementptr inbounds double, double* %10, i64 %266
%268 = load double, double* %267
%269 = add nuw i64 %149, 1
%270 = and i64 %269, 4294967295
%271 = getelementptr inbounds double, double* %10, i64 %270
%272 = load double, double* %271
%273 = extractelement <2 x double> %265, i64 0
%274 = fmul double %273, %272
%275 = tail call double @llvm.fmuladd.f64(double %268, double %264, double %274)
%276 = add nuw i64 %149, 2
%277 = and i64 %276, 4294967295
%278 = getelementptr inbounds double, double* %10, i64 %277
%279 = load double, double* %278
%280 = extractelement <2 x double> %265, i64 1
%281 = tail call double @llvm.fmuladd.f64(double %279, double %280, double %275)
%282 = fdiv double %281, %263
%283 = add nsw i64 %146, %138
%284 = getelementptr inbounds double, double* %12, i64 %283
%285 = load double, double* %284
%286 = fadd double %285, %282
%287 = tail call i64 @pwr2(double %286)
%288 = sitofp i64 %287 to double
%289 = fadd double %147, %288
%290 = add nuw nsw i64 %146, 1
%291 = icmp eq i64 %290, %139
br i1 %291, label %292, label %145
292: ; preds = %262, %142
%293 = phi double [ 0.000000e+00, %142 ], [ %289, %262 ]
%294 = tail call double @llvm.fmuladd.f64(double %143, double %132, double %50)
%295 = fcmp olt double %293, %294
br i1 %295, label %296, label %365
296: ; preds = %292
%297 = fsub double %50, %293
%298 = icmp sgt i32 %23, 0
br i1 %298, label %299, label %369
299: ; preds = %296
%300 = zext i32 %23 to i64
br label %301
301: ; preds = %299, %362
%302 = phi i64 [ 0, %299 ], [ %363, %362 ]
%303 = getelementptr inbounds i32, i32* %13, i64 %302
%304 = load i32, i32* %303
%305 = icmp slt i32 %304, %23
br i1 %305, label %306, label %362
306: ; preds = %301
%307 = shl nsw i32 %304, 1
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %14, i64 %308
%310 = load double, double* %309
%311 = fmul double %143, %310
%312 = trunc i64 %302 to i32
%313 = mul nsw i32 %312, 3
%314 = zext i32 %313 to i64
%315 = getelementptr inbounds double, double* %11, i64 %314
%316 = load double, double* %315
%317 = getelementptr inbounds double, double* %3, i64 %314
%318 = load double, double* %317
%319 = tail call double @llvm.fmuladd.f64(double %311, double %316, double %318)
store double %319, double* %317
%320 = load double, double* %309
%321 = fmul double %143, %320
%322 = add nuw nsw i32 %313, 1
%323 = zext i32 %322 to i64
%324 = getelementptr inbounds double, double* %11, i64 %323
%325 = load double, double* %324
%326 = getelementptr inbounds double, double* %3, i64 %323
%327 = load double, double* %326
%328 = tail call double @llvm.fmuladd.f64(double %321, double %325, double %327)
store double %328, double* %326
%329 = load double, double* %309
%330 = fmul double %143, %329
%331 = add nuw nsw i32 %313, 2
%332 = zext i32 %331 to i64
%333 = getelementptr inbounds double, double* %11, i64 %332
%334 = load double, double* %333
%335 = getelementptr inbounds double, double* %3, i64 %332
%336 = load double, double* %335
%337 = tail call double @llvm.fmuladd.f64(double %330, double %334, double %336)
store double %337, double* %335
%338 = or i32 %307, 1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %14, i64 %339
%341 = load double, double* %340
%342 = shl nsw i32 %312, 2
%343 = or i32 %342, 3
%344 = zext i32 %343 to i64
%345 = getelementptr inbounds double, double* %2, i64 %344
%346 = load double, double* %345
%347 = tail call double @llvm.fmuladd.f64(double %143, double %341, double %346)
store double %347, double* %345
%348 = load double, double* %317
%349 = fmul double %347, %348
%350 = zext i32 %342 to i64
%351 = getelementptr inbounds double, double* %2, i64 %350
store double %349, double* %351
%352 = load double, double* %326
%353 = fmul double %347, %352
%354 = or i32 %342, 1
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds double, double* %2, i64 %355
store double %353, double* %356
%357 = load double, double* %335
%358 = fmul double %347, %357
%359 = or i32 %342, 2
%360 = zext i32 %359 to i64
%361 = getelementptr inbounds double, double* %2, i64 %360
store double %358, double* %361
br label %362
362: ; preds = %301, %306
%363 = add nuw nsw i64 %302, 1
%364 = icmp eq i64 %363, %300
br i1 %364, label %369, label %301
365: ; preds = %292
%366 = fmul double %143, 5.000000e-01
%367 = add nuw nsw i32 %144, 1
%368 = icmp eq i32 %367, 50
br i1 %368, label %369, label %142
369: ; preds = %365, %362, %296
%370 = phi double [ %297, %296 ], [ %297, %362 ], [ 0.000000e+00, %365 ]
ret double %370
}