#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 fabs(double);
double lm_enorm(int const, double *const);
int /*<<< orphan*/ lm_qrsolv(int const, double *const, int const, int *const,
                             double *const, double *const, double *const,
                             double *const, double *const);
double sqrt(double);
void lm_lmpar(const int n, double *const r, const int ldr, int *const ipvt,
              double *const diag, double *const qtb, double delta,
              double *const par, double *const x, double *const sdiag,
              double *const aux, double *const xdi) {
  int i, iter, j, nsing;
  double dxnorm, fp, fp_old, gnorm, parc, parl, paru;
  double sum, temp;
  static double p1 = 0.1;
  nsing = n;
  for (j = 0; j < n; j++) {
    aux[j] = qtb[j];
    if (r[j * ldr + j] == 0 && nsing == n)
      nsing = j;
    if (nsing < n)
      aux[j] = 0;
  }
  for (j = nsing - 1; j >= 0; j--) {
    aux[j] = aux[j] / r[j + ldr * j];
    temp = aux[j];
    for (i = 0; i < j; i++)
      aux[i] -= r[j * ldr + i] * temp;
  }
  for (j = 0; j < n; j++)
    x[ipvt[j]] = aux[j];
  for (j = 0; j < n; j++)
    xdi[j] = diag[j] * x[j];
  dxnorm = lm_enorm(n, xdi);
  fp = dxnorm - delta;
  if (fp <= p1 * delta) {
    *par = 0;
    return;
  }
  parl = 0;
  if (nsing >= n) {
    for (j = 0; j < n; j++)
      aux[j] = diag[ipvt[j]] * xdi[ipvt[j]] / dxnorm;
    for (j = 0; j < n; j++) {
      sum = 0;
      for (i = 0; i < j; i++)
        sum += r[j * ldr + i] * aux[i];
      aux[j] = (aux[j] - sum) / r[j + ldr * j];
    }
    temp = lm_enorm(n, aux);
    parl = fp / delta / temp / temp;
  }
  for (j = 0; j < n; j++) {
    sum = 0;
    for (i = 0; i <= j; i++)
      sum += r[j * ldr + i] * qtb[i];
    aux[j] = sum / diag[ipvt[j]];
  }
  gnorm = lm_enorm(n, aux);
  paru = gnorm / delta;
  if (paru == 0)
    paru = DBL_MIN / (((delta) <= (p1)) ? (delta) : (p1));
  *par = (((*par) >= (parl)) ? (*par) : (parl));
  *par = (((*par) <= (paru)) ? (*par) : (paru));
  if (*par == 0)
    *par = gnorm / dxnorm;
  for (iter = 0;; iter++) {
    if (*par == 0)
      *par = (((DBL_MIN) >= (0.001 * paru)) ? (DBL_MIN) : (0.001 * paru));
    temp = sqrt(*par);
    for (j = 0; j < n; j++)
      aux[j] = temp * diag[j];
    lm_qrsolv(n, r, ldr, ipvt, aux, qtb, x, sdiag, xdi);
    for (j = 0; j < n; j++)
      xdi[j] = diag[j] * x[j];
    dxnorm = lm_enorm(n, xdi);
    fp_old = fp;
    fp = dxnorm - delta;
    if (fabs(fp) <= p1 * delta || (parl == 0 && fp <= fp_old && fp_old < 0) ||
        iter == 10) {
      break;
    }
    for (j = 0; j < n; j++)
      aux[j] = diag[ipvt[j]] * xdi[ipvt[j]] / dxnorm;
    for (j = 0; j < n; j++) {
      aux[j] = aux[j] / sdiag[j];
      for (i = j + 1; i < n; i++)
        aux[i] -= r[j * ldr + i] * aux[j];
    }
    temp = lm_enorm(n, aux);
    parc = fp / delta / temp / temp;
    if (fp > 0)
      parl = (((parl) >= (*par)) ? (parl) : (*par));
    else if (fp < 0)
      paru = (((paru) <= (*par)) ? (paru) : (*par));
    *par = (((parl) >= (*par + parc)) ? (parl) : (*par + parc));
  }
}


x86 assembly (clang, -O0):
<lm_lmpar>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1207 <lm_lmpar+0xd7>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11d8 <lm_lmpar+0xa8>
jp     11d8 <lm_lmpar+0xa8>
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    11d8 <lm_lmpar+0xa8>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f4 <lm_lmpar+0xc4>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    11f9 <lm_lmpar+0xc9>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1177 <lm_lmpar+0x47>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     12e4 <lm_lmpar+0x1b4>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12d1 <lm_lmpar+0x1a1>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    0x28(%rbp),%rax
movslq -0x3c(%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    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1268 <lm_lmpar+0x138>
jmp    12d6 <lm_lmpar+0x1a6>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1210 <lm_lmpar+0xe0>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1327 <lm_lmpar+0x1f7>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12eb <lm_lmpar+0x1bb>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    136f <lm_lmpar+0x23f>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    132e <lm_lmpar+0x1fe>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1040 <lm_enorm@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  0x2c9c(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     13bb <lm_lmpar+0x28b>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    1b82 <lm_lmpar+0xa52>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     1521 <lm_lmpar+0x3f1>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    142c <lm_lmpar+0x2fc>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13d6 <lm_lmpar+0x2a6>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14ee <lm_lmpar+0x3be>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14a6 <lm_lmpar+0x376>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1451 <lm_lmpar+0x321>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1433 <lm_lmpar+0x303>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <lm_enorm@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15d3 <lm_lmpar+0x4a3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     159b <lm_lmpar+0x46b>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1546 <lm_lmpar+0x416>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1528 <lm_lmpar+0x3f8>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <lm_enorm@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1670 <lm_lmpar+0x540>
jp     1670 <lm_lmpar+0x540>
mov    0x29ce(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm1
movsd  0x2a0d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1647 <lm_lmpar+0x517>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1657 <lm_lmpar+0x527>
movsd  0x29e9(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x78(%rbp),%xmm0
jb     1698 <lm_lmpar+0x568>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    16a5 <lm_lmpar+0x575>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     16e1 <lm_lmpar+0x5b1>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    16ee <lm_lmpar+0x5be>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    172b <lm_lmpar+0x5fb>
jp     172b <lm_lmpar+0x5fb>
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17ac <lm_lmpar+0x67c>
jp     17ac <lm_lmpar+0x67c>
mov    0x288c(%rip),%rax
movsd  (%rax),%xmm0
movsd  0x8a0(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     1787 <lm_lmpar+0x657>
mov    0x286a(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    179c <lm_lmpar+0x66c>
movsd  0x871(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1804 <lm_lmpar+0x6d4>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17c8 <lm_lmpar+0x698>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x18(%rbp),%r11
mov    0x20(%rbp),%r10
mov    0x30(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <lm_qrsolv@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1881 <lm_lmpar+0x751>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1840 <lm_lmpar+0x710>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1040 <lm_enorm@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movaps 0x759(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2775(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    1916 <lm_lmpar+0x7e6>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    190c <lm_lmpar+0x7dc>
jp     190c <lm_lmpar+0x7dc>
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     190c <lm_lmpar+0x7dc>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
ja     1916 <lm_lmpar+0x7e6>
cmpl   $0xa,-0x40(%rbp)
jne    191b <lm_lmpar+0x7eb>
jmp    1b82 <lm_lmpar+0xa52>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1978 <lm_lmpar+0x848>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1922 <lm_lmpar+0x7f2>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a3c <lm_lmpar+0x90c>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a29 <lm_lmpar+0x8f9>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x3c(%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    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    19bb <lm_lmpar+0x88b>
jmp    1a2e <lm_lmpar+0x8fe>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    197f <lm_lmpar+0x84f>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
call   1040 <lm_enorm@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ac8 <lm_lmpar+0x998>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1aa6 <lm_lmpar+0x976>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1ab6 <lm_lmpar+0x986>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1b21 <lm_lmpar+0x9f1>
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1b1c <lm_lmpar+0x9ec>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1aff <lm_lmpar+0x9cf>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1b0f <lm_lmpar+0x9df>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    1b21 <lm_lmpar+0x9f1>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x70(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     1b4f <lm_lmpar+0xa1f>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1b64 <lm_lmpar+0xa34>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1732 <lm_lmpar+0x602>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lm_lmpar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
movsd  %xmm0,0x28(%rsp)
mov    %r9,%r14
mov    %r8,%r12
mov    %rsi,%r15
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%r13
mov    %edi,%r9d
mov    %edi,%eax
mov    %rax,0x60(%rsp)
test   %edi,%edi
mov    %rcx,0x8(%rsp)
mov    %edx,0x24(%rsp)
mov    %edi,(%rsp)
mov    %r9,0x10(%rsp)
jle    15d0 <lm_lmpar+0x4a0>
xor    %r8d,%r8d
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
mov    %edi,%eax
jmp    119c <lm_lmpar+0x6c>
add    $0x1,%rbp
add    %edx,%r8d
cmp    %rbp,%r9
je     11d3 <lm_lmpar+0xa3>
mov    %eax,%ebx
movslq %r8d,%rsi
movsd  (%r14,%rbp,8),%xmm1
add    %rbp,%rsi
cmp    %edi,%eax
mov    %ebp,%eax
cmovne %ebx,%eax
movsd  %xmm1,0x0(%r13,%rbp,8)
ucomisd (%r15,%rsi,8),%xmm0
cmovne %ebx,%eax
cmovp  %ebx,%eax
cmp    %edi,%eax
jge    1190 <lm_lmpar+0x60>
movq   $0x0,0x0(%r13,%rbp,8)
jmp    1190 <lm_lmpar+0x60>
mov    %rcx,%rbp
mov    %r15,0x18(%rsp)
mov    %rax,0x60(%rsp)
test   %eax,%eax
jle    1430 <lm_lmpar+0x300>
mov    0x60(%rsp),%rax
lea    -0x1(%rax),%ebx
mov    %eax,%eax
movslq %edx,%rsi
mov    %rax,0x38(%rsp)
lea    -0x1(%rax),%rdi
imul   %rsi,%rdi
lea    (%rdi,%rbx,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x70(%rsp)
mov    %rsi,0x30(%rsp)
lea    0x0(,%rsi,8),%rax
mov    %rax,%rsi
neg    %rsi
mov    %rsi,0x50(%rsp)
xor    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rsp)
lea    (%rcx,%rdi,8),%r15
add    $0x10,%r15
mov    %rdi,0x40(%rsp)
lea    (%rcx,%rdi,8),%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
mov    %rbx,%rax
jmp    1286 <lm_lmpar+0x156>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rax
add    $0x1,%r8
mov    0x50(%rsp),%rdx
add    %rdx,%r15
add    %rdx,%rcx
cmp    $0x1,%r10
mov    0x24(%rsp),%edx
mov    0x10(%rsp),%r9
jbe    1430 <lm_lmpar+0x300>
mov    0x38(%rsp),%r10
lea    -0x1(%r10),%rsi
movsd  -0x8(%r13,%r10,8),%xmm0
mov    %rsi,0x38(%rsp)
imul   %edx,%esi
movslq %esi,%rsi
add    %r10,%rsi
add    $0xffffffffffffffff,%rsi
mov    0x18(%rsp),%rdx
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r13,%r10,8)
cmp    $0x2,%r10
jb     1430 <lm_lmpar+0x300>
mov    %rbx,%r9
sub    %r8,%r9
cmp    $0x4,%r9
jb     131f <lm_lmpar+0x1ef>
mov    0x48(%rsp),%rsi
imul   %r8,%rsi
add    0x70(%rsp),%rsi
cmp    %r13,%rsi
jbe    13c0 <lm_lmpar+0x290>
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
mov    %r8,%rdi
imul   0x30(%rsp),%rdi
mov    %rbx,%rbp
mov    0x40(%rsp),%rbx
sub    %rdi,%rbx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdi
mov    %rbp,%rbx
mov    0x8(%rsp),%rbp
cmp    %rsi,%rdi
jae    13c0 <lm_lmpar+0x290>
xor    %r11d,%r11d
mov    %r8,%rsi
not    %rsi
add    %rbx,%rsi
mov    %r11,%rdi
test   $0x1,%al
je     1367 <lm_lmpar+0x237>
mov    0x38(%rsp),%rdi
imul   0x30(%rsp),%rdi
add    %r11,%rdi
movsd  0x0(%r13,%r11,8),%xmm1
mov    0x18(%rsp),%rdx
movsd  (%rdx,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%r11,8)
mov    %r11,%rdi
or     $0x1,%rdi
cmp    %r11,%rsi
je     1260 <lm_lmpar+0x130>
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,%rax
jne    1370 <lm_lmpar+0x240>
jmp    1260 <lm_lmpar+0x130>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %r9,%r11
and    $0xfffffffffffffffc,%r11
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r15,%rsi,8),%xmm2
movupd (%r15,%rsi,8),%xmm3
movupd 0x0(%r13,%rsi,8),%xmm4
movupd 0x10(%r13,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%rsi,8)
movupd %xmm5,0x10(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    13e0 <lm_lmpar+0x2b0>
cmp    %r11,%r9
je     1260 <lm_lmpar+0x130>
jmp    1322 <lm_lmpar+0x1f2>
mov    (%rsp),%edi
test   %edi,%edi
mov    0x110(%rsp),%rbx
jle    145e <lm_lmpar+0x32e>
mov    %rbp,%rcx
lea    -0x1(%r9),%rdx
mov    %r9d,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1468 <lm_lmpar+0x338>
xor    %ebp,%ebp
mov    0xf8(%rsp),%r8
jmp    14d0 <lm_lmpar+0x3a0>
mov    0x18(%rsp),%r15
jmp    15d0 <lm_lmpar+0x4a0>
mov    %r9d,%edx
and    $0xfffffffc,%edx
xor    %ebp,%ebp
mov    0xf8(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
movslq (%rcx,%rbp,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
movsd  0x8(%r13,%rbp,8),%xmm0
movslq 0x4(%rcx,%rbp,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
movsd  0x10(%r13,%rbp,8),%xmm0
movslq 0x8(%rcx,%rbp,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
movsd  0x18(%r13,%rbp,8),%xmm0
movslq 0xc(%rcx,%rbp,4),%rsi
movsd  %xmm0,(%r8,%rsi,8)
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    1480 <lm_lmpar+0x350>
test   %rax,%rax
mov    0x18(%rsp),%r15
je     1509 <lm_lmpar+0x3d9>
lea    (%rcx,%rbp,4),%rdx
lea    0x0(,%rbp,8),%rbp
add    %r13,%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm0
movslq (%rdx,%rsi,4),%rbx
movsd  %xmm0,(%r8,%rbx,8)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    14f0 <lm_lmpar+0x3c0>
test   %edi,%edi
jle    15c8 <lm_lmpar+0x498>
cmp    $0x4,%r9d
mov    0x110(%rsp),%rbx
jae    1673 <lm_lmpar+0x543>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdx
and    $0x3,%rdx
je     155b <lm_lmpar+0x42b>
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1540 <lm_lmpar+0x410>
cmp    $0x3,%rsi
jb     15d0 <lm_lmpar+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
mulsd  0x10(%r8,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm0
mulsd  0x18(%r8,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r9
jne    1570 <lm_lmpar+0x440>
jmp    15d0 <lm_lmpar+0x4a0>
mov    0x110(%rsp),%rbx
mov    %rbx,%rsi
mov    0xf0(%rsp),%rbx
mov    %edi,%ebp
call   1040 <lm_enorm@plt>
movapd %xmm0,%xmm2
movsd  0x28(%rsp),%xmm3
subsd  %xmm3,%xmm2
movsd  0x1a08(%rip),%xmm1
mulsd  %xmm3,%xmm1
ucomisd %xmm2,%xmm1
jae    165a <lm_lmpar+0x52a>
movsd  %xmm1,0xb0(%rsp)
xorpd  %xmm1,%xmm1
mov    0x24(%rsp),%r10d
movslq %r10d,%rax
mov    %rax,0x40(%rsp)
cmp    %ebp,0x60(%rsp)
movsd  %xmm2,0x70(%rsp)
movsd  %xmm0,0x38(%rsp)
jl     194d <lm_lmpar+0x81d>
test   %ebp,%ebp
mov    0x10(%rsp),%r11
mov    0x110(%rsp),%rbp
jle    192c <lm_lmpar+0x7fc>
mov    (%rsp),%esi
cmp    $0x1,%esi
jne    1787 <lm_lmpar+0x657>
xor    %eax,%eax
jmp    17e0 <lm_lmpar+0x6b0>
movq   $0x0,(%rbx)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rbx,%r9,8),%rax
lea    (%r12,%r9,8),%rcx
cmp    %rbx,%rcx
mov    %rbx,%rsi
seta   %bl
lea    (%r8,%r9,8),%rcx
cmp    %r12,%rax
seta   %dl
cmp    %rsi,%rcx
seta   %cl
cmp    %r8,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%bl
jne    231d <lm_lmpar+0x11ed>
and    %sil,%cl
mov    0x110(%rsp),%rbx
jne    1525 <lm_lmpar+0x3f5>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     232a <lm_lmpar+0x11fa>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebp,%ebp
nopl   (%rax)
movupd (%r12,%rbp,8),%xmm0
movupd 0x10(%r12,%rbp,8),%xmm1
movupd (%r8,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r8,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
movupd 0x20(%r12,%rbp,8),%xmm0
movupd 0x30(%r12,%rbp,8),%xmm1
movupd 0x20(%r8,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r8,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rbp,8)
movupd %xmm0,0x30(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    16e0 <lm_lmpar+0x5b0>
test   $0x1,%dl
je     1779 <lm_lmpar+0x649>
movupd (%r12,%rbp,8),%xmm0
movupd 0x10(%r12,%rbp,8),%xmm1
movupd (%r8,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r8,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
cmp    %r9,%rax
jne    1525 <lm_lmpar+0x3f5>
jmp    15d0 <lm_lmpar+0x4a0>
mov    %r11d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%rdi,%rax,4),%rdx
movsd  (%r12,%rdx,8),%xmm1
mulsd  0x0(%rbp,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rdx
movsd  (%r12,%rdx,8),%xmm1
mulsd  0x0(%rbp,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    17a0 <lm_lmpar+0x670>
test   $0x1,%r11b
je     1806 <lm_lmpar+0x6d6>
mov    0x8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x0(%rbp,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %esi,%esi
jle    192c <lm_lmpar+0x7fc>
lea    0x18(%r15),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
xor    %ebp,%ebp
mov    %r15,%r9
jmp    186b <lm_lmpar+0x73b>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  0x0(%r13,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
mov    %ebp,%ecx
imul   %r10d,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
divsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    %r8,%rax
add    %r8,%r9
cmp    %r11,%rbp
je     192c <lm_lmpar+0x7fc>
test   %rbp,%rbp
je     1830 <lm_lmpar+0x700>
lea    -0x1(%rbp),%rcx
cmp    $0x3,%rcx
jae    1890 <lm_lmpar+0x760>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    18ec <lm_lmpar+0x7bc>
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    18a0 <lm_lmpar+0x770>
test   $0x3,%bpl
je     1834 <lm_lmpar+0x704>
mov    %ebp,%edx
and    $0x3,%edx
lea    0x0(,%rdi,8),%rcx
add    %r13,%rcx
lea    (%r9,%rdi,8),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rdi,%rsi,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1910 <lm_lmpar+0x7e0>
jmp    1834 <lm_lmpar+0x704>
mov    (%rsp),%ebp
mov    %ebp,%edi
mov    %r13,%rsi
call   1040 <lm_enorm@plt>
movsd  0x70(%rsp),%xmm1
divsd  0x28(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
test   %ebp,%ebp
mov    0x10(%rsp),%r11
mov    0x8(%rsp),%rbx
jle    1a6d <lm_lmpar+0x93d>
lea    0x18(%r15),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
mov    $0x1,%r10d
xor    %esi,%esi
mov    %r15,%r9
jmp    19b8 <lm_lmpar+0x888>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rbx,%rsi,4),%rcx
divsd  (%r12,%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     1a6d <lm_lmpar+0x93d>
cmp    $0x3,%rsi
jae    19d0 <lm_lmpar+0x8a0>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    1a2b <lm_lmpar+0x8fb>
cs nopw 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  (%r14,%rbp,8),%xmm1
mulsd  0x8(%r14,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rax,%rbp,8),%xmm3
mulsd  0x10(%r14,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%r14,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    19e0 <lm_lmpar+0x8b0>
test   $0x3,%r10b
je     1990 <lm_lmpar+0x860>
mov    %r10d,%edx
and    $0x3,%edx
lea    (%r14,%rbp,8),%rdi
lea    (%r9,%rbp,8),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  (%rdi,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1a50 <lm_lmpar+0x920>
jmp    1990 <lm_lmpar+0x860>
mov    (%rsp),%edi
mov    %r13,%rsi
call   1040 <lm_enorm@plt>
movapd %xmm0,%xmm1
movapd %xmm0,%xmm3
movsd  0x28(%rsp),%xmm0
divsd  %xmm0,%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm3
mov    0x110(%rsp),%rdx
jne    1ab5 <lm_lmpar+0x985>
jp     1ab5 <lm_lmpar+0x985>
mov    0x353b(%rip),%rax
movsd  (%rax),%xmm3
minsd  0x154f(%rip),%xmm0
divsd  %xmm0,%xmm3
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x80(%rsp)
mov    0xf0(%rsp),%rax
movsd  (%rax),%xmm0
movapd %xmm3,%xmm6
movapd 0x50(%rsp),%xmm5
movapd %xmm5,%xmm3
cmplesd %xmm0,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm5,%xmm3
orpd   %xmm0,%xmm3
movapd %xmm3,%xmm0
cmplesd %xmm6,%xmm0
movapd %xmm0,%xmm4
andpd  %xmm3,%xmm4
movapd %xmm6,0x60(%rsp)
andnpd %xmm6,%xmm0
orpd   %xmm4,%xmm0
ucomisd %xmm2,%xmm0
mov    0xf8(%rsp),%r10
jne    1b2b <lm_lmpar+0x9fb>
jp     1b2b <lm_lmpar+0x9fb>
divsd  0x38(%rsp),%xmm1
movapd %xmm1,%xmm0
mov    (%rsp),%edi
mov    0x10(%rsp),%rbp
mov    0x100(%rsp),%r11
movsd  %xmm0,(%rax)
movslq %edi,%rcx
mov    %rcx,0x38(%rsp)
lea    (%rdx,%rbp,8),%r9
lea    (%r12,%rbp,8),%r8
lea    (%r10,%rbp,8),%rcx
mov    %rcx,0x18(%rsp)
mov    %rdx,%rcx
lea    0x0(,%rbp,8),%rbx
add    %r13,%rbx
mov    %ebp,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x98(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x90(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r13,%r8
seta   %sil
cmp    %r12,%rbx
seta   %bl
and    %sil,%bl
mov    %bl,0x7(%rsp)
mov    %rdx,%rsi
mov    %rdx,0x88(%rsp)
and    %rdx,0x80(%rsp)
mov    %ebp,%edx
and    $0x3,%edx
mov    %rdx,0x48(%rsp)
cmp    %rcx,%r8
seta   %dl
lea    -0x1(%rbp),%rsi
mov    %rsi,0xa0(%rsp)
cmp    %r12,%r9
seta   %bl
and    %dl,%bl
cmp    %rcx,0x18(%rsp)
seta   %cl
cmp    %r10,%r9
seta   %dl
and    %cl,%dl
or     %bl,%dl
mov    %dl,0x6(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0xa8(%rsp)
mov    0x40(%rsp),%rcx
lea    0x8(,%rcx,8),%rcx
mov    %rcx,0x18(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x30(%rsp)
xorpd  %xmm4,%xmm4
mov    0x8(%rsp),%rbx
jmp    1ca9 <lm_lmpar+0xb79>
nopw   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%rax
movsd  (%rax),%xmm1
movapd %xmm1,%xmm2
movapd 0x50(%rsp),%xmm5
cmplesd %xmm5,%xmm2
andpd  %xmm2,%xmm5
andnpd %xmm1,%xmm2
orpd   %xmm2,%xmm5
movsd  0x28(%rsp),%xmm3
mov    0x8(%rsp),%rbx
mov    (%rsp),%edi
mov    0xf8(%rsp),%r10
mov    0x100(%rsp),%r11
movapd %xmm6,%xmm2
divsd  %xmm3,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm5,%xmm0
movapd %xmm0,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm5,%xmm0
orpd   %xmm1,%xmm0
movlpd %xmm0,(%rax)
mov    0x30(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x30(%rsp)
movsd  %xmm6,0x70(%rsp)
ucomisd %xmm4,%xmm0
jne    1ce3 <lm_lmpar+0xbb3>
jp     1ce3 <lm_lmpar+0xbb3>
mov    0x3328(%rip),%rcx
movsd  (%rcx),%xmm1
movapd 0x60(%rsp),%xmm2
mulsd  0x133e(%rip),%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm1,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
movlpd %xmm0,(%rax)
ucomisd %xmm4,%xmm0
movapd %xmm5,0x50(%rsp)
jb     1d00 <lm_lmpar+0xbd0>
sqrtsd %xmm0,%xmm0
jmp    1d18 <lm_lmpar+0xbe8>
cs nopw 0x0(%rax,%rax,1)
nop
call   1050 <sqrt@plt>
mov    0x100(%rsp),%r11
mov    0xf8(%rsp),%r10
mov    (%rsp),%edi
mov    0x24(%rsp),%edx
mov    0x48(%rsp),%rsi
test   %edi,%edi
jle    1d40 <lm_lmpar+0xc10>
cmp    $0x4,%edi
setb   %al
or     0x7(%rsp),%al
je     1d70 <lm_lmpar+0xc40>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
jmp    1e32 <lm_lmpar+0xd02>
nopl   (%rax)
sub    $0x8,%rsp
mov    %r15,%rsi
mov    %rbx,%rcx
mov    %r13,%r8
mov    %r14,%r9
mov    0x118(%rsp),%rbx
push   %rbx
push   %r11
push   %r10
call   1030 <lm_qrsolv@plt>
mov    0x20(%rsp),%edi
add    $0x20,%rsp
jmp    2080 <lm_lmpar+0xf50>
nop
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x90(%rsp)
je     22ee <lm_lmpar+0x11be>
mov    0x80(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%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,%rcx
jne    1da0 <lm_lmpar+0xc70>
testb  $0x1,0x88(%rsp)
01
je     1e1e <lm_lmpar+0xcee>
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     1ed0 <lm_lmpar+0xda0>
mov    0xa0(%rsp),%rcx
sub    %rax,%rcx
test   %rsi,%rsi
je     1e6b <lm_lmpar+0xd3b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1e50 <lm_lmpar+0xd20>
cmp    $0x3,%rcx
jb     1ed0 <lm_lmpar+0xda0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1e80 <lm_lmpar+0xd50>
sub    $0x8,%rsp
mov    %r15,%rsi
mov    %rbx,%rcx
mov    %r13,%r8
mov    %r14,%r9
mov    0x118(%rsp),%rbx
push   %rbx
push   %r11
push   %r10
call   1030 <lm_qrsolv@plt>
mov    0x30(%rsp),%rbp
mov    0x118(%rsp),%rsi
mov    0x20(%rsp),%edi
add    $0x20,%rsp
test   %edi,%edi
jle    2080 <lm_lmpar+0xf50>
cmp    $0x4,%edi
setb   %al
or     0x6(%rsp),%al
je     1f22 <lm_lmpar+0xdf2>
xor    %eax,%eax
jmp    1fec <lm_lmpar+0xebc>
cmpq   $0x0,0x90(%rsp)
je     2308 <lm_lmpar+0x11d8>
mov    0x80(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm0
movupd 0x30(%r12,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm0,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f40 <lm_lmpar+0xe10>
testb  $0x1,0x88(%rsp)
01
je     1fd8 <lm_lmpar+0xea8>
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     2080 <lm_lmpar+0xf50>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x3,%bpl
je     201a <lm_lmpar+0xeea>
mov    0x48(%rsp),%rdx
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2000 <lm_lmpar+0xed0>
cmp    $0x3,%rcx
jb     2080 <lm_lmpar+0xf50>
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2020 <lm_lmpar+0xef0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rsi
call   1040 <lm_enorm@plt>
movapd %xmm0,%xmm3
subsd  0x28(%rsp),%xmm3
movapd %xmm3,%xmm1
andpd  0xf72(%rip),%xmm1
movsd  0xb0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
mov    0x40(%rsp),%r10
movapd 0x50(%rsp),%xmm1
mov    0x100(%rsp),%r11
xorpd  %xmm2,%xmm2
jae    1661 <lm_lmpar+0x531>
ucomisd %xmm2,%xmm1
jne    20ec <lm_lmpar+0xfbc>
jp     20ec <lm_lmpar+0xfbc>
movsd  0x70(%rsp),%xmm1
ucomisd %xmm3,%xmm1
setae  %al
ucomisd %xmm1,%xmm2
seta   %cl
test   %al,%cl
jne    1661 <lm_lmpar+0x531>
cmpl   $0xa,0x30(%rsp)
je     1661 <lm_lmpar+0x531>
movapd %xmm3,0x70(%rsp)
mov    (%rsp),%edi
test   %edi,%edi
mov    0x10(%rsp),%r9
jle    2260 <lm_lmpar+0x1130>
cmpq   $0x0,0xa0(%rsp)
je     22d0 <lm_lmpar+0x11a0>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x110(%rsp),%rsi
mov    0xa8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rdx,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdx,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    2140 <lm_lmpar+0x1010>
test   $0x1,%r9b
je     219e <lm_lmpar+0x106e>
movslq (%rdx,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %edi,%edi
jle    2260 <lm_lmpar+0x1130>
mov    $0x1,%eax
mov    %r15,%rcx
mov    %r13,%rdx
mov    %r9,%rsi
xor    %r8d,%r8d
jmp    21da <lm_lmpar+0x10aa>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
add    $0x8,%rdx
add    0x18(%rsp),%rcx
cmp    %r9,%r8
je     2260 <lm_lmpar+0x1130>
mov    %r8,%rbp
movsd  0x0(%r13,%r8,8),%xmm0
divsd  (%r11,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%r8,8)
add    $0x1,%r8
cmp    0x38(%rsp),%r8
jge    21c0 <lm_lmpar+0x1090>
mov    %rbp,%rbx
imul   %r10,%rbx
add    %rax,%rbx
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  (%r15,%rbx,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rax),%rbx
cmp    %r9,%rbx
je     21c0 <lm_lmpar+0x1090>
mov    $0x2,%ebx
nopl   0x0(%rax)
movsd  (%rcx,%rbx,8),%xmm0
movsd  (%rdx,%rbx,8),%xmm1
mulsd  0x0(%r13,%rbp,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    2230 <lm_lmpar+0x1100>
jmp    21c0 <lm_lmpar+0x1090>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rsi
call   1040 <lm_enorm@plt>
xorpd  %xmm4,%xmm4
movapd 0x70(%rsp),%xmm6
ucomisd %xmm4,%xmm6
ja     1c20 <lm_lmpar+0xaf0>
ucomisd %xmm6,%xmm4
mov    0xf0(%rsp),%rax
movsd  (%rax),%xmm1
jbe    22af <lm_lmpar+0x117f>
movapd 0x60(%rsp),%xmm3
movapd %xmm3,%xmm2
cmplesd %xmm1,%xmm2
andpd  %xmm2,%xmm3
andnpd %xmm1,%xmm2
orpd   %xmm2,%xmm3
movapd %xmm3,0x60(%rsp)
movsd  0x28(%rsp),%xmm3
mov    0x8(%rsp),%rbx
mov    (%rsp),%edi
mov    0xf8(%rsp),%r10
movapd 0x50(%rsp),%xmm5
jmp    1c5d <lm_lmpar+0xb2d>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x110(%rsp),%rsi
test   $0x1,%r9b
jne    2184 <lm_lmpar+0x1054>
jmp    219e <lm_lmpar+0x106e>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
testb  $0x1,0x88(%rsp)
01
jne    1dfb <lm_lmpar+0xccb>
jmp    1e1e <lm_lmpar+0xcee>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
jne    1fad <lm_lmpar+0xe7d>
jmp    1fd8 <lm_lmpar+0xea8>
mov    0x110(%rsp),%rbx
jmp    1525 <lm_lmpar+0x3f5>
xor    %ebp,%ebp
test   $0x1,%dl
jne    174c <lm_lmpar+0x61c>
jmp    1779 <lm_lmpar+0x649>

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

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