#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 */
double dpmpar(int);
double enorm(int, double *);
double fabs(double);
int /*<<< orphan*/ qrsolv(int, double *, int, int const *, double *,
                          double const *, double *, double *, double *);
double sqrt(double);
void lmpar(int n, double *r, int ldr, const int *ipvt, const double *diag,
           const double *qtb, double delta, double *par, double *x,
           double *sdiag, double *wa1, double *wa2) {
  double d1, d2;
  int j, l;
  double fp;
  double parc, parl;
  int iter;
  double temp, paru, dwarf;
  int nsing;
  double gnorm;
  double dxnorm;
  dwarf = dpmpar(2);
  nsing = n;
  for (j = 0; j < n; ++j) {
    wa1[j] = qtb[j];
    if (r[j + j * ldr] == 0. && nsing == n) {
      nsing = j;
    }
    if (nsing < n) {
      wa1[j] = 0.;
    }
  }
  if (nsing >= 1) {
    int k;
    for (k = 1; k <= nsing; ++k) {
      j = nsing - k;
      wa1[j] /= r[j + j * ldr];
      temp = wa1[j];
      if (j >= 1) {
        int i;
        for (i = 0; i < j; ++i) {
          wa1[i] -= r[i + j * ldr] * temp;
        }
      }
    }
  }
  for (j = 0; j < n; ++j) {
    l = ipvt[j] - 1;
    x[l] = wa1[j];
  }
  iter = 0;
  for (j = 0; j < n; ++j) {
    wa2[j] = diag[j] * x[j];
  }
  dxnorm = enorm(n, wa2);
  fp = dxnorm - delta;
  if (fp <= .1 * delta) {
    goto TERMINATE;
  }
  parl = 0.;
  if (nsing >= n) {
    for (j = 0; j < n; ++j) {
      l = ipvt[j] - 1;
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      double sum = 0.;
      if (j >= 1) {
        int i;
        for (i = 0; i < j; ++i) {
          sum += r[i + j * ldr] * wa1[i];
        }
      }
      wa1[j] = (wa1[j] - sum) / r[j + j * ldr];
    }
    temp = enorm(n, wa1);
    parl = fp / delta / temp / temp;
  }
  for (j = 0; j < n; ++j) {
    double sum;
    int i;
    sum = 0.;
    for (i = 0; i <= j; ++i) {
      sum += r[i + j * ldr] * qtb[i];
    }
    l = ipvt[j] - 1;
    wa1[j] = sum / diag[l];
  }
  gnorm = enorm(n, wa1);
  paru = gnorm / delta;
  if (paru == 0.) {
    paru = dwarf / ((delta) <= ((double).1) ? (delta) : ((double).1));
  }
  *par = ((*par) >= (parl) ? (*par) : (parl));
  *par = ((*par) <= (paru) ? (*par) : (paru));
  if (*par == 0.) {
    *par = gnorm / dxnorm;
  }
  for (;;) {
    ++iter;
    if (*par == 0.) {
      d1 = dwarf, d2 = .001 * paru;
      *par = ((d1) >= (d2) ? (d1) : (d2));
    }
    temp = sqrt(*par);
    for (j = 0; j < n; ++j) {
      wa1[j] = temp * diag[j];
    }
    qrsolv(n, r, ldr, ipvt, wa1, qtb, x, sdiag, wa2);
    for (j = 0; j < n; ++j) {
      wa2[j] = diag[j] * x[j];
    }
    dxnorm = enorm(n, wa2);
    temp = fp;
    fp = dxnorm - delta;
    if (fabs(fp) <= .1 * delta || (parl == 0. && fp <= temp && temp < 0.) ||
        iter == 10) {
      goto TERMINATE;
    }
    for (j = 0; j < n; ++j) {
      l = ipvt[j] - 1;
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      wa1[j] /= sdiag[j];
      temp = wa1[j];
      if (n > j + 1) {
        int i;
        for (i = j + 1; i < n; ++i) {
          wa1[i] -= r[i + j * ldr] * temp;
        }
      }
    }
    temp = enorm(n, wa1);
    parc = fp / delta / temp / temp;
    if (fp > 0.) {
      parl = ((parl) >= (*par) ? (parl) : (*par));
    }
    if (fp < 0.) {
      paru = ((paru) <= (*par) ? (paru) : (*par));
    }
    d1 = parl, d2 = *par + parc;
    *par = ((d1) >= (d2) ? (d1) : (d2));
  }
TERMINATE:
  if (iter == 0) {
    *par = 0.;
  }
}


x86 assembly (clang, -O0):
<lmpar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
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    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    $0x2,%edi
call   1040 <dpmpar@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x4(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1237 <lmpar+0xf7>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1205 <lmpar+0xc5>
jp     1205 <lmpar+0xc5>
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1205 <lmpar+0xc5>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1224 <lmpar+0xe4>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1229 <lmpar+0xe9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    119c <lmpar+0x5c>
cmpl   $0x1,-0x8c(%rbp)
jl     135d <lmpar+0x21d>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jg     1358 <lmpar+0x218>
mov    -0x8c(%rbp),%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x1,-0x4c(%rbp)
jl     133f <lmpar+0x1ff>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    133a <lmpar+0x1fa>
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    12c3 <lmpar+0x183>
jmp    133f <lmpar+0x1ff>
jmp    1344 <lmpar+0x204>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    124e <lmpar+0x10e>
jmp    135d <lmpar+0x21d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13a9 <lmpar+0x269>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1364 <lmpar+0x224>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f8 <lmpar+0x2b8>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13b7 <lmpar+0x277>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1050 <enorm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  0xbd5(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     143f <lmpar+0x2ff>
jmp    1c7c <lmpar+0xb3c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     15ca <lmpar+0x48a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14bb <lmpar+0x37b>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    145d <lmpar+0x31d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a0 <lmpar+0x460>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
cmpl   $0x1,-0x4c(%rbp)
jl     1558 <lmpar+0x418>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1553 <lmpar+0x413>
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    14ed <lmpar+0x3ad>
jmp    1558 <lmpar+0x418>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14c2 <lmpar+0x382>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1050 <enorm@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1699 <lmpar+0x559>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1658 <lmpar+0x518>
mov    -0x10(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    15f2 <lmpar+0x4b2>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15d1 <lmpar+0x491>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1050 <enorm@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    173a <lmpar+0x5fa>
jp     173a <lmpar+0x5fa>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x911(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jb     170c <lmpar+0x5cc>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1721 <lmpar+0x5e1>
movsd  0x8ec(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1721 <lmpar+0x5e1>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     1762 <lmpar+0x622>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    176f <lmpar+0x62f>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     17ab <lmpar+0x66b>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    17b8 <lmpar+0x678>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17fb <lmpar+0x6bb>
jp     17fb <lmpar+0x6bb>
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1800 <lmpar+0x6c0>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1882 <lmpar+0x742>
jp     1882 <lmpar+0x742>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  0x7cf(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1865 <lmpar+0x725>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1872 <lmpar+0x732>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18d4 <lmpar+0x794>
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    189b <lmpar+0x75b>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x18(%rbp),%r11
mov    0x20(%rbp),%r10
mov    0x30(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <qrsolv@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1951 <lmpar+0x811>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1910 <lmpar+0x7d0>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1050 <enorm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movaps 0x683(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x667(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    19ec <lmpar+0x8ac>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19e2 <lmpar+0x8a2>
jp     19e2 <lmpar+0x8a2>
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     19e2 <lmpar+0x8a2>
xorps  %xmm0,%xmm0
ucomisd -0x78(%rbp),%xmm0
ja     19ec <lmpar+0x8ac>
cmpl   $0xa,-0x6c(%rbp)
jne    19f1 <lmpar+0x8b1>
jmp    1c7c <lmpar+0xb3c>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a56 <lmpar+0x916>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19f8 <lmpar+0x8b8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b4a <lmpar+0xa0a>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    1b37 <lmpar+0x9f7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b32 <lmpar+0x9f2>
mov    -0x10(%rbp),%rax
mov    -0xc8(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1abb <lmpar+0x97b>
jmp    1b37 <lmpar+0x9f7>
jmp    1b3c <lmpar+0x9fc>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a5d <lmpar+0x91d>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1050 <enorm@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1bc8 <lmpar+0xa88>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1bab <lmpar+0xa6b>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1bbb <lmpar+0xa7b>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1c1c <lmpar+0xadc>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1bff <lmpar+0xabf>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1c0f <lmpar+0xacf>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1c5a <lmpar+0xb1a>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1c67 <lmpar+0xb27>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1800 <lmpar+0x6c0>
cmpl   $0x0,-0x6c(%rbp)
jne    1c91 <lmpar+0xb51>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmpar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
movsd  %xmm0,0x30(%rsp)
mov    %r9,0x50(%rsp)
mov    %r8,%r15
mov    %rcx,0x20(%rsp)
mov    %edx,0x14(%rsp)
mov    %rsi,0x8(%rsp)
mov    %edi,%r12d
mov    0x170(%rsp),%rbx
mov    0x168(%rsp),%r13
mov    $0x2,%edi
call   1040 <dpmpar@plt>
movapd %xmm0,0xf0(%rsp)
mov    %r12d,%eax
mov    %rax,0x18(%rsp)
mov    %r12d,%r14d
test   %r12d,%r12d
mov    %r12d,0x2c(%rsp)
jle    16aa <lmpar+0x56a>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    %r12d,%r14d
mov    0x50(%rsp),%rdi
mov    0x14(%rsp),%ebp
mov    0x8(%rsp),%rbx
jmp    11dd <lmpar+0x9d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %ebp,%eax
cmp    %rcx,0x18(%rsp)
je     1219 <lmpar+0xd9>
mov    %r14d,%edx
movslq %eax,%rsi
movsd  (%rdi,%rcx,8),%xmm1
add    %rcx,%rsi
cmp    %r12d,%r14d
mov    %ecx,%r14d
cmovne %edx,%r14d
movsd  %xmm1,0x0(%r13,%rcx,8)
ucomisd (%rbx,%rsi,8),%xmm0
cmovne %edx,%r14d
cmovp  %edx,%r14d
cmp    %r12d,%r14d
jge    11d0 <lmpar+0x90>
movq   $0x0,0x0(%r13,%rcx,8)
jmp    11d0 <lmpar+0x90>
test   %r14d,%r14d
jle    142e <lmpar+0x2ee>
mov    %r14d,%eax
movslq 0x14(%rsp),%rdx
lea    0x1(%r14),%ecx
mov    %rcx,0x68(%rsp)
lea    -0x1(%r14),%esi
mov    %rax,0x40(%rsp)
add    $0xffffffffffffffff,%rax
imul   %rdx,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
add    $0x10,%rdi
mov    %rdx,%r12
lea    0x0(,%rdx,8),%rdx
neg    %rdx
mov    %rdx,0x38(%rsp)
lea    (%rcx,%rax,8),%rdx
add    $0x8,%rdx
mov    $0x1,%eax
xor    %ecx,%ecx
mov    %esi,0x48(%rsp)
mov    %esi,%r8d
mov    0x8(%rsp),%rbx
jmp    12b2 <lmpar+0x172>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%rcx
mov    0x38(%rsp),%rsi
add    %rsi,%rdi
add    $0xffffffff,%r8d
add    %rsi,%rdx
cmp    0x68(%rsp),%rax
je     142e <lmpar+0x2ee>
mov    %r8d,%r8d
mov    0x40(%rsp),%rsi
sub    %rax,%rsi
mov    %rsi,%r9
imul   %r12,%r9
lea    (%r9,%rsi,1),%rbp
movsd  0x0(%r13,%rsi,8),%xmm0
divsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
test   %rsi,%rsi
jle    1290 <lmpar+0x150>
mov    0x48(%rsp),%esi
mov    %esi,%r11d
sub    %ecx,%r11d
cmp    $0x4,%r11d
jb     1330 <lmpar+0x1f0>
mov    %rcx,%rsi
not    %rsi
add    0x40(%rsp),%rsi
imul   %r12,%rsi
mov    0x8(%rsp),%rbp
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
lea    (%rsi,%r11,8),%rbp
cmp    %r13,%rbp
jbe    13c5 <lmpar+0x285>
lea    0x0(,%r11,8),%rbp
add    %r13,%rbp
cmp    %rbp,%rsi
jae    13c5 <lmpar+0x285>
xor    %r10d,%r10d
mov    %r10,%rbp
test   $0x1,%r11b
je     1367 <lmpar+0x227>
add    %r10,%r9
movsd  0x0(%r13,%r10,8),%xmm1
mov    0x8(%rsp),%rsi
movsd  (%rsi,%r9,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%r10,8)
mov    %r10,%rbp
or     $0x1,%rbp
not    %r10
add    %r11,%r10
je     1290 <lmpar+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rbp,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rbp,8),%xmm1
movsd  %xmm2,0x0(%r13,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r8
jne    1380 <lmpar+0x240>
jmp    1290 <lmpar+0x150>
mov    %r8d,%ebp
and    $0xfffffffc,%ebp
mov    %r11d,%r10d
and    $0xfffffffc,%r10d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rdi,%rsi,8),%xmm2
movupd (%rdi,%rsi,8),%xmm3
movupd 0x0(%r13,%rsi,8),%xmm4
movupd 0x10(%r13,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%rsi,8)
movupd %xmm5,0x10(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    13e0 <lmpar+0x2a0>
cmp    %r11,%r10
je     1290 <lmpar+0x150>
jmp    1333 <lmpar+0x1f3>
mov    0x2c(%rsp),%r12d
test   %r12d,%r12d
mov    0x170(%rsp),%rbx
jle    16aa <lmpar+0x56a>
mov    0x18(%rsp),%rcx
cmp    $0x1,%ecx
jne    145f <lmpar+0x31f>
xor    %eax,%eax
mov    0x158(%rsp),%rsi
mov    0x20(%rsp),%rdi
jmp    14ac <lmpar+0x36c>
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x158(%rsp),%rsi
mov    0x20(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq (%rdi,%rax,4),%rdx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movslq 0x4(%rdi,%rax,4),%rdx
movsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1480 <lmpar+0x340>
testb  $0x1,0x18(%rsp)
je     14c4 <lmpar+0x384>
movslq (%rdi,%rax,4),%rcx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rcx,8)
test   %r12d,%r12d
jle    16aa <lmpar+0x56a>
cmp    $0x4,%r12d
jae    1577 <lmpar+0x437>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
mov    0x18(%rsp),%rdx
add    %rdx,%rcx
and    $0x3,%rdx
je     150a <lmpar+0x3ca>
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    14f0 <lmpar+0x3b0>
cmp    $0x3,%rcx
jb     16aa <lmpar+0x56a>
mov    0x18(%rsp),%rcx
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1520 <lmpar+0x3e0>
jmp    16aa <lmpar+0x56a>
mov    0x18(%rsp),%rdx
lea    (%rbx,%rdx,8),%rax
lea    (%r15,%rdx,8),%rcx
cmp    %rbx,%rcx
seta   %dil
lea    (%rsi,%rdx,8),%rcx
cmp    %r15,%rax
seta   %dl
cmp    %rbx,%rcx
seta   %cl
cmp    %rsi,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1655 <lmpar+0x515>
and    %sil,%cl
mov    0x158(%rsp),%rsi
jne    14d9 <lmpar+0x399>
mov    0x18(%rsp),%rax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1662 <lmpar+0x522>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    0x158(%rsp),%rdi
nop
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
movupd 0x30(%r15,%rcx,8),%xmm1
movupd 0x20(%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm0,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15f0 <lmpar+0x4b0>
jmp    166c <lmpar+0x52c>
mov    0x158(%rsp),%rsi
jmp    14d9 <lmpar+0x399>
xor    %ecx,%ecx
mov    0x158(%rsp),%rdi
test   $0x1,%dl
mov    %rdi,%rsi
je     169f <lmpar+0x55f>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rsi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
cmp    0x18(%rsp),%rax
jne    14d9 <lmpar+0x399>
mov    0x150(%rsp),%rbp
mov    %r12d,%edi
mov    %rbx,%rsi
call   1050 <enorm@plt>
movapd %xmm0,%xmm2
movsd  0x30(%rsp),%xmm3
subsd  %xmm3,%xmm2
movsd  0x192d(%rip),%xmm1
mulsd  %xmm3,%xmm1
ucomisd %xmm2,%xmm1
jae    172b <lmpar+0x5eb>
movsd  %xmm1,0xd8(%rsp)
xorpd  %xmm1,%xmm1
movslq 0x14(%rsp),%rax
mov    %rax,0x38(%rsp)
cmp    %r12d,%r14d
mov    0x18(%rsp),%r14
movsd  %xmm2,0x70(%rsp)
movsd  %xmm0,0x40(%rsp)
jl     190b <lmpar+0x7cb>
test   %r12d,%r12d
mov    0x14(%rsp),%r9d
jle    18ec <lmpar+0x7ac>
cmp    $0x1,%r12d
jne    1745 <lmpar+0x605>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
jmp    17a2 <lmpar+0x662>
movq   $0x0,0x0(%rbp)
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rsi,%rax,4),%rdx
movsd  -0x8(%rbx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rsi,%rax,4),%rdx
movsd  -0x8(%rbx,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1760 <lmpar+0x620>
test   $0x1,%r14b
je     17c4 <lmpar+0x684>
movslq (%rsi,%rax,4),%rcx
movsd  -0x8(%rbx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %r12d,%r12d
jle    18ec <lmpar+0x7ac>
mov    0x8(%rsp),%rsi
lea    0x18(%rsi),%rax
mov    0x38(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
xor    %ebp,%ebp
jmp    182f <lmpar+0x6ef>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  0x0(%r13,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
mov    %ebp,%ecx
imul   %r9d,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
mov    0x8(%rsp),%rdx
divsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    %r8,%rax
add    %r8,%rsi
cmp    %r14,%rbp
je     18ec <lmpar+0x7ac>
test   %rbp,%rbp
je     17f0 <lmpar+0x6b0>
lea    -0x1(%rbp),%rcx
cmp    $0x3,%rcx
jae    1850 <lmpar+0x710>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    18ac <lmpar+0x76c>
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   (%rax)
movsd  -0x18(%rax,%rdi,8),%xmm1
movsd  -0x10(%rax,%rdi,8),%xmm2
mulsd  0x0(%r13,%rdi,8),%xmm1
mulsd  0x8(%r13,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rax,%rdi,8),%xmm3
mulsd  0x10(%r13,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x18(%r13,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1860 <lmpar+0x720>
test   $0x3,%bpl
je     17f4 <lmpar+0x6b4>
mov    %ebp,%edx
and    $0x3,%edx
lea    0x0(,%rdi,8),%rbx
add    %r13,%rbx
lea    (%rsi,%rdi,8),%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    18d0 <lmpar+0x790>
jmp    17f4 <lmpar+0x6b4>
mov    %r12d,%edi
mov    %r13,%rsi
call   1050 <enorm@plt>
movsd  0x70(%rsp),%xmm1
divsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x80(%rsp)
test   %r12d,%r12d
mov    0x50(%rsp),%rbx
jle    1a2d <lmpar+0x8ed>
mov    0x8(%rsp),%r9
lea    0x18(%r9),%rax
mov    0x38(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
mov    $0x1,%r10d
xor    %esi,%esi
jmp    197e <lmpar+0x83e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
movslq (%rcx,%rsi,4),%rcx
divsd  -0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x1,%rsi
add    $0x1,%r10
add    %r8,%rax
add    %r8,%r9
cmp    %r14,%rsi
je     1a2d <lmpar+0x8ed>
cmp    $0x3,%rsi
jae    1990 <lmpar+0x850>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    19e7 <lmpar+0x8a7>
nopl   0x0(%rax)
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  -0x18(%rax,%rbp,8),%xmm1
movsd  -0x10(%rax,%rbp,8),%xmm2
mulsd  (%rbx,%rbp,8),%xmm1
mulsd  0x8(%rbx,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rax,%rbp,8),%xmm3
mulsd  0x10(%rbx,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%rbx,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    19a0 <lmpar+0x860>
test   $0x3,%r10b
je     1950 <lmpar+0x810>
mov    %r10d,%edx
and    $0x3,%edx
lea    (%rbx,%rbp,8),%rcx
lea    (%r9,%rbp,8),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1a10 <lmpar+0x8d0>
jmp    1950 <lmpar+0x810>
mov    %r12d,%edi
mov    %r13,%rsi
call   1050 <enorm@plt>
movapd %xmm0,%xmm5
movsd  0x30(%rsp),%xmm1
divsd  %xmm1,%xmm5
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm5
jne    1a67 <lmpar+0x927>
jp     1a67 <lmpar+0x927>
minsd  0x15a6(%rip),%xmm1
movapd 0xf0(%rsp),%xmm5
divsd  %xmm1,%xmm5
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x58(%rsp)
mov    0x150(%rsp),%rdx
movsd  (%rdx),%xmm1
movapd 0x80(%rsp),%xmm4
movapd %xmm4,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm4,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm3,%xmm1
cmplesd %xmm5,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm3,%xmm4
andnpd %xmm5,%xmm1
orpd   %xmm4,%xmm1
ucomisd %xmm2,%xmm1
mov    0x170(%rsp),%rdi
jne    1ad3 <lmpar+0x993>
jp     1ad3 <lmpar+0x993>
divsd  0x40(%rsp),%xmm0
movapd %xmm0,%xmm1
movslq %r12d,%rax
mov    %rax,0x40(%rsp)
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
mov    0x8(%rsp),%r9
lea    0x8(%r9),%rax
mov    %rax,0xb8(%rsp)
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x68(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x48(%rsp)
lea    (%rdi,%r14,8),%r10
lea    (%r15,%r14,8),%r11
mov    0x158(%rsp),%r8
lea    (%r8,%r14,8),%rbp
mov    %r14d,%ebx
and    $0xfffffffc,%ebx
mov    %rbx,0xa0(%rsp)
add    $0xfffffffffffffffc,%rbx
mov    %rbx,0x98(%rsp)
shr    $0x2,%rbx
add    $0x1,%rbx
lea    -0x1(%r14),%rax
mov    %rax,0x60(%rsp)
cmp    %r13,%r11
seta   %al
mov    %rsi,0xe0(%rsp)
cmp    %r15,%rsi
seta   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %rbx,%rsi
mov    %rbx,0x90(%rsp)
and    %rbx,0x58(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0xa8(%rsp)
cmp    %rdi,%r11
seta   %cl
cmp    %r15,%r10
seta   %bl
and    %cl,%bl
cmp    %rdi,%rbp
seta   %cl
cmp    %r8,%r10
seta   %al
and    %cl,%al
or     %bl,%al
mov    %al,0x6(%rsp)
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xd0(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
lea    0x18(%r9),%rax
mov    %rax,0xc8(%rsp)
xorpd  %xmm6,%xmm6
lea    0x18(%r13),%rax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
jmp    1cab <lmpar+0xb6b>
cs nopw 0x0(%rax,%rax,1)
mov    0x150(%rsp),%rdx
movsd  (%rdx),%xmm1
movapd %xmm1,%xmm2
movapd 0x80(%rsp),%xmm4
cmplesd %xmm4,%xmm2
andpd  %xmm2,%xmm4
andnpd %xmm1,%xmm2
orpd   %xmm2,%xmm4
movsd  0x30(%rsp),%xmm1
movapd 0x100(%rsp),%xmm5
movapd %xmm7,%xmm2
divsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
movsd  (%rdx),%xmm0
movapd %xmm5,%xmm1
cmplesd %xmm0,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm5,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm7,%xmm3
cmpltsd %xmm6,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm5,%xmm3
orpd   %xmm1,%xmm3
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm1
cmplesd %xmm4,%xmm1
movapd %xmm1,%xmm0
andnpd %xmm2,%xmm0
movapd %xmm4,0x80(%rsp)
andpd  %xmm4,%xmm1
orpd   %xmm0,%xmm1
movsd  %xmm7,0x70(%rsp)
movapd %xmm3,%xmm5
movapd %xmm5,%xmm0
mulsd  0x1351(%rip),%xmm0
movapd %xmm0,%xmm2
movapd 0xf0(%rsp),%xmm4
cmplesd %xmm4,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm4,%xmm3
andnpd %xmm0,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm1,%xmm0
cmpeqsd %xmm6,%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movlpd %xmm0,(%rdx)
ucomisd %xmm6,%xmm0
movapd %xmm5,0x100(%rsp)
jb     1d10 <lmpar+0xbd0>
sqrtsd %xmm0,%xmm0
jmp    1d15 <lmpar+0xbd5>
nopw   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
mov    0x50(%rsp),%r9
mov    0x170(%rsp),%rbx
mov    0x20(%rsp),%rcx
mov    0x160(%rsp),%rbp
test   %r12d,%r12d
jle    1d50 <lmpar+0xc10>
cmp    $0x4,%r12d
setb   %al
or     0x7(%rsp),%al
je     1d80 <lmpar+0xc40>
xor    %eax,%eax
jmp    1e32 <lmpar+0xcf2>
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    0x10(%rsp),%rsi
mov    0x1c(%rsp),%edx
mov    %r13,%r8
push   %rbx
push   %rbp
push   0x170(%rsp)
call   1030 <qrsolv@plt>
add    $0x20,%rsp
jmp    2080 <lmpar+0xf40>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x98(%rsp)
je     2422 <lmpar+0x12e2>
mov    0x58(%rsp),%rdx
xor    %eax,%eax
xchg   %ax,%ax
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm2
movupd 0x30(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm3,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1da0 <lmpar+0xc60>
testb  $0x1,0x90(%rsp)
01
je     1e1e <lmpar+0xcde>
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
mov    0xa0(%rsp),%rdx
mov    %rdx,%rax
cmp    %r14,%rdx
je     1ed0 <lmpar+0xd90>
mov    0x60(%rsp),%rsi
sub    %rax,%rsi
mov    0xa8(%rsp),%rdx
test   %rdx,%rdx
je     1e6b <lmpar+0xd2b>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e50 <lmpar+0xd10>
cmp    $0x3,%rsi
jb     1ed0 <lmpar+0xd90>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1e80 <lmpar+0xd40>
sub    $0x8,%rsp
mov    %r12d,%edi
mov    0x10(%rsp),%rsi
mov    0x1c(%rsp),%edx
mov    %r13,%r8
push   %rbx
push   %rbp
mov    0x170(%rsp),%rbp
push   %rbp
call   1030 <qrsolv@plt>
add    $0x20,%rsp
test   %r12d,%r12d
jle    2080 <lmpar+0xf40>
mov    %rbp,%rsi
cmp    $0x4,%r12d
setb   %al
or     0x6(%rsp),%al
je     1f17 <lmpar+0xdd7>
xor    %eax,%eax
jmp    1fdc <lmpar+0xe9c>
cmpq   $0x0,0x98(%rsp)
je     2437 <lmpar+0x12f7>
mov    0x58(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm0,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f30 <lmpar+0xdf0>
testb  $0x1,0x90(%rsp)
01
je     1fc8 <lmpar+0xe88>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
je     2080 <lmpar+0xf40>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
test   $0x3,%r14b
je     201a <lmpar+0xeda>
mov    0xa8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2000 <lmpar+0xec0>
cmp    $0x3,%rcx
jb     2080 <lmpar+0xf40>
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    2020 <lmpar+0xee0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%edi
mov    %rbx,%rsi
call   1050 <enorm@plt>
movapd %xmm0,%xmm3
subsd  0x30(%rsp),%xmm3
movapd %xmm3,%xmm1
andpd  0xf6f(%rip),%xmm1
movsd  0xd8(%rsp),%xmm2
ucomisd %xmm1,%xmm2
movapd 0x80(%rsp),%xmm1
mov    0x48(%rsp),%rbp
xorpd  %xmm2,%xmm2
mov    0xb0(%rsp),%rdx
jae    1733 <lmpar+0x5f3>
add    $0x1,%edx
ucomisd %xmm2,%xmm1
jne    20f5 <lmpar+0xfb5>
jp     20f5 <lmpar+0xfb5>
movsd  0x70(%rsp),%xmm1
ucomisd %xmm3,%xmm1
setae  %al
ucomisd %xmm1,%xmm2
seta   %cl
test   %al,%cl
jne    1733 <lmpar+0x5f3>
cmp    $0xa,%edx
je     1733 <lmpar+0x5f3>
movapd %xmm3,0x70(%rsp)
mov    %rdx,0xb0(%rsp)
test   %r12d,%r12d
mov    0x160(%rsp),%r11
jle    23c0 <lmpar+0x1280>
cmpq   $0x0,0x60(%rsp)
je     2400 <lmpar+0x12c0>
xor    %eax,%eax
mov    0x2c(%rsp),%edx
mov    0x170(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0xd0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    2150 <lmpar+0x1010>
test   $0x1,%r14b
je     21b4 <lmpar+0x1074>
movslq (%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %edx,%edx
jle    23c0 <lmpar+0x1280>
mov    $0x1,%r12d
mov    0xb8(%rsp),%rcx
mov    0xc0(%rsp),%rdx
mov    0xc8(%rsp),%rsi
mov    0x60(%rsp),%r10
xor    %r8d,%r8d
jmp    220d <lmpar+0x10cd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0xffffffffffffffff,%r10
add    %rbp,%rsi
add    $0x8,%rdx
add    0x68(%rsp),%rcx
cmp    %r14,%r8
je     23c0 <lmpar+0x1280>
mov    %r8,%rbx
movsd  0x0(%r13,%r8,8),%xmm0
divsd  (%r11,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%r8,8)
add    $0x1,%r8
cmp    0x40(%rsp),%r8
jge    21f0 <lmpar+0x10b0>
mov    %rbx,%rdi
not    %rdi
add    %r14,%rdi
mov    %rbx,%r9
imul   0x38(%rsp),%r9
mov    %r12,%rax
cmp    $0x4,%rdi
jb     2320 <lmpar+0x11e0>
lea    0x0(,%r12,8),%r11
add    %r13,%r11
lea    (%r9,%r14,1),%rax
mov    0x8(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x160(%rsp),%rbp
cmp    %rax,%r11
mov    %rbp,%r11
mov    0x48(%rsp),%rbp
jae    229f <lmpar+0x115f>
imul   %rbp,%rbx
add    0xb8(%rsp),%rbx
mov    %r12,%rax
cmp    0xe0(%rsp),%rbx
jb     2320 <lmpar+0x11e0>
mov    %r10,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rdi,%r11
and    $0xfffffffffffffffc,%r11
lea    (%r12,%r11,1),%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r14d,%r14d
nopl   0x0(%rax)
movupd -0x10(%rsi,%r14,8),%xmm2
movupd (%rsi,%r14,8),%xmm3
movupd -0x10(%rdx,%r14,8),%xmm4
movupd (%rdx,%r14,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdx,%r14,8)
movupd %xmm5,(%rdx,%r14,8)
add    $0x4,%r14
cmp    %r14,%rbx
jne    22c0 <lmpar+0x1180>
cmp    %r11,%rdi
mov    0x18(%rsp),%r14
mov    0x48(%rsp),%rbp
mov    0x160(%rsp),%r11
je     21f0 <lmpar+0x10b0>
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ebx
sub    %eax,%ebx
mov    %rax,%rdi
test   $0x1,%bl
je     2355 <lmpar+0x1215>
add    %rax,%r9
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x8(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rax),%rdi
not    %rax
cmp    0xe8(%rsp),%rax
je     21f0 <lmpar+0x10b0>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rdi,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rdi,8),%xmm1
movsd  %xmm2,0x0(%r13,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    2370 <lmpar+0x1230>
jmp    21f0 <lmpar+0x10b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x2c(%rsp),%r12d
mov    %r12d,%edi
mov    %r13,%rsi
call   1050 <enorm@plt>
xorpd  %xmm6,%xmm6
movapd 0x70(%rsp),%xmm7
ucomisd %xmm6,%xmm7
ja     1c00 <lmpar+0xac0>
movsd  0x30(%rsp),%xmm1
mov    0x150(%rsp),%rdx
movapd 0x80(%rsp),%xmm4
jmp    1c30 <lmpar+0xaf0>
xor    %eax,%eax
mov    0x2c(%rsp),%edx
mov    0x170(%rsp),%rsi
mov    0x20(%rsp),%rdi
test   $0x1,%r14b
jne    2198 <lmpar+0x1058>
jmp    21b4 <lmpar+0x1074>
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
jne    1dfb <lmpar+0xcbb>
jmp    1e1e <lmpar+0xcde>
xor    %eax,%eax
testb  $0x1,0x90(%rsp)
01
jne    1f9d <lmpar+0xe5d>
jmp    1fc8 <lmpar+0xe88>

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

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