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
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  0x2c8f(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     13c8 <lm_lmpar+0x298>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    1b8e <lm_lmpar+0xa5e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     1534 <lm_lmpar+0x404>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1439 <lm_lmpar+0x309>
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    13e3 <lm_lmpar+0x2b3>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14fb <lm_lmpar+0x3cb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14b3 <lm_lmpar+0x383>
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    145e <lm_lmpar+0x32e>
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    1440 <lm_lmpar+0x310>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
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    15e6 <lm_lmpar+0x4b6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     15ae <lm_lmpar+0x47e>
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    1559 <lm_lmpar+0x429>
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    153b <lm_lmpar+0x40b>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
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    1676 <lm_lmpar+0x546>
jp     1676 <lm_lmpar+0x546>
movsd  -0x38(%rbp),%xmm1
movsd  0x2a07(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     164d <lm_lmpar+0x51d>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    165d <lm_lmpar+0x52d>
movsd  0x29e3(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x993(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x78(%rbp),%xmm0
jb     169e <lm_lmpar+0x56e>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    16ab <lm_lmpar+0x57b>
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     16e7 <lm_lmpar+0x5b7>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    16f4 <lm_lmpar+0x5c4>
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    1731 <lm_lmpar+0x601>
jp     1731 <lm_lmpar+0x601>
movsd  -0x68(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1736 <lm_lmpar+0x606>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17aa <lm_lmpar+0x67a>
jp     17aa <lm_lmpar+0x67a>
movsd  0x28e7(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0x89a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1785 <lm_lmpar+0x655>
movsd  0x888(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    179a <lm_lmpar+0x66a>
movsd  0x28b3(%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    1802 <lm_lmpar+0x6d2>
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    17c6 <lm_lmpar+0x696>
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)
mov    $0x0,%al
call   1030 <lm_qrsolv@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1881 <lm_lmpar+0x751>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1840 <lm_lmpar+0x710>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
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 0x753(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x276f(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    191c <lm_lmpar+0x7ec>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1912 <lm_lmpar+0x7e2>
jp     1912 <lm_lmpar+0x7e2>
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1912 <lm_lmpar+0x7e2>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
ja     191c <lm_lmpar+0x7ec>
cmpl   $0xa,-0x40(%rbp)
jne    1921 <lm_lmpar+0x7f1>
jmp    1b8e <lm_lmpar+0xa5e>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    197e <lm_lmpar+0x84e>
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    1928 <lm_lmpar+0x7f8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a42 <lm_lmpar+0x912>
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    1a2f <lm_lmpar+0x8ff>
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    19c1 <lm_lmpar+0x891>
jmp    1a34 <lm_lmpar+0x904>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1985 <lm_lmpar+0x855>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
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    1ad4 <lm_lmpar+0x9a4>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1ab2 <lm_lmpar+0x982>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1ac2 <lm_lmpar+0x992>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1b2d <lm_lmpar+0x9fd>
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1b28 <lm_lmpar+0x9f8>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1b0b <lm_lmpar+0x9db>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1b1b <lm_lmpar+0x9eb>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
jmp    1b2d <lm_lmpar+0x9fd>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x70(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     1b5b <lm_lmpar+0xa2b>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1b70 <lm_lmpar+0xa40>
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    1736 <lm_lmpar+0x606>
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    $0xc8,%rsp
movsd  %xmm0,0x28(%rsp)
mov    %r9,%r14
mov    %r8,%r12
mov    %rsi,%r15
mov    0x120(%rsp),%rbx
mov    0x118(%rsp),%r13
mov    %edi,%r9d
mov    %edi,%eax
mov    %rax,0x38(%rsp)
test   %edi,%edi
mov    %rcx,0x8(%rsp)
mov    %edx,0x24(%rsp)
mov    %edi,(%rsp)
mov    %r9,0x10(%rsp)
jle    15e0 <lm_lmpar+0x4b0>
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,0x38(%rsp)
test   %eax,%eax
jle    1440 <lm_lmpar+0x310>
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%ebx
mov    %eax,%eax
movslq %edx,%rsi
mov    %rax,0x30(%rsp)
lea    -0x1(%rax),%rdi
imul   %rsi,%rdi
lea    (%rdi,%rbx,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x60(%rsp)
mov    %rsi,0x48(%rsp)
lea    0x0(,%rsi,8),%rax
mov    %rax,%rsi
neg    %rsi
mov    %rsi,0x50(%rsp)
xor    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
lea    (%rcx,%rdi,8),%r15
add    $0x10,%r15
mov    %rdi,0x80(%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)
nop
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    1440 <lm_lmpar+0x310>
mov    0x30(%rsp),%r10
lea    -0x1(%r10),%rsi
movsd  -0x8(%r13,%r10,8),%xmm0
mov    %rsi,0x30(%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     1440 <lm_lmpar+0x310>
mov    %rbx,%r9
sub    %r8,%r9
cmp    $0x4,%r9
jb     1322 <lm_lmpar+0x1f2>
mov    0x40(%rsp),%rsi
imul   %r8,%rsi
add    0x60(%rsp),%rsi
cmp    %r13,%rsi
jbe    13d0 <lm_lmpar+0x2a0>
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
mov    %r8,%rdi
imul   0x48(%rsp),%rdi
mov    %rbx,%rbp
mov    0x80(%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    13d0 <lm_lmpar+0x2a0>
xor    %r11d,%r11d
mov    %r8,%rsi
not    %rsi
add    %rbx,%rsi
mov    %r11,%rdi
test   $0x1,%al
je     136a <lm_lmpar+0x23a>
mov    0x30(%rsp),%rdi
imul   0x48(%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>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rdi,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rdi,8),%xmm1
movsd  %xmm2,0x0(%r13,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1380 <lm_lmpar+0x250>
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    13f0 <lm_lmpar+0x2c0>
cmp    %r11,%r9
je     1260 <lm_lmpar+0x130>
jmp    1325 <lm_lmpar+0x1f5>
mov    (%rsp),%edi
test   %edi,%edi
mov    0x120(%rsp),%rbx
jle    146e <lm_lmpar+0x33e>
mov    %rbp,%rcx
lea    -0x1(%r9),%rdx
mov    %r9d,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1478 <lm_lmpar+0x348>
xor    %ebp,%ebp
mov    0x108(%rsp),%r8
jmp    14e0 <lm_lmpar+0x3b0>
mov    0x18(%rsp),%r15
jmp    15e0 <lm_lmpar+0x4b0>
mov    %r9d,%edx
and    $0xfffffffc,%edx
xor    %ebp,%ebp
mov    0x108(%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    1490 <lm_lmpar+0x360>
test   %rax,%rax
mov    0x18(%rsp),%r15
je     1519 <lm_lmpar+0x3e9>
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    1500 <lm_lmpar+0x3d0>
test   %edi,%edi
jle    15d8 <lm_lmpar+0x4a8>
cmp    $0x4,%r9d
mov    0x120(%rsp),%rbx
jae    168c <lm_lmpar+0x55c>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdx
and    $0x3,%rdx
je     156b <lm_lmpar+0x43b>
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    1550 <lm_lmpar+0x420>
cmp    $0x3,%rsi
jb     15e0 <lm_lmpar+0x4b0>
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    1580 <lm_lmpar+0x450>
jmp    15e0 <lm_lmpar+0x4b0>
mov    0x120(%rsp),%rbx
mov    %rbx,%rsi
mov    0x100(%rsp),%rbx
xor    %eax,%eax
mov    %edi,%ebp
call   1040 <lm_enorm@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movapd %xmm3,%xmm2
movsd  0x28(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  0x19ef(%rip),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
jae    1673 <lm_lmpar+0x543>
movsd  %xmm1,0xc0(%rsp)
xorpd  %xmm1,%xmm1
mov    0x24(%rsp),%r10d
movslq %r10d,%rax
mov    %rax,0x40(%rsp)
cmp    %ebp,0x38(%rsp)
movsd  %xmm2,0x60(%rsp)
movsd  %xmm3,0x30(%rsp)
jl     1976 <lm_lmpar+0x846>
test   %ebp,%ebp
mov    0x10(%rsp),%r11
mov    0x120(%rsp),%rbp
jle    194c <lm_lmpar+0x81c>
mov    (%rsp),%esi
cmp    $0x1,%esi
jne    17a7 <lm_lmpar+0x677>
xor    %eax,%eax
jmp    1800 <lm_lmpar+0x6d0>
movq   $0x0,(%rbx)
add    $0xc8,%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    235d <lm_lmpar+0x122d>
and    %sil,%cl
mov    0x120(%rsp),%rbx
jne    1535 <lm_lmpar+0x405>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     236a <lm_lmpar+0x123a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
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    1700 <lm_lmpar+0x5d0>
test   $0x1,%dl
je     1799 <lm_lmpar+0x669>
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    1535 <lm_lmpar+0x405>
jmp    15e0 <lm_lmpar+0x4b0>
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),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rdx
movsd  (%r12,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    17c0 <lm_lmpar+0x690>
test   $0x1,%r11b
je     1826 <lm_lmpar+0x6f6>
mov    0x8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
test   %esi,%esi
jle    194c <lm_lmpar+0x81c>
lea    0x18(%r15),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
xor    %ebp,%ebp
mov    %r15,%r9
jmp    188b <lm_lmpar+0x75b>
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     194c <lm_lmpar+0x81c>
test   %rbp,%rbp
je     1850 <lm_lmpar+0x720>
lea    -0x1(%rbp),%rcx
cmp    $0x3,%rcx
jae    18b0 <lm_lmpar+0x780>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    190c <lm_lmpar+0x7dc>
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    18c0 <lm_lmpar+0x790>
test   $0x3,%bpl
je     1854 <lm_lmpar+0x724>
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    1930 <lm_lmpar+0x800>
jmp    1854 <lm_lmpar+0x724>
mov    (%rsp),%ebp
mov    %ebp,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x60(%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    1a8d <lm_lmpar+0x95d>
lea    0x18(%r15),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
mov    $0x1,%r10d
xor    %esi,%esi
mov    %r15,%r9
jmp    19d8 <lm_lmpar+0x8a8>
nopl   0x0(%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     1a8d <lm_lmpar+0x95d>
cmp    $0x3,%rsi
jae    19f0 <lm_lmpar+0x8c0>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    1a4b <lm_lmpar+0x91b>
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    1a00 <lm_lmpar+0x8d0>
test   $0x3,%r10b
je     19b0 <lm_lmpar+0x880>
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    1a70 <lm_lmpar+0x940>
jmp    19b0 <lm_lmpar+0x880>
mov    (%rsp),%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm1,%xmm3
movsd  0x28(%rsp),%xmm0
divsd  %xmm0,%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm3
mov    0x120(%rsp),%rcx
jne    1ad7 <lm_lmpar+0x9a7>
jp     1ad7 <lm_lmpar+0x9a7>
minsd  0x1535(%rip),%xmm0
movsd  0x1535(%rip),%xmm3
divsd  %xmm0,%xmm3
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x78(%rsp)
mov    0x100(%rsp),%rsi
movsd  (%rsi),%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,0x80(%rsp)
andnpd %xmm6,%xmm0
orpd   %xmm4,%xmm0
ucomisd %xmm2,%xmm0
mov    0x108(%rsp),%r10
jne    1b4d <lm_lmpar+0xa1d>
jp     1b4d <lm_lmpar+0xa1d>
divsd  0x30(%rsp),%xmm1
movapd %xmm1,%xmm0
mov    (%rsp),%edi
mov    0x10(%rsp),%rbp
mov    0x110(%rsp),%r11
movsd  %xmm0,(%rsi)
movslq %edi,%rax
mov    %rax,0x30(%rsp)
lea    (%rcx,%rbp,8),%r9
lea    (%r12,%rbp,8),%r8
lea    (%r10,%rbp,8),%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
mov    %ebp,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xa8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xa0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r13,%r8
seta   %bl
cmp    %r12,%rax
seta   %al
and    %bl,%al
mov    %al,0x7(%rsp)
mov    %rdx,%rax
mov    %rdx,0x98(%rsp)
and    %rdx,0x78(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0xb0(%rsp)
cmp    %rcx,%r8
seta   %al
lea    -0x1(%rbp),%rdx
mov    %rdx,0x38(%rsp)
cmp    %r12,%r9
seta   %bl
and    %al,%bl
cmp    %rcx,0x18(%rsp)
seta   %cl
cmp    %r10,%r9
seta   %al
and    %cl,%al
or     %bl,%al
mov    %al,0x6(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0xb8(%rsp)
mov    0x40(%rsp),%rax
lea    0x8(,%rax,8),%rax
mov    %rax,0x18(%rsp)
xorpd  %xmm4,%xmm4
movl   $0x0,0x48(%rsp)
mov    0x8(%rsp),%rbx
jmp    1cc8 <lm_lmpar+0xb98>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x100(%rsp),%rsi
movsd  (%rsi),%xmm0
movapd %xmm0,%xmm1
movapd 0x50(%rsp),%xmm5
cmplesd %xmm5,%xmm1
andpd  %xmm1,%xmm5
andnpd %xmm0,%xmm1
orpd   %xmm1,%xmm5
movsd  0x28(%rsp),%xmm3
mov    0x8(%rsp),%rbx
mov    (%rsp),%edi
mov    0x108(%rsp),%r10
mov    0x110(%rsp),%r11
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm6,%xmm2
divsd  %xmm3,%xmm2
divsd  %xmm1,%xmm2
divsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm5,%xmm0
movapd %xmm0,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm5,%xmm0
orpd   %xmm1,%xmm0
movlpd %xmm0,(%rsi)
addl   $0x1,0x48(%rsp)
movsd  %xmm6,0x60(%rsp)
ucomisd %xmm4,%xmm0
jne    1cf1 <lm_lmpar+0xbc1>
jp     1cf1 <lm_lmpar+0xbc1>
movapd 0x80(%rsp),%xmm1
mulsd  0x132f(%rip),%xmm1
movsd  0x131f(%rip),%xmm0
maxsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi)
ucomisd %xmm4,%xmm0
movapd %xmm5,0x50(%rsp)
jb     1d10 <lm_lmpar+0xbe0>
sqrtsd %xmm0,%xmm0
jmp    1d28 <lm_lmpar+0xbf8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1050 <sqrt@plt>
mov    0x110(%rsp),%r11
mov    0x108(%rsp),%r10
mov    (%rsp),%edi
mov    0x24(%rsp),%edx
test   %edi,%edi
jle    1d50 <lm_lmpar+0xc20>
cmp    $0x4,%edi
setb   %al
or     0x7(%rsp),%al
je     1d90 <lm_lmpar+0xc60>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
jmp    1e52 <lm_lmpar+0xd22>
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    %r15,%rsi
mov    %rbx,%rcx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
mov    0x128(%rsp),%rbx
push   %rbx
push   %r11
push   %r10
call   1030 <lm_qrsolv@plt>
mov    0x20(%rsp),%edi
add    $0x20,%rsp
jmp    20b0 <lm_lmpar+0xf80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xa0(%rsp)
je     232e <lm_lmpar+0x11fe>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
mov    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    1dc0 <lm_lmpar+0xc90>
testb  $0x1,0x98(%rsp)
01
je     1e3e <lm_lmpar+0xd0e>
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    0xa8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     1ef0 <lm_lmpar+0xdc0>
mov    0x38(%rsp),%rcx
sub    %rax,%rcx
mov    0xb0(%rsp),%rsi
test   %rsi,%rsi
je     1e8b <lm_lmpar+0xd5b>
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1e70 <lm_lmpar+0xd40>
cmp    $0x3,%rcx
jb     1ef0 <lm_lmpar+0xdc0>
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    1ea0 <lm_lmpar+0xd70>
sub    $0x8,%rsp
mov    %r15,%rsi
mov    %rbx,%rcx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
mov    0x128(%rsp),%rbx
push   %rbx
push   %r11
push   %r10
call   1030 <lm_qrsolv@plt>
mov    0x30(%rsp),%rbp
mov    0x128(%rsp),%rsi
mov    0x20(%rsp),%edi
add    $0x20,%rsp
test   %edi,%edi
jle    20b0 <lm_lmpar+0xf80>
cmp    $0x4,%edi
setb   %al
or     0x6(%rsp),%al
je     1f44 <lm_lmpar+0xe14>
xor    %eax,%eax
jmp    200c <lm_lmpar+0xedc>
cmpq   $0x0,0xa0(%rsp)
je     2348 <lm_lmpar+0x1218>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
nopw   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    1f60 <lm_lmpar+0xe30>
testb  $0x1,0x98(%rsp)
01
je     1ff8 <lm_lmpar+0xec8>
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    0xa8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     20b0 <lm_lmpar+0xf80>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x3,%bpl
je     204a <lm_lmpar+0xf1a>
mov    0xb0(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2030 <lm_lmpar+0xf00>
cmp    $0x3,%rcx
jb     20b0 <lm_lmpar+0xf80>
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    2050 <lm_lmpar+0xf20>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm3
subsd  0x28(%rsp),%xmm3
movapd %xmm3,%xmm1
andpd  0xf49(%rip),%xmm1
movsd  0xc0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
mov    0x40(%rsp),%r10
movapd 0x50(%rsp),%xmm1
mov    0x110(%rsp),%r11
xorpd  %xmm2,%xmm2
jae    167a <lm_lmpar+0x54a>
ucomisd %xmm2,%xmm1
jne    2125 <lm_lmpar+0xff5>
jp     2125 <lm_lmpar+0xff5>
movsd  0x60(%rsp),%xmm1
ucomisd %xmm3,%xmm1
setae  %al
ucomisd %xmm1,%xmm2
seta   %cl
test   %al,%cl
jne    167a <lm_lmpar+0x54a>
cmpl   $0xa,0x48(%rsp)
je     167a <lm_lmpar+0x54a>
movapd %xmm3,0x60(%rsp)
mov    (%rsp),%edi
test   %edi,%edi
mov    0x10(%rsp),%r9
jle    2290 <lm_lmpar+0x1160>
cmpq   $0x0,0x38(%rsp)
je     2310 <lm_lmpar+0x11e0>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x120(%rsp),%rsi
mov    0xb8(%rsp),%rbp
nopl   0x0(%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    2170 <lm_lmpar+0x1040>
test   $0x1,%r9b
je     21ce <lm_lmpar+0x109e>
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    2290 <lm_lmpar+0x1160>
mov    $0x1,%eax
mov    %r15,%rcx
mov    %r13,%rdx
mov    %r9,%rsi
xor    %r8d,%r8d
jmp    220a <lm_lmpar+0x10da>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
add    $0x8,%rdx
add    0x18(%rsp),%rcx
cmp    %r9,%r8
je     2290 <lm_lmpar+0x1160>
mov    %r8,%rbp
movsd  0x0(%r13,%r8,8),%xmm0
divsd  (%r11,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%r8,8)
add    $0x1,%r8
cmp    0x30(%rsp),%r8
jge    21f0 <lm_lmpar+0x10c0>
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     21f0 <lm_lmpar+0x10c0>
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    2260 <lm_lmpar+0x1130>
jmp    21f0 <lm_lmpar+0x10c0>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorpd  %xmm4,%xmm4
movapd 0x60(%rsp),%xmm6
ucomisd %xmm4,%xmm6
ja     1c40 <lm_lmpar+0xb10>
ucomisd %xmm6,%xmm4
mov    0x100(%rsp),%rsi
movsd  (%rsi),%xmm0
jbe    22e7 <lm_lmpar+0x11b7>
movapd 0x80(%rsp),%xmm2
movapd %xmm2,%xmm1
cmplesd %xmm0,%xmm1
andpd  %xmm1,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm1,%xmm2
movapd %xmm2,0x80(%rsp)
movsd  0x28(%rsp),%xmm3
mov    0x8(%rsp),%rbx
mov    (%rsp),%edi
mov    0x108(%rsp),%r10
movapd 0x50(%rsp),%xmm5
jmp    1c7d <lm_lmpar+0xb4d>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x120(%rsp),%rsi
test   $0x1,%r9b
jne    21b4 <lm_lmpar+0x1084>
jmp    21ce <lm_lmpar+0x109e>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
testb  $0x1,0x98(%rsp)
01
jne    1e1b <lm_lmpar+0xceb>
jmp    1e3e <lm_lmpar+0xd0e>
xor    %eax,%eax
testb  $0x1,0x98(%rsp)
01
jne    1fcd <lm_lmpar+0xe9d>
jmp    1ff8 <lm_lmpar+0xec8>
mov    0x120(%rsp),%rbx
jmp    1535 <lm_lmpar+0x405>
xor    %ebp,%ebp
test   $0x1,%dl
jne    176c <lm_lmpar+0x63c>
jmp    1799 <lm_lmpar+0x669>

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