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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
void LScurveApp(int deg, int ncp, double *knot, double *us, int dim, int nus,
                double *qmat, double *startq, double *endq, double *nmat,
                double *rmat, double *left, double *right, double *N) {
  int i, j, jj, span, sd, ncpm2;
  double Rk[4];
  ncpm2 = ncp - 2;
  for (jj = 0; jj < nus; jj++) {
    for (j = 0; j < dim; j++) {
      Rk[j] = qmat[dim * jj + j];
    }
    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);
      sd = span - deg - 1;
      if (span == deg) {
        for (j = 0; j < dim; j++) {
          Rk[j] -= N[0] * startq[j];
        }
      }
      if (span == (ncp - 1)) {
        for (j = 0; j < dim; j++) {
          Rk[j] -= N[deg] * endq[j];
        }
      }
      if (span == deg && span < (ncp - 1)) {
        for (i = 1; i <= deg; i++) {
          for (j = 1; j <= deg; j++) {
            nmat[j - 1 + (i - 1) * ncpm2] += N[i] * N[j];
          }
          for (j = 0; j < dim; j++) {
            rmat[i - 1 + j * ncpm2] += N[i] * Rk[j];
          }
        }
      } else if (span == (ncp - 1) && span > deg) {
        for (i = 0; i < deg; i++) {
          for (j = 0; j < deg; j++) {
            nmat[j + sd + (i + sd) * ncpm2] += N[i] * N[j];
          }
          for (j = 0; j < dim; j++) {
            rmat[i + sd + j * ncpm2] += N[i] * Rk[j];
          }
        }
      } else if (span == (ncp - 1) && span == deg) {
        for (i = 1; i < deg; i++) {
          for (j = 1; j < deg; j++) {
            nmat[j - 1 + (i - 1) * ncpm2] += N[i] * N[j];
          }
          for (j = 0; j < dim; j++) {
            rmat[i - 1 + j * ncpm2] += N[i] * Rk[j];
          }
        }
      } else {
        for (i = 0; i <= deg; i++) {
          for (j = 0; j <= deg; j++) {
            nmat[j + sd + (i + sd) * ncpm2] += N[i] * N[j];
          }
          for (j = 0; j < dim; j++) {
            rmat[i + sd + j * ncpm2] += N[i] * Rk[j];
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<LScurveApp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    179e <LScurveApp+0x67e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11bb <LScurveApp+0x9b>
mov    0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1181 <LScurveApp+0x61>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jae    11e9 <LScurveApp+0xc9>
cmpl   $0x0,-0x4(%rbp)
jne    11ee <LScurveApp+0xce>
jmp    178b <LScurveApp+0x66b>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1213 <LScurveApp+0xf3>
jmp    1786 <LScurveApp+0x666>
mov    -0x8(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    0x48(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x40(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x30(%rbp),%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    12dc <LScurveApp+0x1bc>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12d7 <LScurveApp+0x1b7>
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1279 <LScurveApp+0x159>
jmp    12dc <LScurveApp+0x1bc>
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    135c <LScurveApp+0x23c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1357 <LScurveApp+0x237>
mov    0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12f4 <LScurveApp+0x1d4>
jmp    135c <LScurveApp+0x23c>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    146a <LScurveApp+0x34a>
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    146a <LScurveApp+0x34a>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1465 <LScurveApp+0x345>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13f2 <LScurveApp+0x2d2>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1393 <LScurveApp+0x273>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1452 <LScurveApp+0x332>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13f9 <LScurveApp+0x2d9>
jmp    1457 <LScurveApp+0x337>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1380 <LScurveApp+0x260>
jmp    1781 <LScurveApp+0x661>
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1578 <LScurveApp+0x458>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1578 <LScurveApp+0x458>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1573 <LScurveApp+0x453>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1500 <LScurveApp+0x3e0>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x34(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14a1 <LScurveApp+0x381>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1560 <LScurveApp+0x440>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1507 <LScurveApp+0x3e7>
jmp    1565 <LScurveApp+0x445>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    148e <LScurveApp+0x36e>
jmp    177c <LScurveApp+0x65c>
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1686 <LScurveApp+0x566>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1686 <LScurveApp+0x566>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1681 <LScurveApp+0x561>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    160e <LScurveApp+0x4ee>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15af <LScurveApp+0x48f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    166e <LScurveApp+0x54e>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1615 <LScurveApp+0x4f5>
jmp    1673 <LScurveApp+0x553>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    159c <LScurveApp+0x47c>
jmp    1777 <LScurveApp+0x657>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1772 <LScurveApp+0x652>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16ff <LScurveApp+0x5df>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x34(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16a0 <LScurveApp+0x580>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    175f <LScurveApp+0x63f>
mov    0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1706 <LScurveApp+0x5e6>
jmp    1764 <LScurveApp+0x644>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    168d <LScurveApp+0x56d>
jmp    1777 <LScurveApp+0x657>
jmp    177c <LScurveApp+0x65c>
jmp    1781 <LScurveApp+0x661>
jmp    1786 <LScurveApp+0x666>
jmp    178b <LScurveApp+0x66b>
jmp    1790 <LScurveApp+0x670>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116e <LScurveApp+0x4e>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LScurveApp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %rcx,0x120(%rsp)
mov    %rdx,0xa8(%rsp)
mov    %rsi,0xe0(%rsp)
test   %r9d,%r9d
jle    2333 <LScurveApp+0x1203>
mov    %edi,%ebx
movslq %edi,%rax
mov    %eax,%ecx
not    %ecx
mov    %rcx,0x158(%rsp)
mov    %r8d,%r10d
lea    0x1(%rax),%esi
mov    %r9d,%ecx
mov    %rcx,0x190(%rsp)
mov    %eax,%edx
lea    -0x1(%rdx),%r9
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xd8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,0xc8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xc0(%rsp)
mov    %esi,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x150(%rsp)
mov    %rsi,%rcx
neg    %rcx
mov    %rcx,0x138(%rsp)
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x50(%rsp)
mov    %r9,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rcx
neg    %rcx
mov    %rcx,0x128(%rsp)
mov    %edx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x160(%rsp)
lea    -0x1(%rsi),%rcx
mov    %rcx,0xb0(%rsp)
mov    %rcx,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %rax,%rcx
mov    %rax,0x118(%rsp)
neg    %eax
mov    %eax,0x7c(%rsp)
mov    0xe0(%rsp),%rax
lea    -0x2(%rax),%ecx
mov    %rcx,0x8(%rsp)
movslq %ecx,%r13
mov    %r13,%rcx
shl    $0x4,%rcx
mov    %rcx,0x88(%rsp)
mov    %r9,%rcx
mov    %r9,0xa0(%rsp)
shr    $0x20,%r9
mov    %r9,0x178(%rsp)
mov    0x208(%rsp),%r14
mov    0x1e8(%rsp),%r15
movslq %eax,%rcx
mov    %rcx,%rax
mov    %rcx,0x180(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0xbc(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,0x188(%rsp)
lea    -0x2(%rsi),%rax
mov    %rax,0x130(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x100(%rsp)
lea    (%r14,%rsi,8),%rax
mov    %rax,0x110(%rsp)
mov    %rsi,0x18(%rsp)
lea    -0x8(%r15,%rsi,8),%rax
mov    %rax,0x108(%rsp)
lea    (%r14,%rdx,8),%rax
mov    %rax,0xf8(%rsp)
lea    (%r15,%rdx,8),%rax
mov    %rax,0xf0(%rsp)
lea    -0x2(%rdx),%rax
mov    %rax,0xe8(%rsp)
mov    %r10,0x68(%rsp)
lea    -0x1(%r10),%rax
mov    %rax,0x90(%rsp)
mov    %rdi,0x148(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x140(%rsp)
mov    %rbp,0x170(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x168(%rsp)
xor    %eax,%eax
mov    %rax,0x70(%rsp)
mov    %r8d,0x14(%rsp)
mov    %rdx,0x48(%rsp)
mov    %ebx,0x5c(%rsp)
jmp    1373 <LScurveApp+0x243>
nopl   (%rax)
mov    0x70(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x70(%rsp)
cmp    0x190(%rsp),%rcx
mov    0x5c(%rsp),%ebx
je     2333 <LScurveApp+0x1203>
test   %r8d,%r8d
jle    13a6 <LScurveApp+0x276>
mov    0x70(%rsp),%rax
imul   %r8d,%eax
cltq
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
lea    0x20(%rsp),%rdi
mov    0x188(%rsp),%rdx
call   1040 <memcpy@plt>
mov    0x14(%rsp),%r8d
test   %ebx,%ebx
je     1350 <LScurveApp+0x220>
mov    0x120(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xa8(%rsp),%rax
mov    0x118(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
jae    1350 <LScurveApp+0x220>
mov    0xa8(%rsp),%rax
mov    0x180(%rsp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jae    1350 <LScurveApp+0x220>
mov    0xe0(%rsp),%rdi
mov    0x5c(%rsp),%ebx
mov    %ebx,%esi
mov    0xa8(%rsp),%rbp
mov    %rbp,%rdx
call   1050 <FindSpan@plt>
mov    %eax,%r12d
mov    0x120(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    %r12d,%edi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    %r14,%rcx
mov    0x1f8(%rsp),%r8
mov    0x200(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x14(%rsp),%r8d
cmp    %ebx,%r12d
mov    0x68(%rsp),%rdx
mov    0x1e0(%rsp),%rsi
mov    0x1d8(%rsp),%rdi
jne    157e <LScurveApp+0x44e>
test   %r8d,%r8d
jle    157e <LScurveApp+0x44e>
movsd  (%r14),%xmm0
xorpd  0x1b7e(%rip),%xmm0
cmp    $0x4,%r8d
jae    148f <LScurveApp+0x35f>
xor    %eax,%eax
jmp    1560 <LScurveApp+0x430>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xd0(%rsp)
je     2309 <LScurveApp+0x11d9>
mov    0xc0(%rsp),%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm2
movupd 0x10(%rdi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rax,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x30(%rsp,%rax,8),%xmm3
movapd %xmm2,0x20(%rsp,%rax,8)
movapd %xmm3,0x30(%rsp,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x40(%rsp,%rax,8),%xmm2
movupd 0x30(%rdi,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x50(%rsp,%rax,8),%xmm3
movapd %xmm2,0x40(%rsp,%rax,8)
movapd %xmm3,0x50(%rsp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    14b0 <LScurveApp+0x380>
testb  $0x1,0xc8(%rsp)
01
je     1546 <LScurveApp+0x416>
movupd (%rdi,%rax,8),%xmm2
movupd 0x10(%rdi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rax,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x30(%rsp,%rax,8),%xmm3
movapd %xmm2,0x20(%rsp,%rax,8)
movapd %xmm3,0x30(%rsp,%rax,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     157e <LScurveApp+0x44e>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x20(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1560 <LScurveApp+0x430>
mov    0xbc(%rsp),%edi
cmp    %edi,%r12d
mov    0x50(%rsp),%r9
jne    16ae <LScurveApp+0x57e>
test   %r8d,%r8d
jle    16ae <LScurveApp+0x57e>
mov    0x118(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
xorpd  0x1a4e(%rip),%xmm0
cmp    $0x4,%r8d
jae    15bf <LScurveApp+0x48f>
xor    %eax,%eax
jmp    1690 <LScurveApp+0x560>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xd0(%rsp)
je     231e <LScurveApp+0x11ee>
mov    0xc0(%rsp),%rcx
xor    %eax,%eax
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rax,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x30(%rsp,%rax,8),%xmm3
movapd %xmm2,0x20(%rsp,%rax,8)
movapd %xmm3,0x30(%rsp,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x40(%rsp,%rax,8),%xmm2
movupd 0x30(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x50(%rsp,%rax,8),%xmm3
movapd %xmm2,0x40(%rsp,%rax,8)
movapd %xmm3,0x50(%rsp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    15e0 <LScurveApp+0x4b0>
testb  $0x1,0xc8(%rsp)
01
je     1676 <LScurveApp+0x546>
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rax,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x30(%rsp,%rax,8),%xmm3
movapd %xmm2,0x20(%rsp,%rax,8)
movapd %xmm3,0x30(%rsp,%rax,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     16ae <LScurveApp+0x57e>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x20(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1690 <LScurveApp+0x560>
cmp    %ebx,%r12d
jne    198e <LScurveApp+0x85e>
cmp    %edi,%r12d
jge    198e <LScurveApp+0x85e>
test   %ebx,%ebx
jle    1350 <LScurveApp+0x220>
mov    $0x1,%eax
mov    $0xffffffffffffffff,%r9
mov    0x1f0(%rsp),%r11
xor    %esi,%esi
xor    %r10d,%r10d
jmp    1710 <LScurveApp+0x5e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
add    $0x1,%r10
mov    0x8(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%r9
add    $0x8,%r11
cmp    %rbp,%rax
je     1350 <LScurveApp+0x220>
mov    $0x1,%edx
cmpq   $0x4,0xb0(%rsp)
mov    0x18(%rsp),%rbp
jb     1840 <LScurveApp+0x710>
mov    0x8(%rsp),%rbx
imul   %r10d,%ebx
mov    0x130(%rsp),%rcx
lea    (%rbx,%rcx,1),%edi
mov    $0x1,%edx
cmp    %ebx,%edi
jl     1840 <LScurveApp+0x710>
mov    0x130(%rsp),%rdx
shr    $0x20,%rdx
mov    $0x1,%edx
jne    1840 <LScurveApp+0x710>
mov    0x8(%rsp),%rdx
imul   %r10d,%edx
movslq %edx,%rdx
lea    (%r15,%rdx,8),%rdi
mov    0x108(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
lea    (%r14,%rax,8),%rbx
lea    (%r14,%r10,8),%rcx
add    $0x10,%rcx
cmp    %rdx,0x100(%rsp)
setb   %r8b
cmp    0x110(%rsp),%rdi
setb   %r12b
cmp    %rdx,%rbx
setb   %bl
cmp    %rcx,%rdi
setb   %cl
mov    $0x1,%edx
test   %r12b,%r8b
mov    0x18(%rsp),%rbp
mov    0x14(%rsp),%r8d
jne    1840 <LScurveApp+0x710>
mov    $0x1,%edx
and    %cl,%bl
jne    1840 <LScurveApp+0x710>
movsd  (%r14,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edx,%edx
mov    0x170(%rsp),%rbx
xchg   %ax,%ax
movupd 0x8(%r14,%rdx,8),%xmm1
movupd 0x18(%r14,%rdx,8),%xmm2
lea    (%rsi,%rdx,1),%edi
movslq %edi,%rdi
movupd (%r15,%rdi,8),%xmm3
movupd 0x10(%r15,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%r15,%rdi,8)
movupd %xmm2,0x10(%r15,%rdi,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    17e0 <LScurveApp+0x6b0>
mov    0x168(%rsp),%rdx
cmp    %rbx,0xb0(%rsp)
je     18d7 <LScurveApp+0x7a7>
nopl   (%rax)
mov    %rdx,%rbx
test   $0x1,%bpl
jne    1875 <LScurveApp+0x745>
lea    -0x1(%rax),%edi
imul   0x8(%rsp),%edi
add    $0xffffffff,%edi
movsd  (%r14,%rax,8),%xmm0
add    %edx,%edi
movslq %edi,%rdi
mulsd  (%r14,%rdx,8),%xmm0
addsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%r15,%rdi,8)
lea    0x1(%rdx),%rbx
not    %rdx
cmp    0x138(%rsp),%rdx
je     18d7 <LScurveApp+0x7a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
lea    (%r9,%rbx,1),%edx
movslq %edx,%rdx
mulsd  (%r14,%rbx,8),%xmm0
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r14,%rax,8),%xmm0
lea    (%rsi,%rbx,1),%edx
movslq %edx,%rdx
mulsd  0x8(%r14,%rbx,8),%xmm0
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%rbx
cmp    %rbx,%rbp
jne    1890 <LScurveApp+0x760>
test   %r8d,%r8d
mov    0x50(%rsp),%rdi
jle    16f0 <LScurveApp+0x5c0>
cmpq   $0x0,0x90(%rsp)
je     1950 <LScurveApp+0x820>
mov    %r11,%rbx
xor    %edx,%edx
mov    0x88(%rsp),%rcx
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp,%rdx,8),%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%r14,%rax,8),%xmm0
mulsd  0x28(%rsp,%rdx,8),%xmm0
addsd  (%rbx,%r13,8),%xmm0
movsd  %xmm0,(%rbx,%r13,8)
add    $0x2,%rdx
add    %rcx,%rbx
cmp    %rdx,%rdi
jne    1900 <LScurveApp+0x7d0>
testb  $0x1,0x68(%rsp)
je     16f0 <LScurveApp+0x5c0>
jmp    195d <LScurveApp+0x82d>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
testb  $0x1,0x68(%rsp)
je     16f0 <LScurveApp+0x5c0>
lea    -0x1(%rax),%rdi
movsd  (%r14,%rax,8),%xmm0
mov    %rdx,%rbx
imul   %r13,%rbx
mulsd  0x20(%rsp,%rdx,8),%xmm0
add    %rdi,%rbx
mov    0x1f0(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
jmp    16f0 <LScurveApp+0x5c0>
mov    0x158(%rsp),%rax
lea    (%r12,%rax,1),%r11d
cmp    %edi,%r12d
mov    %r11,0x80(%rsp)
jne    1cd9 <LScurveApp+0xba9>
cmp    %ebx,%r12d
jle    1cd9 <LScurveApp+0xba9>
test   %ebx,%ebx
jle    1350 <LScurveApp+0x220>
movslq %r11d,%rdx
mov    0x8(%rsp),%rax
imul   %r11d,%eax
lea    (%r11,%rax,1),%ebp
add    0x7c(%rsp),%r12d
add    %eax,%r12d
lea    (%rdx,%r13,1),%rax
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %rdx,0x98(%rsp)
lea    (%rcx,%rdx,8),%rdi
mov    %rbp,0x60(%rsp)
mov    %rbp,%rdx
xor    %eax,%eax
jmp    1a20 <LScurveApp+0x8f0>
nopl   0x0(%rax)
add    $0x1,%rax
mov    0x8(%rsp),%rcx
add    %rcx,%rdx
add    %rcx,%r12
add    $0x8,%rsi
add    $0x8,%rdi
cmp    %r10,%rax
je     1350 <LScurveApp+0x220>
cmpl   $0x4,0x5c(%rsp)
jb     1b60 <LScurveApp+0xa30>
mov    0x8(%rsp),%rcx
imul   %eax,%ecx
add    0x60(%rsp),%ecx
mov    0xa0(%rsp),%rbx
add    %ecx,%ebx
cmp    %ecx,%ebx
jl     1b60 <LScurveApp+0xa30>
mov    $0x0,%ecx
cmpq   $0x0,0x178(%rsp)
mov    0x48(%rsp),%r10
jne    1b67 <LScurveApp+0xa37>
mov    0x8(%rsp),%rcx
imul   %eax,%ecx
add    0x60(%rsp),%ecx
movslq %ecx,%rcx
lea    (%r15,%rcx,8),%rbx
mov    0xf0(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    (%r14,%rax,8),%r8
cmp    %r14,%rcx
seta   %r10b
lea    (%r14,%rax,8),%r11
add    $0x8,%r11
cmp    0xf8(%rsp),%rbx
setb   %r9b
cmp    %rcx,%r8
setb   %r8b
cmp    %r11,%rbx
setb   %r11b
test   %r9b,%r10b
jne    1cbb <LScurveApp+0xb8b>
mov    $0x0,%ecx
and    %r11b,%r8b
mov    0x14(%rsp),%r8d
mov    0x50(%rsp),%r9
mov    0x160(%rsp),%rbp
mov    0x48(%rsp),%r10
mov    0x80(%rsp),%r11
jne    1b67 <LScurveApp+0xa37>
movsd  (%r14,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rcx,8),%xmm1
movupd 0x10(%r14,%rcx,8),%xmm2
lea    (%rdx,%rcx,1),%ebx
movslq %ebx,%rbx
movupd (%r15,%rbx,8),%xmm3
movupd 0x10(%r15,%rbx,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%r15,%rbx,8)
movupd %xmm2,0x10(%r15,%rbx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1b00 <LScurveApp+0x9d0>
mov    %rbp,%rcx
cmp    %r10,%rbp
jne    1b67 <LScurveApp+0xa37>
jmp    1bf7 <LScurveApp+0xac7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ecx,%ecx
mov    0x48(%rsp),%r10
mov    %rcx,%rbx
test   $0x1,%r10b
je     1ba0 <LScurveApp+0xa70>
lea    (%r11,%rax,1),%ebx
imul   0x8(%rsp),%ebx
add    %r11d,%ebx
movsd  (%r14,%rax,8),%xmm0
add    %ecx,%ebx
movslq %ebx,%rbx
mulsd  (%r14,%rcx,8),%xmm0
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x128(%rsp),%rcx
je     1bf7 <LScurveApp+0xac7>
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
lea    (%rdx,%rbx,1),%ecx
movslq %ecx,%rcx
mulsd  (%r14,%rbx,8),%xmm0
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r14,%rax,8),%xmm0
lea    (%r12,%rbx,1),%ecx
movslq %ecx,%rcx
mulsd  0x8(%r14,%rbx,8),%xmm0
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x2,%rbx
cmp    %rbx,%r10
jne    1bb0 <LScurveApp+0xa80>
test   %r8d,%r8d
jle    1a00 <LScurveApp+0x8d0>
cmpq   $0x0,0x90(%rsp)
je     1c70 <LScurveApp+0xb40>
xor    %ebx,%ebx
xor    %ecx,%ecx
mov    0x88(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp,%rcx,8),%xmm0
addsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
movsd  (%r14,%rax,8),%xmm0
mulsd  0x28(%rsp,%rcx,8),%xmm0
addsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,(%rsi,%rbx,1)
add    $0x2,%rcx
add    %rbp,%rbx
cmp    %rcx,%r9
jne    1c20 <LScurveApp+0xaf0>
testb  $0x1,0x68(%rsp)
je     1a00 <LScurveApp+0x8d0>
jmp    1c7d <LScurveApp+0xb4d>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ecx,%ecx
testb  $0x1,0x68(%rsp)
je     1a00 <LScurveApp+0x8d0>
mov    0x98(%rsp),%rbp
lea    (%rax,%rbp,1),%r9
movsd  (%r14,%rax,8),%xmm0
mov    %rcx,%rbx
imul   %r13,%rbx
mulsd  0x20(%rsp,%rcx,8),%xmm0
add    %r9,%rbx
mov    0x50(%rsp),%r9
mov    0x1f0(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
jmp    1a00 <LScurveApp+0x8d0>
xor    %ecx,%ecx
mov    0x14(%rsp),%r8d
mov    0x50(%rsp),%r9
mov    0x48(%rsp),%r10
mov    0x80(%rsp),%r11
jmp    1b67 <LScurveApp+0xa37>
cmp    %edi,%r12d
jne    1fde <LScurveApp+0xeae>
cmp    %ebx,%r12d
jne    1fde <LScurveApp+0xeae>
cmp    $0x2,%ebx
jl     1350 <LScurveApp+0x220>
mov    $0x1,%eax
mov    $0xffffffffffffffff,%rcx
mov    0x1f0(%rsp),%r11
xor    %esi,%esi
xor    %r10d,%r10d
jmp    1d32 <LScurveApp+0xc02>
nop
add    $0x1,%rax
add    $0x1,%r10
mov    0x8(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%rcx
add    $0x8,%r11
cmp    0x48(%rsp),%rax
je     1350 <LScurveApp+0x220>
mov    $0x1,%edx
cmpq   $0x4,0xa0(%rsp)
mov    0x48(%rsp),%r9
jae    1e60 <LScurveApp+0xd30>
mov    %rdx,%rbx
test   $0x1,%r9b
jne    1d80 <LScurveApp+0xc50>
lea    -0x1(%rax),%edi
imul   0x8(%rsp),%edi
add    $0xffffffff,%edi
movsd  (%r14,%rax,8),%xmm0
add    %edx,%edi
movslq %edi,%rdi
mulsd  (%r14,%rdx,8),%xmm0
addsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%r15,%rdi,8)
lea    0x1(%rdx),%rbx
not    %rdx
cmp    0x128(%rsp),%rdx
mov    0x48(%rsp),%rdi
je     1de6 <LScurveApp+0xcb6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
lea    (%rcx,%rbx,1),%edx
movslq %edx,%rdx
mulsd  (%r14,%rbx,8),%xmm0
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r14,%rax,8),%xmm0
lea    (%rsi,%rbx,1),%edx
movslq %edx,%rdx
mulsd  0x8(%r14,%rbx,8),%xmm0
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    1da0 <LScurveApp+0xc70>
test   %r8d,%r8d
mov    0x50(%rsp),%rdi
jle    1d10 <LScurveApp+0xbe0>
cmpq   $0x0,0x90(%rsp)
je     1fa0 <LScurveApp+0xe70>
mov    %r11,%rbx
xor    %edx,%edx
mov    0x88(%rsp),%rbp
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp,%rdx,8),%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%r14,%rax,8),%xmm0
mulsd  0x28(%rsp,%rdx,8),%xmm0
addsd  (%rbx,%r13,8),%xmm0
movsd  %xmm0,(%rbx,%r13,8)
add    $0x2,%rdx
add    %rbp,%rbx
cmp    %rdx,%rdi
jne    1e10 <LScurveApp+0xce0>
testb  $0x1,0x68(%rsp)
je     1d10 <LScurveApp+0xbe0>
jmp    1fad <LScurveApp+0xe7d>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rbx
imul   %r10d,%ebx
mov    0xe8(%rsp),%rdx
lea    (%rbx,%rdx,1),%edi
mov    $0x1,%edx
cmp    %ebx,%edi
jl     1d4b <LScurveApp+0xc1b>
mov    0xe8(%rsp),%rdx
shr    $0x20,%rdx
mov    $0x1,%edx
jne    1d4b <LScurveApp+0xc1b>
mov    0x8(%rsp),%rdx
imul   %r10d,%edx
movslq %edx,%rdx
lea    (%r15,%rdx,8),%rdi
mov    0xf0(%rsp),%rbp
lea    -0x8(,%rdx,8),%rdx
ff
add    %rbp,%rdx
lea    (%r14,%rax,8),%rbx
lea    (%r14,%r10,8),%rbp
add    $0x10,%rbp
cmp    %rdx,0x100(%rsp)
setb   %r8b
cmp    0xf8(%rsp),%rdi
setb   %r12b
cmp    %rdx,%rbx
setb   %bl
cmp    %rbp,%rdi
setb   %dil
mov    $0x1,%edx
test   %r12b,%r8b
mov    0x14(%rsp),%r8d
jne    1d4b <LScurveApp+0xc1b>
mov    $0x1,%edx
and    %dil,%bl
jne    1d4b <LScurveApp+0xc1b>
movsd  (%r14,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edx,%edx
mov    0x148(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r14,%rdx,8),%xmm1
movupd 0x18(%r14,%rdx,8),%xmm2
lea    (%rsi,%rdx,1),%edi
movslq %edi,%rdi
movupd (%r15,%rdi,8),%xmm3
movupd 0x10(%r15,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%r15,%rdi,8)
movupd %xmm2,0x10(%r15,%rdi,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1f30 <LScurveApp+0xe00>
mov    0x140(%rsp),%rdx
cmp    %rbx,0xa0(%rsp)
mov    0x48(%rsp),%r9
jne    1d4b <LScurveApp+0xc1b>
jmp    1de6 <LScurveApp+0xcb6>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
testb  $0x1,0x68(%rsp)
je     1d10 <LScurveApp+0xbe0>
lea    -0x1(%rax),%rdi
movsd  (%r14,%rax,8),%xmm0
mov    %rdx,%rbx
imul   %r13,%rbx
mulsd  0x20(%rsp,%rdx,8),%xmm0
add    %rdi,%rbx
mov    0x1f0(%rsp),%rdx
addsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
jmp    1d10 <LScurveApp+0xbe0>
test   %ebx,%ebx
js     1350 <LScurveApp+0x220>
movslq %r11d,%rdx
mov    %r13d,%eax
imul   %r11d,%eax
lea    (%r11,%rax,1),%ebp
add    0x7c(%rsp),%r12d
add    %eax,%r12d
lea    (%rdx,%r13,1),%rax
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %rdx,0x98(%rsp)
lea    (%rcx,%rdx,8),%rdi
mov    %rbp,0x60(%rsp)
mov    %rbp,%rdx
xor    %ecx,%ecx
jmp    2052 <LScurveApp+0xf22>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
mov    0x8(%rsp),%rax
add    %rax,%rdx
add    %rax,%r12
add    $0x8,%rsi
add    $0x8,%rdi
cmp    0x18(%rsp),%rcx
je     1350 <LScurveApp+0x220>
cmpl   $0x4,0x18(%rsp)
jae    2170 <LScurveApp+0x1040>
xor    %ebx,%ebx
mov    0x18(%rsp),%rbp
mov    %rbx,%rax
test   $0x1,%bpl
je     209c <LScurveApp+0xf6c>
lea    (%r11,%rcx,1),%eax
imul   0x8(%rsp),%eax
add    %r11d,%eax
movsd  (%r14,%rcx,8),%xmm0
add    %ebx,%eax
cltq
mulsd  (%r14,%rbx,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
mov    %rbx,%rax
or     $0x1,%rax
not    %rbx
cmp    0x138(%rsp),%rbx
mov    0x18(%rsp),%rbp
je     20f7 <LScurveApp+0xfc7>
xchg   %ax,%ax
movsd  (%r14,%rcx,8),%xmm0
lea    (%rdx,%rax,1),%ebx
movslq %ebx,%rbx
mulsd  (%r14,%rax,8),%xmm0
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
movsd  (%r14,%rcx,8),%xmm0
lea    (%r12,%rax,1),%ebx
movslq %ebx,%rbx
mulsd  0x8(%r14,%rax,8),%xmm0
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    20b0 <LScurveApp+0xf80>
test   %r8d,%r8d
jle    2030 <LScurveApp+0xf00>
cmpq   $0x0,0x90(%rsp)
je     22a0 <LScurveApp+0x1170>
xor    %ebx,%ebx
xor    %eax,%eax
mov    0x88(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  0x20(%rsp,%rax,8),%xmm0
addsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  0x28(%rsp,%rax,8),%xmm0
addsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,(%rsi,%rbx,1)
add    $0x2,%rax
add    %rbp,%rbx
cmp    %rax,%r9
jne    2120 <LScurveApp+0xff0>
testb  $0x1,0x68(%rsp)
je     2030 <LScurveApp+0xf00>
jmp    22ad <LScurveApp+0x117d>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
imul   %ecx,%eax
add    0x60(%rsp),%eax
mov    0xb0(%rsp),%rbp
lea    (%rax,%rbp,1),%ebx
cmp    %eax,%ebx
jl     205d <LScurveApp+0xf2d>
mov    %rbp,%rax
shr    $0x20,%rax
mov    $0x0,%ebx
mov    0x18(%rsp),%rbp
jne    2064 <LScurveApp+0xf34>
mov    0x8(%rsp),%rax
imul   %ecx,%eax
add    0x60(%rsp),%eax
cltq
lea    (%r15,%rax,8),%rbx
mov    0x108(%rsp),%rbp
lea    0x8(,%rax,8),%rax
add    %rbp,%rax
lea    (%r14,%rcx,8),%r10
cmp    %r14,%rax
seta   %r8b
lea    (%r14,%rcx,8),%r11
add    $0x8,%r11
cmp    0x110(%rsp),%rbx
setb   %r9b
cmp    %rax,%r10
setb   %al
cmp    %r11,%rbx
setb   %r11b
test   %r9b,%r8b
jne    22eb <LScurveApp+0x11bb>
mov    $0x0,%ebx
and    %r11b,%al
mov    0x14(%rsp),%r8d
mov    0x18(%rsp),%rbp
mov    0x50(%rsp),%r9
mov    0x80(%rsp),%r11
jne    2064 <LScurveApp+0xf34>
movsd  (%r14,%rcx,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
mov    0x150(%rsp),%rbp
nopl   0x0(%rax)
movupd (%r14,%rax,8),%xmm1
movupd 0x10(%r14,%rax,8),%xmm2
lea    (%rdx,%rax,1),%ebx
movslq %ebx,%rbx
movupd (%r15,%rbx,8),%xmm3
movupd 0x10(%r15,%rbx,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%r15,%rbx,8)
movupd %xmm2,0x10(%r15,%rbx,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2240 <LScurveApp+0x1110>
mov    %rbp,%rbx
mov    %rbp,%rax
mov    0x18(%rsp),%rbp
cmp    %rbp,%rax
jne    2064 <LScurveApp+0xf34>
jmp    20f7 <LScurveApp+0xfc7>
nop
xor    %eax,%eax
testb  $0x1,0x68(%rsp)
je     2030 <LScurveApp+0xf00>
mov    0x98(%rsp),%rbp
lea    (%rcx,%rbp,1),%r9
movsd  (%r14,%rcx,8),%xmm0
mov    %rax,%rbx
imul   %r13,%rbx
mulsd  0x20(%rsp,%rax,8),%xmm0
add    %r9,%rbx
mov    0x50(%rsp),%r9
mov    0x1f0(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
jmp    2030 <LScurveApp+0xf00>
xor    %ebx,%ebx
mov    0x14(%rsp),%r8d
mov    0x18(%rsp),%rbp
mov    0x50(%rsp),%r9
mov    0x80(%rsp),%r11
jmp    2064 <LScurveApp+0xf34>
xor    %eax,%eax
testb  $0x1,0xc8(%rsp)
01
jne    151b <LScurveApp+0x3eb>
jmp    1546 <LScurveApp+0x416>
xor    %eax,%eax
testb  $0x1,0xc8(%rsp)
01
jne    164b <LScurveApp+0x51b>
jmp    1676 <LScurveApp+0x546>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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