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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
void BspEval2(int degU, int degV, double *cp, int mcp, int ncp, int kcp,
              double *knotU, double *knotV, double *us, int nus, double *ep,
              double *leftU, double *rightU, double *NU, double *leftV,
              double *rightV, double *NV) {
  int i, j, ii, jj, spanU, spanV, ind, myint1, myint2, myint3, mcpncp,
      jjmcp = 0, twojj = 0;
  double NN;
  mcpncp = mcp * ncp;
  myint3 = mcpncp * (kcp - 1);
  for (jj = 0; jj < nus; jj++) {
    if (us[twojj] <= knotU[degU]) {
      if (us[twojj + 1] <= knotV[degV]) {
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = cp[ii];
        }
      } else if (us[twojj + 1] >= knotV[kcp]) {
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = cp[myint3 + ii];
        }
      } else {
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = 0.0;
        }
        spanV = FindSpan(kcp, degV, us[twojj + 1], knotV);
        BasisFuns(spanV, us[twojj + 1], degV, knotV, NV, leftV, rightV);
        myint2 = (spanV - degV) * mcpncp;
        for (i = 0; i <= degV; i++) {
          for (ii = 0; ii < mcp; ii++) {
            ep[jjmcp + ii] += NV[i] * cp[myint2 + ii];
          }
          myint2 += mcpncp;
        }
      }
    } else if (us[twojj] >= knotU[ncp]) {
      if (us[twojj + 1] <= knotV[degV]) {
        myint2 = mcpncp - mcp;
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = cp[myint2 + ii];
        }
      } else if (us[twojj + 1] >= knotV[kcp]) {
        myint2 = mcpncp * kcp - mcp;
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = cp[myint2 + ii];
        }
      } else {
        for (ii = 0; ii < mcp; ii++) {
          ep[jjmcp + ii] = 0.0;
        }
        spanV = FindSpan(kcp, degV, us[twojj + 1], knotV);
        BasisFuns(spanV, us[twojj + 1], degV, knotV, NV, leftV, rightV);
        myint2 = (spanV - degV + 1) * mcpncp - mcp;
        for (i = 0; i <= degV; i++) {
          for (ii = 0; ii < mcp; ii++) {
            ep[jjmcp + ii] += NV[i] * cp[myint2 + ii];
          }
          myint2 += mcpncp;
        }
      }
    } else {
      for (ii = 0; ii < mcp; ii++) {
        ep[jjmcp + ii] = 0.0;
      }
      if (us[twojj + 1] <= knotV[degV]) {
        spanU = FindSpan(ncp, degU, us[twojj], knotU);
        BasisFuns(spanU, us[twojj], degU, knotU, NU, leftU, rightU);
        myint2 = (spanU - degU) * mcp;
        for (i = 0; i <= degU; i++) {
          for (ii = 0; ii < mcp; ii++) {
            ep[jjmcp + ii] += NU[i] * cp[myint2 + ii];
          }
          myint2 += mcp;
        }
      } else if (us[twojj + 1] >= knotV[kcp]) {
        spanU = FindSpan(ncp, degU, us[twojj], knotU);
        BasisFuns(spanU, us[twojj], degU, knotU, NU, leftU, rightU);
        myint2 = myint3 + (spanU - degU) * mcp;
        for (i = 0; i <= degU; i++) {
          for (ii = 0; ii < mcp; ii++) {
            ep[jjmcp + ii] += NU[i] * cp[myint2 + ii];
          }
          myint2 += mcp;
        }
      } else {
        spanU = FindSpan(ncp, degU, us[twojj], knotU);
        BasisFuns(spanU, us[twojj], degU, knotU, NU, leftU, rightU);
        spanV = FindSpan(kcp, degV, us[twojj + 1], knotV);
        BasisFuns(spanV, us[twojj + 1], degV, knotV, NV, leftV, rightV);
        ind = (spanU - degU) * mcp;
        myint1 = (spanV - degV) * mcpncp;
        for (i = 0; i <= degV; i++) {
          myint2 = ind + myint1;
          for (j = 0; j <= degU; j++) {
            NN = NV[i] * NU[j];
            for (ii = 0; ii < mcp; ii++) {
              ep[jjmcp + ii] += NN * cp[myint2 + ii];
            }
            myint2 += mcp;
          }
          myint1 += mcpncp;
        }
      }
    }
    jjmcp += mcp;
    twojj += 2;
  }
}


x86 assembly (clang, -O0):
<BspEval2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%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    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1a1f <BspEval2+0x8ff>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     13cf <BspEval2+0x2af>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1234 <BspEval2+0x114>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    122f <BspEval2+0x10f>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11f6 <BspEval2+0xd6>
jmp    13ca <BspEval2+0x2aa>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     12a3 <BspEval2+0x183>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    129e <BspEval2+0x17e>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1260 <BspEval2+0x140>
jmp    13c5 <BspEval2+0x2a5>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d9 <BspEval2+0x1b9>
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12aa <BspEval2+0x18a>
mov    -0x1c(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13c0 <BspEval2+0x2a0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13a9 <BspEval2+0x289>
mov    0x60(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1351 <BspEval2+0x231>
mov    -0x48(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    133e <BspEval2+0x21e>
jmp    13c5 <BspEval2+0x2a5>
jmp    13ca <BspEval2+0x2aa>
jmp    19ff <BspEval2+0x8df>
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1619 <BspEval2+0x4f9>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     146b <BspEval2+0x34b>
mov    -0x48(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1466 <BspEval2+0x346>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1428 <BspEval2+0x308>
jmp    1614 <BspEval2+0x4f4>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     14e7 <BspEval2+0x3c7>
mov    -0x48(%rbp),%eax
imul   -0x1c(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14e2 <BspEval2+0x3c2>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14a4 <BspEval2+0x384>
jmp    160f <BspEval2+0x4ef>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    151d <BspEval2+0x3fd>
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14ee <BspEval2+0x3ce>
mov    -0x1c(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
add    $0x1,%eax
imul   -0x48(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     160a <BspEval2+0x4ea>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15f3 <BspEval2+0x4d3>
mov    0x60(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    159b <BspEval2+0x47b>
mov    -0x48(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1588 <BspEval2+0x468>
jmp    160f <BspEval2+0x4ef>
jmp    1614 <BspEval2+0x4f4>
jmp    19fa <BspEval2+0x8da>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    164f <BspEval2+0x52f>
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1620 <BspEval2+0x500>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     175a <BspEval2+0x63a>
mov    -0x18(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1755 <BspEval2+0x635>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    173e <BspEval2+0x61e>
mov    0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e6 <BspEval2+0x5c6>
mov    -0x14(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16d3 <BspEval2+0x5b3>
jmp    19f5 <BspEval2+0x8d5>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1866 <BspEval2+0x746>
mov    -0x18(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x44(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x4(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1861 <BspEval2+0x741>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    184a <BspEval2+0x72a>
mov    0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17f2 <BspEval2+0x6d2>
mov    -0x14(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    17df <BspEval2+0x6bf>
jmp    19f0 <BspEval2+0x8d0>
mov    -0x18(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x1c(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rdx
mov    0x60(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x58(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     19eb <BspEval2+0x8cb>
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     19d4 <BspEval2+0x8b4>
mov    0x60(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19bd <BspEval2+0x89d>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    196d <BspEval2+0x84d>
mov    -0x14(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    193b <BspEval2+0x81b>
mov    -0x48(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    191f <BspEval2+0x7ff>
jmp    19f0 <BspEval2+0x8d0>
jmp    19f5 <BspEval2+0x8d5>
jmp    19fa <BspEval2+0x8da>
jmp    19ff <BspEval2+0x8df>
mov    -0x14(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1196 <BspEval2+0x76>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BspEval2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,0x88(%rsp)
mov    %r8d,0x24(%rsp)
mov    %rdx,0x8(%rsp)
mov    %esi,0x10(%rsp)
mov    %edi,0x14(%rsp)
mov    0x1e8(%rsp),%r9d
test   %r9d,%r9d
jle    28a0 <BspEval2+0x1770>
mov    %ecx,%r11d
mov    0x24(%rsp),%edi
imul   %ecx,%edi
mov    0x88(%rsp),%r14
lea    -0x1(%r14),%ebx
imul   %edi,%ebx
movslq 0x10(%rsp),%r15
mov    %edi,%ecx
sub    %r11d,%ecx
mov    %edi,%edx
imul   %r14d,%edx
sub    %r11d,%edx
mov    $0x1,%eax
sub    %r15d,%eax
mov    %eax,0xf0(%rsp)
mov    %ebx,0xf4(%rsp)
movslq %ebx,%r12
movslq %r11d,%rsi
mov    %esi,%r13d
movslq %ecx,%r10
movslq %edx,%r8
mov    %r9d,%eax
mov    %rax,0x180(%rsp)
lea    (%r8,%r13,1),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x138(%rsp)
lea    (%r10,%r13,1),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0x150(%rsp)
lea    (%r12,%r13,1),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0x148(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %ebp,%r9d
and    $0x3,%r9d
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x130(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x80(%rsp)
movabs $0x7ffffffffffffffc,%rbx
ff ff 7f
or     $0x2,%rbx
mov    %rbp,%rax
mov    %rbp,0xa0(%rsp)
and    %rbp,%rbx
mov    %rbx,0x98(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x70(%rsp)
mov    %r9,0x140(%rsp)
shl    $0x5,%r9
mov    %r9,0xf8(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0xb0(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0x90(%rsp)
mov    0x1f0(%rsp),%rbp
mov    0x1e0(%rsp),%rbx
movslq 0x14(%rsp),%rcx
movslq %r14d,%rax
mov    %rax,0xb8(%rsp)
movslq 0x24(%rsp),%rax
mov    %rax,0x168(%rsp)
mov    %edi,0x5c(%rsp)
movslq %edi,%rdi
mov    %r15,%rax
mov    %r15,0xc8(%rsp)
lea    0x1(%r15),%eax
mov    %rax,0xe8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x178(%rsp)
lea    0x1(%rcx),%eax
mov    %rax,0x28(%rsp)
mov    %r8,0x118(%rsp)
lea    (%rdx,%r8,8),%rax
mov    %rax,0xc0(%rsp)
mov    %r10,0x120(%rsp)
lea    (%rdx,%r10,8),%rax
mov    %rax,0xd8(%rsp)
mov    %r12,0x128(%rsp)
lea    (%rdx,%r12,8),%rax
mov    %rax,0xd0(%rsp)
lea    (%rdx,%r13,8),%rax
mov    %rax,0x158(%rsp)
lea    0x70(%rbp),%rax
lea    0x0(,%rsi,8),%r14
lea    0x10(%rbp),%r15
lea    0x10(%rdx),%rcx
mov    %rcx,0x60(%rsp)
mov    %rdi,0xa8(%rsp)
lea    0x0(,%rdi,8),%rcx
mov    %rcx,0x110(%rsp)
lea    0x30(%rdx),%rcx
mov    %rcx,0x170(%rsp)
xor    %edx,%edx
xor    %r8d,%r8d
xor    %edi,%edi
mov    %r11d,0x4(%rsp)
mov    %rsi,0x50(%rsp)
jmp    13ec <BspEval2+0x2bc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x50(%rsp),%rsi
mov    0x30(%rsp),%rdx
add    %rsi,%rdx
mov    0xe0(%rsp),%r8
add    $0x2,%r8
mov    0x190(%rsp),%rdi
add    $0x1,%rdi
mov    0x108(%rsp),%rax
add    %r14,%rax
add    %r14,%r15
add    %r14,%rbp
cmp    0x180(%rsp),%rdi
mov    0x1e0(%rsp),%rbx
je     28a0 <BspEval2+0x1770>
mov    %rax,0x108(%rsp)
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x48(%rsp)
lea    (%rdx,%r13,1),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x40(%rsp)
mov    %rdi,0x190(%rsp)
mov    %rdi,%rax
imul   %rsi,%rax
lea    (%rcx,%rax,8),%rdi
movsd  (%rbx,%r8,8),%xmm0
mov    0x1d0(%rsp),%rax
mov    0x178(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
mov    %r8,0xe0(%rsp)
mov    %rdx,0x30(%rsp)
jae    1880 <BspEval2+0x750>
mov    0x168(%rsp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
mov    0x14(%rsp),%r12d
jae    1b40 <BspEval2+0xa10>
test   %r11d,%r11d
jle    1498 <BspEval2+0x368>
xor    %esi,%esi
mov    0xb0(%rsp),%rdx
call   1030 <memset@plt>
mov    0xe0(%rsp),%r8
mov    0x1e0(%rsp),%rbx
mov    0x14(%rsp),%r12d
mov    %r8,%rdx
or     $0x1,%rdx
movsd  (%rbx,%rdx,8),%xmm1
mov    0xc8(%rsp),%rax
mov    0x1d8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
jae    1ea5 <BspEval2+0xd75>
mov    %rcx,%rax
mov    %rdx,0x100(%rsp)
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  (%rbx,%r8,8),%xmm0
mov    0x24(%rsp),%edi
mov    %r12d,%esi
mov    0x1d0(%rsp),%rdx
movsd  %xmm1,0x160(%rsp)
call   1050 <FindSpan@plt>
mov    0xe0(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    %eax,0x7c(%rsp)
mov    %eax,%edi
mov    %r12d,%esi
mov    0x1d0(%rsp),%rdx
mov    0x208(%rsp),%rcx
mov    0x1f8(%rsp),%r8
mov    0x200(%rsp),%r9
call   1040 <BasisFuns@plt>
movsd  0x160(%rsp),%xmm0
ucomisd 0x18(%rsp),%xmm0
jae    2298 <BspEval2+0x1168>
mov    0x1e0(%rsp),%rbx
mov    0x100(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
mov    0x88(%rsp),%rdi
mov    0x10(%rsp),%r12d
mov    %r12d,%esi
mov    0x1d8(%rsp),%rdx
call   1050 <FindSpan@plt>
mov    0x100(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
mov    %eax,%ebx
mov    %eax,%edi
mov    %r12d,%esi
mov    0x1d8(%rsp),%rdx
mov    0x220(%rsp),%rcx
mov    0x210(%rsp),%r8
mov    0x218(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %r12d,%r12d
mov    0x4(%rsp),%r11d
mov    0x28(%rsp),%r10
js     13a0 <BspEval2+0x270>
sub    0x10(%rsp),%ebx
mov    0x7c(%rsp),%eax
sub    0x14(%rsp),%eax
imul   0x24(%rsp),%ebx
add    %eax,%ebx
imul   %r11d,%ebx
mov    %ebx,0x18(%rsp)
xor    %r9d,%r9d
mov    %r15,0x188(%rsp)
jmp    161e <BspEval2+0x4ee>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x18(%rsp),%eax
add    0x5c(%rsp),%eax
mov    %eax,0x18(%rsp)
cmp    0xe8(%rsp),%r9
je     13a0 <BspEval2+0x270>
cmpl   $0x0,0x14(%rsp)
mov    0x50(%rsp),%r12
js     1600 <BspEval2+0x4d0>
movslq 0x18(%rsp),%rcx
lea    (%rcx,%r13,1),%r8
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
mov    0x170(%rsp),%rax
lea    (%rax,%rcx,8),%rdi
xor    %ebx,%ebx
jmp    1662 <BspEval2+0x532>
nopl   0x0(%rax)
add    %r12,%rcx
add    $0x1,%rbx
add    %r14,%rdi
add    %r14,%rsi
cmp    %r10,%rbx
je     1600 <BspEval2+0x4d0>
test   %r11d,%r11d
jle    1650 <BspEval2+0x520>
mov    0x220(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
mov    0x208(%rsp),%rax
mulsd  (%rax,%rbx,8),%xmm0
cmp    $0x4,%r11d
jb     16b5 <BspEval2+0x585>
mov    %rbx,%rax
imul   %r12,%rax
add    %r8,%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
cmp    %rax,0x48(%rsp)
jae    1749 <BspEval2+0x619>
lea    (%rdx,%rcx,8),%rax
cmp    0x40(%rsp),%rax
jae    1749 <BspEval2+0x619>
xor    %edx,%edx
mov    %rdx,%rax
test   $0x1,%r13b
je     1700 <BspEval2+0x5d0>
lea    (%rdx,%rcx,1),%r10
mov    0x30(%rsp),%rax
add    %rdx,%rax
mov    0x8(%rsp),%r12
movsd  (%r12,%r10,8),%xmm1
mov    0x50(%rsp),%r12
mulsd  %xmm0,%xmm1
mov    0x1f0(%rsp),%r10
addsd  (%r10,%rax,8),%xmm1
movsd  %xmm1,(%r10,%rax,8)
mov    0x28(%rsp),%r10
mov    %rdx,%rax
or     $0x1,%rax
not    %rdx
cmp    0x70(%rsp),%rdx
je     1650 <BspEval2+0x520>
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1710 <BspEval2+0x5e0>
jmp    1650 <BspEval2+0x520>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x68(%rsp)
je     186a <BspEval2+0x73a>
mov    0x98(%rsp),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rdx,8),%xmm2
movupd -0x20(%rdi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd 0x0(%rbp,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbp,%rdx,8),%xmm2
movupd 0x20(%rbp,%rdx,8),%xmm5
movupd 0x30(%rbp,%rdx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,0x0(%rbp,%rdx,8)
movupd %xmm3,0x10(%rbp,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm2
movupd (%rdi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbp,%rdx,8)
movupd %xmm3,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1770 <BspEval2+0x640>
testb  $0x1,0xa0(%rsp)
01
je     1854 <BspEval2+0x724>
lea    (%rdx,%rcx,1),%rax
mov    %r9,%r15
mov    %r8,%r9
mov    %r11d,%r8d
mov    %r14,%r11
mov    0x8(%rsp),%r14
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
mov    %r11,%r14
mov    %r8d,%r11d
mov    %r9,%r8
mov    %r15,%r9
mov    0x188(%rsp),%r15
add    0x30(%rsp),%rdx
mov    0x1f0(%rsp),%rax
movupd (%rax,%rdx,8),%xmm4
movupd 0x10(%rax,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rax,%rdx,8)
movupd %xmm3,0x10(%rax,%rdx,8)
mov    0x38(%rsp),%rax
mov    %rax,%rdx
cmp    %r13,%rax
je     1650 <BspEval2+0x520>
jmp    16b7 <BspEval2+0x587>
xor    %edx,%edx
testb  $0x1,0xa0(%rsp)
01
jne    17eb <BspEval2+0x6bb>
jmp    1854 <BspEval2+0x724>
nopl   0x0(%rax)
mov    %r8,%r12
or     $0x1,%r12
movsd  (%rbx,%r12,8),%xmm0
mov    0xc8(%rsp),%rax
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1df0 <BspEval2+0xcc0>
mov    0xb8(%rsp),%rax
ucomisd (%rdx,%rax,8),%xmm0
jae    2112 <BspEval2+0xfe2>
test   %r11d,%r11d
jle    18e1 <BspEval2+0x7b1>
xor    %esi,%esi
mov    0xb0(%rsp),%rdx
call   1030 <memset@plt>
mov    0x1d8(%rsp),%rdx
movsd  (%rbx,%r12,8),%xmm0
mov    0x88(%rsp),%rdi
mov    0x10(%rsp),%esi
call   1050 <FindSpan@plt>
mov    %rbx,%rcx
mov    %eax,%ebx
movsd  (%rcx,%r12,8),%xmm0
mov    %eax,%edi
mov    0x10(%rsp),%r12d
mov    %r12d,%esi
mov    0x1d8(%rsp),%rdx
mov    0x220(%rsp),%rcx
mov    0x210(%rsp),%r8
mov    0x218(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %r12d,%r12d
mov    0x4(%rsp),%r11d
js     13a0 <BspEval2+0x270>
sub    0x10(%rsp),%ebx
imul   0x5c(%rsp),%ebx
movslq %ebx,%r8
lea    (%r8,%r13,1),%rax
mov    %rax,0x18(%rsp)
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r8,8),%rsi
xor    %edi,%edi
jmp    1998 <BspEval2+0x868>
cs nopw 0x0(%rax,%rax,1)
nop
add    0xa8(%rsp),%r8
add    $0x1,%rdi
mov    0x110(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    0xe8(%rsp),%rdi
je     13a0 <BspEval2+0x270>
test   %r11d,%r11d
mov    0x220(%rsp),%rax
jle    1970 <BspEval2+0x840>
cmp    $0x4,%r11d
jae    1a40 <BspEval2+0x910>
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%r13b
je     19f2 <BspEval2+0x8c2>
movsd  (%rax,%rdi,8),%xmm0
lea    (%rcx,%r8,1),%r9
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,1),%r10
mov    0x8(%rsp),%rbx
mulsd  (%rbx,%r9,8),%xmm0
mov    0x1f0(%rsp),%rbx
addsd  (%rbx,%r10,8),%xmm0
movsd  %xmm0,(%rbx,%r10,8)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x70(%rsp),%rcx
je     1970 <BspEval2+0x840>
movsd  (%rax,%rdi,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
addsd  0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1a00 <BspEval2+0x8d0>
jmp    1970 <BspEval2+0x840>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rcx
imul   0xa8(%rsp),%rcx
add    0x18(%rsp),%rcx
lea    (%rax,%rdi,8),%r9
lea    (%rax,%rdi,8),%r11
add    $0x8,%r11
mov    0x8(%rsp),%rbx
lea    (%rbx,%r8,8),%r10
lea    (%rbx,%rcx,8),%rcx
mov    0x48(%rsp),%rbx
cmp    %r11,%rbx
setb   %r11b
mov    0x40(%rsp),%rax
cmp    %rax,%r9
setb   %r12b
cmp    %rcx,%rbx
setb   %bl
cmp    %rax,%r10
setb   %r9b
test   %r12b,%r11b
jne    1b24 <BspEval2+0x9f4>
mov    $0x0,%ecx
and    %r9b,%bl
mov    0x4(%rsp),%r11d
mov    0x220(%rsp),%rax
jne    19b1 <BspEval2+0x881>
movsd  (%rax,%rdi,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x90(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rcx,1),%xmm1
movupd (%rdx,%rcx,1),%xmm2
movupd -0x10(%r15,%rcx,1),%xmm3
movupd (%r15,%rcx,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r15,%rcx,1)
movupd %xmm2,(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    1ad0 <BspEval2+0x9a0>
mov    0x38(%rsp),%rbx
mov    %rbx,%rcx
cmp    %r13,%rbx
je     1970 <BspEval2+0x840>
jmp    19b1 <BspEval2+0x881>
xor    %ecx,%ecx
mov    0x4(%rsp),%r11d
mov    0x220(%rsp),%rax
jmp    19b1 <BspEval2+0x881>
nopl   0x0(%rax,%rax,1)
mov    %r8,%r12
or     $0x1,%r12
movsd  (%rbx,%r12,8),%xmm0
mov    0xc8(%rsp),%rax
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jae    21d8 <BspEval2+0x10a8>
mov    0xb8(%rsp),%rax
ucomisd (%rdx,%rax,8),%xmm0
jae    24bb <BspEval2+0x138b>
test   %r11d,%r11d
jle    1ba1 <BspEval2+0xa71>
xor    %esi,%esi
mov    0xb0(%rsp),%rdx
call   1030 <memset@plt>
mov    0x1d8(%rsp),%rdx
movsd  (%rbx,%r12,8),%xmm0
mov    0x88(%rsp),%rdi
mov    0x10(%rsp),%esi
call   1050 <FindSpan@plt>
mov    %rbx,%rcx
mov    %eax,%ebx
movsd  (%rcx,%r12,8),%xmm0
mov    %eax,%edi
mov    0x10(%rsp),%r12d
mov    %r12d,%esi
mov    0x1d8(%rsp),%rdx
mov    0x220(%rsp),%rcx
mov    0x210(%rsp),%r8
mov    0x218(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %r12d,%r12d
mov    0x4(%rsp),%r11d
js     13a0 <BspEval2+0x270>
add    0xf0(%rsp),%ebx
imul   0x5c(%rsp),%ebx
sub    %r11d,%ebx
movslq %ebx,%r8
lea    (%r8,%r13,1),%rax
mov    %rax,0x18(%rsp)
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r8,8),%rsi
xor    %edi,%edi
jmp    1c58 <BspEval2+0xb28>
nopl   0x0(%rax,%rax,1)
add    0xa8(%rsp),%r8
add    $0x1,%rdi
mov    0x110(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    0xe8(%rsp),%rdi
je     13a0 <BspEval2+0x270>
test   %r11d,%r11d
mov    0x220(%rsp),%rax
jle    1c30 <BspEval2+0xb00>
cmp    $0x4,%r11d
jae    1c80 <BspEval2+0xb50>
xor    %ecx,%ecx
jmp    1d60 <BspEval2+0xc30>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdi,%rcx
imul   0xa8(%rsp),%rcx
add    0x18(%rsp),%rcx
lea    (%rax,%rdi,8),%r9
lea    (%rax,%rdi,8),%r11
add    $0x8,%r11
mov    0x8(%rsp),%rbx
lea    (%rbx,%r8,8),%r10
lea    (%rbx,%rcx,8),%rcx
mov    0x48(%rsp),%rbx
cmp    %r11,%rbx
setb   %r11b
mov    0x40(%rsp),%rax
cmp    %rax,%r9
setb   %r12b
cmp    %rcx,%rbx
setb   %bl
cmp    %rax,%r10
setb   %r9b
test   %r12b,%r11b
jne    1d51 <BspEval2+0xc21>
mov    $0x0,%ecx
and    %r9b,%bl
mov    0x4(%rsp),%r11d
mov    0x220(%rsp),%rax
jne    1d60 <BspEval2+0xc30>
movsd  (%rax,%rdi,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x90(%rsp),%rbx
xchg   %ax,%ax
movupd -0x10(%rdx,%rcx,1),%xmm1
movupd (%rdx,%rcx,1),%xmm2
movupd -0x10(%r15,%rcx,1),%xmm3
movupd (%r15,%rcx,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r15,%rcx,1)
movupd %xmm2,(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    1d00 <BspEval2+0xbd0>
mov    0x38(%rsp),%rbx
mov    %rbx,%rcx
cmp    %r13,%rbx
je     1c30 <BspEval2+0xb00>
jmp    1d60 <BspEval2+0xc30>
xor    %ecx,%ecx
mov    0x4(%rsp),%r11d
mov    0x220(%rsp),%rax
mov    %rcx,%rbx
test   $0x1,%r13b
je     1da1 <BspEval2+0xc71>
movsd  (%rax,%rdi,8),%xmm0
lea    (%rcx,%r8,1),%r9
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,1),%r10
mov    0x8(%rsp),%rbx
mulsd  (%rbx,%r9,8),%xmm0
mov    0x1f0(%rsp),%rbx
addsd  (%rbx,%r10,8),%xmm0
movsd  %xmm0,(%rbx,%r10,8)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x70(%rsp),%rcx
je     1c30 <BspEval2+0xb00>
nop
movsd  (%rax,%rdi,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
addsd  0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1db0 <BspEval2+0xc80>
jmp    1c30 <BspEval2+0xb00>
nopl   0x0(%rax,%rax,1)
test   %r11d,%r11d
jle    13a0 <BspEval2+0x270>
cmp    $0x4,%r11d
jb     1e22 <BspEval2+0xcf2>
mov    0x48(%rsp),%rax
cmp    0x158(%rsp),%rax
mov    0x8(%rsp),%rdi
jae    2588 <BspEval2+0x1458>
cmp    %rdi,0x40(%rsp)
jbe    2588 <BspEval2+0x1458>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
mov    0x80(%rsp),%rdx
test   %rdx,%rdx
je     1e55 <BspEval2+0xd25>
mov    0x8(%rsp),%rsi
nop
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e40 <BspEval2+0xd10>
cmp    $0x3,%rcx
jb     13a0 <BspEval2+0x270>
nop
mov    0x8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    1e60 <BspEval2+0xd30>
jmp    13a0 <BspEval2+0x270>
movsd  (%rbx,%r8,8),%xmm0
mov    0x24(%rsp),%edi
mov    %r12d,%esi
mov    0x1d0(%rsp),%rdx
mov    %r8,%rbx
call   1050 <FindSpan@plt>
mov    %eax,%r12d
mov    0x1e0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12d,%edi
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
mov    0x1d0(%rsp),%rdx
mov    0x208(%rsp),%rcx
mov    0x1f8(%rsp),%r8
mov    0x200(%rsp),%r9
call   1040 <BasisFuns@plt>
test   %ebx,%ebx
mov    0x4(%rsp),%r11d
mov    0x28(%rsp),%r9
js     13a0 <BspEval2+0x270>
sub    0x14(%rsp),%r12d
imul   %r11d,%r12d
movslq %r12d,%r8
lea    (%r8,%r13,1),%rax
mov    %rax,0x18(%rsp)
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r8,8),%rsi
xor    %edi,%edi
jmp    1f56 <BspEval2+0xe26>
nopl   (%rax)
add    %r12,%r8
add    $0x1,%rdi
add    %r14,%rdx
add    %r14,%rsi
cmp    %r9,%rdi
je     13a0 <BspEval2+0x270>
test   %r11d,%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
jle    1f40 <BspEval2+0xe10>
cmp    $0x4,%r11d
jae    2010 <BspEval2+0xee0>
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%r13b
je     1fc2 <BspEval2+0xe92>
movsd  (%rax,%rdi,8),%xmm0
lea    (%rcx,%r8,1),%r9
mov    0x30(%rsp),%rax
lea    (%rcx,%rax,1),%r10
mov    0x8(%rsp),%rax
mulsd  (%rax,%r9,8),%xmm0
mov    0x208(%rsp),%rax
mov    0x1f0(%rsp),%rbx
addsd  (%rbx,%r10,8),%xmm0
movsd  %xmm0,(%rbx,%r10,8)
mov    0x28(%rsp),%r9
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x70(%rsp),%rcx
je     1f40 <BspEval2+0xe10>
movsd  (%rax,%rdi,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
addsd  0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1fd0 <BspEval2+0xea0>
jmp    1f40 <BspEval2+0xe10>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rcx
imul   %r12,%rcx
add    0x18(%rsp),%rcx
lea    (%rax,%rdi,8),%r9
lea    (%rax,%rdi,8),%r11
add    $0x8,%r11
mov    0x8(%rsp),%rbx
lea    (%rbx,%r8,8),%r10
lea    (%rbx,%rcx,8),%rcx
mov    0x48(%rsp),%rbx
cmp    %r11,%rbx
setb   %r11b
mov    0x40(%rsp),%rax
cmp    %rax,%r9
setb   %r12b
cmp    %rcx,%rbx
setb   %bl
cmp    %rax,%r10
setb   %r9b
test   %r12b,%r11b
jne    20f4 <BspEval2+0xfc4>
mov    $0x0,%ecx
and    %r9b,%bl
mov    0x4(%rsp),%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
mov    0x28(%rsp),%r9
jne    1f74 <BspEval2+0xe44>
movsd  (%rax,%rdi,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x90(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rcx,1),%xmm1
movupd (%rdx,%rcx,1),%xmm2
movupd -0x10(%r15,%rcx,1),%xmm3
movupd (%r15,%rcx,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r15,%rcx,1)
movupd %xmm2,(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    20a0 <BspEval2+0xf70>
mov    0x38(%rsp),%rbx
mov    %rbx,%rcx
cmp    %r13,%rbx
je     1f40 <BspEval2+0xe10>
jmp    1f74 <BspEval2+0xe44>
xor    %ecx,%ecx
mov    0x4(%rsp),%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
mov    0x28(%rsp),%r9
jmp    1f74 <BspEval2+0xe44>
test   %r11d,%r11d
jle    13a0 <BspEval2+0x270>
cmp    $0x4,%r11d
jb     2147 <BspEval2+0x1017>
mov    0x48(%rsp),%rax
cmp    0x148(%rsp),%rax
mov    0xd0(%rsp),%rdx
jae    25a3 <BspEval2+0x1473>
cmp    0x40(%rsp),%rdx
jae    25a3 <BspEval2+0x1473>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
test   $0x3,%r13b
je     2185 <BspEval2+0x1055>
mov    0x80(%rsp),%rdx
mov    0xd0(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2170 <BspEval2+0x1040>
cmp    $0x3,%rcx
jb     13a0 <BspEval2+0x270>
nop
mov    0xd0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    2190 <BspEval2+0x1060>
jmp    13a0 <BspEval2+0x270>
test   %r11d,%r11d
jle    13a0 <BspEval2+0x270>
cmp    $0x4,%r11d
jb     220d <BspEval2+0x10dd>
mov    0x48(%rsp),%rax
cmp    0x150(%rsp),%rax
mov    0xd8(%rsp),%rdx
jae    2648 <BspEval2+0x1518>
cmp    0x40(%rsp),%rdx
jae    2648 <BspEval2+0x1518>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
test   $0x3,%r13b
je     2245 <BspEval2+0x1115>
mov    0x80(%rsp),%rdx
mov    0xd8(%rsp),%rsi
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2230 <BspEval2+0x1100>
cmp    $0x3,%rcx
jb     13a0 <BspEval2+0x270>
nop
mov    0xd8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    2250 <BspEval2+0x1120>
jmp    13a0 <BspEval2+0x270>
test   %r12d,%r12d
mov    0x4(%rsp),%r11d
mov    0x28(%rsp),%r9
js     13a0 <BspEval2+0x270>
mov    0x7c(%rsp),%eax
sub    0x14(%rsp),%eax
imul   %r11d,%eax
add    0xf4(%rsp),%eax
movslq %eax,%r8
lea    (%r8,%r13,1),%rax
mov    %rax,0x18(%rsp)
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r8,8),%rsi
xor    %edi,%edi
jmp    22f6 <BspEval2+0x11c6>
add    %r12,%r8
add    $0x1,%rdi
add    %r14,%rdx
add    %r14,%rsi
cmp    %r9,%rdi
je     13a0 <BspEval2+0x270>
test   %r11d,%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
jle    22e0 <BspEval2+0x11b0>
cmp    $0x4,%r11d
jae    2320 <BspEval2+0x11f0>
xor    %ecx,%ecx
jmp    2420 <BspEval2+0x12f0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%rcx
imul   %r12,%rcx
add    0x18(%rsp),%rcx
lea    (%rax,%rdi,8),%r9
lea    (%rax,%rdi,8),%r11
add    $0x8,%r11
mov    0x8(%rsp),%rbx
lea    (%rbx,%r8,8),%r10
lea    (%rbx,%rcx,8),%rcx
mov    0x48(%rsp),%rbx
cmp    %r11,%rbx
setb   %r11b
mov    0x40(%rsp),%rax
cmp    %rax,%r9
setb   %r12b
cmp    %rcx,%rbx
setb   %bl
cmp    %rax,%r10
setb   %r9b
test   %r12b,%r11b
jne    2401 <BspEval2+0x12d1>
mov    $0x0,%ecx
and    %r9b,%bl
mov    0x4(%rsp),%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
mov    0x28(%rsp),%r9
jne    2420 <BspEval2+0x12f0>
movsd  (%rax,%rdi,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x90(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rcx,1),%xmm1
movupd (%rdx,%rcx,1),%xmm2
movupd -0x10(%r15,%rcx,1),%xmm3
movupd (%r15,%rcx,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%r15,%rcx,1)
movupd %xmm2,(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbx
jne    23b0 <BspEval2+0x1280>
mov    0x38(%rsp),%rbx
mov    %rbx,%rcx
cmp    %r13,%rbx
je     22e0 <BspEval2+0x11b0>
jmp    2420 <BspEval2+0x12f0>
xor    %ecx,%ecx
mov    0x4(%rsp),%r11d
mov    0x50(%rsp),%r12
mov    0x208(%rsp),%rax
mov    0x28(%rsp),%r9
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rbx
test   $0x1,%r13b
je     246e <BspEval2+0x133e>
movsd  (%rax,%rdi,8),%xmm0
lea    (%rcx,%r8,1),%r9
mov    0x30(%rsp),%rax
lea    (%rcx,%rax,1),%r10
mov    0x8(%rsp),%rax
mulsd  (%rax,%r9,8),%xmm0
mov    0x208(%rsp),%rax
mov    0x1f0(%rsp),%rbx
addsd  (%rbx,%r10,8),%xmm0
movsd  %xmm0,(%rbx,%r10,8)
mov    0x28(%rsp),%r9
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x70(%rsp),%rcx
je     22e0 <BspEval2+0x11b0>
nopl   0x0(%rax)
movsd  (%rax,%rdi,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
addsd  0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    2480 <BspEval2+0x1350>
jmp    22e0 <BspEval2+0x11b0>
test   %r11d,%r11d
jle    13a0 <BspEval2+0x270>
cmp    $0x4,%r11d
jb     24f0 <BspEval2+0x13c0>
mov    0x48(%rsp),%rax
cmp    0x138(%rsp),%rax
mov    0xc0(%rsp),%rdx
jae    27c5 <BspEval2+0x1695>
cmp    0x40(%rsp),%rdx
jae    27c5 <BspEval2+0x1695>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
test   $0x3,%r13b
je     2535 <BspEval2+0x1405>
mov    0x80(%rsp),%rdx
mov    0xc0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2520 <BspEval2+0x13f0>
cmp    $0x3,%rcx
jb     13a0 <BspEval2+0x270>
nop
mov    0xc0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    2540 <BspEval2+0x1410>
jmp    13a0 <BspEval2+0x270>
cmpq   $0xc,0x68(%rsp)
jae    26e8 <BspEval2+0x15b8>
xor    %eax,%eax
mov    0xf8(%rsp),%rsi
jmp    276c <BspEval2+0x163c>
cmpq   $0x0,0x68(%rsp)
je     2868 <BspEval2+0x1738>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd %xmm0,0x20(%rbp,%rax,8)
movupd %xmm1,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    25c0 <BspEval2+0x1490>
testb  $0x1,0xa0(%rsp)
01
je     2632 <BspEval2+0x1502>
mov    0x128(%rsp),%rcx
add    %rax,%rcx
mov    0x8(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
add    0x30(%rsp),%rax
mov    0x1f0(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     13a0 <BspEval2+0x270>
jmp    2149 <BspEval2+0x1019>
cmpq   $0x0,0x68(%rsp)
je     287d <BspEval2+0x174d>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
xchg   %ax,%ax
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd %xmm0,0x20(%rbp,%rax,8)
movupd %xmm1,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2660 <BspEval2+0x1530>
testb  $0x1,0xa0(%rsp)
01
je     26d2 <BspEval2+0x15a2>
mov    0x120(%rsp),%rcx
add    %rax,%rcx
mov    0x8(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
add    0x30(%rsp),%rax
mov    0x1f0(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     13a0 <BspEval2+0x270>
jmp    220f <BspEval2+0x10df>
mov    0x130(%rsp),%rcx
xor    %eax,%eax
mov    0xf8(%rsp),%rsi
mov    0x108(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm0
movups 0x10(%rdi,%rax,8),%xmm1
movups %xmm0,-0x70(%rdx,%rax,8)
movups %xmm1,-0x60(%rdx,%rax,8)
movups 0x20(%rdi,%rax,8),%xmm0
movups 0x30(%rdi,%rax,8),%xmm1
movups %xmm0,-0x50(%rdx,%rax,8)
movups %xmm1,-0x40(%rdx,%rax,8)
movups 0x40(%rdi,%rax,8),%xmm0
movups 0x50(%rdi,%rax,8),%xmm1
movups %xmm0,-0x30(%rdx,%rax,8)
movups %xmm1,-0x20(%rdx,%rax,8)
movupd 0x60(%rdi,%rax,8),%xmm0
movupd 0x70(%rdi,%rax,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rax,8)
movupd %xmm1,(%rdx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    2710 <BspEval2+0x15e0>
cmpq   $0x0,0x140(%rsp)
je     27af <BspEval2+0x167f>
lea    (%r15,%rax,8),%rcx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2790 <BspEval2+0x1660>
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     13a0 <BspEval2+0x270>
jmp    1e24 <BspEval2+0xcf4>
cmpq   $0x0,0x68(%rsp)
je     2892 <BspEval2+0x1762>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd %xmm0,0x20(%rbp,%rax,8)
movupd %xmm1,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    27e0 <BspEval2+0x16b0>
testb  $0x1,0xa0(%rsp)
01
je     2852 <BspEval2+0x1722>
mov    0x118(%rsp),%rcx
add    %rax,%rcx
mov    0x8(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
add    0x30(%rsp),%rax
mov    0x1f0(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
je     13a0 <BspEval2+0x270>
jmp    24f2 <BspEval2+0x13c2>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    25ff <BspEval2+0x14cf>
jmp    2632 <BspEval2+0x1502>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    269f <BspEval2+0x156f>
jmp    26d2 <BspEval2+0x15a2>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    281f <BspEval2+0x16ef>
jmp    2852 <BspEval2+0x1722>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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