#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 DBL_MIN;
double enorm_(int, double *);
double const fabs(double);
int /*<<< orphan*/ qrsolv_(int, double *, int, int *, double *, double *,
                           double *, double *, double *);
double sqrt(double);
int lmpar_(int n, double *r, int ldr, int *ipvt, double *diag, double *qtb,
           double delta, double *par, double *x, double *sdiag, double *wa1,
           double *wa2) {
  const double p1 = .1;
  const double p001 = .001;
  double fp, sum, parc, parl;
  double temp, paru, dwarf;
  double d, gnorm, dxnorm;
  int iter, nsing;
  int i, j, k, l;
  dwarf = DBL_MIN;
  nsing = n;
  for (j = 0; j < n; ++j) {
    wa1[j] = qtb[j];
    if (r[j + j * ldr] == 0.0 && nsing == n) {
      nsing = j;
    }
    if (nsing < n) {
      wa1[j] = 0.0;
    }
  }
  if (nsing > 0) {
    for (k = 0; k < nsing; ++k) {
      j = nsing - k - 1;
      wa1[j] /= r[j + j * ldr];
      temp = wa1[j];
      for (i = 0; i < j; ++i) {
        wa1[i] -= r[i + j * ldr] * temp;
      }
    }
  }
  for (j = 0; j < n; ++j) {
    l = ipvt[j];
    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 <= p1 * delta) {
    *par = 0.0;
    return 0;
  }
  parl = 0.0;
  if (nsing >= n) {
    for (j = 0; j < n; ++j) {
      l = ipvt[j];
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      sum = 0.0;
      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) {
    sum = 0.0;
    for (i = 0; i <= j; ++i) {
      sum += r[i + j * ldr] * qtb[i];
    }
    l = ipvt[j];
    wa1[j] = sum / diag[l];
  }
  gnorm = enorm_(n, wa1);
  paru = gnorm / delta;
  if (paru == 0.0) {
    paru = dwarf / ((delta) <= (p1) ? (delta) : (p1));
  }
  *par = ((*par) >= (parl) ? (*par) : (parl));
  *par = ((*par) <= (paru) ? (*par) : (paru));
  if (*par == 0.0) {
    *par = gnorm / dxnorm;
  }
  while (1) {
    ++iter;
    if (*par == 0.0) {
      d = p001 * paru;
      *par = ((dwarf) >= (d) ? (dwarf) : (d));
    }
    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) <= p1 * delta || (parl == 0.0 && fp <= temp && temp < 0.0) ||
        iter == 10) {
      break;
    }
    for (j = 0; j < n; ++j) {
      l = ipvt[j];
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      wa1[j] /= sdiag[j];
      temp = wa1[j];
      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.0) {
      parl = ((parl) >= (*par) ? (parl) : (*par));
    } else if (fp < 0.0) {
      paru = ((paru) <= (*par) ? (paru) : (*par));
    }
    d = *par + parc;
    *par = ((parl) >= (d) ? (parl) : (d));
  }
  if (iter == 0) {
    *par = 0.0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<lmpar_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%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)
movsd  0xe86(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe71(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x2e45(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xa0(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    126d <lmpar_+0x12d>
mov    -0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1232 <lmpar_+0xf2>
jp     1232 <lmpar_+0xf2>
mov    -0xa0(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1232 <lmpar_+0xf2>
mov    -0xa8(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1254 <lmpar_+0x114>
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1259 <lmpar_+0x119>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    11b7 <lmpar_+0x77>
cmpl   $0x0,-0xa0(%rbp)
jle    139c <lmpar_+0x25c>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1397 <lmpar_+0x257>
mov    -0xa0(%rbp),%eax
sub    -0xac(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    137e <lmpar_+0x23e>
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xa4(%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    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1301 <lmpar_+0x1c1>
jmp    1383 <lmpar_+0x243>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1284 <lmpar_+0x144>
jmp    139c <lmpar_+0x25c>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13fd <lmpar_+0x2bd>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    13a6 <lmpar_+0x266>
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1464 <lmpar_+0x324>
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1411 <lmpar_+0x2d1>
mov    -0x8(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1040 <enorm_@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  0xb71(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     14bd <lmpar_+0x37d>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1d8f <lmpar_+0xc4f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1663 <lmpar_+0x523>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1551 <lmpar_+0x411>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    14de <lmpar_+0x39e>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1639 <lmpar_+0x4f9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jge    15e2 <lmpar_+0x4a2>
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    157c <lmpar_+0x43c>
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    155b <lmpar_+0x41b>
mov    -0x8(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <enorm_@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1741 <lmpar_+0x601>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     16f4 <lmpar_+0x5b4>
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    168e <lmpar_+0x54e>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    166d <lmpar_+0x52d>
mov    -0x8(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <enorm_@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17df <lmpar_+0x69f>
jp     17df <lmpar_+0x69f>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0x874(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jb     17b1 <lmpar_+0x671>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    17c6 <lmpar_+0x686>
movsd  0x84f(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    17c6 <lmpar_+0x686>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     1807 <lmpar_+0x6c7>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1814 <lmpar_+0x6d4>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1850 <lmpar_+0x710>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    185d <lmpar_+0x71d>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18a0 <lmpar_+0x760>
jp     18a0 <lmpar_+0x760>
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    18a5 <lmpar_+0x765>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1929 <lmpar_+0x7e9>
jp     1929 <lmpar_+0x7e9>
movsd  0x729(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1909 <lmpar_+0x7c9>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1919 <lmpar_+0x7d9>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    198d <lmpar_+0x84d>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1945 <lmpar_+0x805>
mov    -0x8(%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   1050 <qrsolv_@plt>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a1f <lmpar_+0x8df>
mov    -0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    19cc <lmpar_+0x88c>
mov    -0x8(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1040 <enorm_@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x5a4(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    1aba <lmpar_+0x97a>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1aad <lmpar_+0x96d>
jp     1aad <lmpar_+0x96d>
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1aad <lmpar_+0x96d>
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
ja     1aba <lmpar_+0x97a>
cmpl   $0xa,-0x9c(%rbp)
jne    1abf <lmpar_+0x97f>
jmp    1d70 <lmpar_+0xc30>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b3c <lmpar_+0x9fc>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1ac9 <lmpar_+0x989>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c35 <lmpar_+0xaf5>
mov    0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c1c <lmpar_+0xadc>
mov    -0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xa4(%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    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1ba2 <lmpar_+0xa62>
jmp    1c21 <lmpar_+0xae1>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1b46 <lmpar_+0xa06>
mov    -0x8(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <enorm_@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1cb8 <lmpar_+0xb78>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1c96 <lmpar_+0xb56>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1ca6 <lmpar_+0xb66>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
jmp    1d11 <lmpar_+0xbd1>
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1d0c <lmpar_+0xbcc>
movsd  -0x78(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1cef <lmpar_+0xbaf>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1cff <lmpar_+0xbbf>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1d11 <lmpar_+0xbd1>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1d4b <lmpar_+0xc0b>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1d5b <lmpar_+0xc1b>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    18a5 <lmpar_+0x765>
cmpl   $0x0,-0x9c(%rbp)
jne    1d88 <lmpar_+0xc48>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmpar_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movsd  %xmm0,0x30(%rsp)
mov    %r8,%r15
mov    %edi,%ebp
mov    0x180(%rsp),%r14
mov    0x178(%rsp),%r13
mov    0x3e7d(%rip),%rax
movsd  (%rax),%xmm0
movapd %xmm0,0x110(%rsp)
mov    %edi,%r11d
mov    %edi,%r12d
test   %edi,%edi
mov    %r9,0x58(%rsp)
mov    %edx,0x2c(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r11,0x10(%rsp)
mov    %rcx,0x20(%rsp)
mov    %edi,0x8(%rsp)
jle    16b8 <lmpar_+0x588>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    %ebp,%r12d
mov    0x8(%rsp),%r8d
jmp    11bb <lmpar_+0x8b>
nopl   0x0(%rax)
add    $0x1,%rbx
add    %edx,%eax
cmp    %rbx,%r11
je     11f8 <lmpar_+0xc8>
mov    %r12d,%edi
movslq %eax,%rbp
movsd  (%r9,%rbx,8),%xmm1
add    %rbx,%rbp
cmp    %r8d,%r12d
mov    %ebx,%r12d
cmovne %edi,%r12d
movsd  %xmm1,0x0(%r13,%rbx,8)
ucomisd (%rsi,%rbp,8),%xmm0
cmovne %edi,%r12d
cmovp  %edi,%r12d
cmp    %r8d,%r12d
jge    11b0 <lmpar_+0x80>
movq   $0x0,0x0(%r13,%rbx,8)
jmp    11b0 <lmpar_+0x80>
test   %r12d,%r12d
jle    13ee <lmpar_+0x2be>
mov    %r12d,%eax
mov    %rax,0x48(%rsp)
lea    -0x1(%r12),%eax
lea    0x10(%rsi),%rcx
mov    %rcx,0x70(%rsp)
mov    %edx,%r14d
imul   %eax,%r14d
lea    0x8(%rsi),%rcx
mov    %rcx,0x40(%rsp)
xor    %ebp,%ebp
mov    %eax,0x38(%rsp)
mov    %eax,%r10d
jmp    1256 <lmpar_+0x126>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
sub    %edx,%r14d
add    $0xffffffff,%r10d
cmp    0x48(%rsp),%rbp
je     13ee <lmpar_+0x2be>
mov    %r10d,%r10d
mov    %ebp,%ecx
not    %ecx
add    %r12d,%ecx
mov    %ecx,%eax
imul   %edx,%eax
lea    (%rax,%rcx,1),%edi
movslq %edi,%rdi
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
divsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
test   %ecx,%ecx
jle    1240 <lmpar_+0x110>
movslq %r14d,%rbx
mov    0x38(%rsp),%ecx
mov    %ecx,%r9d
sub    %ebp,%r9d
cmp    $0x4,%r9d
mov    %rbx,0x78(%rsp)
jb     12cf <lmpar_+0x19f>
mov    %r9d,%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
lea    (%rcx,%r9,1),%rdi
lea    (%rsi,%rdi,8),%rdi
cmp    %r13,%rdi
jbe    1365 <lmpar_+0x235>
lea    0x0(,%r9,8),%rdi
add    %r13,%rdi
lea    (%rsi,%rcx,8),%rcx
cmp    %rdi,%rcx
jae    1365 <lmpar_+0x235>
xor    %r8d,%r8d
mov    %r8,%rcx
test   $0x1,%r9b
je     1302 <lmpar_+0x1d2>
cltq
add    %r8,%rax
movsd  0x0(%r13,%r8,8),%xmm1
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%r8,8)
mov    %r8,%rcx
or     $0x1,%rcx
not    %r8
add    %r9,%r8
je     1240 <lmpar_+0x110>
mov    0x40(%rsp),%rax
mov    0x78(%rsp),%rdi
lea    (%rax,%rdi,8),%rax
nopl   0x0(%rax)
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rcx,8),%xmm1
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1320 <lmpar_+0x1f0>
jmp    1240 <lmpar_+0x110>
mov    0x70(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
mov    %r10d,%edi
and    $0xfffffffc,%edi
mov    %r9d,%r8d
and    $0xfffffffc,%r8d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%r11,8),%xmm2
movupd (%rcx,%r11,8),%xmm3
movupd 0x0(%r13,%r11,8),%xmm4
movupd 0x10(%r13,%r11,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%r11,8)
movupd %xmm5,0x10(%r13,%r11,8)
add    $0x4,%r11
cmp    %r11,%rdi
jne    1390 <lmpar_+0x260>
cmp    %r9,%r8
mov    0x2c(%rsp),%edx
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%r11
je     1240 <lmpar_+0x110>
jmp    12d2 <lmpar_+0x1a2>
cmpl   $0x0,0x8(%rsp)
jle    1421 <lmpar_+0x2f1>
lea    -0x1(%r11),%rcx
mov    %r11d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    142e <lmpar_+0x2fe>
xor    %edi,%edi
mov    0x180(%rsp),%r14
mov    0x168(%rsp),%rbp
mov    0x20(%rsp),%rcx
jmp    14a0 <lmpar_+0x370>
mov    0x180(%rsp),%r14
jmp    16b4 <lmpar_+0x584>
mov    %r11d,%edx
and    $0xfffffffc,%edx
xor    %edi,%edi
mov    0x180(%rsp),%r14
mov    0x168(%rsp),%rbp
mov    0x20(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movslq (%rcx,%rdi,4),%rsi
movsd  0x0(%r13,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
movslq 0x4(%rcx,%rdi,4),%rsi
movsd  0x8(%r13,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
movslq 0x8(%rcx,%rdi,4),%rsi
movsd  0x10(%r13,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
movslq 0xc(%rcx,%rdi,4),%rsi
movsd  0x18(%r13,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1450 <lmpar_+0x320>
test   %rax,%rax
je     14d8 <lmpar_+0x3a8>
lea    0x0(,%rdi,8),%rdx
add    %r13,%rdx
lea    (%rcx,%rdi,4),%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movslq (%rbx,%rsi,4),%rdi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    14c0 <lmpar_+0x390>
cmpl   $0x0,0x8(%rsp)
jle    16b4 <lmpar_+0x584>
cmp    $0x4,%r11d
jae    159c <lmpar_+0x46c>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r11,%rsi
mov    %r11,%rdx
and    $0x3,%rdx
je     152c <lmpar_+0x3fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1510 <lmpar_+0x3e0>
cmp    $0x3,%rsi
jb     16b4 <lmpar_+0x584>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1540 <lmpar_+0x410>
jmp    16b4 <lmpar_+0x584>
lea    (%r14,%r11,8),%rax
lea    (%r15,%r11,8),%rdx
cmp    %r14,%rdx
seta   %dil
lea    0x0(,%r11,8),%rsi
add    %rbp,%rsi
cmp    %r15,%rax
seta   %dl
cmp    %r14,%rsi
seta   %bl
cmp    %rbp,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    14ef <lmpar_+0x3bf>
and    %sil,%bl
jne    14ef <lmpar_+0x3bf>
mov    %r11d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     24c9 <lmpar_+0x1399>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rdi,8),%xmm0
movupd 0x10(%r15,%rdi,8),%xmm1
movupd 0x0(%rbp,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdi,8)
movupd %xmm0,0x10(%r14,%rdi,8)
movupd 0x20(%r15,%rdi,8),%xmm0
movupd 0x30(%r15,%rdi,8),%xmm1
movupd 0x20(%rbp,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbp,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rdi,8)
movupd %xmm0,0x30(%r14,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1610 <lmpar_+0x4e0>
test   $0x1,%dl
je     16ab <lmpar_+0x57b>
movupd (%r15,%rdi,8),%xmm0
movupd 0x10(%r15,%rdi,8),%xmm1
movupd 0x0(%rbp,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdi,8)
movupd %xmm0,0x10(%r14,%rdi,8)
cmp    %r11,%rax
jne    14ef <lmpar_+0x3bf>
mov    0x8(%rsp),%ebp
mov    0x160(%rsp),%rbx
mov    %ebp,%edi
mov    %r14,%rsi
call   1030 <enorm_@plt>
movapd %xmm0,%xmm2
movsd  0x30(%rsp),%xmm3
subsd  %xmm3,%xmm2
movsd  0x1920(%rip),%xmm1
mulsd  %xmm3,%xmm1
ucomisd %xmm2,%xmm1
jae    1741 <lmpar_+0x611>
movsd  %xmm1,0x100(%rsp)
xorpd  %xmm1,%xmm1
mov    0x2c(%rsp),%r9d
movslq %r9d,%rax
mov    %rax,0x38(%rsp)
cmp    %ebp,%r12d
mov    %ebp,%r12d
movsd  %xmm2,0x90(%rsp)
movsd  %xmm0,0x48(%rsp)
jl     191e <lmpar_+0x7ee>
test   %r12d,%r12d
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%r11
jle    18fc <lmpar_+0x7cc>
cmp    $0x1,%r12d
jne    175c <lmpar_+0x62c>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
jmp    17b0 <lmpar_+0x680>
movq   $0x0,(%rbx)
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r11d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
nopl   0x0(%rax)
movslq (%rsi,%rax,4),%rdx
movsd  (%r14,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rsi,%rax,4),%rdx
movsd  (%r14,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1770 <lmpar_+0x640>
test   $0x1,%r11b
je     17d1 <lmpar_+0x6a1>
movslq (%rsi,%rax,4),%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %r12d,%r12d
jle    18fc <lmpar_+0x7cc>
lea    0x18(%r10),%rax
mov    0x38(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
xor    %ebp,%ebp
mov    %r10,%rsi
jmp    183b <lmpar_+0x70b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
movsd  0x0(%r13,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
mov    %ebp,%ecx
imul   %r9d,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
divsd  (%r10,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    %r8,%rax
add    %r8,%rsi
cmp    %r11,%rbp
je     18fc <lmpar_+0x7cc>
test   %rbp,%rbp
je     1800 <lmpar_+0x6d0>
lea    -0x1(%rbp),%rcx
cmp    $0x3,%rcx
jae    1860 <lmpar_+0x730>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    18bc <lmpar_+0x78c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    1870 <lmpar_+0x740>
test   $0x3,%bpl
je     1804 <lmpar_+0x6d4>
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    18e0 <lmpar_+0x7b0>
jmp    1804 <lmpar_+0x6d4>
mov    %r12d,%edi
mov    %r13,%rsi
call   1030 <enorm_@plt>
movsd  0x90(%rsp),%xmm1
divsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x80(%rsp)
test   %r12d,%r12d
mov    0x58(%rsp),%rbx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r11
jle    1a3d <lmpar_+0x90d>
lea    0x18(%r9),%rax
mov    0x38(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
mov    $0x1,%r10d
xor    %esi,%esi
jmp    198d <lmpar_+0x85d>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
movslq (%rcx,%rsi,4),%rcx
divsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x1,%rsi
add    $0x1,%r10
add    %r8,%rax
add    %r8,%r9
cmp    %r11,%rsi
je     1a3d <lmpar_+0x90d>
cmp    $0x3,%rsi
jae    19a0 <lmpar_+0x870>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    19f7 <lmpar_+0x8c7>
nopl   0x0(%rax,%rax,1)
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    19b0 <lmpar_+0x880>
test   $0x3,%r10b
je     1960 <lmpar_+0x830>
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    1a20 <lmpar_+0x8f0>
jmp    1960 <lmpar_+0x830>
mov    %r12d,%edi
mov    %r13,%rsi
call   1030 <enorm_@plt>
movapd %xmm0,%xmm5
movsd  0x30(%rsp),%xmm1
divsd  %xmm1,%xmm5
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm5
jne    1a77 <lmpar_+0x947>
jp     1a77 <lmpar_+0x947>
minsd  0x1596(%rip),%xmm1
movapd 0x110(%rsp),%xmm5
divsd  %xmm1,%xmm5
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x50(%rsp)
mov    0x160(%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    0x168(%rsp),%r10
jne    1ae3 <lmpar_+0x9b3>
jp     1ae3 <lmpar_+0x9b3>
divsd  0x48(%rsp),%xmm0
movapd %xmm0,%xmm1
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbp
movslq %r12d,%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rbp,8),%r9
add    %r13,%r9
lea    0x8(%rsi),%rax
mov    %rax,0xc8(%rsp)
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x78(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x40(%rsp)
lea    (%r14,%rbp,8),%r11
lea    (%r15,%rbp,8),%rcx
lea    (%r10,%rbp,8),%r8
mov    %ebp,%edi
and    $0xfffffffc,%edi
mov    %rdi,0xb8(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0xb0(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
lea    -0x1(%rbp),%rbx
mov    %rbx,0x68(%rsp)
cmp    %r13,%rcx
seta   %bl
mov    %r9,0x108(%rsp)
cmp    %r15,%r9
seta   %al
and    %bl,%al
mov    %al,0xf(%rsp)
mov    %rdi,%rbx
mov    %rdi,0xa8(%rsp)
and    %rdi,0x50(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x60(%rsp)
cmp    %r14,%rcx
seta   %cl
cmp    %r15,%r11
seta   %bl
and    %cl,%bl
cmp    %r14,%r8
seta   %cl
cmp    %r10,%r11
seta   %al
and    %cl,%al
or     %bl,%al
mov    %al,0xe(%rsp)
mov    %ebp,%eax
and    $0xfffffffe,%eax
mov    %rax,0xf8(%rsp)
neg    %rbp
mov    %rbp,0x70(%rsp)
lea    0x18(%rsi),%rax
mov    %rax,0xf0(%rsp)
xorpd  %xmm6,%xmm6
lea    0x18(%r13),%rax
mov    %rax,0xe8(%rsp)
xor    %eax,%eax
mov    %rax,0xc0(%rsp)
jmp    1c85 <lmpar_+0xb55>
nopw   0x0(%rax,%rax,1)
mov    0x160(%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),%xmm3
mov    0x18(%rsp),%rsi
mov    0x168(%rsp),%r10
movapd 0xd0(%rsp),%xmm5
movapd %xmm7,%xmm2
divsd  %xmm3,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm1,%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,0x90(%rsp)
movapd %xmm5,%xmm0
mulsd  0x1377(%rip),%xmm0
movapd %xmm0,%xmm2
movapd 0x110(%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,0xd0(%rsp)
jb     1cf0 <lmpar_+0xbc0>
sqrtsd %xmm0,%xmm0
jmp    1d02 <lmpar_+0xbd2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
mov    0x168(%rsp),%r10
mov    0x18(%rsp),%rsi
mov    0x58(%rsp),%r9
mov    0x2c(%rsp),%edx
mov    0x20(%rsp),%rcx
mov    0x60(%rsp),%r8
test   %r12d,%r12d
jle    1d40 <lmpar_+0xc10>
cmp    $0x4,%r12d
setb   %al
or     0xf(%rsp),%al
je     1d70 <lmpar_+0xc40>
xor    %eax,%eax
mov    0x10(%rsp),%rbx
jmp    1e32 <lmpar_+0xd02>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %r13,%r8
push   %r14
push   0x180(%rsp)
push   %r10
call   1040 <qrsolv_@plt>
add    $0x20,%rsp
jmp    2090 <lmpar_+0xf60>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xb0(%rsp)
je     249a <lmpar_+0x136a>
mov    0x50(%rsp),%rdi
xor    %eax,%eax
mov    0x10(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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,%rdi
jne    1da0 <lmpar_+0xc70>
testb  $0x1,0xa8(%rsp)
01
je     1e1e <lmpar_+0xcee>
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    0xb8(%rsp),%rdi
mov    %rdi,%rax
cmp    %rbx,%rdi
je     1ed0 <lmpar_+0xda0>
mov    0x68(%rsp),%rbp
sub    %rax,%rbp
test   %r8,%r8
je     1e6b <lmpar_+0xd3b>
mov    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1e50 <lmpar_+0xd20>
cmp    $0x3,%rbp
jb     1ed0 <lmpar_+0xda0>
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,%rbx
jne    1e80 <lmpar_+0xd50>
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %r13,%r8
push   %r14
push   0x180(%rsp)
push   %r10
call   1040 <qrsolv_@plt>
mov    0x30(%rsp),%rdi
mov    0x188(%rsp),%rsi
add    $0x20,%rsp
test   %r12d,%r12d
jle    2090 <lmpar_+0xf60>
cmp    $0x4,%r12d
setb   %al
or     0xe(%rsp),%al
je     1f18 <lmpar_+0xde8>
xor    %eax,%eax
jmp    1fe2 <lmpar_+0xeb2>
cmpq   $0x0,0xb0(%rsp)
je     24b4 <lmpar_+0x1384>
mov    0x50(%rsp),%rcx
xor    %eax,%eax
xchg   %ax,%ax
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,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%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(%r14,%rax,8)
movupd %xmm0,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f30 <lmpar_+0xe00>
testb  $0x1,0xa8(%rsp)
01
je     1fce <lmpar_+0xe9e>
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,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     2090 <lmpar_+0xf60>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   $0x3,%dil
je     201b <lmpar_+0xeeb>
mov    0x60(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2000 <lmpar_+0xed0>
cmp    $0x3,%rcx
jb     2090 <lmpar_+0xf60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    2030 <lmpar_+0xf00>
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%edi
mov    %r14,%rsi
call   1030 <enorm_@plt>
movapd %xmm0,%xmm3
subsd  0x30(%rsp),%xmm3
movapd %xmm3,%xmm1
andpd  0xf5f(%rip),%xmm1
movsd  0x100(%rsp),%xmm2
ucomisd %xmm1,%xmm2
movapd 0x80(%rsp),%xmm1
mov    0x40(%rsp),%r11
xorpd  %xmm2,%xmm2
mov    0xc0(%rsp),%rdx
jae    1748 <lmpar_+0x618>
add    $0x1,%edx
ucomisd %xmm2,%xmm1
jne    2108 <lmpar_+0xfd8>
jp     2108 <lmpar_+0xfd8>
movsd  0x90(%rsp),%xmm1
ucomisd %xmm3,%xmm1
setae  %al
ucomisd %xmm1,%xmm2
seta   %cl
test   %al,%cl
jne    1748 <lmpar_+0x618>
cmp    $0xa,%edx
je     1748 <lmpar_+0x618>
movapd %xmm3,0x90(%rsp)
mov    %rdx,0xc0(%rsp)
test   %r12d,%r12d
mov    0x10(%rsp),%rbp
jle    23d0 <lmpar_+0x12a0>
cmpq   $0x0,0x68(%rsp)
je     2480 <lmpar_+0x1350>
xor    %eax,%eax
mov    0x8(%rsp),%edx
mov    0x20(%rsp),%rsi
mov    0xf8(%rsp),%rdi
nop
movslq (%rsi,%rax,4),%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rsi,%rax,4),%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    2150 <lmpar_+0x1020>
test   $0x1,%bpl
je     21b1 <lmpar_+0x1081>
movslq (%rsi,%rax,4),%rcx
movsd  (%r14,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %edx,%edx
jle    23d0 <lmpar_+0x12a0>
mov    $0x1,%r12d
mov    0xc8(%rsp),%rcx
mov    0xe8(%rsp),%rdx
mov    0xf0(%rsp),%rsi
mov    0x68(%rsp),%r10
xor    %r8d,%r8d
jmp    220d <lmpar_+0x10dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0xffffffffffffffff,%r10
add    %r11,%rsi
add    $0x8,%rdx
add    0x78(%rsp),%rcx
cmp    %rbp,%r8
je     23d0 <lmpar_+0x12a0>
mov    %r8,%rbx
movsd  0x0(%r13,%r8,8),%xmm0
mov    0x170(%rsp),%rax
divsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%r8,8)
add    $0x1,%r8
cmp    0x48(%rsp),%r8
jge    21f0 <lmpar_+0x10c0>
mov    %rbx,%rdi
not    %rdi
add    %rbp,%rdi
mov    %rbx,%r9
imul   0x38(%rsp),%r9
mov    %r12,%rax
cmp    $0x4,%rdi
jb     2330 <lmpar_+0x1200>
lea    0x0(,%r12,8),%r11
add    %r13,%r11
mov    0x10(%rsp),%rax
add    %r9,%rax
mov    0x18(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rax,%r11
mov    0x40(%rsp),%r11
mov    0x10(%rsp),%rbp
jae    22a5 <lmpar_+0x1175>
imul   %r11,%rbx
add    0xc8(%rsp),%rbx
mov    %r12,%rax
cmp    0x108(%rsp),%rbx
jb     2330 <lmpar_+0x1200>
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
cs nopw 0x0(%rax,%rax,1)
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    22d0 <lmpar_+0x11a0>
cmp    %r11,%rdi
mov    0x180(%rsp),%r14
mov    0x10(%rsp),%rbp
mov    0x40(%rsp),%r11
je     21f0 <lmpar_+0x10c0>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%ebx
sub    %eax,%ebx
mov    %rax,%rdi
test   $0x1,%bl
je     2364 <lmpar_+0x1234>
add    %rax,%r9
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x18(%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    0x70(%rsp),%rax
je     21f0 <lmpar_+0x10c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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,%rbp
jne    2380 <lmpar_+0x1250>
jmp    21f0 <lmpar_+0x10c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%r12d
mov    %r12d,%edi
mov    %r13,%rsi
call   1030 <enorm_@plt>
xorpd  %xmm6,%xmm6
movapd 0x90(%rsp),%xmm7
ucomisd %xmm6,%xmm7
ja     1c00 <lmpar_+0xad0>
ucomisd %xmm7,%xmm6
mov    0x160(%rsp),%rdx
movsd  (%rdx),%xmm1
jbe    2450 <lmpar_+0x1320>
movapd 0xd0(%rsp),%xmm5
movapd %xmm5,%xmm2
cmplesd %xmm1,%xmm2
andpd  %xmm2,%xmm5
andnpd %xmm1,%xmm2
orpd   %xmm2,%xmm5
movsd  0x30(%rsp),%xmm3
mov    0x18(%rsp),%rsi
mov    0x168(%rsp),%r10
movapd 0x80(%rsp),%xmm4
jmp    1c46 <lmpar_+0xb16>
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp),%xmm3
mov    0x18(%rsp),%rsi
mov    0x168(%rsp),%r10
movapd 0x80(%rsp),%xmm4
jmp    1c3d <lmpar_+0xb0d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x8(%rsp),%edx
mov    0x20(%rsp),%rsi
test   $0x1,%bpl
jne    2196 <lmpar_+0x1066>
jmp    21b1 <lmpar_+0x1081>
xor    %eax,%eax
mov    0x10(%rsp),%rbx
testb  $0x1,0xa8(%rsp)
01
jne    1dfb <lmpar_+0xccb>
jmp    1e1e <lmpar_+0xcee>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    1fa1 <lmpar_+0xe71>
jmp    1fce <lmpar_+0xe9e>
xor    %edi,%edi
test   $0x1,%dl
jne    167d <lmpar_+0x54d>
jmp    16ab <lmpar_+0x57b>

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

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