#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 fabs(double);
double lm_enorm(int, double *);
int /*<<< orphan*/ lm_qrsolv(int, double *, int, int *, double *, double *,
                             double *, double *, double *);
double sqrt(double);
void lm_lmpar(int n, double *r, int ldr, int *ipvt, double *diag, double *qtb,
              double delta, double *par, double *x, double *sdiag, double *wa1,
              double *wa2) {
  int i, iter, j, nsing;
  double dxnorm, fp, fp_old, gnorm, parc, parl, paru;
  double sum, temp;
  static double p1 = 0.1;
  static double p001 = 0.001;
  nsing = n;
  for (j = 0; j < n; j++) {
    wa1[j] = qtb[j];
    if (r[j * ldr + j] == 0 && nsing == n)
      nsing = j;
    if (nsing < n)
      wa1[j] = 0;
  }
  for (j = nsing - 1; j >= 0; j--) {
    wa1[j] = wa1[j] / r[j + ldr * j];
    temp = wa1[j];
    for (i = 0; i < j; i++)
      wa1[i] -= r[j * ldr + i] * temp;
  }
  for (j = 0; j < n; j++)
    x[ipvt[j]] = wa1[j];
  iter = 0;
  for (j = 0; j < n; j++)
    wa2[j] = diag[j] * x[j];
  dxnorm = lm_enorm(n, wa2);
  fp = dxnorm - delta;
  if (fp <= p1 * delta) {
    *par = 0;
    return;
  }
  parl = 0;
  if (nsing >= n) {
    for (j = 0; j < n; j++)
      wa1[j] = diag[ipvt[j]] * wa2[ipvt[j]] / dxnorm;
    for (j = 0; j < n; j++) {
      sum = 0.;
      for (i = 0; i < j; i++)
        sum += r[j * ldr + i] * wa1[i];
      wa1[j] = (wa1[j] - sum) / r[j + ldr * j];
    }
    temp = lm_enorm(n, wa1);
    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];
    wa1[j] = sum / diag[ipvt[j]];
  }
  gnorm = lm_enorm(n, wa1);
  paru = gnorm / delta;
  if (paru == 0.)
    paru = 9.9e-324 / (((delta) <= (p1)) ? (delta) : (p1));
  *par = (((*par) >= (parl)) ? (*par) : (parl));
  *par = (((*par) <= (paru)) ? (*par) : (paru));
  if (*par == 0.)
    *par = gnorm / dxnorm;
  for (;; iter++) {
    if (*par == 0.)
      *par = (((9.9e-324) >= (p001 * paru)) ? (9.9e-324) : (p001 * paru));
    temp = sqrt(*par);
    for (j = 0; j < n; j++)
      wa1[j] = temp * diag[j];
    lm_qrsolv(n, r, ldr, ipvt, wa1, qtb, x, sdiag, wa2);
    for (j = 0; j < n; j++)
      wa2[j] = diag[j] * x[j];
    dxnorm = lm_enorm(n, wa2);
    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++)
      wa1[j] = diag[ipvt[j]] * wa2[ipvt[j]] / dxnorm;
    for (j = 0; j < n; j++) {
      wa1[j] = wa1[j] / sdiag[j];
      for (i = j + 1; i < n; i++)
        wa1[i] -= r[j * ldr + i] * wa1[j];
    }
    temp = lm_enorm(n, wa1);
    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    $0xe0,%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,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1376 <lm_lmpar+0x246>
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    1335 <lm_lmpar+0x205>
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  0x2c95(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     13c2 <lm_lmpar+0x292>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    1b6e <lm_lmpar+0xa3e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     1528 <lm_lmpar+0x3f8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1433 <lm_lmpar+0x303>
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    13dd <lm_lmpar+0x2ad>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14f5 <lm_lmpar+0x3c5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14ad <lm_lmpar+0x37d>
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    1458 <lm_lmpar+0x328>
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    143a <lm_lmpar+0x30a>
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    15da <lm_lmpar+0x4aa>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     15a2 <lm_lmpar+0x472>
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    154d <lm_lmpar+0x41d>
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    152f <lm_lmpar+0x3ff>
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    1664 <lm_lmpar+0x534>
jp     1664 <lm_lmpar+0x534>
movsd  -0x38(%rbp),%xmm1
movsd  0x2a19(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     163b <lm_lmpar+0x50b>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    164b <lm_lmpar+0x51b>
movsd  0x29f5(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x9a5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x78(%rbp),%xmm0
jb     168c <lm_lmpar+0x55c>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1699 <lm_lmpar+0x569>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%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     16d5 <lm_lmpar+0x5a5>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    16e2 <lm_lmpar+0x5b2>
movsd  -0x80(%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),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    171f <lm_lmpar+0x5ef>
jp     171f <lm_lmpar+0x5ef>
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1724 <lm_lmpar+0x5f4>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1798 <lm_lmpar+0x668>
jp     1798 <lm_lmpar+0x668>
movsd  0x28f9(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0x8ac(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1773 <lm_lmpar+0x643>
movsd  0x89a(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1788 <lm_lmpar+0x658>
movsd  0x28c5(%rip),%xmm0
mulsd  -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
call   1050 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17f0 <lm_lmpar+0x6c0>
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    17b4 <lm_lmpar+0x684>
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    186d <lm_lmpar+0x73d>
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    182c <lm_lmpar+0x6fc>
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 0x76d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2789(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    1902 <lm_lmpar+0x7d2>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18f8 <lm_lmpar+0x7c8>
jp     18f8 <lm_lmpar+0x7c8>
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     18f8 <lm_lmpar+0x7c8>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
ja     1902 <lm_lmpar+0x7d2>
cmpl   $0xa,-0x40(%rbp)
jne    1907 <lm_lmpar+0x7d7>
jmp    1b6e <lm_lmpar+0xa3e>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1964 <lm_lmpar+0x834>
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    190e <lm_lmpar+0x7de>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a28 <lm_lmpar+0x8f8>
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    1a15 <lm_lmpar+0x8e5>
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    19a7 <lm_lmpar+0x877>
jmp    1a1a <lm_lmpar+0x8ea>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    196b <lm_lmpar+0x83b>
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    1ab4 <lm_lmpar+0x984>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1a92 <lm_lmpar+0x962>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1aa2 <lm_lmpar+0x972>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1b0d <lm_lmpar+0x9dd>
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1b08 <lm_lmpar+0x9d8>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1aeb <lm_lmpar+0x9bb>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1afb <lm_lmpar+0x9cb>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    1b0d <lm_lmpar+0x9dd>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x70(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     1b3b <lm_lmpar+0xa0b>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1b50 <lm_lmpar+0xa20>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1724 <lm_lmpar+0x5f4>
add    $0xe0,%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    230d <lm_lmpar+0x11dd>
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     231a <lm_lmpar+0x11ea>
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    1ab2 <lm_lmpar+0x982>
jp     1ab2 <lm_lmpar+0x982>
minsd  0x155a(%rip),%xmm0
movsd  0x155a(%rip),%xmm3
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    1b28 <lm_lmpar+0x9f8>
jp     1b28 <lm_lmpar+0x9f8>
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    1ccf <lm_lmpar+0xb9f>
jp     1ccf <lm_lmpar+0xb9f>
movapd 0x60(%rsp),%xmm1
mulsd  0x1351(%rip),%xmm1
movsd  0x1341(%rip),%xmm0
maxsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
ucomisd %xmm4,%xmm0
movapd %xmm5,0x50(%rsp)
jb     1cf0 <lm_lmpar+0xbc0>
sqrtsd %xmm0,%xmm0
jmp    1d08 <lm_lmpar+0xbd8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    1d30 <lm_lmpar+0xc00>
cmp    $0x4,%edi
setb   %al
or     0x7(%rsp),%al
je     1d60 <lm_lmpar+0xc30>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
jmp    1e22 <lm_lmpar+0xcf2>
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    2070 <lm_lmpar+0xf40>
nop
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x90(%rsp)
je     22de <lm_lmpar+0x11ae>
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    1d90 <lm_lmpar+0xc60>
testb  $0x1,0x88(%rsp)
01
je     1e0e <lm_lmpar+0xcde>
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     1ec0 <lm_lmpar+0xd90>
mov    0xa0(%rsp),%rcx
sub    %rax,%rcx
test   %rsi,%rsi
je     1e5b <lm_lmpar+0xd2b>
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    1e40 <lm_lmpar+0xd10>
cmp    $0x3,%rcx
jb     1ec0 <lm_lmpar+0xd90>
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    1e70 <lm_lmpar+0xd40>
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    2070 <lm_lmpar+0xf40>
cmp    $0x4,%edi
setb   %al
or     0x6(%rsp),%al
je     1f12 <lm_lmpar+0xde2>
xor    %eax,%eax
jmp    1fdc <lm_lmpar+0xeac>
cmpq   $0x0,0x90(%rsp)
je     22f8 <lm_lmpar+0x11c8>
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    1f30 <lm_lmpar+0xe00>
testb  $0x1,0x88(%rsp)
01
je     1fc8 <lm_lmpar+0xe98>
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     2070 <lm_lmpar+0xf40>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x3,%bpl
je     200a <lm_lmpar+0xeda>
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    1ff0 <lm_lmpar+0xec0>
cmp    $0x3,%rcx
jb     2070 <lm_lmpar+0xf40>
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    2010 <lm_lmpar+0xee0>
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  0xf92(%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    20dc <lm_lmpar+0xfac>
jp     20dc <lm_lmpar+0xfac>
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    2250 <lm_lmpar+0x1120>
cmpq   $0x0,0xa0(%rsp)
je     22c0 <lm_lmpar+0x1190>
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    2130 <lm_lmpar+0x1000>
test   $0x1,%r9b
je     218e <lm_lmpar+0x105e>
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    2250 <lm_lmpar+0x1120>
mov    $0x1,%eax
mov    %r15,%rcx
mov    %r13,%rdx
mov    %r9,%rsi
xor    %r8d,%r8d
jmp    21ca <lm_lmpar+0x109a>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
add    $0x8,%rdx
add    0x18(%rsp),%rcx
cmp    %r9,%r8
je     2250 <lm_lmpar+0x1120>
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    21b0 <lm_lmpar+0x1080>
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     21b0 <lm_lmpar+0x1080>
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    2220 <lm_lmpar+0x10f0>
jmp    21b0 <lm_lmpar+0x1080>
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    229f <lm_lmpar+0x116f>
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    2174 <lm_lmpar+0x1044>
jmp    218e <lm_lmpar+0x105e>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
testb  $0x1,0x88(%rsp)
01
jne    1deb <lm_lmpar+0xcbb>
jmp    1e0e <lm_lmpar+0xcde>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
jne    1f9d <lm_lmpar+0xe6d>
jmp    1fc8 <lm_lmpar+0xe98>
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
@lm_lmpar.p001 = internal global double 1.000000e-03
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* %26
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 %662
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 %375
364: ; preds = %355
%365 = load double, double* %19
%366 = load double, double* @lm_lmpar.p1
%367 = fcmp ole double %365, %366
br i1 %367, label %368, label %370
368: ; preds = %364
%369 = load double, double* %19
br label %372
370: ; preds = %364
%371 = load double, double* @lm_lmpar.p1
br label %372
372: ; preds = %370, %368
%373 = phi double [ %369, %368 ], [ %371, %370 ]
%374 = fdiv double 9.881310e-324, %373
store double %374, double* %35
br label %375
375: ; preds = %372, %355
%376 = load double*, double** %20
%377 = load double, double* %376
%378 = load double, double* %34
%379 = fcmp oge double %377, %378
br i1 %379, label %380, label %383
380: ; preds = %375
%381 = load double*, double** %20
%382 = load double, double* %381
br label %385
383: ; preds = %375
%384 = load double, double* %34
br label %385
385: ; preds = %383, %380
%386 = phi double [ %382, %380 ], [ %384, %383 ]
%387 = load double*, double** %20
store double %386, double* %387
%388 = load double*, double** %20
%389 = load double, double* %388
%390 = load double, double* %35
%391 = fcmp ole double %389, %390
br i1 %391, label %392, label %395
392: ; preds = %385
%393 = load double*, double** %20
%394 = load double, double* %393
br label %397
395: ; preds = %385
%396 = load double, double* %35
br label %397
397: ; preds = %395, %392
%398 = phi double [ %394, %392 ], [ %396, %395 ]
%399 = load double*, double** %20
store double %398, double* %399
%400 = load double*, double** %20
%401 = load double, double* %400
%402 = fcmp oeq double %401, 0.000000e+00
br i1 %402, label %403, label %408
403: ; preds = %397
%404 = load double, double* %32
%405 = load double, double* %29
%406 = fdiv double %404, %405
%407 = load double*, double** %20
store double %406, double* %407
br label %408
408: ; preds = %403, %397
br label %409
409: ; preds = %659, %408
%410 = load double*, double** %20
%411 = load double, double* %410
%412 = fcmp oeq double %411, 0.000000e+00
br i1 %412, label %413, label %426
413: ; preds = %409
%414 = load double, double* @lm_lmpar.p001
%415 = load double, double* %35
%416 = fmul double %414, %415
%417 = fcmp oge double 9.881310e-324, %416
br i1 %417, label %418, label %419
418: ; preds = %413
br label %423
419: ; preds = %413
%420 = load double, double* @lm_lmpar.p001
%421 = load double, double* %35
%422 = fmul double %420, %421
br label %423
423: ; preds = %419, %418
%424 = phi double [ 9.881310e-324, %418 ], [ %422, %419 ]
%425 = load double*, double** %20
store double %424, double* %425
br label %426
426: ; preds = %423, %409
%427 = load double*, double** %20
%428 = load double, double* %427
%429 = call double @sqrt(double %428)
store double %429, double* %37
store i32 0, i32* %27
br label %430
430: ; preds = %446, %426
%431 = load i32, i32* %27
%432 = load i32, i32* %13
%433 = icmp slt i32 %431, %432
br i1 %433, label %434, label %449
434: ; preds = %430
%435 = load double, double* %37
%436 = load double*, double** %17
%437 = load i32, i32* %27
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %436, i64 %438
%440 = load double, double* %439
%441 = fmul double %435, %440
%442 = load double*, double** %23
%443 = load i32, i32* %27
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
store double %441, double* %445
br label %446
446: ; preds = %434
%447 = load i32, i32* %27
%448 = add nsw i32 %447, 1
store i32 %448, i32* %27
br label %430
449: ; preds = %430
%450 = load i32, i32* %13
%451 = load double*, double** %14
%452 = load i32, i32* %15
%453 = load i32*, i32** %16
%454 = load double*, double** %23
%455 = load double*, double** %18
%456 = load double*, double** %21
%457 = load double*, double** %22
%458 = load double*, double** %24
%459 = call i32 @lm_qrsolv(i32 %450, double* %451, i32 %452, i32* %453, double* %454, double* %455, double* %456, double* %457, double* %458)
store i32 0, i32* %27
br label %460
460: ; preds = %480, %449
%461 = load i32, i32* %27
%462 = load i32, i32* %13
%463 = icmp slt i32 %461, %462
br i1 %463, label %464, label %483
464: ; preds = %460
%465 = load double*, double** %17
%466 = load i32, i32* %27
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds double, double* %465, i64 %467
%469 = load double, double* %468
%470 = load double*, double** %21
%471 = load i32, i32* %27
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %470, i64 %472
%474 = load double, double* %473
%475 = fmul double %469, %474
%476 = load double*, double** %24
%477 = load i32, i32* %27
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
store double %475, double* %479
br label %480
480: ; preds = %464
%481 = load i32, i32* %27
%482 = add nsw i32 %481, 1
store i32 %482, i32* %27
br label %460
483: ; preds = %460
%484 = load i32, i32* %13
%485 = load double*, double** %24
%486 = call double @lm_enorm(i32 %484, double* %485)
store double %486, double* %29
%487 = load double, double* %30
store double %487, double* %31
%488 = load double, double* %29
%489 = load double, double* %19
%490 = fsub double %488, %489
store double %490, double* %30
%491 = load double, double* %30
%492 = call double @llvm.fabs.f64(double %491)
%493 = load double, double* @lm_lmpar.p1
%494 = load double, double* %19
%495 = fmul double %493, %494
%496 = fcmp ole double %492, %495
br i1 %496, label %510, label %497
497: ; preds = %483
%498 = load double, double* %34
%499 = fcmp oeq double %498, 0.000000e+00
br i1 %499, label %500, label %507
500: ; preds = %497
%501 = load double, double* %30
%502 = load double, double* %31
%503 = fcmp ole double %501, %502
br i1 %503, label %504, label %507
504: ; preds = %500
%505 = load double, double* %31
%506 = fcmp olt double %505, 0.000000e+00
br i1 %506, label %510, label %507
507: ; preds = %504, %500, %497
%508 = load i32, i32* %26
%509 = icmp eq i32 %508, 10
br i1 %509, label %510, label %511
510: ; preds = %507, %504, %483
br label %662
511: ; preds = %507
store i32 0, i32* %27
br label %512
512: ; preds = %542, %511
%513 = load i32, i32* %27
%514 = load i32, i32* %13
%515 = icmp slt i32 %513, %514
br i1 %515, label %516, label %545
516: ; preds = %512
%517 = load double*, double** %17
%518 = load i32*, i32** %16
%519 = load i32, i32* %27
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds i32, i32* %518, i64 %520
%522 = load i32, i32* %521
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double, double* %517, i64 %523
%525 = load double, double* %524
%526 = load double*, double** %24
%527 = load i32*, i32** %16
%528 = load i32, i32* %27
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds i32, i32* %527, i64 %529
%531 = load i32, i32* %530
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %526, i64 %532
%534 = load double, double* %533
%535 = fmul double %525, %534
%536 = load double, double* %29
%537 = fdiv double %535, %536
%538 = load double*, double** %23
%539 = load i32, i32* %27
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
store double %537, double* %541
br label %542
542: ; preds = %516
%543 = load i32, i32* %27
%544 = add nsw i32 %543, 1
store i32 %544, i32* %27
br label %512
545: ; preds = %512
store i32 0, i32* %27
br label %546
546: ; preds = %598, %545
%547 = load i32, i32* %27
%548 = load i32, i32* %13
%549 = icmp slt i32 %547, %548
br i1 %549, label %550, label %601
550: ; preds = %546
%551 = load double*, double** %23
%552 = load i32, i32* %27
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %551, i64 %553
%555 = load double, double* %554
%556 = load double*, double** %22
%557 = load i32, i32* %27
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds double, double* %556, i64 %558
%560 = load double, double* %559
%561 = fdiv double %555, %560
%562 = load double*, double** %23
%563 = load i32, i32* %27
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds double, double* %562, i64 %564
store double %561, double* %565
%566 = load i32, i32* %27
%567 = add nsw i32 %566, 1
store i32 %567, i32* %25
br label %568
568: ; preds = %594, %550
%569 = load i32, i32* %25
%570 = load i32, i32* %13
%571 = icmp slt i32 %569, %570
br i1 %571, label %572, label %597
572: ; preds = %568
%573 = load double*, double** %14
%574 = load i32, i32* %27
%575 = load i32, i32* %15
%576 = mul nsw i32 %574, %575
%577 = load i32, i32* %25
%578 = add nsw i32 %576, %577
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds double, double* %573, i64 %579
%581 = load double, double* %580
%582 = load double*, double** %23
%583 = load i32, i32* %27
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds double, double* %582, i64 %584
%586 = load double, double* %585
%587 = load double*, double** %23
%588 = load i32, i32* %25
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %587, i64 %589
%591 = load double, double* %590
%592 = fneg double %581
%593 = call double @llvm.fmuladd.f64(double %592, double %586, double %591)
store double %593, double* %590
br label %594
594: ; preds = %572
%595 = load i32, i32* %25
%596 = add nsw i32 %595, 1
store i32 %596, i32* %25
br label %568
597: ; preds = %568
br label %598
598: ; preds = %597
%599 = load i32, i32* %27
%600 = add nsw i32 %599, 1
store i32 %600, i32* %27
br label %546
601: ; preds = %546
%602 = load i32, i32* %13
%603 = load double*, double** %23
%604 = call double @lm_enorm(i32 %602, double* %603)
store double %604, double* %37
%605 = load double, double* %30
%606 = load double, double* %19
%607 = fdiv double %605, %606
%608 = load double, double* %37
%609 = fdiv double %607, %608
%610 = load double, double* %37
%611 = fdiv double %609, %610
store double %611, double* %33
%612 = load double, double* %30
%613 = fcmp ogt double %612, 0.000000e+00
br i1 %613, label %614, label %626
614: ; preds = %601
%615 = load double, double* %34
%616 = load double*, double** %20
%617 = load double, double* %616
%618 = fcmp oge double %615, %617
br i1 %618, label %619, label %621
619: ; preds = %614
%620 = load double, double* %34
br label %624
621: ; preds = %614
%622 = load double*, double** %20
%623 = load double, double* %622
br label %624
624: ; preds = %621, %619
%625 = phi double [ %620, %619 ], [ %623, %621 ]
store double %625, double* %34
br label %642
626: ; preds = %601
%627 = load double, double* %30
%628 = fcmp olt double %627, 0.000000e+00
br i1 %628, label %629, label %641
629: ; preds = %626
%630 = load double, double* %35
%631 = load double*, double** %20
%632 = load double, double* %631
%633 = fcmp ole double %630, %632
br i1 %633, label %634, label %636
634: ; preds = %629
%635 = load double, double* %35
br label %639
636: ; preds = %629
%637 = load double*, double** %20
%638 = load double, double* %637
br label %639
639: ; preds = %636, %634
%640 = phi double [ %635, %634 ], [ %638, %636 ]
store double %640, double* %35
br label %641
641: ; preds = %639, %626
br label %642
642: ; preds = %641, %624
%643 = load double, double* %34
%644 = load double*, double** %20
%645 = load double, double* %644
%646 = load double, double* %33
%647 = fadd double %645, %646
%648 = fcmp oge double %643, %647
br i1 %648, label %649, label %651
649: ; preds = %642
%650 = load double, double* %34
br label %656
651: ; preds = %642
%652 = load double*, double** %20
%653 = load double, double* %652
%654 = load double, double* %33
%655 = fadd double %653, %654
br label %656
656: ; preds = %651, %649
%657 = phi double [ %650, %649 ], [ %655, %651 ]
%658 = load double*, double** %20
store double %657, double* %658
br label %659
659: ; preds = %656
%660 = load i32, i32* %26
%661 = add nsw i32 %660, 1
store i32 %661, i32* %26
br label %409
662: ; preds = %200, %510
ret void
}

LLVM IR (-O2):
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 %982
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 %578
574: ; preds = %570
%575 = fcmp ole double %6, 1.000000e-01
%576 = select i1 %575, double %6, double 1.000000e-01
%577 = fdiv double 9.881310e-324, %576
br label %578
578: ; preds = %574, %570
%579 = phi double [ %577, %574 ], [ %572, %570 ]
%580 = load double, double* %7
%581 = fcmp oge double %580, %494
%582 = select i1 %581, double %580, double %494
%583 = fcmp ole double %582, %579
%584 = select i1 %583, double %582, double %579
%585 = fcmp oeq double %584, 0.000000e+00
%586 = fdiv double %571, %353
%587 = select i1 %585, double %586, double %584
store double %587, double* %7
%588 = sext i32 %0 to i64
%589 = sext i32 %2 to i64
%590 = zext i32 %0 to i64
%591 = zext i32 %0 to i64
%592 = zext i32 %0 to i64
%593 = getelementptr double, double* %11, i64 %590
%594 = getelementptr double, double* %4, i64 %590
%595 = getelementptr double, double* %8, i64 %590
%596 = getelementptr double, double* %10, i64 %590
%597 = getelementptr double, double* %4, i64 %590
%598 = and i64 %590, 4294967292
%599 = add nsw i64 %598, -4
%600 = lshr exact i64 %599, 2
%601 = add nuw nsw i64 %600, 1
%602 = add nsw i64 %590, -1
%603 = icmp ult i32 %0, 4
%604 = icmp ugt double* %597, %10
%605 = icmp ugt double* %596, %4
%606 = and i1 %604, %605
%607 = and i64 %590, 4294967292
%608 = and i64 %601, 1
%609 = icmp eq i64 %599, 0
%610 = and i64 %601, 9223372036854775806
%611 = icmp eq i64 %608, 0
%612 = icmp eq i64 %607, %590
%613 = and i64 %590, 3
%614 = icmp eq i64 %613, 0
%615 = icmp ult i32 %0, 4
%616 = icmp ugt double* %594, %11
%617 = icmp ugt double* %593, %4
%618 = and i1 %616, %617
%619 = icmp ugt double* %595, %11
%620 = icmp ugt double* %593, %8
%621 = and i1 %619, %620
%622 = or i1 %618, %621
%623 = and i64 %590, 4294967292
%624 = and i64 %601, 1
%625 = icmp eq i64 %599, 0
%626 = and i64 %601, 9223372036854775806
%627 = icmp eq i64 %624, 0
%628 = icmp eq i64 %623, %590
%629 = and i64 %590, 3
%630 = icmp eq i64 %629, 0
%631 = and i64 %590, 1
%632 = icmp eq i64 %602, 0
%633 = and i64 %590, 4294967294
%634 = icmp eq i64 %631, 0
br label %635
635: ; preds = %974, %578
%636 = phi double [ %980, %974 ], [ %587, %578 ]
%637 = phi double [ %866, %974 ], [ %354, %578 ]
%638 = phi i32 [ %981, %974 ], [ 0, %578 ]
%639 = phi double [ %976, %974 ], [ %494, %578 ]
%640 = phi double [ %977, %974 ], [ %579, %578 ]
%641 = fcmp oeq double %636, 0.000000e+00
br i1 %641, label %642, label %646
642: ; preds = %635
%643 = fmul double %640, 1.000000e-03
%644 = fcmp ole double %643, 9.881310e-324
%645 = select i1 %644, double 9.881310e-324, double %643
store double %645, double* %7
br label %646
646: ; preds = %642, %635
%647 = phi double [ %645, %642 ], [ %636, %635 ]
%648 = tail call double @sqrt(double %647)
br i1 %14, label %649, label %719
649: ; preds = %646
%650 = or i1 %603, %606
br i1 %650, label %703, label %651
651: ; preds = %649
%652 = insertelement <2 x double> poison, double %648, i64 0
%653 = shufflevector <2 x double> %652, <2 x double> poison, <2 x i32> zeroinitializer
%654 = insertelement <2 x double> poison, double %648, i64 0
%655 = shufflevector <2 x double> %654, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %609, label %687, label %656
656: ; preds = %651, %656
%657 = phi i64 [ %684, %656 ], [ 0, %651 ]
%658 = phi i64 [ %685, %656 ], [ 0, %651 ]
%659 = getelementptr inbounds double, double* %4, i64 %657
%660 = bitcast double* %659 to <2 x double>*
%661 = load <2 x double>, <2 x double>* %660
%662 = getelementptr inbounds double, double* %659, i64 2
%663 = bitcast double* %662 to <2 x double>*
%664 = load <2 x double>, <2 x double>* %663
%665 = fmul <2 x double> %653, %661
%666 = fmul <2 x double> %655, %664
%667 = getelementptr inbounds double, double* %10, i64 %657
%668 = bitcast double* %667 to <2 x double>*
store <2 x double> %665, <2 x double>* %668
%669 = getelementptr inbounds double, double* %667, i64 2
%670 = bitcast double* %669 to <2 x double>*
store <2 x double> %666, <2 x double>* %670
%671 = or i64 %657, 4
%672 = getelementptr inbounds double, double* %4, i64 %671
%673 = bitcast double* %672 to <2 x double>*
%674 = load <2 x double>, <2 x double>* %673
%675 = getelementptr inbounds double, double* %672, i64 2
%676 = bitcast double* %675 to <2 x double>*
%677 = load <2 x double>, <2 x double>* %676
%678 = fmul <2 x double> %653, %674
%679 = fmul <2 x double> %655, %677
%680 = getelementptr inbounds double, double* %10, i64 %671
%681 = bitcast double* %680 to <2 x double>*
store <2 x double> %678, <2 x double>* %681
%682 = getelementptr inbounds double, double* %680, i64 2
%683 = bitcast double* %682 to <2 x double>*
store <2 x double> %679, <2 x double>* %683
%684 = add nuw i64 %657, 8
%685 = add i64 %658, 2
%686 = icmp eq i64 %685, %610
br i1 %686, label %687, label %656
687: ; preds = %656, %651
%688 = phi i64 [ 0, %651 ], [ %684, %656 ]
br i1 %611, label %702, label %689
689: ; preds = %687
%690 = getelementptr inbounds double, double* %4, i64 %688
%691 = bitcast double* %690 to <2 x double>*
%692 = load <2 x double>, <2 x double>* %691
%693 = getelementptr inbounds double, double* %690, i64 2
%694 = bitcast double* %693 to <2 x double>*
%695 = load <2 x double>, <2 x double>* %694
%696 = fmul <2 x double> %653, %692
%697 = fmul <2 x double> %655, %695
%698 = getelementptr inbounds double, double* %10, i64 %688
%699 = bitcast double* %698 to <2 x double>*
store <2 x double> %696, <2 x double>* %699
%700 = getelementptr inbounds double, double* %698, i64 2
%701 = bitcast double* %700 to <2 x double>*
store <2 x double> %697, <2 x double>* %701
br label %702
702: ; preds = %687, %689
br i1 %612, label %744, label %703
703: ; preds = %649, %702
%704 = phi i64 [ 0, %649 ], [ %607, %702 ]
%705 = sub nsw i64 %602, %704
br i1 %614, label %716, label %706
706: ; preds = %703, %706
%707 = phi i64 [ %713, %706 ], [ %704, %703 ]
%708 = phi i64 [ %714, %706 ], [ 0, %703 ]
%709 = getelementptr inbounds double, double* %4, i64 %707
%710 = load double, double* %709
%711 = fmul double %648, %710
%712 = getelementptr inbounds double, double* %10, i64 %707
store double %711, double* %712
%713 = add nuw nsw i64 %707, 1
%714 = add i64 %708, 1
%715 = icmp eq i64 %714, %613
br i1 %715, label %716, label %706
716: ; preds = %706, %703
%717 = phi i64 [ %704, %703 ], [ %713, %706 ]
%718 = icmp ult i64 %705, 3
br i1 %718, label %744, label %721
719: ; preds = %646
%720 = 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 %864
721: ; preds = %716, %721
%722 = phi i64 [ %742, %721 ], [ %717, %716 ]
%723 = getelementptr inbounds double, double* %4, i64 %722
%724 = load double, double* %723
%725 = fmul double %648, %724
%726 = getelementptr inbounds double, double* %10, i64 %722
store double %725, double* %726
%727 = add nuw nsw i64 %722, 1
%728 = getelementptr inbounds double, double* %4, i64 %727
%729 = load double, double* %728
%730 = fmul double %648, %729
%731 = getelementptr inbounds double, double* %10, i64 %727
store double %730, double* %731
%732 = add nuw nsw i64 %722, 2
%733 = getelementptr inbounds double, double* %4, i64 %732
%734 = load double, double* %733
%735 = fmul double %648, %734
%736 = getelementptr inbounds double, double* %10, i64 %732
store double %735, double* %736
%737 = add nuw nsw i64 %722, 3
%738 = getelementptr inbounds double, double* %4, i64 %737
%739 = load double, double* %738
%740 = fmul double %648, %739
%741 = getelementptr inbounds double, double* %10, i64 %737
store double %740, double* %741
%742 = add nuw nsw i64 %722, 4
%743 = icmp eq i64 %742, %590
br i1 %743, label %744, label %721
744: ; preds = %716, %721, %702
%745 = 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 %746, label %864
746: ; preds = %744
%747 = or i1 %615, %622
br i1 %747, label %814, label %748
748: ; preds = %746
br i1 %625, label %792, label %749
749: ; preds = %748, %749
%750 = phi i64 [ %789, %749 ], [ 0, %748 ]
%751 = phi i64 [ %790, %749 ], [ 0, %748 ]
%752 = getelementptr inbounds double, double* %4, i64 %750
%753 = bitcast double* %752 to <2 x double>*
%754 = load <2 x double>, <2 x double>* %753
%755 = getelementptr inbounds double, double* %752, i64 2
%756 = bitcast double* %755 to <2 x double>*
%757 = load <2 x double>, <2 x double>* %756
%758 = getelementptr inbounds double, double* %8, i64 %750
%759 = bitcast double* %758 to <2 x double>*
%760 = load <2 x double>, <2 x double>* %759
%761 = getelementptr inbounds double, double* %758, i64 2
%762 = bitcast double* %761 to <2 x double>*
%763 = load <2 x double>, <2 x double>* %762
%764 = fmul <2 x double> %754, %760
%765 = fmul <2 x double> %757, %763
%766 = getelementptr inbounds double, double* %11, i64 %750
%767 = bitcast double* %766 to <2 x double>*
store <2 x double> %764, <2 x double>* %767
%768 = getelementptr inbounds double, double* %766, i64 2
%769 = bitcast double* %768 to <2 x double>*
store <2 x double> %765, <2 x double>* %769
%770 = or i64 %750, 4
%771 = getelementptr inbounds double, double* %4, i64 %770
%772 = bitcast double* %771 to <2 x double>*
%773 = load <2 x double>, <2 x double>* %772
%774 = getelementptr inbounds double, double* %771, i64 2
%775 = bitcast double* %774 to <2 x double>*
%776 = load <2 x double>, <2 x double>* %775
%777 = getelementptr inbounds double, double* %8, i64 %770
%778 = bitcast double* %777 to <2 x double>*
%779 = load <2 x double>, <2 x double>* %778
%780 = getelementptr inbounds double, double* %777, i64 2
%781 = bitcast double* %780 to <2 x double>*
%782 = load <2 x double>, <2 x double>* %781
%783 = fmul <2 x double> %773, %779
%784 = fmul <2 x double> %776, %782
%785 = getelementptr inbounds double, double* %11, i64 %770
%786 = bitcast double* %785 to <2 x double>*
store <2 x double> %783, <2 x double>* %786
%787 = getelementptr inbounds double, double* %785, i64 2
%788 = bitcast double* %787 to <2 x double>*
store <2 x double> %784, <2 x double>* %788
%789 = add nuw i64 %750, 8
%790 = add i64 %751, 2
%791 = icmp eq i64 %790, %626
br i1 %791, label %792, label %749
792: ; preds = %749, %748
%793 = phi i64 [ 0, %748 ], [ %789, %749 ]
br i1 %627, label %813, label %794
794: ; preds = %792
%795 = getelementptr inbounds double, double* %4, i64 %793
%796 = bitcast double* %795 to <2 x double>*
%797 = load <2 x double>, <2 x double>* %796
%798 = getelementptr inbounds double, double* %795, i64 2
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = getelementptr inbounds double, double* %8, i64 %793
%802 = bitcast double* %801 to <2 x double>*
%803 = load <2 x double>, <2 x double>* %802
%804 = getelementptr inbounds double, double* %801, i64 2
%805 = bitcast double* %804 to <2 x double>*
%806 = load <2 x double>, <2 x double>* %805
%807 = fmul <2 x double> %797, %803
%808 = fmul <2 x double> %800, %806
%809 = getelementptr inbounds double, double* %11, i64 %793
%810 = bitcast double* %809 to <2 x double>*
store <2 x double> %807, <2 x double>* %810
%811 = getelementptr inbounds double, double* %809, i64 2
%812 = bitcast double* %811 to <2 x double>*
store <2 x double> %808, <2 x double>* %812
br label %813
813: ; preds = %792, %794
br i1 %628, label %864, label %814
814: ; preds = %746, %813
%815 = phi i64 [ 0, %746 ], [ %623, %813 ]
%816 = xor i64 %815, -1
%817 = add nsw i64 %816, %590
br i1 %630, label %830, label %818
818: ; preds = %814, %818
%819 = phi i64 [ %827, %818 ], [ %815, %814 ]
%820 = phi i64 [ %828, %818 ], [ 0, %814 ]
%821 = getelementptr inbounds double, double* %4, i64 %819
%822 = load double, double* %821
%823 = getelementptr inbounds double, double* %8, i64 %819
%824 = load double, double* %823
%825 = fmul double %822, %824
%826 = getelementptr inbounds double, double* %11, i64 %819
store double %825, double* %826
%827 = add nuw nsw i64 %819, 1
%828 = add i64 %820, 1
%829 = icmp eq i64 %828, %629
br i1 %829, label %830, label %818
830: ; preds = %818, %814
%831 = phi i64 [ %815, %814 ], [ %827, %818 ]
%832 = icmp ult i64 %817, 3
br i1 %832, label %864, label %833
833: ; preds = %830, %833
%834 = phi i64 [ %862, %833 ], [ %831, %830 ]
%835 = getelementptr inbounds double, double* %4, i64 %834
%836 = load double, double* %835
%837 = getelementptr inbounds double, double* %8, i64 %834
%838 = load double, double* %837
%839 = fmul double %836, %838
%840 = getelementptr inbounds double, double* %11, i64 %834
store double %839, double* %840
%841 = add nuw nsw i64 %834, 1
%842 = getelementptr inbounds double, double* %4, i64 %841
%843 = load double, double* %842
%844 = getelementptr inbounds double, double* %8, i64 %841
%845 = load double, double* %844
%846 = fmul double %843, %845
%847 = getelementptr inbounds double, double* %11, i64 %841
store double %846, double* %847
%848 = add nuw nsw i64 %834, 2
%849 = getelementptr inbounds double, double* %4, i64 %848
%850 = load double, double* %849
%851 = getelementptr inbounds double, double* %8, i64 %848
%852 = load double, double* %851
%853 = fmul double %850, %852
%854 = getelementptr inbounds double, double* %11, i64 %848
store double %853, double* %854
%855 = add nuw nsw i64 %834, 3
%856 = getelementptr inbounds double, double* %4, i64 %855
%857 = load double, double* %856
%858 = getelementptr inbounds double, double* %8, i64 %855
%859 = load double, double* %858
%860 = fmul double %857, %859
%861 = getelementptr inbounds double, double* %11, i64 %855
store double %860, double* %861
%862 = add nuw nsw i64 %834, 4
%863 = icmp eq i64 %862, %591
br i1 %863, label %864, label %833
864: ; preds = %830, %833, %813, %719, %744
%865 = tail call double @lm_enorm(i32 %0, double* %11)
%866 = fsub double %865, %6
%867 = tail call double @llvm.fabs.f64(double %866)
%868 = fcmp ugt double %867, %355
br i1 %868, label %869, label %982
869: ; preds = %864
%870 = fcmp oeq double %639, 0.000000e+00
br i1 %870, label %871, label %877
871: ; preds = %869
%872 = fcmp ole double %866, %637
%873 = fcmp olt double %637, 0.000000e+00
%874 = and i1 %873, %872
%875 = icmp eq i32 %638, 10
%876 = select i1 %874, i1 true, i1 %875
br i1 %876, label %982, label %879
877: ; preds = %869
%878 = icmp eq i32 %638, 10
br i1 %878, label %982, label %879
879: ; preds = %871, %877
br i1 %14, label %880, label %958
880: ; preds = %879
br i1 %632, label %881, label %895
881: ; preds = %895, %880
%882 = phi i64 [ 0, %880 ], [ %919, %895 ]
br i1 %634, label %894, label %883
883: ; preds = %881
%884 = getelementptr inbounds i32, i32* %3, i64 %882
%885 = load i32, i32* %884
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %4, i64 %886
%888 = load double, double* %887
%889 = getelementptr inbounds double, double* %11, i64 %886
%890 = load double, double* %889
%891 = fmul double %888, %890
%892 = fdiv double %891, %865
%893 = getelementptr inbounds double, double* %10, i64 %882
store double %892, double* %893
br label %894
894: ; preds = %881, %883
br i1 %14, label %925, label %958
895: ; preds = %880, %895
%896 = phi i64 [ %919, %895 ], [ 0, %880 ]
%897 = phi i64 [ %920, %895 ], [ 0, %880 ]
%898 = getelementptr inbounds i32, i32* %3, i64 %896
%899 = load i32, i32* %898
%900 = sext i32 %899 to i64
%901 = getelementptr inbounds double, double* %4, i64 %900
%902 = load double, double* %901
%903 = getelementptr inbounds double, double* %11, i64 %900
%904 = load double, double* %903
%905 = fmul double %902, %904
%906 = fdiv double %905, %865
%907 = getelementptr inbounds double, double* %10, i64 %896
store double %906, double* %907
%908 = or i64 %896, 1
%909 = getelementptr inbounds i32, i32* %3, i64 %908
%910 = load i32, i32* %909
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds double, double* %4, i64 %911
%913 = load double, double* %912
%914 = getelementptr inbounds double, double* %11, i64 %911
%915 = load double, double* %914
%916 = fmul double %913, %915
%917 = fdiv double %916, %865
%918 = getelementptr inbounds double, double* %10, i64 %908
store double %917, double* %918
%919 = add nuw nsw i64 %896, 2
%920 = add i64 %897, 2
%921 = icmp eq i64 %920, %633
br i1 %921, label %881, label %895
922: ; preds = %946, %935, %925
%923 = add nuw nsw i64 %927, 1
%924 = icmp eq i64 %933, %592
br i1 %924, label %958, label %925
925: ; preds = %894, %922
%926 = phi i64 [ %933, %922 ], [ 0, %894 ]
%927 = phi i64 [ %923, %922 ], [ 1, %894 ]
%928 = getelementptr inbounds double, double* %10, i64 %926
%929 = load double, double* %928
%930 = getelementptr inbounds double, double* %9, i64 %926
%931 = load double, double* %930
%932 = fdiv double %929, %931
store double %932, double* %928
%933 = add nuw nsw i64 %926, 1
%934 = icmp slt i64 %933, %588
br i1 %934, label %935, label %922
935: ; preds = %925
%936 = mul nsw i64 %926, %589
%937 = add nsw i64 %927, %936
%938 = getelementptr inbounds double, double* %1, i64 %937
%939 = load double, double* %938
%940 = getelementptr inbounds double, double* %10, i64 %927
%941 = load double, double* %940
%942 = fneg double %939
%943 = tail call double @llvm.fmuladd.f64(double %942, double %932, double %941)
store double %943, double* %940
%944 = add nuw nsw i64 %927, 1
%945 = icmp eq i64 %944, %592
br i1 %945, label %922, label %946
946: ; preds = %935, %946
%947 = phi i64 [ %956, %946 ], [ %944, %935 ]
%948 = load double, double* %928
%949 = add nsw i64 %947, %936
%950 = getelementptr inbounds double, double* %1, i64 %949
%951 = load double, double* %950
%952 = getelementptr inbounds double, double* %10, i64 %947
%953 = load double, double* %952
%954 = fneg double %951
%955 = tail call double @llvm.fmuladd.f64(double %954, double %948, double %953)
store double %955, double* %952
%956 = add nuw nsw i64 %947, 1
%957 = icmp eq i64 %956, %592
br i1 %957, label %922, label %946
958: ; preds = %922, %879, %894
%959 = tail call double @lm_enorm(i32 %0, double* %10)
%960 = fdiv double %866, %6
%961 = fdiv double %960, %959
%962 = fdiv double %961, %959
%963 = fcmp ogt double %866, 0.000000e+00
br i1 %963, label %964, label %968
964: ; preds = %958
%965 = load double, double* %7
%966 = fcmp oge double %639, %965
%967 = select i1 %966, double %639, double %965
br label %974
968: ; preds = %958
%969 = fcmp olt double %866, 0.000000e+00
%970 = load double, double* %7
br i1 %969, label %971, label %974
971: ; preds = %968
%972 = fcmp ole double %640, %970
%973 = select i1 %972, double %640, double %970
br label %974
974: ; preds = %968, %971, %964
%975 = phi double [ %965, %964 ], [ %970, %971 ], [ %970, %968 ]
%976 = phi double [ %967, %964 ], [ %639, %971 ], [ %639, %968 ]
%977 = phi double [ %640, %964 ], [ %973, %971 ], [ %640, %968 ]
%978 = fadd double %962, %975
%979 = fcmp oge double %976, %978
%980 = select i1 %979, double %976, double %978
store double %980, double* %7
%981 = add nuw nsw i32 %638, 1
br label %635
982: ; preds = %871, %877, %864, %357
ret void
}