#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double mp_dmax1(double, double);
double mp_dmin1(double, double);
double mp_enorm(int, double *);
int /*<<< orphan*/ mp_qrsolv(int, double *, int, int *, double *, double *,
                             double *, double *, double *);
double sqrt(double);
void mp_lmpar(int n, double *r, int ldr, int *ipvt, int *ifree, double *diag,
              double *qtb, double delta, double *par, double *x, double *sdiag,
              double *wa1, double *wa2) {
  int i, iter, ij, jj, j, jm1, jp1, k, l, nsing;
  double dxnorm, fp, gnorm, parc, parl, paru;
  double sum, temp;
  static double zero = 0.0;
  static double p1 = 0.1;
  static double p001 = 0.001;
  nsing = n;
  jj = 0;
  for (j = 0; j < n; j++) {
    wa1[j] = qtb[j];
    if ((r[jj] == zero) && (nsing == n))
      nsing = j;
    if (nsing < n)
      wa1[j] = zero;
    jj += ldr + 1;
  }
  if (nsing >= 1) {
    for (k = 0; k < nsing; k++) {
      j = nsing - k - 1;
      wa1[j] = wa1[j] / r[j + ldr * j];
      temp = wa1[j];
      jm1 = j - 1;
      if (jm1 >= 0) {
        ij = ldr * j;
        for (i = 0; i <= jm1; i++) {
          wa1[i] -= r[ij] * temp;
          ij += 1;
        }
      }
    }
  }
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    x[l] = wa1[j];
  }
  iter = 0;
  for (j = 0; j < n; j++)
    wa2[j] = diag[ifree[j]] * x[j];
  dxnorm = mp_enorm(n, wa2);
  fp = dxnorm - delta;
  if (fp <= p1 * delta) {
    goto L220;
  }
  parl = zero;
  if (nsing >= n) {
    for (j = 0; j < n; j++) {
      l = ipvt[j];
      wa1[j] = diag[ifree[l]] * (wa2[l] / dxnorm);
    }
    jj = 0;
    for (j = 0; j < n; j++) {
      sum = zero;
      jm1 = j - 1;
      if (jm1 >= 0) {
        ij = jj;
        for (i = 0; i <= jm1; i++) {
          sum += r[ij] * wa1[i];
          ij += 1;
        }
      }
      wa1[j] = (wa1[j] - sum) / r[j + ldr * j];
      jj += ldr;
    }
    temp = mp_enorm(n, wa1);
    parl = ((fp / delta) / temp) / temp;
  }
  jj = 0;
  for (j = 0; j < n; j++) {
    sum = zero;
    ij = jj;
    for (i = 0; i <= j; i++) {
      sum += r[ij] * qtb[i];
      ij += 1;
    }
    l = ipvt[j];
    wa1[j] = sum / diag[ifree[l]];
    jj += ldr;
  }
  gnorm = mp_enorm(n, wa1);
  paru = gnorm / delta;
  if (paru == zero)
    paru = 1.17549e-38 / mp_dmin1(delta, p1);
  *par = mp_dmax1(*par, parl);
  *par = mp_dmin1(*par, paru);
  if (*par == zero)
    *par = gnorm / dxnorm;
L150:
  iter += 1;
  if (*par == zero)
    *par = mp_dmax1(1.17549e-38, p001 * paru);
  temp = sqrt(*par);
  for (j = 0; j < n; j++)
    wa1[j] = temp * diag[ifree[j]];
  mp_qrsolv(n, r, ldr, ipvt, wa1, qtb, x, sdiag, wa2);
  for (j = 0; j < n; j++)
    wa2[j] = diag[ifree[j]] * x[j];
  dxnorm = mp_enorm(n, wa2);
  temp = fp;
  fp = dxnorm - delta;
  if ((fabs(fp) <= p1 * delta) ||
      ((parl == zero) && (fp <= temp) && (temp < zero)) || (iter == 10))
    goto L220;
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    wa1[j] = diag[ifree[l]] * (wa2[l] / dxnorm);
  }
  jj = 0;
  for (j = 0; j < n; j++) {
    wa1[j] = wa1[j] / sdiag[j];
    temp = wa1[j];
    jp1 = j + 1;
    if (jp1 < n) {
      ij = jp1 + jj;
      for (i = jp1; i < n; i++) {
        wa1[i] -= r[ij] * temp;
        ij += 1;
      }
    }
    jj += ldr;
  }
  temp = mp_enorm(n, wa1);
  parc = ((fp / delta) / temp) / temp;
  if (fp > zero)
    parl = mp_dmax1(parl, *par);
  if (fp < zero)
    paru = mp_dmin1(paru, *par);
  *par = mp_dmax1(parl, *par + parc);
  goto L150;
L220:
  if (iter == 0)
    *par = zero;
}


x86 assembly (clang, -O0):
<mp_lmpar>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x38(%rbp),%rax
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,-0x60(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1236 <mp_lmpar+0xe6>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x2e83(%rip),%xmm0
jne    11fb <mp_lmpar+0xab>
jp     11fb <mp_lmpar+0xab>
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    11fb <mp_lmpar+0xab>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    121c <mp_lmpar+0xcc>
movsd  0x2e51(%rip),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11a2 <mp_lmpar+0x52>
cmpl   $0x1,-0x60(%rbp)
jl     1350 <mp_lmpar+0x200>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    134b <mp_lmpar+0x1fb>
mov    -0x60(%rbp),%eax
sub    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jl     1338 <mp_lmpar+0x1e8>
mov    -0x14(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1333 <mp_lmpar+0x1e3>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    0x30(%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    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ca <mp_lmpar+0x17a>
jmp    1338 <mp_lmpar+0x1e8>
jmp    133d <mp_lmpar+0x1ed>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1247 <mp_lmpar+0xf7>
jmp    1350 <mp_lmpar+0x200>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1399 <mp_lmpar+0x249>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1357 <mp_lmpar+0x207>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f0 <mp_lmpar+0x2a0>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13a7 <mp_lmpar+0x257>
mov    -0x4(%rbp),%edi
mov    0x38(%rbp),%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  0x2c2b(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1431 <mp_lmpar+0x2e1>
jmp    1b92 <mp_lmpar+0xa42>
movsd  0x2c27(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     15df <mp_lmpar+0x48f>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14b4 <mp_lmpar+0x364>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1454 <mp_lmpar+0x304>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a9 <mp_lmpar+0x459>
movsd  0x2b8a(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jl     1558 <mp_lmpar+0x408>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1553 <mp_lmpar+0x403>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14fe <mp_lmpar+0x3ae>
jmp    1558 <mp_lmpar+0x408>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0x4c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14c2 <mp_lmpar+0x372>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ba <mp_lmpar+0x56a>
movsd  0x2a5f(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     166b <mp_lmpar+0x51b>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1616 <mp_lmpar+0x4c6>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15ed <mp_lmpar+0x49d>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd 0x2973(%rip),%xmm0
jne    1722 <mp_lmpar+0x5d2>
jp     1722 <mp_lmpar+0x5d2>
movsd  -0x38(%rbp),%xmm0
movsd  0x2942(%rip),%xmm1
call   1070 <mp_dmin1@plt>
movaps %xmm0,%xmm1
movsd  0x8ea(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
call   1040 <mp_dmax1@plt>
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
call   1070 <mp_dmin1@plt>
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x28f4(%rip),%xmm0
jne    178a <mp_lmpar+0x63a>
jp     178a <mp_lmpar+0x63a>
movsd  -0x78(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    178f <mp_lmpar+0x63f>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x28b8(%rip),%xmm0
jne    17d9 <mp_lmpar+0x689>
jp     17d9 <mp_lmpar+0x689>
movsd  0x2894(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  0x834(%rip),%xmm0
call   1040 <mp_dmax1@plt>
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1839 <mp_lmpar+0x6e9>
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    17f5 <mp_lmpar+0x6a5>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    0x10(%rbp),%r9
mov    0x20(%rbp),%r11
mov    0x28(%rbp),%r10
mov    0x38(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <mp_qrsolv@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18be <mp_lmpar+0x76e>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1875 <mp_lmpar+0x725>
mov    -0x4(%rbp),%edi
mov    0x38(%rbp),%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
movaps 0x719(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2745(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    1969 <mp_lmpar+0x819>
movsd  -0x88(%rbp),%xmm0
ff
ucomisd 0x273e(%rip),%xmm0
jne    195f <mp_lmpar+0x80f>
jp     195f <mp_lmpar+0x80f>
movsd  -0x70(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     195f <mp_lmpar+0x80f>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0x270b(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1969 <mp_lmpar+0x819>
cmpl   $0xa,-0x40(%rbp)
jne    196e <mp_lmpar+0x81e>
jmp    1b92 <mp_lmpar+0xa42>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19d5 <mp_lmpar+0x885>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1975 <mp_lmpar+0x825>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ad4 <mp_lmpar+0x984>
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1abd <mp_lmpar+0x96d>
mov    -0x54(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ab8 <mp_lmpar+0x968>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    0x30(%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    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a4f <mp_lmpar+0x8ff>
jmp    1abd <mp_lmpar+0x96d>
mov    -0x14(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19e3 <mp_lmpar+0x893>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
ucomisd 0x254c(%rip),%xmm0
jbe    1b37 <mp_lmpar+0x9e7>
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
call   1040 <mp_dmax1@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  0x251c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b6b <mp_lmpar+0xa1b>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
call   1070 <mp_dmin1@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x80(%rbp),%xmm1
call   1040 <mp_dmax1@plt>
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    178f <mp_lmpar+0x63f>
cmpl   $0x0,-0x40(%rbp)
jne    1bac <mp_lmpar+0xa5c>
movsd  0x24bc(%rip),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mp_lmpar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
movsd  %xmm0,0x38(%rsp)
mov    %r9,%r13
mov    %r8,%r14
mov    %rcx,%r8
mov    %edx,%r10d
mov    0x120(%rsp),%r15
mov    %edi,%r9d
mov    %edi,%r12d
test   %edi,%edi
mov    %rcx,0x28(%rsp)
mov    %r10,0x18(%rsp)
mov    %rsi,0x10(%rsp)
mov    %edi,0x4(%rsp)
mov    %r9,0x8(%rsp)
jle    156b <mp_lmpar+0x41b>
lea    0x1(%r10),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
mov    %rsi,%rbx
mov    %edi,%r12d
jmp    11cc <mp_lmpar+0x7c>
nopl   0x0(%rax)
add    $0x1,%rcx
add    %rax,%rbx
cmp    %rcx,%r9
je     1208 <mp_lmpar+0xb8>
mov    %r12d,%edx
mov    0x100(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm1
cmp    %r9d,%r12d
mov    %ecx,%r12d
cmovne %edx,%r12d
movsd  %xmm1,(%r15,%rcx,8)
ucomisd (%rbx),%xmm0
cmovne %edx,%r12d
cmovp  %edx,%r12d
cmp    %edi,%r12d
jge    11c0 <mp_lmpar+0x70>
movq   $0x0,(%r15,%rcx,8)
jmp    11c0 <mp_lmpar+0x70>
test   %r12d,%r12d
jle    1421 <mp_lmpar+0x2d1>
lea    -0x1(%r12),%eax
mov    %eax,%edx
imul   %r10d,%edx
mov    %r12d,%ecx
mov    %rcx,0x48(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0x20(%rsp)
lea    0x8(%rsi),%rcx
mov    %rcx,0x60(%rsp)
lea    0x8(%r15),%rcx
mov    %rcx,0x78(%rsp)
xor    %edi,%edi
mov    %eax,0x40(%rsp)
mov    %eax,%r9d
jmp    1266 <mp_lmpar+0x116>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
sub    %r10d,%edx
add    $0xffffffff,%r9d
cmp    0x48(%rsp),%rdi
je     1421 <mp_lmpar+0x2d1>
mov    %r9d,%r9d
mov    %edi,%eax
not    %eax
add    %r12d,%eax
cltq
movsd  (%r15,%rax,8),%xmm0
mov    %eax,%ecx
imul   %r10d,%ecx
add    %eax,%ecx
movslq %ecx,%rcx
divsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
test   %eax,%eax
jle    1250 <mp_lmpar+0x100>
movslq %edx,%rax
mov    0x40(%rsp),%ecx
mov    %ecx,%r11d
sub    %edi,%r11d
cmp    $0x4,%r11d
jae    12c0 <mp_lmpar+0x170>
xor    %ebx,%ebx
mov    0x10(%rsp),%rsi
jmp    1380 <mp_lmpar+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rax,%r11,1),%rcx
mov    0x10(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
cmp    %r15,%rcx
jbe    12f7 <mp_lmpar+0x1a7>
lea    (%r15,%r11,8),%rcx
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
cmp    %rcx,%rsi
jae    12f7 <mp_lmpar+0x1a7>
xor    %ebx,%ebx
mov    %rbp,%rsi
jmp    1380 <mp_lmpar+0x230>
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
mov    %r9d,%esi
and    $0xfffffffc,%esi
mov    %r11d,%ebx
and    $0xfffffffc,%ebx
add    %rbx,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
movupd -0x10(%r8,%r10,8),%xmm2
movupd (%r8,%r10,8),%xmm3
movupd (%r15,%r10,8),%xmm4
movupd 0x10(%r15,%r10,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,(%r15,%r10,8)
movupd %xmm5,0x10(%r15,%r10,8)
add    $0x4,%r10
cmp    %r10,%rsi
jne    1320 <mp_lmpar+0x1d0>
cmp    %r11,%rbx
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%rsi
je     1250 <mp_lmpar+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   $0x1,%r9b
jne    1390 <mp_lmpar+0x240>
mov    %rbx,%r8
jmp    13b4 <mp_lmpar+0x264>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm1
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%rbx,8)
add    $0x1,%rax
mov    %rbx,%r8
or     $0x1,%r8
not    %rbx
add    %r9,%rbx
je     1250 <mp_lmpar+0x100>
mov    0x60(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %r9,%rcx
sub    %r8,%rcx
mov    0x78(%rsp),%rbp
lea    0x0(%rbp,%r8,8),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  -0x8(%rbp,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm2,-0x8(%rbp,%rbx,8)
movsd  (%rax,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    13e0 <mp_lmpar+0x290>
jmp    1250 <mp_lmpar+0x100>
mov    0x4(%rsp),%edi
test   %edi,%edi
jle    156b <mp_lmpar+0x41b>
mov    0x8(%rsp),%rsi
lea    -0x1(%rsi),%r9
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%r9
jae    1452 <mp_lmpar+0x302>
xor    %edx,%edx
mov    0x28(%rsp),%r8
mov    0x110(%rsp),%rbp
jmp    14bf <mp_lmpar+0x36f>
and    $0xfffffffc,%esi
xor    %edx,%edx
mov    0x28(%rsp),%r8
mov    0x110(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%r8,%rdx,4),%rax
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0x4(%r8,%rdx,4),%rax
movsd  0x8(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0x8(%r8,%rdx,4),%rax
movsd  0x10(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0xc(%r8,%rdx,4),%rax
movsd  0x18(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1470 <mp_lmpar+0x320>
test   %rcx,%rcx
je     14e8 <mp_lmpar+0x398>
lea    (%r15,%rdx,8),%rsi
lea    (%r8,%rdx,4),%rdx
xor    %eax,%eax
xchg   %ax,%ax
movslq (%rdx,%rax,4),%rbx
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    14d0 <mp_lmpar+0x380>
test   %edi,%edi
jle    156b <mp_lmpar+0x41b>
test   %r9,%r9
je     1617 <mp_lmpar+0x4c7>
mov    0x8(%rsp),%r9
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x128(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movslq 0x4(%r14,%rax,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1510 <mp_lmpar+0x3c0>
test   $0x1,%r9b
je     156b <mp_lmpar+0x41b>
movslq (%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
mov    0x128(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    0x108(%rsp),%rbp
mov    0x128(%rsp),%rsi
mov    %edi,%ebx
call   1030 <mp_enorm@plt>
movapd %xmm0,%xmm3
movapd %xmm0,%xmm2
movsd  0x38(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  0x1a64(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp)
movsd  %xmm2,0x30(%rsp)
ucomisd %xmm2,%xmm1
jae    15fd <mp_lmpar+0x4ad>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
cmp    %ebx,%r12d
mov    0x128(%rsp),%r12
movsd  %xmm3,0x48(%rsp)
jl     1804 <mp_lmpar+0x6b4>
test   %ebx,%ebx
mov    0x10(%rsp),%r11
jle    17dc <mp_lmpar+0x68c>
mov    0x4(%rsp),%edi
cmp    $0x1,%edi
mov    0x28(%rsp),%rbp
mov    0x8(%rsp),%rbx
jne    162d <mp_lmpar+0x4dd>
xor    %eax,%eax
jmp    168a <mp_lmpar+0x53a>
movq   $0x0,0x0(%rbp)
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
mov    0x8(%rsp),%r9
test   $0x1,%r9b
jne    154d <mp_lmpar+0x3fd>
jmp    156b <mp_lmpar+0x41b>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x0(%rbp,%rax,4),%rdx
movslq (%r14,%rdx,4),%rsi
movsd  (%r12,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  0x0(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movslq 0x4(%rbp,%rax,4),%rdx
movslq (%r14,%rdx,4),%rsi
movsd  (%r12,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  0x0(%r13,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1640 <mp_lmpar+0x4f0>
test   $0x1,%bl
je     16af <mp_lmpar+0x55f>
movslq 0x0(%rbp,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r12,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
test   %edi,%edi
jle    17dc <mp_lmpar+0x68c>
movslq 0x18(%rsp),%r9
lea    0x18(%r11),%rcx
lea    0x0(,%r9,8),%r8
xor    %r10d,%r10d
xor    %edx,%edx
xor    %ebp,%ebp
jmp    171e <mp_lmpar+0x5ce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  (%r15,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
mov    %edx,%eax
imul   0x18(%rsp),%eax
cltq
add    %rdx,%rax
divsd  (%r11,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
add    %r9,%rbp
add    $0x1,%rdx
sub    %r9,%r10
add    %r8,%rcx
cmp    0x8(%rsp),%rdx
je     17dc <mp_lmpar+0x68c>
test   %rdx,%rdx
je     16e0 <mp_lmpar+0x590>
lea    -0x1(%rdx),%rax
cmp    $0x3,%rax
jae    1740 <mp_lmpar+0x5f0>
xorpd  %xmm0,%xmm0
mov    %rbp,%rax
xor    %ebx,%ebx
test   $0x3,%dl
jne    17aa <mp_lmpar+0x65a>
jmp    16e4 <mp_lmpar+0x594>
nopl   (%rax)
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
nopl   (%rax)
movsd  -0x18(%rcx,%rbx,8),%xmm1
movsd  -0x10(%rcx,%rbx,8),%xmm2
mulsd  (%r15,%rbx,8),%xmm1
mulsd  0x8(%r15,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm3
mulsd  0x10(%r15,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rcx,%rbx,8),%xmm0
mulsd  0x18(%r15,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1750 <mp_lmpar+0x600>
mov    %rbx,%rax
sub    %r10,%rax
test   $0x3,%dl
je     16e4 <mp_lmpar+0x594>
mov    %edx,%edi
and    $0x3,%edi
lea    (%r11,%rax,8),%rax
lea    (%r15,%rbx,8),%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rax,%rsi,8),%xmm1
mulsd  (%rbx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    17c0 <mp_lmpar+0x670>
jmp    16e4 <mp_lmpar+0x594>
mov    0x4(%rsp),%ebx
mov    %ebx,%edi
mov    %r15,%rsi
call   1030 <mp_enorm@plt>
movsd  0x30(%rsp),%xmm1
divsd  0x38(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
test   %ebx,%ebx
jle    194c <mp_lmpar+0x7fc>
movslq 0x18(%rsp),%r9
mov    0x10(%rsp),%rax
lea    0x18(%rax),%rcx
lea    0x0(,%r9,8),%r8
mov    $0x1,%edi
xor    %r10d,%r10d
xor    %ebp,%ebp
xor    %r11d,%r11d
jmp    1876 <mp_lmpar+0x726>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
movslq (%rax,%rbp,4),%rax
movslq (%r14,%rax,4),%rax
divsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    %r9,%r11
add    $0x1,%rbp
add    $0x1,%rdi
sub    %r9,%r10
add    %r8,%rcx
cmp    0x8(%rsp),%rbp
je     194c <mp_lmpar+0x7fc>
cmp    $0x3,%rbp
jae    1890 <mp_lmpar+0x740>
xorpd  %xmm0,%xmm0
mov    %r11,%rsi
xor    %ebx,%ebx
test   $0x3,%dil
jne    1907 <mp_lmpar+0x7b7>
jmp    1840 <mp_lmpar+0x6f0>
nopl   (%rax)
mov    %rdi,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0x100(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rcx,%rbx,8),%xmm1
movsd  -0x10(%rcx,%rbx,8),%xmm2
mulsd  (%rax,%rbx,8),%xmm1
mulsd  0x8(%rax,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm3
mulsd  0x10(%rax,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rcx,%rbx,8),%xmm0
mulsd  0x18(%rax,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    18b0 <mp_lmpar+0x760>
mov    %rbx,%rsi
sub    %r10,%rsi
test   $0x3,%dil
je     1840 <mp_lmpar+0x6f0>
mov    %edi,%eax
and    $0x3,%eax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rsi,8),%rsi
mov    0x100(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdx,8),%xmm1
mulsd  (%rbx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1930 <mp_lmpar+0x7e0>
jmp    1840 <mp_lmpar+0x6f0>
mov    0x4(%rsp),%ebx
mov    %ebx,%edi
mov    %r15,%rsi
call   1030 <mp_enorm@plt>
movsd  %xmm0,0x40(%rsp)
movapd %xmm0,%xmm1
movsd  0x38(%rsp),%xmm0
divsd  %xmm0,%xmm1
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jne    1993 <mp_lmpar+0x843>
jp     1993 <mp_lmpar+0x843>
movsd  0x167e(%rip),%xmm1
call   1070 <mp_dmin1@plt>
movsd  0x1679(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
mov    0x108(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
movsd  0x20(%rsp),%xmm1
call   1040 <mp_dmax1@plt>
movsd  %xmm0,0x0(%rbp)
movsd  0x50(%rsp),%xmm1
call   1070 <mp_dmin1@plt>
ucomisd 0x164f(%rip),%xmm0
jne    19d9 <mp_lmpar+0x889>
jp     19d9 <mp_lmpar+0x889>
movsd  0x40(%rsp),%xmm0
divsd  0x48(%rsp),%xmm0
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
add    $0x1,%eax
mov    %eax,0x48(%rsp)
movslq %ebx,%rax
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rax
lea    (%r15,%rax,8),%rdx
mov    %rdx,0xb0(%rsp)
lea    -0x1(%rax),%rdx
mov    %rdx,0x58(%rsp)
mov    %eax,%r8d
and    $0x3,%r8d
mov    %eax,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x90(%rsp)
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x80(%rsp)
neg    %rax
mov    %rax,0x78(%rsp)
lea    0x18(%r15),%rax
mov    %rax,0x98(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0xa8(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0xc0(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0xb8(%rsp)
xor    %eax,%eax
mov    %rax,0x88(%rsp)
mov    %r8,0x70(%rsp)
jmp    1abf <mp_lmpar+0x96f>
cs nopw 0x0(%rax,%rax,1)
movsd  0x38(%rsp),%xmm0
movsd  0x30(%rsp),%xmm2
movapd 0x60(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
divsd  %xmm2,%xmm1
addsd  0x0(%rbp),%xmm1
movsd  0x20(%rsp),%xmm0
call   1040 <mp_dmax1@plt>
movapd 0x60(%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
mov    0x70(%rsp),%r8
movsd  %xmm0,0x0(%rbp)
ucomisd 0x154c(%rip),%xmm0
jne    1af5 <mp_lmpar+0x9a5>
jp     1af5 <mp_lmpar+0x9a5>
movsd  0x50(%rsp),%xmm1
mulsd  0x1532(%rip),%xmm1
movsd  0x1522(%rip),%xmm0
call   1040 <mp_dmax1@plt>
mov    0x70(%rsp),%r8
movsd  %xmm0,0x0(%rbp)
ucomisd 0x151b(%rip),%xmm0
jb     1b10 <mp_lmpar+0x9c0>
sqrtsd %xmm0,%xmm0
jmp    1b1a <mp_lmpar+0x9ca>
cs nopw 0x0(%rax,%rax,1)
nop
call   1060 <sqrt@plt>
mov    0x70(%rsp),%r8
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rsi
mov    0x110(%rsp),%r10
mov    0x28(%rsp),%rcx
test   %ebx,%ebx
jle    1b50 <mp_lmpar+0xa00>
cmpq   $0x3,0x58(%rsp)
jae    1b80 <mp_lmpar+0xa30>
xor    %eax,%eax
jmp    1bf3 <mp_lmpar+0xaa3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    $0x8,%rsp
mov    %ebx,%edi
mov    %r15,%r8
mov    0x108(%rsp),%r9
push   %r12
push   0x128(%rsp)
push   %r10
call   1050 <mp_qrsolv@plt>
add    $0x20,%rsp
jmp    1ce0 <mp_lmpar+0xb90>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x90(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rax,8)
movslq 0x4(%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
movslq 0x8(%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r15,%rax,8)
movslq 0xc(%r14,%rax,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1b90 <mp_lmpar+0xa40>
test   %r8,%r8
je     1c2d <mp_lmpar+0xadd>
lea    (%r15,%rax,8),%rbx
lea    (%r14,%rax,4),%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rax,%rdi,4),%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r8
jne    1c10 <mp_lmpar+0xac0>
sub    $0x8,%rsp
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
mov    %r15,%r8
mov    0x108(%rsp),%r9
push   %r12
push   0x128(%rsp)
push   %r10
call   1050 <mp_qrsolv@plt>
add    $0x20,%rsp
test   %ebx,%ebx
jle    1ce0 <mp_lmpar+0xb90>
cmpq   $0x0,0x58(%rsp)
je     20af <mp_lmpar+0xf5f>
xor    %eax,%eax
mov    0x110(%rsp),%rdx
mov    0x80(%rsp),%rsi
nopl   0x0(%rax)
movslq (%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movslq 0x4(%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1c80 <mp_lmpar+0xb30>
testb  $0x1,0x8(%rsp)
je     1ce0 <mp_lmpar+0xb90>
movslq (%r14,%rax,4),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
mov    0x110(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
nopl   (%rax)
mov    %ebx,%edi
mov    %r12,%rsi
call   1030 <mp_enorm@plt>
movapd %xmm0,%xmm1
subsd  0x38(%rsp),%xmm1
movapd %xmm1,0x60(%rsp)
andpd  0x131e(%rip),%xmm1
movsd  0xa0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
mov    0x10(%rsp),%r11
mov    0x88(%rsp),%rax
jae    1605 <mp_lmpar+0x4b5>
add    $0x1,%eax
movsd  0x20(%rsp),%xmm1
ucomisd 0x12e5(%rip),%xmm1
jne    1d55 <mp_lmpar+0xc05>
jp     1d55 <mp_lmpar+0xc05>
movsd  0x30(%rsp),%xmm1
ucomisd 0x60(%rsp),%xmm1
jb     1d55 <mp_lmpar+0xc05>
xorpd  %xmm1,%xmm1
ucomisd 0x30(%rsp),%xmm1
ja     1605 <mp_lmpar+0x4b5>
cmp    $0xa,%eax
je     1605 <mp_lmpar+0x4b5>
mov    %rax,0x88(%rsp)
test   %ebx,%ebx
jle    2010 <mp_lmpar+0xec0>
cmpq   $0x0,0x58(%rsp)
je     2090 <mp_lmpar+0xf40>
xor    %eax,%eax
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%rbp
mov    0x80(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq 0x0(%rbp,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r12,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
movslq 0x4(%rbp,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r12,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1da0 <mp_lmpar+0xc50>
test   $0x1,%dil
je     1e10 <mp_lmpar+0xcc0>
movslq 0x0(%rbp,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r12,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
test   %esi,%esi
jle    2010 <mp_lmpar+0xec0>
mov    $0x1,%eax
mov    $0x1,%ecx
mov    0x98(%rsp),%rdx
mov    0x58(%rsp),%r10
xor    %r9d,%r9d
jmp    1e5b <mp_lmpar+0xd0b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
add    0x48(%rsp),%ecx
add    $0xffffffffffffffff,%r10
add    $0x8,%rdx
cmp    0x8(%rsp),%r9
je     2010 <mp_lmpar+0xec0>
mov    %r9,%rdi
movsd  (%r15,%r9,8),%xmm0
mov    0x118(%rsp),%rsi
divsd  (%rsi,%r9,8),%xmm0
movsd  %xmm0,(%r15,%r9,8)
add    $0x1,%r9
cmp    0x40(%rsp),%r9
jge    1e40 <mp_lmpar+0xcf0>
movslq %ecx,%r8
not    %rdi
add    0x8(%rsp),%rdi
cmp    $0x4,%rdi
jb     1ebc <mp_lmpar+0xd6c>
lea    (%r15,%rax,8),%rsi
lea    (%r11,%rdi,8),%rbp
lea    0x0(%rbp,%r8,8),%rbp
cmp    %rbp,%rsi
jae    1f81 <mp_lmpar+0xe31>
lea    (%r11,%r8,8),%rsi
cmp    0xb0(%rsp),%rsi
jae    1f81 <mp_lmpar+0xe31>
mov    %rax,%rbx
mov    0x8(%rsp),%rsi
sub    %ebx,%esi
test   $0x1,%sil
jne    1ee0 <mp_lmpar+0xd90>
mov    %rbx,%rbp
jmp    1f02 <mp_lmpar+0xdb2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm1
movsd  (%r11,%r8,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%rbx,8)
add    $0x1,%r8
lea    0x1(%rbx),%rbp
not    %rbx
cmp    0x78(%rsp),%rbx
je     1e40 <mp_lmpar+0xcf0>
mov    0xc0(%rsp),%rsi
lea    (%rsi,%r8,8),%rsi
mov    0x8(%rsp),%rdi
sub    %rbp,%rdi
mov    0xb8(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  -0x8(%rbp,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm2,-0x8(%rbp,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    1f40 <mp_lmpar+0xdf0>
jmp    1e40 <mp_lmpar+0xcf0>
mov    0xa8(%rsp),%rsi
lea    (%rsi,%r8,8),%rbp
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %rdi,%r11
and    $0xfffffffffffffffc,%r11
add    %r11,%r8
lea    (%rax,%r11,1),%rbx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r12d,%r12d
nopl   (%rax)
movupd -0x10(%rbp,%r12,8),%xmm2
movupd 0x0(%rbp,%r12,8),%xmm3
movupd -0x10(%rdx,%r12,8),%xmm4
movupd (%rdx,%r12,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdx,%r12,8)
movupd %xmm5,(%rdx,%r12,8)
add    $0x4,%r12
cmp    %r12,%rsi
jne    1fb0 <mp_lmpar+0xe60>
cmp    %r11,%rdi
mov    0x10(%rsp),%r11
mov    0x128(%rsp),%r12
je     1e40 <mp_lmpar+0xcf0>
jmp    1ebf <mp_lmpar+0xd6f>
nopl   0x0(%rax)
mov    0x4(%rsp),%ebx
mov    %ebx,%edi
mov    %r15,%rsi
call   1030 <mp_enorm@plt>
movapd %xmm0,%xmm1
movapd 0x60(%rsp),%xmm0
ucomisd 0xfe8(%rip),%xmm0
movsd  %xmm1,0x30(%rsp)
mov    0x108(%rsp),%rbp
jbe    2056 <mp_lmpar+0xf06>
movsd  0x0(%rbp),%xmm1
movsd  0x20(%rsp),%xmm0
call   1040 <mp_dmax1@plt>
movsd  %xmm0,0x20(%rsp)
xorpd  %xmm0,%xmm0
ucomisd 0x60(%rsp),%xmm0
jbe    1a80 <mp_lmpar+0x930>
movsd  0x0(%rbp),%xmm1
movsd  0x50(%rsp),%xmm0
call   1070 <mp_dmin1@plt>
movsd  %xmm0,0x50(%rsp)
jmp    1a80 <mp_lmpar+0x930>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%rbp
test   $0x1,%dil
jne    1df0 <mp_lmpar+0xca0>
jmp    1e10 <mp_lmpar+0xcc0>
xor    %eax,%eax
testb  $0x1,0x8(%rsp)
jne    1cbf <mp_lmpar+0xb6f>
jmp    1ce0 <mp_lmpar+0xb90>

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

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