#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 *);
int fabs(double);
double pwr2(double);
void LScurveAppEqPntStartEnd(int deg, int ncp, double *knot, double *us,
                             int nus, double *qmat, unsigned int *ctrlPeq,
                             int numCtrlPeq, double ctrlPeqWgh,
                             double *ctrlpnts, double *startq, double *endq,
                             double *nmat, double *rmat, double *left,
                             double *right, double *N) {
  int i, j, jj, span, ind;
  double Rk[2], wghtmp;
  if (ctrlPeq[numCtrlPeq - 1] == (ncp - 1)) {
    numCtrlPeq--;
  }
  for (jj = 0; jj < nus; jj++) {
    Rk[0] = qmat[2 * jj];
    Rk[1] = qmat[2 * jj + 1];
    if (us[jj] <= knot[deg] || deg == 0) {
    } else if (us[jj] >= knot[ncp]) {
    } else {
      span = FindSpan(ncp, deg, us[jj], knot);
      BasisFuns(span, us[jj], deg, knot, N, left, right);
      ind = span - deg - 1;
      if (span < (ncp - 1) || span > deg) {
        if (fabs(knot[span + 2] - knot[span + 1]) < 1e-12) {
          if (fabs(knot[span] - knot[span - 1]) > 1e-12) {
            wghtmp = (ctrlPeqWgh - 1.0) * pwr2((us[jj] - knot[span]) /
                                               (knot[span + 1] - knot[span])) +
                     1.0;
          } else {
            wghtmp = 1.0;
          }
        } else if (fabs(knot[span] - knot[span - 1]) < 1e-12) {
          wghtmp = (1.0 - ctrlPeqWgh) * pwr2((us[jj] - knot[span]) /
                                             (knot[span + 1] - knot[span])) +
                   ctrlPeqWgh;
        } else {
          wghtmp = 1.0;
        }
      } else {
        wghtmp = 1.0;
      }
      if (span == deg) {
        Rk[0] -= N[0] * startq[0];
        Rk[1] -= N[0] * startq[1];
      }
      if (span == (ncp - 1)) {
        Rk[0] -= N[deg] * endq[0];
        Rk[1] -= N[deg] * endq[1];
      }
      if (span == deg && span < (ncp - 1)) {
        for (i = 1; i < deg; i++) {
          for (j = 0; j < numCtrlPeq; j++) {
            if ((i + ind + 1) == ctrlPeq[j]) {
              N[i + 1] += N[i];
              N[i] = 0.0;
              break;
            }
          }
        }
        for (j = 0; j < numCtrlPeq; j++) {
          if (span == ctrlPeq[j]) {
            nmat[span + span * (ncp - 2)] += wghtmp * N[deg] * N[deg];
            rmat[span] += wghtmp * N[deg] * Rk[0];
            rmat[span + ncp - 2] += wghtmp * N[deg] * Rk[1];
            for (i = 0; i < deg; i++) {
              nmat[ind + i + span * (ncp - 2)] += wghtmp * N[deg] * N[i];
              nmat[span + (ind + i) * (ncp - 2)] += wghtmp * N[i] * N[deg];
            }
            N[deg] = 0.0;
            break;
          }
        }
        for (i = 1; i <= deg; i++) {
          for (j = 1; j <= deg; j++) {
            nmat[j - 1 + (i - 1) * (ncp - 2)] += wghtmp * N[i] * N[j];
          }
          rmat[i - 1] += wghtmp * N[i] * Rk[0];
          rmat[i - 1 + ncp - 2] += wghtmp * N[i] * Rk[1];
        }
      } else if (span == (ncp - 1) && span > deg) {
        for (i = 0; i < deg; i++) {
          for (j = 0; j < numCtrlPeq; j++) {
            if ((i + ind + 1) == ctrlPeq[j]) {
              N[i + 1] += N[i];
              N[i] = 0.0;
              break;
            }
          }
        }
        for (i = 0; i < deg; i++) {
          for (j = 0; j < deg; j++) {
            nmat[j + ind + (i + ind) * (ncp - 2)] += wghtmp * N[i] * N[j];
          }
          rmat[i + ind] += wghtmp * N[i] * Rk[0];
          rmat[i + ind + ncp - 2] += wghtmp * N[i] * Rk[1];
        }
      } else if (span == (ncp - 1) && span == deg) {
        for (i = 1; i < deg; i++) {
          for (j = 0; j < numCtrlPeq; j++) {
            if ((i + ind + 1) == ctrlPeq[j]) {
              N[i + 1] += N[i];
              N[i] = 0.0;
              break;
            }
          }
        }
        for (i = 1; i < deg; i++) {
          for (j = 1; j < deg; j++) {
            nmat[j - 1 + (i - 1) * (ncp - 2)] += wghtmp * N[i] * N[j];
          }
          rmat[i - 1] += wghtmp * N[i] * Rk[0];
          rmat[i - 1 + ncp - 2] += wghtmp * N[i] * Rk[1];
        }
      } else {
        for (i = 0; i < deg; i++) {
          for (j = 0; j < numCtrlPeq; j++) {
            if ((i + ind + 1) == ctrlPeq[j]) {
              N[i + 1] += N[i];
              N[i] = 0.0;
              break;
            }
          }
        }
        for (j = 0; j < numCtrlPeq; j++) {
          if (span == ctrlPeq[j]) {
            nmat[span + span * (ncp - 2)] += wghtmp * N[deg] * N[deg];
            rmat[span] += wghtmp * N[deg] * Rk[0];
            rmat[span + ncp - 2] += wghtmp * N[deg] * Rk[1];
            for (i = 0; i < deg; i++) {
              nmat[ind + i + span * (ncp - 2)] += wghtmp * N[deg] * N[i];
              nmat[span + (ind + i) * (ncp - 2)] += wghtmp * N[i] * N[deg];
            }
            N[deg] = 0.0;
            break;
          }
        }
        for (i = 0; i <= deg; i++) {
          for (j = 0; j <= deg; j++) {
            nmat[j + ind + (i + ind) * (ncp - 2)] += wghtmp * N[i] * N[j];
          }
          rmat[i + ind] += wghtmp * N[i] * Rk[0];
          rmat[i + ind + ncp - 2] += wghtmp * N[i] * Rk[1];
        }
      }
    }
  }
  for (i = 0; i < (ncp - 2); i++) {
    if (nmat[i + i * (ncp - 2)] < 1.0) {
      nmat[i + i * (ncp - 2)] += 1.0;
      rmat[i] += ctrlpnts[4 * (i + 1)];
      rmat[i + ncp - 2] += ctrlpnts[4 * (i + 1) + 1];
    }
  }
}


x86 assembly (clang, -O0):
<LScurveAppEqPntStartEnd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    11b4 <LScurveAppEqPntStartEnd+0x74>
mov    0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,0x18(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    2033 <LScurveAppEqPntStartEnd+0xef3>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jae    1226 <LScurveAppEqPntStartEnd+0xe6>
cmpl   $0x0,-0x4(%rbp)
jne    122b <LScurveAppEqPntStartEnd+0xeb>
jmp    2020 <LScurveAppEqPntStartEnd+0xee0>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1250 <LScurveAppEqPntStartEnd+0x110>
jmp    201b <LScurveAppEqPntStartEnd+0xedb>
mov    -0x8(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rdx
call   1060 <FindSpan@plt>
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x48(%rbp),%r8
mov    0x50(%rbp),%r9
call   1050 <BasisFuns@plt>
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     12c0 <LScurveAppEqPntStartEnd+0x180>
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1489 <LScurveAppEqPntStartEnd+0x349>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x1d13(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13c5 <LScurveAppEqPntStartEnd+0x285>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0x1cd9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13b3 <LScurveAppEqPntStartEnd+0x273>
movsd  -0x30(%rbp),%xmm0
movsd  0x1cba(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
call   1030 <pwr2@plt>
movaps %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1c5b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    13c0 <LScurveAppEqPntStartEnd+0x280>
movsd  0x1c45(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1484 <LScurveAppEqPntStartEnd+0x344>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x1c13(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1472 <LScurveAppEqPntStartEnd+0x332>
movsd  0x1bf9(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
call   1030 <pwr2@plt>
movaps %xmm0,%xmm2
movsd  -0x78(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    147f <LScurveAppEqPntStartEnd+0x33f>
movsd  0x1b86(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1484 <LScurveAppEqPntStartEnd+0x344>
jmp    1496 <LScurveAppEqPntStartEnd+0x356>
movsd  0x1b6f(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1515 <LScurveAppEqPntStartEnd+0x3d5>
mov    0x58(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x58(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15a3 <LScurveAppEqPntStartEnd+0x463>
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1922 <LScurveAppEqPntStartEnd+0x7e2>
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1922 <LScurveAppEqPntStartEnd+0x7e2>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    165f <LScurveAppEqPntStartEnd+0x51f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    164c <LScurveAppEqPntStartEnd+0x50c>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0x1,%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1639 <LScurveAppEqPntStartEnd+0x4f9>
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    164c <LScurveAppEqPntStartEnd+0x50c>
jmp    163e <LScurveAppEqPntStartEnd+0x4fe>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15da <LScurveAppEqPntStartEnd+0x49a>
jmp    1651 <LScurveAppEqPntStartEnd+0x511>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15c7 <LScurveAppEqPntStartEnd+0x487>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    181a <LScurveAppEqPntStartEnd+0x6da>
mov    -0x40(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1807 <LScurveAppEqPntStartEnd+0x6c7>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17f2 <LScurveAppEqPntStartEnd+0x6b2>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    -0x34(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1740 <LScurveAppEqPntStartEnd+0x600>
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    181a <LScurveAppEqPntStartEnd+0x6da>
jmp    180c <LScurveAppEqPntStartEnd+0x6cc>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1666 <LScurveAppEqPntStartEnd+0x526>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     191d <LScurveAppEqPntStartEnd+0x7dd>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     189d <LScurveAppEqPntStartEnd+0x75d>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1834 <LScurveAppEqPntStartEnd+0x6f4>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1821 <LScurveAppEqPntStartEnd+0x6e1>
jmp    2016 <LScurveAppEqPntStartEnd+0xed6>
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1ae6 <LScurveAppEqPntStartEnd+0x9a6>
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1ae6 <LScurveAppEqPntStartEnd+0x9a6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19de <LScurveAppEqPntStartEnd+0x89e>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    19cb <LScurveAppEqPntStartEnd+0x88b>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0x1,%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    19b8 <LScurveAppEqPntStartEnd+0x878>
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    19cb <LScurveAppEqPntStartEnd+0x88b>
jmp    19bd <LScurveAppEqPntStartEnd+0x87d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1959 <LScurveAppEqPntStartEnd+0x819>
jmp    19d0 <LScurveAppEqPntStartEnd+0x890>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1946 <LScurveAppEqPntStartEnd+0x806>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ae1 <LScurveAppEqPntStartEnd+0x9a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a61 <LScurveAppEqPntStartEnd+0x921>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    -0x44(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19f8 <LScurveAppEqPntStartEnd+0x8b8>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19e5 <LScurveAppEqPntStartEnd+0x8a5>
jmp    2011 <LScurveAppEqPntStartEnd+0xed1>
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1caa <LScurveAppEqPntStartEnd+0xb6a>
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1caa <LScurveAppEqPntStartEnd+0xb6a>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ba2 <LScurveAppEqPntStartEnd+0xa62>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b8f <LScurveAppEqPntStartEnd+0xa4f>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0x1,%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1b7c <LScurveAppEqPntStartEnd+0xa3c>
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b8f <LScurveAppEqPntStartEnd+0xa4f>
jmp    1b81 <LScurveAppEqPntStartEnd+0xa41>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b1d <LScurveAppEqPntStartEnd+0x9dd>
jmp    1b94 <LScurveAppEqPntStartEnd+0xa54>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b0a <LScurveAppEqPntStartEnd+0x9ca>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ca5 <LScurveAppEqPntStartEnd+0xb65>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c25 <LScurveAppEqPntStartEnd+0xae5>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bbc <LScurveAppEqPntStartEnd+0xa7c>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ba9 <LScurveAppEqPntStartEnd+0xa69>
jmp    200c <LScurveAppEqPntStartEnd+0xecc>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d49 <LScurveAppEqPntStartEnd+0xc09>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1d36 <LScurveAppEqPntStartEnd+0xbf6>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0x1,%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1d23 <LScurveAppEqPntStartEnd+0xbe3>
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d36 <LScurveAppEqPntStartEnd+0xbf6>
jmp    1d28 <LScurveAppEqPntStartEnd+0xbe8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cc4 <LScurveAppEqPntStartEnd+0xb84>
jmp    1d3b <LScurveAppEqPntStartEnd+0xbfb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1cb1 <LScurveAppEqPntStartEnd+0xb71>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1f04 <LScurveAppEqPntStartEnd+0xdc4>
mov    -0x40(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1ef1 <LScurveAppEqPntStartEnd+0xdb1>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1edc <LScurveAppEqPntStartEnd+0xd9c>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    -0x34(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e2a <LScurveAppEqPntStartEnd+0xcea>
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f04 <LScurveAppEqPntStartEnd+0xdc4>
jmp    1ef6 <LScurveAppEqPntStartEnd+0xdb6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d50 <LScurveAppEqPntStartEnd+0xc10>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2007 <LScurveAppEqPntStartEnd+0xec7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1f87 <LScurveAppEqPntStartEnd+0xe47>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    -0x34(%rbp),%edx
add    -0x44(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1f1e <LScurveAppEqPntStartEnd+0xdde>
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f0b <LScurveAppEqPntStartEnd+0xdcb>
jmp    200c <LScurveAppEqPntStartEnd+0xecc>
jmp    2011 <LScurveAppEqPntStartEnd+0xed1>
jmp    2016 <LScurveAppEqPntStartEnd+0xed6>
jmp    201b <LScurveAppEqPntStartEnd+0xedb>
jmp    2020 <LScurveAppEqPntStartEnd+0xee0>
jmp    2025 <LScurveAppEqPntStartEnd+0xee5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11bb <LScurveAppEqPntStartEnd+0x7b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    210c <LScurveAppEqPntStartEnd+0xfcc>
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xf95(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    20f9 <LScurveAppEqPntStartEnd+0xfb9>
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x8(%rbp),%esi
sub    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xf6a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    20fe <LScurveAppEqPntStartEnd+0xfbe>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    203a <LScurveAppEqPntStartEnd+0xefa>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LScurveAppEqPntStartEnd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x158(%rsp)
mov    %rcx,0x78(%rsp)
mov    %rdx,0x40(%rsp)
movslq 0x1c8(%rsp),%rax
mov    0x1f0(%rsp),%r11
mov    0x1e8(%rsp),%r13
mov    0x1c0(%rsp),%rcx
lea    -0x1(%rsi),%edx
cmp    %edx,-0x4(%rcx,%rax,4)
lea    -0x1(%rax),%r10d
cmovne %eax,%r10d
test   %r8d,%r8d
jle    24c3 <LScurveAppEqPntStartEnd+0x1383>
movslq %edi,%rbp
mov    %ebp,%eax
not    %eax
mov    %rax,0x150(%rsp)
movsd  0x1e4e(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x108(%rsp)
movsd  0x1e41(%rip),%xmm1
movsd  %xmm0,0x110(%rsp)
addsd  %xmm0,%xmm1
movsd  %xmm1,0x100(%rsp)
lea    -0x2(%rsi),%eax
mov    %rax,0x8(%rsp)
movslq %eax,%r9
lea    0x1(%rbp),%r15d
mov    %r8d,%eax
mov    %rax,0x180(%rsp)
mov    %ebp,%ebx
mov    %edx,0x1c(%rsp)
mov    %edx,%eax
sub    %ebp,%eax
mov    %rax,0x128(%rsp)
mov    %r9d,%eax
imul   %edi,%eax
lea    (%rax,%rdi,1),%ecx
movslq %ecx,%rcx
mov    %rcx,0x138(%rsp)
lea    (%rsi,%rbp,1),%ecx
add    $0xfffffffe,%ecx
movslq %ecx,%rcx
mov    %rcx,0x130(%rsp)
cltq
mov    %rax,0xf8(%rsp)
lea    -0x1(%rbx),%r8
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x140(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0xf0(%rsp)
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rbx,%rcx
neg    %rcx
mov    %rcx,0xe0(%rsp)
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x148(%rsp)
lea    -0x1(%r15),%rcx
mov    %rcx,0x88(%rsp)
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rbp,0x70(%rsp)
mov    %ebp,%ecx
neg    %ecx
mov    %ecx,0x6c(%rsp)
mov    %r8,%rcx
mov    %r8,0x80(%rsp)
shr    $0x20,%r8
mov    %r8,0x160(%rsp)
mov    0x208(%rsp),%rbp
mov    %rsi,0xc0(%rsp)
movslq %esi,%rcx
mov    %rcx,0x178(%rsp)
mov    %r10d,0x2c(%rsp)
mov    %r10d,%r12d
lea    -0x2(%r15),%rcx
mov    %rcx,0xe8(%rsp)
lea    0x8(%rbp),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x0(%rbp,%r15,8),%rcx
mov    %rcx,0xd8(%rsp)
lea    -0x8(%r13,%r15,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    0x0(%rbp,%rbx,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(%r13,%rbx,8),%rcx
mov    %rcx,0xb0(%rsp)
mov    %rbx,0x10(%rsp)
lea    -0x2(%rbx),%rcx
mov    %rcx,0xa8(%rsp)
mov    %rdx,0x120(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0x118(%rsp)
mov    %rax,0x170(%rsp)
add    $0x1,%rax
mov    %rax,0x168(%rsp)
mov    %r9,0x90(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %rdi,0x20(%rsp)
jmp    13a4 <LScurveAppEqPntStartEnd+0x264>
nop
mov    0x48(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
cmp    0x180(%rsp),%rcx
mov    0x20(%rsp),%rdi
je     24b1 <LScurveAppEqPntStartEnd+0x1371>
test   %edi,%edi
je     1380 <LScurveAppEqPntStartEnd+0x240>
mov    0x78(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1380 <LScurveAppEqPntStartEnd+0x240>
mov    0x40(%rsp),%rax
mov    0x178(%rsp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jae    1380 <LScurveAppEqPntStartEnd+0x240>
mov    0x48(%rsp),%rax
shl    $0x4,%rax
mov    0x158(%rsp),%rcx
movupd (%rcx,%rax,1),%xmm1
movapd %xmm1,0x50(%rsp)
mov    0xc0(%rsp),%rdi
mov    0x20(%rsp),%rbx
mov    %ebx,%esi
mov    0x40(%rsp),%rdx
call   1060 <FindSpan@plt>
mov    %eax,%r14d
mov    0x78(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    %r14d,%edi
mov    %ebx,%esi
mov    0x40(%rsp),%rdx
mov    %rbp,%rcx
mov    0x1f8(%rsp),%r8
mov    0x200(%rsp),%r9
call   1050 <BasisFuns@plt>
mov    0x1c(%rsp),%ecx
cmp    %ecx,%r14d
jl     1463 <LScurveAppEqPntStartEnd+0x323>
movsd  0x1ba6(%rip),%xmm0
cmp    %ebx,%r14d
jle    1590 <LScurveAppEqPntStartEnd+0x450>
movslq %r14d,%rbx
mov    0x40(%rsp),%rcx
movsd  0x10(%rcx,%rbx,8),%xmm0
lea    0x1(%rbx),%rax
mov    %rax,0x30(%rsp)
subsd  0x8(%rcx,%rbx,8),%xmm0
call   1040 <fabs@plt>
mov    %eax,0x38(%rsp)
mov    0x40(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %rbx,0x98(%rsp)
subsd  -0x8(%rax,%rbx,8),%xmm0
call   1040 <fabs@plt>
cmpl   $0x0,0x38(%rsp)
jle    151f <LScurveAppEqPntStartEnd+0x3df>
movsd  0x1b4b(%rip),%xmm0
test   %eax,%eax
mov    0x20(%rsp),%rbx
mov    0x1c(%rsp),%ecx
jg     1590 <LScurveAppEqPntStartEnd+0x450>
mov    0x78(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rsp),%rax
mov    0x98(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mov    0x30(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
call   1030 <pwr2@plt>
mov    0x1c(%rsp),%ecx
mov    0x20(%rsp),%rbx
mulsd  0x108(%rsp),%xmm0
addsd  0x110(%rsp),%xmm0
jmp    1590 <LScurveAppEqPntStartEnd+0x450>
movsd  0x1ad9(%rip),%xmm0
test   %eax,%eax
mov    0x20(%rsp),%rbx
mov    0x1c(%rsp),%ecx
jle    1590 <LScurveAppEqPntStartEnd+0x450>
mov    0x78(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rsp),%rax
mov    0x98(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mov    0x30(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
call   1030 <pwr2@plt>
mov    0x1c(%rsp),%ecx
mov    0x20(%rsp),%rbx
mulsd  0x100(%rsp),%xmm0
addsd  0x1a76(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
cmp    %ebx,%r14d
jne    15d9 <LScurveAppEqPntStartEnd+0x499>
mov    0x1d8(%rsp),%rax
movupd (%rax),%xmm1
movsd  0x0(%rbp),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
movapd 0x50(%rsp),%xmm7
subpd  %xmm2,%xmm7
mov    0x1f0(%rsp),%r11
mov    0x1c0(%rsp),%rdi
mov    0x2c(%rsp),%r8d
mov    0x10(%rsp),%r9
cmp    %ecx,%r14d
je     15fe <LScurveAppEqPntStartEnd+0x4be>
jmp    1621 <LScurveAppEqPntStartEnd+0x4e1>
mov    0x1f0(%rsp),%r11
mov    0x1c0(%rsp),%rdi
mov    0x2c(%rsp),%r8d
mov    0x10(%rsp),%r9
movapd 0x50(%rsp),%xmm7
cmp    %ecx,%r14d
jne    1621 <LScurveAppEqPntStartEnd+0x4e1>
mov    0x1e0(%rsp),%rax
movupd (%rax),%xmm1
mov    0x70(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm7
mov    0x150(%rsp),%rax
add    %r14d,%eax
mov    %rax,0x50(%rsp)
mov    %r14d,%eax
sub    %ebx,%eax
jne    1690 <LScurveAppEqPntStartEnd+0x550>
cmp    %ecx,%r14d
jge    1690 <LScurveAppEqPntStartEnd+0x550>
cmp    $0x2,%ebx
jl     1720 <LScurveAppEqPntStartEnd+0x5e0>
mov    $0x1,%eax
jmp    1678 <LScurveAppEqPntStartEnd+0x538>
nopl   (%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
addsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %r9,%rax
je     1720 <LScurveAppEqPntStartEnd+0x5e0>
test   %r8d,%r8d
jle    166b <LScurveAppEqPntStartEnd+0x52b>
xor    %ecx,%ecx
nop
cmp    %eax,(%rdi,%rcx,4)
je     1650 <LScurveAppEqPntStartEnd+0x510>
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1680 <LScurveAppEqPntStartEnd+0x540>
jmp    166b <LScurveAppEqPntStartEnd+0x52b>
cmp    %ecx,%r14d
jne    174f <LScurveAppEqPntStartEnd+0x60f>
cmp    %ebx,%r14d
jle    174f <LScurveAppEqPntStartEnd+0x60f>
test   %ebx,%ebx
jle    1380 <LScurveAppEqPntStartEnd+0x240>
xor    %eax,%eax
mov    0x20(%rsp),%r8
mov    0x1c0(%rsp),%rdi
mov    0x2c(%rsp),%ebx
mov    0x10(%rsp),%rsi
mov    0x128(%rsp),%r9
jmp    16f8 <LScurveAppEqPntStartEnd+0x5b8>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
addsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rsi,%rax
je     1b36 <LScurveAppEqPntStartEnd+0x9f6>
test   %ebx,%ebx
jle    16eb <LScurveAppEqPntStartEnd+0x5ab>
lea    (%r9,%rax,1),%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    (%rdi,%rdx,4),%ecx
je     16d0 <LScurveAppEqPntStartEnd+0x590>
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1710 <LScurveAppEqPntStartEnd+0x5d0>
jmp    16eb <LScurveAppEqPntStartEnd+0x5ab>
test   %r8d,%r8d
mov    0xa0(%rsp),%r8
jle    1742 <LScurveAppEqPntStartEnd+0x602>
xor    %eax,%eax
nop
cmp    %ebx,(%rdi,%rax,4)
je     17d0 <LScurveAppEqPntStartEnd+0x690>
add    $0x1,%rax
cmp    %rax,%r12
jne    1730 <LScurveAppEqPntStartEnd+0x5f0>
test   %ebx,%ebx
jg     18cf <LScurveAppEqPntStartEnd+0x78f>
jmp    1380 <LScurveAppEqPntStartEnd+0x240>
cmp    %ecx,%r14d
jne    1deb <LScurveAppEqPntStartEnd+0xcab>
cmp    %ebx,%r14d
jne    1deb <LScurveAppEqPntStartEnd+0xcab>
cmp    $0x2,%ebx
jl     1380 <LScurveAppEqPntStartEnd+0x240>
mov    $0x1,%eax
mov    0x20(%rsp),%rdx
mov    0x1c0(%rsp),%rsi
mov    0x2c(%rsp),%edi
mov    0x10(%rsp),%rbx
jmp    17b8 <LScurveAppEqPntStartEnd+0x678>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm1
addsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rbx,%rax
je     1e70 <LScurveAppEqPntStartEnd+0xd30>
test   %edi,%edi
jle    17ab <LScurveAppEqPntStartEnd+0x66b>
xor    %ecx,%ecx
xchg   %ax,%ax
cmp    %eax,(%rsi,%rcx,4)
je     1790 <LScurveAppEqPntStartEnd+0x650>
add    $0x1,%rcx
cmp    %rcx,%r12
jne    17c0 <LScurveAppEqPntStartEnd+0x680>
jmp    17ab <LScurveAppEqPntStartEnd+0x66b>
mov    0x70(%rsp),%rsi
movsd  0x0(%rbp,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm2
mov    0x138(%rsp),%rax
addsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  (%r11,%rsi,8),%xmm1
movsd  %xmm1,(%r11,%rsi,8)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
mov    0x130(%rsp),%rax
addsd  (%r11,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
test   %ebx,%ebx
jle    18be <LScurveAppEqPntStartEnd+0x77e>
movslq 0x50(%rsp),%rcx
mov    0x90(%rsp),%rax
imul   %rcx,%rax
add    %rsi,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
add    0xf8(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rdx,8),%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rsi,8),%xmm1
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
add    $0x1,%rdx
add    %r8,%rax
cmp    %rdx,%r9
jne    1880 <LScurveAppEqPntStartEnd+0x740>
movq   $0x0,0x0(%rbp,%rsi,8)
test   %ebx,%ebx
jle    1380 <LScurveAppEqPntStartEnd+0x240>
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
mov    $0x1,%eax
mov    $0xffffffffffffffff,%rcx
xor    %edx,%edx
xor    %r10d,%r10d
jmp    1948 <LScurveAppEqPntStartEnd+0x808>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm7,%xmm2
addsd  -0x8(%r11,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r11,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0x8(%rsp),%rdi
add    %edi,%r8d
movslq %r8d,%rsi
mulsd  %xmm1,%xmm2
addsd  (%r11,%rsi,8),%xmm2
movsd  %xmm2,(%r11,%rsi,8)
add    $0x1,%rax
add    $0x1,%r10
add    %rdi,%rdx
add    %rdi,%rcx
cmp    %r15,%rax
je     1380 <LScurveAppEqPntStartEnd+0x240>
lea    -0x1(%rax),%r8
mov    $0x1,%edi
cmpq   $0x4,0x88(%rsp)
jb     1a90 <LScurveAppEqPntStartEnd+0x950>
mov    0x8(%rsp),%rbx
imul   %r10d,%ebx
mov    0xe8(%rsp),%rsi
add    %ebx,%esi
mov    $0x1,%edi
cmp    %ebx,%esi
jl     1a90 <LScurveAppEqPntStartEnd+0x950>
mov    0xe8(%rsp),%rsi
shr    $0x20,%rsi
mov    $0x1,%edi
jne    1a90 <LScurveAppEqPntStartEnd+0x950>
movslq %ebx,%rsi
lea    0x0(,%rsi,8),%rdi
add    %r13,%rdi
mov    0xd0(%rsp),%rbx
lea    (%rbx,%rsi,8),%rsi
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
lea    0x10(,%r10,8),%r9
add    %rbp,%r9
cmp    %rsi,0xc8(%rsp)
setb   %r11b
cmp    0xd8(%rsp),%rdi
setb   %r14b
cmp    %rsi,%rbx
setb   %bl
cmp    %r9,%rdi
setb   %r9b
mov    $0x1,%edi
test   %r14b,%r11b
mov    0x1f0(%rsp),%r11
jne    1a90 <LScurveAppEqPntStartEnd+0x950>
mov    $0x1,%edi
and    %r9b,%bl
jne    1a90 <LScurveAppEqPntStartEnd+0x950>
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm2
xor    %edi,%edi
mov    0x170(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rbp,%rdi,8),%xmm3
movupd 0x18(%rbp,%rdi,8),%xmm4
lea    (%rdx,%rdi,1),%esi
movslq %esi,%rsi
movupd 0x0(%r13,%rsi,8),%xmm5
movupd 0x10(%r13,%rsi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x0(%r13,%rsi,8)
movupd %xmm4,0x10(%r13,%rsi,8)
add    $0x4,%rdi
cmp    %rdi,%rbx
jne    1a30 <LScurveAppEqPntStartEnd+0x8f0>
mov    0x168(%rsp),%rdi
cmp    %rbx,0x88(%rsp)
je     18f0 <LScurveAppEqPntStartEnd+0x7b0>
nopl   (%rax)
mov    %rdi,%rbx
test   $0x1,%r15b
jne    1acc <LScurveAppEqPntStartEnd+0x98c>
mov    0x8(%rsp),%rsi
imul   %r8d,%esi
add    $0xffffffff,%esi
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
add    %edi,%esi
movslq %esi,%rsi
mulsd  0x0(%rbp,%rdi,8),%xmm2
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    0xf0(%rsp),%rdi
je     18f0 <LScurveAppEqPntStartEnd+0x7b0>
nopl   (%rax)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rcx,%rbx,1),%esi
mulsd  0x0(%rbp,%rbx,8),%xmm2
movslq %esi,%rsi
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rdx,%rbx,1),%esi
movslq %esi,%rsi
mulsd  0x8(%rbp,%rbx,8),%xmm2
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
add    $0x2,%rbx
cmp    %rbx,%r15
jne    1ae0 <LScurveAppEqPntStartEnd+0x9a0>
jmp    18f0 <LScurveAppEqPntStartEnd+0x7b0>
test   %r8d,%r8d
jle    1380 <LScurveAppEqPntStartEnd+0x240>
mov    0x50(%rsp),%rcx
movslq %ecx,%r9
mov    0x8(%rsp),%rax
imul   %ecx,%eax
lea    (%rcx,%rax,1),%r8d
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
add    0x6c(%rsp),%r14d
add    %eax,%r14d
mov    %r8,%rsi
xor    %edi,%edi
mov    %r9,0x30(%rsp)
mov    %r8,0x38(%rsp)
jmp    1bd2 <LScurveAppEqPntStartEnd+0xa92>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm7,%xmm2
addsd  (%r11,%r10,8),%xmm2
movsd  %xmm2,(%r11,%r10,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0x8(%rsp),%rcx
add    %ecx,%r10d
movslq %r10d,%rax
mulsd  %xmm1,%xmm2
addsd  (%r11,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
add    $0x1,%rdi
add    %rcx,%rsi
add    %rcx,%r14
cmp    %rbx,%rdi
je     1380 <LScurveAppEqPntStartEnd+0x240>
lea    (%rdi,%r9,1),%r10
cmpl   $0x4,0x20(%rsp)
jae    1ca0 <LScurveAppEqPntStartEnd+0xb60>
xor    %eax,%eax
mov    0x10(%rsp),%rbx
mov    %rax,%rdx
test   $0x1,%bl
je     1c27 <LScurveAppEqPntStartEnd+0xae7>
mov    0x8(%rsp),%rcx
imul   %r10d,%ecx
add    0x50(%rsp),%ecx
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
add    %eax,%ecx
movslq %ecx,%rcx
mulsd  0x0(%rbp,%rax,8),%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0xe0(%rsp),%rax
je     1b80 <LScurveAppEqPntStartEnd+0xa40>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rsi,%rdx,1),%ecx
mulsd  0x0(%rbp,%rdx,8),%xmm2
movslq %ecx,%rcx
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%r14,%rdx,1),%ecx
movslq %ecx,%rcx
mulsd  0x8(%rbp,%rdx,8),%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    1c40 <LScurveAppEqPntStartEnd+0xb00>
jmp    1b80 <LScurveAppEqPntStartEnd+0xa40>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
imul   %edi,%edx
lea    (%rdx,%r8,1),%ecx
mov    0x80(%rsp),%rax
lea    (%rcx,%rax,1),%ebx
cmp    %ecx,%ebx
jl     1be1 <LScurveAppEqPntStartEnd+0xaa1>
mov    $0x0,%eax
cmpq   $0x0,0x160(%rsp)
mov    0x10(%rsp),%rbx
jne    1be8 <LScurveAppEqPntStartEnd+0xaa8>
add    %r8d,%edx
movslq %edx,%rcx
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
mov    0xb0(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
lea    0x0(,%rdi,8),%rdx
add    %rbp,%rdx
cmp    %rbp,%rcx
seta   %r11b
lea    0x8(,%rdi,8),%r8
add    %rbp,%r8
cmp    0xb8(%rsp),%rbx
setb   %r9b
cmp    %rcx,%rdx
setb   %dl
cmp    %r8,%rbx
setb   %cl
test   %r9b,%r11b
jne    1dcd <LScurveAppEqPntStartEnd+0xc8d>
mov    $0x0,%eax
and    %cl,%dl
mov    0x1f0(%rsp),%r11
mov    0x10(%rsp),%rbx
mov    0x30(%rsp),%r9
mov    0x38(%rsp),%r8
jne    1be8 <LScurveAppEqPntStartEnd+0xaa8>
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm2
xor    %edx,%edx
mov    0x148(%rsp),%r8
nop
movupd 0x0(%rbp,%rdx,8),%xmm3
movupd 0x10(%rbp,%rdx,8),%xmm4
lea    (%rsi,%rdx,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm5
movupd 0x10(%r13,%rcx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x0(%r13,%rcx,8)
movupd %xmm4,0x10(%r13,%rcx,8)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    1d70 <LScurveAppEqPntStartEnd+0xc30>
mov    %r8,%rax
cmp    %rbx,%r8
mov    0x38(%rsp),%r8
je     1b80 <LScurveAppEqPntStartEnd+0xa40>
jmp    1be8 <LScurveAppEqPntStartEnd+0xaa8>
xor    %eax,%eax
mov    0x1f0(%rsp),%r11
mov    0x10(%rsp),%rbx
mov    0x30(%rsp),%r9
mov    0x38(%rsp),%r8
jmp    1be8 <LScurveAppEqPntStartEnd+0xaa8>
test   %ebx,%ebx
jle    1e40 <LScurveAppEqPntStartEnd+0xd00>
xor    %ecx,%ecx
jmp    1e24 <LScurveAppEqPntStartEnd+0xce4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rcx,8),%xmm1
addsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
movq   $0x0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %r9,%rcx
je     1e40 <LScurveAppEqPntStartEnd+0xd00>
test   %r8d,%r8d
jle    1e1b <LScurveAppEqPntStartEnd+0xcdb>
lea    (%rax,%rcx,1),%edx
xor    %esi,%esi
xchg   %ax,%ax
cmp    (%rdi,%rsi,4),%edx
je     1e00 <LScurveAppEqPntStartEnd+0xcc0>
add    $0x1,%rsi
cmp    %rsi,%r12
jne    1e30 <LScurveAppEqPntStartEnd+0xcf0>
jmp    1e1b <LScurveAppEqPntStartEnd+0xcdb>
test   %r8d,%r8d
mov    0xa0(%rsp),%rsi
jle    1e63 <LScurveAppEqPntStartEnd+0xd23>
xor    %eax,%eax
nop
cmp    (%rdi,%rax,4),%r14d
je     2107 <LScurveAppEqPntStartEnd+0xfc7>
add    $0x1,%rax
cmp    %rax,%r12
jne    1e50 <LScurveAppEqPntStartEnd+0xd10>
test   %ebx,%ebx
jns    220f <LScurveAppEqPntStartEnd+0x10cf>
jmp    1380 <LScurveAppEqPntStartEnd+0x240>
cmp    $0x2,%edx
jl     1380 <LScurveAppEqPntStartEnd+0x240>
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
mov    $0x1,%eax
mov    $0xffffffffffffffff,%rcx
xor    %edx,%edx
xor    %r10d,%r10d
jmp    1ef8 <LScurveAppEqPntStartEnd+0xdb8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm7,%xmm2
addsd  -0x8(%r11,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r11,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0x8(%rsp),%rdi
add    %edi,%r8d
movslq %r8d,%rsi
mulsd  %xmm1,%xmm2
addsd  (%r11,%rsi,8),%xmm2
movsd  %xmm2,(%r11,%rsi,8)
add    $0x1,%rax
add    $0x1,%r10
add    %rdi,%rdx
add    %rdi,%rcx
cmp    %r9,%rax
je     1380 <LScurveAppEqPntStartEnd+0x240>
lea    -0x1(%rax),%r8
mov    $0x1,%edi
cmpq   $0x4,0x80(%rsp)
mov    0x10(%rsp),%r9
jae    1fd0 <LScurveAppEqPntStartEnd+0xe90>
mov    %rdi,%rbx
test   $0x1,%r9b
jne    1f51 <LScurveAppEqPntStartEnd+0xe11>
mov    0x8(%rsp),%rsi
imul   %r8d,%esi
add    $0xffffffff,%esi
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
add    %edi,%esi
movslq %esi,%rsi
mulsd  0x0(%rbp,%rdi,8),%xmm2
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    0xe0(%rsp),%rdi
mov    0x10(%rsp),%r9
je     1ea0 <LScurveAppEqPntStartEnd+0xd60>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rcx,%rbx,1),%esi
mulsd  0x0(%rbp,%rbx,8),%xmm2
movslq %esi,%rsi
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rdx,%rbx,1),%esi
movslq %esi,%rsi
mulsd  0x8(%rbp,%rbx,8),%xmm2
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    1f70 <LScurveAppEqPntStartEnd+0xe30>
jmp    1ea0 <LScurveAppEqPntStartEnd+0xd60>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%rbx
imul   %r10d,%ebx
mov    0xa8(%rsp),%rsi
add    %ebx,%esi
mov    $0x1,%edi
cmp    %ebx,%esi
jl     1f15 <LScurveAppEqPntStartEnd+0xdd5>
mov    0xa8(%rsp),%rsi
shr    $0x20,%rsi
mov    $0x1,%edi
jne    1f15 <LScurveAppEqPntStartEnd+0xdd5>
movslq %ebx,%rsi
lea    0x0(,%rsi,8),%rdi
add    %r13,%rdi
mov    0xb0(%rsp),%rbx
lea    (%rbx,%rsi,8),%rsi
add    $0xfffffffffffffff8,%rsi
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
lea    0x10(,%r10,8),%r11
add    %rbp,%r11
cmp    %rsi,0xc8(%rsp)
setb   0x50(%rsp)
cmp    0xb8(%rsp),%rdi
setb   %r14b
cmp    %rsi,%rbx
setb   %bl
cmp    %r11,%rdi
setb   %sil
mov    $0x1,%edi
test   %r14b,0x50(%rsp)
mov    0x1f0(%rsp),%r11
jne    1f15 <LScurveAppEqPntStartEnd+0xdd5>
mov    $0x1,%edi
and    %sil,%bl
jne    1f15 <LScurveAppEqPntStartEnd+0xdd5>
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm2
xor    %edi,%edi
mov    0x120(%rsp),%rbx
nop
movupd 0x8(%rbp,%rdi,8),%xmm3
movupd 0x18(%rbp,%rdi,8),%xmm4
lea    (%rdx,%rdi,1),%esi
movslq %esi,%rsi
movupd 0x0(%r13,%rsi,8),%xmm5
movupd 0x10(%r13,%rsi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x0(%r13,%rsi,8)
movupd %xmm4,0x10(%r13,%rsi,8)
add    $0x4,%rdi
cmp    %rdi,%rbx
jne    20a0 <LScurveAppEqPntStartEnd+0xf60>
mov    0x118(%rsp),%rdi
cmp    %rbx,0x80(%rsp)
mov    0x10(%rsp),%r9
je     1ea0 <LScurveAppEqPntStartEnd+0xd60>
jmp    1f15 <LScurveAppEqPntStartEnd+0xdd5>
mov    %r14d,%eax
mov    0x8(%rsp),%rdx
imul   %edx,%eax
lea    (%rax,%r14,1),%ecx
add    %r14d,%edx
mov    0x70(%rsp),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movslq %ecx,%rcx
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movslq %r14d,%rcx
mulsd  %xmm7,%xmm1
addsd  (%r11,%rcx,8),%xmm1
movsd  %xmm1,(%r11,%rcx,8)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movslq %edx,%rdx
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%rdx,8),%xmm2
movsd  %xmm2,(%r11,%rdx,8)
test   %ebx,%ebx
jle    21fe <LScurveAppEqPntStartEnd+0x10be>
movslq 0x50(%rsp),%r8
movslq %eax,%rdx
mov    0x90(%rsp),%rax
imul   %r8,%rax
add    %rcx,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
add    %r8,%rdx
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rdx,8),%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rdi,8),%xmm1
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
add    $0x1,%rdx
add    %rsi,%rax
cmp    %rdx,%r9
jne    21c0 <LScurveAppEqPntStartEnd+0x1080>
movq   $0x0,0x0(%rbp,%rdi,8)
test   %ebx,%ebx
js     1380 <LScurveAppEqPntStartEnd+0x240>
mov    0x50(%rsp),%rcx
movslq %ecx,%r8
mov    0x8(%rsp),%rax
imul   %ecx,%eax
lea    (%rcx,%rax,1),%r9d
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
add    0x6c(%rsp),%r14d
add    %eax,%r14d
mov    %r9,%rsi
xor    %edi,%edi
mov    %r8,0x38(%rsp)
mov    %r9,0x30(%rsp)
jmp    22a2 <LScurveAppEqPntStartEnd+0x1162>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm7,%xmm2
addsd  (%r11,%r10,8),%xmm2
movsd  %xmm2,(%r11,%r10,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0x8(%rsp),%rcx
add    %ecx,%r10d
movslq %r10d,%rax
mulsd  %xmm1,%xmm2
addsd  (%r11,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
add    $0x1,%rdi
add    %rcx,%rsi
add    %rcx,%r14
cmp    %r15,%rdi
je     1380 <LScurveAppEqPntStartEnd+0x240>
lea    (%rdi,%r8,1),%r10
cmp    $0x4,%r15d
jae    2370 <LScurveAppEqPntStartEnd+0x1230>
xor    %ebx,%ebx
mov    %rbx,%rdx
test   $0x1,%r15b
je     22f2 <LScurveAppEqPntStartEnd+0x11b2>
mov    0x8(%rsp),%rcx
imul   %r10d,%ecx
add    0x50(%rsp),%ecx
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
add    %ebx,%ecx
movslq %ecx,%rcx
mulsd  0x0(%rbp,%rbx,8),%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
cmp    0xf0(%rsp),%rbx
je     2250 <LScurveAppEqPntStartEnd+0x1110>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%rsi,%rdx,1),%ecx
mulsd  0x0(%rbp,%rdx,8),%xmm2
movslq %ecx,%rcx
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
lea    (%r14,%rdx,1),%ecx
movslq %ecx,%rcx
mulsd  0x8(%rbp,%rdx,8),%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    2310 <LScurveAppEqPntStartEnd+0x11d0>
jmp    2250 <LScurveAppEqPntStartEnd+0x1110>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
imul   %edi,%edx
lea    (%rdx,%r9,1),%ecx
mov    0x88(%rsp),%rax
lea    (%rcx,%rax,1),%ebx
cmp    %ecx,%ebx
jl     22b0 <LScurveAppEqPntStartEnd+0x1170>
mov    %rax,%rcx
shr    $0x20,%rcx
mov    $0x0,%ebx
jne    22b2 <LScurveAppEqPntStartEnd+0x1172>
add    %r9d,%edx
movslq %edx,%rcx
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
mov    0xd0(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
add    $0x8,%rcx
lea    0x0(,%rdi,8),%rdx
add    %rbp,%rdx
cmp    %rbp,%rcx
seta   %r8b
lea    0x8(,%rdi,8),%r11
add    %rbp,%r11
cmp    0xd8(%rsp),%rbx
setb   %r9b
cmp    %rcx,%rdx
setb   %dl
cmp    %r11,%rbx
setb   %cl
test   %r9b,%r8b
jne    2498 <LScurveAppEqPntStartEnd+0x1358>
mov    $0x0,%ebx
and    %cl,%dl
mov    0x1f0(%rsp),%r11
mov    0x38(%rsp),%r8
mov    0x30(%rsp),%r9
jne    22b2 <LScurveAppEqPntStartEnd+0x1172>
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
unpcklpd %xmm2,%xmm2
xor    %edx,%edx
mov    0x140(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm3
movupd 0x10(%rbp,%rdx,8),%xmm4
lea    (%rsi,%rdx,1),%ecx
movslq %ecx,%rcx
movupd 0x0(%r13,%rcx,8),%xmm5
movupd 0x10(%r13,%rcx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x0(%r13,%rcx,8)
movupd %xmm4,0x10(%r13,%rcx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    2440 <LScurveAppEqPntStartEnd+0x1300>
mov    %rbx,%rcx
cmp    %r15,%rbx
je     2250 <LScurveAppEqPntStartEnd+0x1110>
jmp    22b2 <LScurveAppEqPntStartEnd+0x1172>
xor    %ebx,%ebx
mov    0x1f0(%rsp),%r11
mov    0x38(%rsp),%r8
mov    0x30(%rsp),%r9
jmp    22b2 <LScurveAppEqPntStartEnd+0x1172>
mov    0xc0(%rsp),%rsi
cmp    $0x3,%esi
jge    24d4 <LScurveAppEqPntStartEnd+0x1394>
jmp    2561 <LScurveAppEqPntStartEnd+0x1421>
lea    -0x2(%rsi),%eax
mov    %rax,0x8(%rsp)
cmp    $0x3,%esi
jl     2561 <LScurveAppEqPntStartEnd+0x1421>
mov    0x1d0(%rsp),%rax
mov    0x8(%rsp),%rdi
mov    %edi,%ecx
mov    $0x5,%edx
xor    %esi,%esi
movsd  0xb0e(%rip),%xmm0
xor    %ebp,%ebp
jmp    2513 <LScurveAppEqPntStartEnd+0x13d3>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%edi
add    $0x4,%edx
add    0x8(%rsp),%esi
cmp    %rbp,%rcx
je     2561 <LScurveAppEqPntStartEnd+0x1421>
movslq %esi,%rbx
add    %rbp,%rbx
movsd  0x0(%r13,%rbx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    2500 <LScurveAppEqPntStartEnd+0x13c0>
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
lea    -0x1(%rdx),%ebx
movslq %ebx,%rbx
movsd  (%rax,%rbx,8),%xmm1
addsd  (%r11,%rbp,8),%xmm1
movsd  %xmm1,(%r11,%rbp,8)
movslq %edx,%rbx
movsd  (%rax,%rbx,8),%xmm1
movslq %edi,%rbx
addsd  (%r11,%rbx,8),%xmm1
movsd  %xmm1,(%r11,%rbx,8)
jmp    2500 <LScurveAppEqPntStartEnd+0x13c0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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