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 = 2.2250739e-308 / 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(2.2250739e-308, 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
mov    $0x0,%al
call   1030 <mp_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  0x2c25(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1437 <mp_lmpar+0x2e7>
jmp    1bd9 <mp_lmpar+0xa89>
movsd  0x2c21(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     15eb <mp_lmpar+0x49b>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14ba <mp_lmpar+0x36a>
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    145a <mp_lmpar+0x30a>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15af <mp_lmpar+0x45f>
movsd  0x2b84(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jl     155e <mp_lmpar+0x40e>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1559 <mp_lmpar+0x409>
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    1504 <mp_lmpar+0x3b4>
jmp    155e <mp_lmpar+0x40e>
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    14c8 <mp_lmpar+0x378>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1030 <mp_enorm@plt>
cvtsi2sd %eax,%xmm0
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    16c6 <mp_lmpar+0x576>
movsd  0x2a53(%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     1677 <mp_lmpar+0x527>
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    1622 <mp_lmpar+0x4d2>
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    15f9 <mp_lmpar+0x4a9>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1030 <mp_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd 0x2961(%rip),%xmm0
jne    1737 <mp_lmpar+0x5e7>
jp     1737 <mp_lmpar+0x5e7>
movsd  -0x38(%rbp),%xmm0
movsd  0x2930(%rip),%xmm1
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
cvtsi2sd %eax,%xmm1
movsd  0x8d5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
cvtsi2sd %eax,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
cvtsi2sd %eax,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x28d3(%rip),%xmm0
jne    17ab <mp_lmpar+0x65b>
jp     17ab <mp_lmpar+0x65b>
movsd  -0x78(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    17b0 <mp_lmpar+0x660>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x2897(%rip),%xmm0
jne    1800 <mp_lmpar+0x6b0>
jp     1800 <mp_lmpar+0x6b0>
movsd  0x2873(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  0x813(%rip),%xmm0
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
cvtsi2sd %eax,%xmm0
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    1860 <mp_lmpar+0x710>
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    181c <mp_lmpar+0x6cc>
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)
mov    $0x0,%al
call   1050 <mp_qrsolv@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18e7 <mp_lmpar+0x797>
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    189e <mp_lmpar+0x74e>
mov    -0x4(%rbp),%edi
mov    0x38(%rbp),%rsi
mov    $0x0,%al
call   1030 <mp_enorm@plt>
cvtsi2sd %eax,%xmm0
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 0x6ea(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2716(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    1998 <mp_lmpar+0x848>
movsd  -0x88(%rbp),%xmm0
ff
ucomisd 0x270f(%rip),%xmm0
jne    198e <mp_lmpar+0x83e>
jp     198e <mp_lmpar+0x83e>
movsd  -0x70(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     198e <mp_lmpar+0x83e>
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0x26dc(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1998 <mp_lmpar+0x848>
cmpl   $0xa,-0x40(%rbp)
jne    199d <mp_lmpar+0x84d>
jmp    1bd9 <mp_lmpar+0xa89>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a04 <mp_lmpar+0x8b4>
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    19a4 <mp_lmpar+0x854>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b03 <mp_lmpar+0x9b3>
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    1aec <mp_lmpar+0x99c>
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    1ae7 <mp_lmpar+0x997>
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    1a7e <mp_lmpar+0x92e>
jmp    1aec <mp_lmpar+0x99c>
mov    -0x14(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a12 <mp_lmpar+0x8c2>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1030 <mp_enorm@plt>
cvtsi2sd %eax,%xmm0
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 0x2517(%rip),%xmm0
jbe    1b72 <mp_lmpar+0xa22>
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  0x24e1(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bac <mp_lmpar+0xa5c>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x80(%rbp),%xmm1
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
cvtsi2sd %eax,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    17b0 <mp_lmpar+0x660>
cmpl   $0x0,-0x40(%rbp)
jne    1bf3 <mp_lmpar+0xaa3>
movsd  0x2475(%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    $0xd8,%rsp
movsd  %xmm0,0x38(%rsp)
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r8
mov    %edx,%r10d
mov    0x130(%rsp),%r13
mov    %edi,%r9d
mov    %edi,%r15d
test   %edi,%edi
mov    %rcx,0x30(%rsp)
mov    %r10,0x20(%rsp)
mov    %rsi,0x18(%rsp)
mov    %edi,0xc(%rsp)
mov    %r9,0x10(%rsp)
jle    1588 <mp_lmpar+0x438>
lea    0x1(%r10),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
mov    %rsi,%rbx
mov    %edi,%r15d
jmp    11cc <mp_lmpar+0x7c>
nopl   0x0(%rax)
add    $0x1,%rcx
add    %rax,%rbx
cmp    %rcx,%r9
je     120a <mp_lmpar+0xba>
mov    %r15d,%edx
mov    0x110(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm1
cmp    %r9d,%r15d
mov    %ecx,%r15d
cmovne %edx,%r15d
movsd  %xmm1,0x0(%r13,%rcx,8)
ucomisd (%rbx),%xmm0
cmovne %edx,%r15d
cmovp  %edx,%r15d
cmp    %edi,%r15d
jge    11c0 <mp_lmpar+0x70>
movq   $0x0,0x0(%r13,%rcx,8)
jmp    11c0 <mp_lmpar+0x70>
test   %r15d,%r15d
jle    1431 <mp_lmpar+0x2e1>
lea    -0x1(%r15),%eax
mov    %eax,%edx
imul   %r10d,%edx
mov    %r15d,%ecx
mov    %rcx,0x48(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0x28(%rsp)
lea    0x8(%rsi),%rcx
mov    %rcx,0x70(%rsp)
lea    0x8(%r13),%rcx
mov    %rcx,0x90(%rsp)
xor    %edi,%edi
mov    %eax,0x40(%rsp)
mov    %eax,%r9d
jmp    1266 <mp_lmpar+0x116>
xchg   %ax,%ax
add    $0x1,%rdi
sub    %r10d,%edx
add    $0xffffffff,%r9d
cmp    0x48(%rsp),%rdi
je     1431 <mp_lmpar+0x2e1>
mov    %r9d,%r9d
mov    %edi,%eax
not    %eax
add    %r15d,%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm0
mov    %eax,%ecx
imul   %r10d,%ecx
add    %eax,%ecx
movslq %ecx,%rcx
divsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%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    0x18(%rsp),%rsi
jmp    1390 <mp_lmpar+0x240>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rax,%r11,1),%rcx
mov    0x18(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
cmp    %r13,%rcx
jbe    12fe <mp_lmpar+0x1ae>
lea    0x0(,%r11,8),%rcx
add    %r13,%rcx
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
cmp    %rcx,%rsi
jae    12fe <mp_lmpar+0x1ae>
xor    %ebx,%ebx
mov    %rbp,%rsi
jmp    1390 <mp_lmpar+0x240>
mov    0x28(%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
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r8,%r10,8),%xmm2
movupd (%r8,%r10,8),%xmm3
movupd 0x0(%r13,%r10,8),%xmm4
movupd 0x10(%r13,%r10,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%r10,8)
movupd %xmm5,0x10(%r13,%r10,8)
add    $0x4,%r10
cmp    %r10,%rsi
jne    1330 <mp_lmpar+0x1e0>
cmp    %r11,%rbx
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rsi
je     1250 <mp_lmpar+0x100>
cs nopw 0x0(%rax,%rax,1)
nop
test   $0x1,%r9b
jne    13a0 <mp_lmpar+0x250>
mov    %rbx,%r8
jmp    13c6 <mp_lmpar+0x276>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm1
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
add    $0x1,%rax
mov    %rbx,%r8
or     $0x1,%r8
not    %rbx
add    %r9,%rbx
je     1250 <mp_lmpar+0x100>
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %r9,%rcx
sub    %r8,%rcx
mov    0x90(%rsp),%rbp
lea    0x0(%rbp,%r8,8),%rbp
xor    %ebx,%ebx
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    13f0 <mp_lmpar+0x2a0>
jmp    1250 <mp_lmpar+0x100>
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    1588 <mp_lmpar+0x438>
mov    0x10(%rsp),%rsi
lea    -0x1(%rsi),%r9
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%r9
jae    1462 <mp_lmpar+0x312>
xor    %edx,%edx
mov    0x30(%rsp),%r8
mov    0x120(%rsp),%rbp
jmp    14d0 <mp_lmpar+0x380>
and    $0xfffffffc,%esi
xor    %edx,%edx
mov    0x30(%rsp),%r8
mov    0x120(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%r8,%rdx,4),%rax
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0x4(%r8,%rdx,4),%rax
movsd  0x8(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0x8(%r8,%rdx,4),%rax
movsd  0x10(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movslq 0xc(%r8,%rdx,4),%rax
movsd  0x18(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1480 <mp_lmpar+0x330>
test   %rcx,%rcx
je     1508 <mp_lmpar+0x3b8>
lea    0x0(,%rdx,8),%rsi
add    %r13,%rsi
lea    (%r8,%rdx,4),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movslq (%rdx,%rax,4),%rbx
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    14f0 <mp_lmpar+0x3a0>
test   %edi,%edi
jle    1588 <mp_lmpar+0x438>
test   %r9,%r9
je     1639 <mp_lmpar+0x4e9>
mov    0x10(%rsp),%r9
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x138(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movslq (%r14,%rax,4),%rdx
movsd  (%r12,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movslq 0x4(%r14,%rax,4),%rdx
movsd  (%r12,%rdx,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1530 <mp_lmpar+0x3e0>
test   $0x1,%r9b
je     1588 <mp_lmpar+0x438>
movslq (%r14,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
mov    0x138(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    0x118(%rsp),%rbp
mov    0x138(%rsp),%rsi
xor    %eax,%eax
mov    %edi,%ebx
call   1030 <mp_enorm@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movapd %xmm3,%xmm2
movsd  0x38(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  0x1a42(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xb0(%rsp)
movsd  %xmm2,0x68(%rsp)
ucomisd %xmm2,%xmm1
jae    161f <mp_lmpar+0x4cf>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
cmp    %ebx,%r15d
mov    0x138(%rsp),%r15
movsd  %xmm3,0x48(%rsp)
jl     183f <mp_lmpar+0x6ef>
test   %ebx,%ebx
mov    0x18(%rsp),%r11
mov    0x10(%rsp),%rbx
jle    180c <mp_lmpar+0x6bc>
mov    0xc(%rsp),%edi
cmp    $0x1,%edi
mov    0x30(%rsp),%rbp
jne    164f <mp_lmpar+0x4ff>
xor    %eax,%eax
jmp    16a9 <mp_lmpar+0x559>
movq   $0x0,0x0(%rbp)
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
mov    0x10(%rsp),%r9
test   $0x1,%r9b
jne    156b <mp_lmpar+0x41b>
jmp    1588 <mp_lmpar+0x438>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movslq 0x0(%rbp,%rax,4),%rdx
movslq (%r14,%rdx,4),%rsi
movsd  (%r15,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  (%r12,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movslq 0x4(%rbp,%rax,4),%rdx
movslq (%r14,%rdx,4),%rsi
movsd  (%r15,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  (%r12,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1660 <mp_lmpar+0x510>
test   $0x1,%bl
je     16ce <mp_lmpar+0x57e>
movslq 0x0(%rbp,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r15,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
test   %edi,%edi
jle    180c <mp_lmpar+0x6bc>
movslq 0x20(%rsp),%r9
lea    0x18(%r11),%rcx
lea    0x0(,%r9,8),%r8
xor    %r10d,%r10d
xor    %edx,%edx
xor    %ebp,%ebp
jmp    1733 <mp_lmpar+0x5e3>
xorpd  %xmm0,%xmm0
movsd  0x0(%r13,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
mov    %edx,%eax
imul   0x20(%rsp),%eax
cltq
add    %rdx,%rax
divsd  (%r11,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    %r9,%rbp
add    $0x1,%rdx
sub    %r9,%r10
add    %r8,%rcx
mov    0x10(%rsp),%rbx
cmp    %rbx,%rdx
je     180c <mp_lmpar+0x6bc>
test   %rdx,%rdx
je     16f0 <mp_lmpar+0x5a0>
lea    -0x1(%rdx),%rax
cmp    $0x3,%rax
jae    1760 <mp_lmpar+0x610>
xorpd  %xmm0,%xmm0
mov    %rbp,%rax
xor    %ebx,%ebx
test   $0x3,%dl
jne    17cb <mp_lmpar+0x67b>
jmp    16f4 <mp_lmpar+0x5a4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%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  0x0(%r13,%rbx,8),%xmm1
mulsd  0x8(%r13,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm3
mulsd  0x10(%r13,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rcx,%rbx,8),%xmm0
mulsd  0x18(%r13,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1770 <mp_lmpar+0x620>
mov    %rbx,%rax
sub    %r10,%rax
test   $0x3,%dl
je     16f4 <mp_lmpar+0x5a4>
mov    %edx,%edi
and    $0x3,%edi
lea    (%r11,%rax,8),%rax
lea    0x0(,%rbx,8),%rbx
add    %r13,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm1
mulsd  (%rbx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    17f0 <mp_lmpar+0x6a0>
jmp    16f4 <mp_lmpar+0x5a4>
mov    0xc(%rsp),%ebp
mov    %ebp,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <mp_enorm@plt>
mov    %ebp,%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x68(%rsp),%xmm1
divsd  0x38(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
test   %ebx,%ebx
mov    0x10(%rsp),%rbx
jle    198c <mp_lmpar+0x83c>
movslq 0x20(%rsp),%r9
mov    0x18(%rsp),%rax
lea    0x18(%rax),%rcx
lea    0x0(,%r9,8),%r8
mov    $0x1,%edi
xor    %r10d,%r10d
xor    %ebp,%ebp
xor    %r11d,%r11d
jmp    18b9 <mp_lmpar+0x769>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
movslq (%rax,%rbp,4),%rax
movslq (%r14,%rax,4),%rax
divsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    %r9,%r11
add    $0x1,%rbp
add    $0x1,%rdi
sub    %r9,%r10
add    %r8,%rcx
mov    0x10(%rsp),%rbx
cmp    %rbx,%rbp
je     198c <mp_lmpar+0x83c>
cmp    $0x3,%rbp
jae    18d0 <mp_lmpar+0x780>
xorpd  %xmm0,%xmm0
mov    %r11,%rsi
xor    %ebx,%ebx
test   $0x3,%dil
jne    1947 <mp_lmpar+0x7f7>
jmp    1880 <mp_lmpar+0x730>
mov    %rdi,%rsi
and    $0xfffffffffffffffc,%rsi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    0x110(%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    18f0 <mp_lmpar+0x7a0>
mov    %rbx,%rsi
sub    %r10,%rsi
test   $0x3,%dil
je     1880 <mp_lmpar+0x730>
mov    %edi,%eax
and    $0x3,%eax
mov    0x18(%rsp),%rdx
lea    (%rdx,%rsi,8),%rsi
mov    0x110(%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    1970 <mp_lmpar+0x820>
jmp    1880 <mp_lmpar+0x730>
mov    0xc(%rsp),%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <mp_enorm@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movsd  %xmm2,0x40(%rsp)
movsd  0x38(%rsp),%xmm0
divsd  %xmm0,%xmm2
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jne    19df <mp_lmpar+0x88f>
jp     19df <mp_lmpar+0x88f>
movsd  0x163b(%rip),%xmm1
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x162d(%rip),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x58(%rsp)
mov    0x118(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
movsd  0x28(%rsp),%xmm1
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x58(%rsp),%xmm1
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
test   %eax,%eax
je     1a25 <mp_lmpar+0x8d5>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
jmp    1a31 <mp_lmpar+0x8e1>
movsd  0x40(%rsp),%xmm0
divsd  0x48(%rsp),%xmm0
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    0xc(%rsp),%edx
add    $0x1,%eax
mov    %eax,0x48(%rsp)
movslq %edx,%rax
mov    %rax,0x40(%rsp)
lea    0x0(%r13,%rbx,8),%rax
mov    %rax,0xc0(%rsp)
lea    -0x1(%rbx),%rax
mov    %rax,0x60(%rsp)
mov    %ebx,%r8d
and    $0x3,%r8d
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0xa8(%rsp)
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x98(%rsp)
neg    %rbx
mov    %rbx,0x90(%rsp)
lea    0x18(%r13),%rax
mov    %rax,0xa0(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0xb8(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0xd0(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0xc8(%rsp)
movl   $0x0,0x54(%rsp)
mov    0x118(%rsp),%rbp
mov    %r8,0x88(%rsp)
jmp    1b53 <mp_lmpar+0xa03>
nopw   0x0(%rax,%rax,1)
mov    0x118(%rsp),%rbp
movsd  0x0(%rbp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    $0x2,%al
call   1070 <mp_dmin1@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x38(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movapd 0x70(%rsp),%xmm1
divsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
addsd  0x0(%rbp),%xmm1
movsd  0x28(%rsp),%xmm0
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd 0x70(%rsp),%xmm1
movsd  %xmm1,0x68(%rsp)
mov    0x88(%rsp),%r8
movsd  %xmm0,0x0(%rbp)
ucomisd 0x14b8(%rip),%xmm0
jne    1b95 <mp_lmpar+0xa45>
jp     1b95 <mp_lmpar+0xa45>
movsd  0x58(%rsp),%xmm1
mulsd  0x149e(%rip),%xmm1
movsd  0x148e(%rip),%xmm0
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
mov    0x88(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp)
ucomisd 0x147b(%rip),%xmm0
jb     1bb0 <mp_lmpar+0xa60>
sqrtsd %xmm0,%xmm0
jmp    1bbd <mp_lmpar+0xa6d>
cs nopw 0x0(%rax,%rax,1)
nop
call   1060 <sqrt@plt>
mov    0x88(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x120(%rsp),%r10
mov    0x30(%rsp),%rcx
mov    0xc(%rsp),%ebx
test   %ebx,%ebx
mov    0xa8(%rsp),%rbp
jle    1c00 <mp_lmpar+0xab0>
cmpq   $0x3,0x60(%rsp)
jae    1c40 <mp_lmpar+0xaf0>
xor    %eax,%eax
jmp    1cb0 <mp_lmpar+0xb60>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    %r13,%r8
mov    0x118(%rsp),%r9
xor    %eax,%eax
push   %r15
push   0x138(%rsp)
push   %r10
call   1050 <mp_qrsolv@plt>
add    $0x20,%rsp
mov    0x10(%rsp),%rax
mov    %ebx,%ebp
mov    %rax,%rbx
jmp    1db0 <mp_lmpar+0xc60>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%r14,%rax,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%r14,%rax,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movslq 0x8(%r14,%rax,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
movslq 0xc(%r14,%rax,4),%rdi
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1c50 <mp_lmpar+0xb00>
test   %r8,%r8
je     1cec <mp_lmpar+0xb9c>
lea    0x0(,%rax,8),%rbx
add    %r13,%rbx
lea    (%r14,%rax,4),%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movslq (%rax,%rdi,4),%rbp
movsd  (%r12,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r8
jne    1cd0 <mp_lmpar+0xb80>
sub    $0x8,%rsp
mov    0x14(%rsp),%ebp
mov    %ebp,%edi
mov    %r13,%r8
mov    0x118(%rsp),%r9
xor    %eax,%eax
push   %r15
push   0x138(%rsp)
push   %r10
call   1050 <mp_qrsolv@plt>
add    $0x20,%rsp
test   %ebp,%ebp
mov    0x10(%rsp),%rbx
jle    1db0 <mp_lmpar+0xc60>
cmpq   $0x0,0x60(%rsp)
je     2149 <mp_lmpar+0xff9>
xor    %eax,%eax
mov    0x120(%rsp),%rdx
mov    0x98(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%r14,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm0
mulsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movslq 0x4(%r14,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1d50 <mp_lmpar+0xc00>
test   $0x1,%bl
je     1db0 <mp_lmpar+0xc60>
movslq (%r14,%rax,4),%rcx
movsd  (%r12,%rcx,8),%xmm0
mov    0x120(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1030 <mp_enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm1
subsd  0x38(%rsp),%xmm1
movapd %xmm1,0x70(%rsp)
andpd  0x1245(%rip),%xmm1
movsd  0xb0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
mov    0x18(%rsp),%r11
mov    0x54(%rsp),%eax
jae    1627 <mp_lmpar+0x4d7>
add    $0x1,%eax
movsd  0x28(%rsp),%xmm1
ucomisd 0x1210(%rip),%xmm1
jne    1e2a <mp_lmpar+0xcda>
jp     1e2a <mp_lmpar+0xcda>
movsd  0x68(%rsp),%xmm1
ucomisd 0x70(%rsp),%xmm1
jb     1e2a <mp_lmpar+0xcda>
xorpd  %xmm1,%xmm1
ucomisd 0x68(%rsp),%xmm1
ja     1627 <mp_lmpar+0x4d7>
cmp    $0xa,%eax
je     1627 <mp_lmpar+0x4d7>
mov    %eax,0x54(%rsp)
test   %ebp,%ebp
jle    20c0 <mp_lmpar+0xf70>
cmpq   $0x0,0x60(%rsp)
je     2130 <mp_lmpar+0xfe0>
xor    %eax,%eax
mov    0xc(%rsp),%esi
mov    0x30(%rsp),%rdi
mov    0x98(%rsp),%rbp
xchg   %ax,%ax
movslq (%rdi,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r15,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r15,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1e60 <mp_lmpar+0xd10>
test   $0x1,%bl
je     1ecc <mp_lmpar+0xd7c>
movslq (%rdi,%rax,4),%rcx
movslq (%r14,%rcx,4),%rdx
movsd  (%r15,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %esi,%esi
jle    20c0 <mp_lmpar+0xf70>
mov    $0x1,%eax
mov    $0x1,%ecx
mov    0xa0(%rsp),%rdx
mov    0x60(%rsp),%r10
xor    %r9d,%r9d
jmp    1f0b <mp_lmpar+0xdbb>
add    $0x1,%rax
add    0x48(%rsp),%ecx
add    $0xffffffffffffffff,%r10
add    $0x8,%rdx
cmp    0x10(%rsp),%r9
je     20c0 <mp_lmpar+0xf70>
mov    %r9,%rdi
movsd  0x0(%r13,%r9,8),%xmm0
mov    0x128(%rsp),%rsi
divsd  (%rsi,%r9,8),%xmm0
movsd  %xmm0,0x0(%r13,%r9,8)
add    $0x1,%r9
cmp    0x40(%rsp),%r9
jge    1ef0 <mp_lmpar+0xda0>
movslq %ecx,%r8
not    %rdi
add    0x10(%rsp),%rdi
cmp    $0x4,%rdi
jb     1f75 <mp_lmpar+0xe25>
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
lea    (%r11,%rdi,8),%rbp
lea    0x0(%rbp,%r8,8),%rbp
cmp    %rbp,%rsi
jae    2031 <mp_lmpar+0xee1>
lea    (%r11,%r8,8),%rsi
cmp    0xc0(%rsp),%rsi
jae    2031 <mp_lmpar+0xee1>
mov    %rax,%rbx
mov    0x10(%rsp),%rsi
sub    %ebx,%esi
test   $0x1,%sil
jne    1f90 <mp_lmpar+0xe40>
mov    %rbx,%rbp
jmp    1fb4 <mp_lmpar+0xe64>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm1
movsd  (%r11,%r8,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
add    $0x1,%r8
lea    0x1(%rbx),%rbp
not    %rbx
cmp    0x90(%rsp),%rbx
je     1ef0 <mp_lmpar+0xda0>
mov    0xd0(%rsp),%rsi
lea    (%rsi,%r8,8),%rsi
mov    0x10(%rsp),%rdi
sub    %rbp,%rdi
mov    0xc8(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
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    1ff0 <mp_lmpar+0xea0>
jmp    1ef0 <mp_lmpar+0xda0>
mov    0xb8(%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    %r15d,%r15d
nopl   (%rax)
movupd -0x10(%rbp,%r15,8),%xmm2
movupd 0x0(%rbp,%r15,8),%xmm3
movupd -0x10(%rdx,%r15,8),%xmm4
movupd (%rdx,%r15,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdx,%r15,8)
movupd %xmm5,(%rdx,%r15,8)
add    $0x4,%r15
cmp    %r15,%rsi
jne    2060 <mp_lmpar+0xf10>
cmp    %r11,%rdi
mov    0x18(%rsp),%r11
mov    0x138(%rsp),%r15
je     1ef0 <mp_lmpar+0xda0>
jmp    1f78 <mp_lmpar+0xe28>
nopl   0x0(%rax)
mov    0xc(%rsp),%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <mp_enorm@plt>
mov    %eax,%ebx
movapd 0x70(%rsp),%xmm0
ucomisd 0xf3a(%rip),%xmm0
jbe    2106 <mp_lmpar+0xfb6>
mov    0x118(%rsp),%rax
movsd  (%rax),%xmm1
movsd  0x28(%rsp),%xmm0
mov    $0x2,%al
call   1040 <mp_dmax1@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
xorpd  %xmm0,%xmm0
ucomisd 0x70(%rsp),%xmm0
ja     1ae0 <mp_lmpar+0x990>
movsd  0x38(%rsp),%xmm2
mov    0x118(%rsp),%rbp
jmp    1b0d <mp_lmpar+0x9bd>
nopl   0x0(%rax)
xor    %eax,%eax
mov    0xc(%rsp),%esi
mov    0x30(%rsp),%rdi
test   $0x1,%bl
jne    1ead <mp_lmpar+0xd5d>
jmp    1ecc <mp_lmpar+0xd7c>
xor    %eax,%eax
test   $0x1,%bl
jne    1d8b <mp_lmpar+0xc3b>
jmp    1db0 <mp_lmpar+0xc60>

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 i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %217, double* %218)
%220 = sitofp i32 %219 to double
store double %220, double* %37
%221 = load double, double* %37
%222 = load double, double* %21
%223 = fsub double %221, %222
store double %223, double* %38
%224 = load double, double* %38
%225 = load double, double* @mp_lmpar.p1
%226 = load double, double* %21
%227 = fmul double %225, %226
%228 = fcmp ole double %224, %227
br i1 %228, label %229, label %230
229: ; preds = %216
br label %695
230: ; preds = %216
%231 = load double, double* @mp_lmpar.zero
store double %231, double* %41
%232 = load i32, i32* %36
%233 = load i32, i32* %14
%234 = icmp sge i32 %232, %233
br i1 %234, label %235, label %346
235: ; preds = %230
store i32 0, i32* %31
br label %236
236: ; preds = %267, %235
%237 = load i32, i32* %31
%238 = load i32, i32* %14
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %270
240: ; preds = %236
%241 = load i32*, i32** %17
%242 = load i32, i32* %31
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
store i32 %245, i32* %35
%246 = load double*, double** %19
%247 = load i32*, i32** %18
%248 = load i32, i32* %35
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
%251 = load i32, i32* %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %246, i64 %252
%254 = load double, double* %253
%255 = load double*, double** %26
%256 = load i32, i32* %35
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
%259 = load double, double* %258
%260 = load double, double* %37
%261 = fdiv double %259, %260
%262 = fmul double %254, %261
%263 = load double*, double** %25
%264 = load i32, i32* %31
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %263, i64 %265
store double %262, double* %266
br label %267
267: ; preds = %240
%268 = load i32, i32* %31
%269 = add nsw i32 %268, 1
store i32 %269, i32* %31
br label %236
270: ; preds = %236
store i32 0, i32* %30
store i32 0, i32* %31
br label %271
271: ; preds = %331, %270
%272 = load i32, i32* %31
%273 = load i32, i32* %14
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %334
275: ; preds = %271
%276 = load double, double* @mp_lmpar.zero
store double %276, double* %43
%277 = load i32, i32* %31
%278 = sub nsw i32 %277, 1
store i32 %278, i32* %32
%279 = load i32, i32* %32
%280 = icmp sge i32 %279, 0
br i1 %280, label %281, label %306
281: ; preds = %275
%282 = load i32, i32* %30
store i32 %282, i32* %29
store i32 0, i32* %27
br label %283
283: ; preds = %302, %281
%284 = load i32, i32* %27
%285 = load i32, i32* %32
%286 = icmp sle i32 %284, %285
br i1 %286, label %287, label %305
287: ; preds = %283
%288 = load double*, double** %15
%289 = load i32, i32* %29
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = load double*, double** %25
%294 = load i32, i32* %27
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %293, i64 %295
%297 = load double, double* %296
%298 = load double, double* %43
%299 = call double @llvm.fmuladd.f64(double %292, double %297, double %298)
store double %299, double* %43
%300 = load i32, i32* %29
%301 = add nsw i32 %300, 1
store i32 %301, i32* %29
br label %302
302: ; preds = %287
%303 = load i32, i32* %27
%304 = add nsw i32 %303, 1
store i32 %304, i32* %27
br label %283
305: ; preds = %283
br label %306
306: ; preds = %305, %275
%307 = load double*, double** %25
%308 = load i32, i32* %31
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = load double, double* %43
%313 = fsub double %311, %312
%314 = load double*, double** %15
%315 = load i32, i32* %31
%316 = load i32, i32* %16
%317 = load i32, i32* %31
%318 = mul nsw i32 %316, %317
%319 = add nsw i32 %315, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %314, i64 %320
%322 = load double, double* %321
%323 = fdiv double %313, %322
%324 = load double*, double** %25
%325 = load i32, i32* %31
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %324, i64 %326
store double %323, double* %327
%328 = load i32, i32* %16
%329 = load i32, i32* %30
%330 = add nsw i32 %329, %328
store i32 %330, i32* %30
br label %331
331: ; preds = %306
%332 = load i32, i32* %31
%333 = add nsw i32 %332, 1
store i32 %333, i32* %31
br label %271
334: ; preds = %271
%335 = load i32, i32* %14
%336 = load double*, double** %25
%337 = call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %335, double* %336)
%338 = sitofp i32 %337 to double
store double %338, double* %44
%339 = load double, double* %38
%340 = load double, double* %21
%341 = fdiv double %339, %340
%342 = load double, double* %44
%343 = fdiv double %341, %342
%344 = load double, double* %44
%345 = fdiv double %343, %344
store double %345, double* %41
br label %346
346: ; preds = %334, %230
store i32 0, i32* %30
store i32 0, i32* %31
br label %347
347: ; preds = %400, %346
%348 = load i32, i32* %31
%349 = load i32, i32* %14
%350 = icmp slt i32 %348, %349
br i1 %350, label %351, label %403
351: ; preds = %347
%352 = load double, double* @mp_lmpar.zero
store double %352, double* %43
%353 = load i32, i32* %30
store i32 %353, i32* %29
store i32 0, i32* %27
br label %354
354: ; preds = %373, %351
%355 = load i32, i32* %27
%356 = load i32, i32* %31
%357 = icmp sle i32 %355, %356
br i1 %357, label %358, label %376
358: ; preds = %354
%359 = load double*, double** %15
%360 = load i32, i32* %29
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %359, i64 %361
%363 = load double, double* %362
%364 = load double*, double** %20
%365 = load i32, i32* %27
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
%368 = load double, double* %367
%369 = load double, double* %43
%370 = call double @llvm.fmuladd.f64(double %363, double %368, double %369)
store double %370, double* %43
%371 = load i32, i32* %29
%372 = add nsw i32 %371, 1
store i32 %372, i32* %29
br label %373
373: ; preds = %358
%374 = load i32, i32* %27
%375 = add nsw i32 %374, 1
store i32 %375, i32* %27
br label %354
376: ; preds = %354
%377 = load i32*, i32** %17
%378 = load i32, i32* %31
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
%381 = load i32, i32* %380
store i32 %381, i32* %35
%382 = load double, double* %43
%383 = load double*, double** %19
%384 = load i32*, i32** %18
%385 = load i32, i32* %35
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32, i32* %384, i64 %386
%388 = load i32, i32* %387
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %383, i64 %389
%391 = load double, double* %390
%392 = fdiv double %382, %391
%393 = load double*, double** %25
%394 = load i32, i32* %31
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %393, i64 %395
store double %392, double* %396
%397 = load i32, i32* %16
%398 = load i32, i32* %30
%399 = add nsw i32 %398, %397
store i32 %399, i32* %30
br label %400
400: ; preds = %376
%401 = load i32, i32* %31
%402 = add nsw i32 %401, 1
store i32 %402, i32* %31
br label %347
403: ; preds = %347
%404 = load i32, i32* %14
%405 = load double*, double** %25
%406 = call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %404, double* %405)
%407 = sitofp i32 %406 to double
store double %407, double* %39
%408 = load double, double* %39
%409 = load double, double* %21
%410 = fdiv double %408, %409
store double %410, double* %42
%411 = load double, double* %42
%412 = load double, double* @mp_lmpar.zero
%413 = fcmp oeq double %411, %412
br i1 %413, label %414, label %420
414: ; preds = %403
%415 = load double, double* %21
%416 = load double, double* @mp_lmpar.p1
%417 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %415, double %416)
%418 = sitofp i32 %417 to double
%419 = fdiv double 0x10000005017817, %418
store double %419, double* %42
br label %420
420: ; preds = %414, %403
%421 = load double*, double** %22
%422 = load double, double* %421
%423 = load double, double* %41
%424 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %422, double %423)
%425 = sitofp i32 %424 to double
%426 = load double*, double** %22
store double %425, double* %426
%427 = load double*, double** %22
%428 = load double, double* %427
%429 = load double, double* %42
%430 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %428, double %429)
%431 = sitofp i32 %430 to double
%432 = load double*, double** %22
store double %431, double* %432
%433 = load double*, double** %22
%434 = load double, double* %433
%435 = load double, double* @mp_lmpar.zero
%436 = fcmp oeq double %434, %435
br i1 %436, label %437, label %442
437: ; preds = %420
%438 = load double, double* %39
%439 = load double, double* %37
%440 = fdiv double %438, %439
%441 = load double*, double** %22
store double %440, double* %441
br label %442
442: ; preds = %437, %420
br label %443
443: ; preds = %686, %442
%444 = load i32, i32* %28
%445 = add nsw i32 %444, 1
store i32 %445, i32* %28
%446 = load double*, double** %22
%447 = load double, double* %446
%448 = load double, double* @mp_lmpar.zero
%449 = fcmp oeq double %447, %448
br i1 %449, label %450, label %457
450: ; preds = %443
%451 = load double, double* @mp_lmpar.p001
%452 = load double, double* %42
%453 = fmul double %451, %452
%454 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double 0x10000005017817, double %453)
%455 = sitofp i32 %454 to double
%456 = load double*, double** %22
store double %455, double* %456
br label %457
457: ; preds = %450, %443
%458 = load double*, double** %22
%459 = load double, double* %458
%460 = call double @sqrt(double %459)
store double %460, double* %44
store i32 0, i32* %31
br label %461
461: ; preds = %481, %457
%462 = load i32, i32* %31
%463 = load i32, i32* %14
%464 = icmp slt i32 %462, %463
br i1 %464, label %465, label %484
465: ; preds = %461
%466 = load double, double* %44
%467 = load double*, double** %19
%468 = load i32*, i32** %18
%469 = load i32, i32* %31
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i32, i32* %468, i64 %470
%472 = load i32, i32* %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %467, i64 %473
%475 = load double, double* %474
%476 = fmul double %466, %475
%477 = load double*, double** %25
%478 = load i32, i32* %31
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %477, i64 %479
store double %476, double* %480
br label %481
481: ; preds = %465
%482 = load i32, i32* %31
%483 = add nsw i32 %482, 1
store i32 %483, i32* %31
br label %461
484: ; preds = %461
%485 = load i32, i32* %14
%486 = load double*, double** %15
%487 = load i32, i32* %16
%488 = load i32*, i32** %17
%489 = load double*, double** %25
%490 = load double*, double** %20
%491 = load double*, double** %23
%492 = load double*, double** %24
%493 = load double*, double** %26
%494 = call i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @mp_qrsolv to i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...)*)(i32 %485, double* %486, i32 %487, i32* %488, double* %489, double* %490, double* %491, double* %492, double* %493)
store i32 0, i32* %31
br label %495
495: ; preds = %519, %484
%496 = load i32, i32* %31
%497 = load i32, i32* %14
%498 = icmp slt i32 %496, %497
br i1 %498, label %499, label %522
499: ; preds = %495
%500 = load double*, double** %19
%501 = load i32*, i32** %18
%502 = load i32, i32* %31
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i32, i32* %501, i64 %503
%505 = load i32, i32* %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %500, i64 %506
%508 = load double, double* %507
%509 = load double*, double** %23
%510 = load i32, i32* %31
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %509, i64 %511
%513 = load double, double* %512
%514 = fmul double %508, %513
%515 = load double*, double** %26
%516 = load i32, i32* %31
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %515, i64 %517
store double %514, double* %518
br label %519
519: ; preds = %499
%520 = load i32, i32* %31
%521 = add nsw i32 %520, 1
store i32 %521, i32* %31
br label %495
522: ; preds = %495
%523 = load i32, i32* %14
%524 = load double*, double** %26
%525 = call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %523, double* %524)
%526 = sitofp i32 %525 to double
store double %526, double* %37
%527 = load double, double* %38
store double %527, double* %44
%528 = load double, double* %37
%529 = load double, double* %21
%530 = fsub double %528, %529
store double %530, double* %38
%531 = load double, double* %38
%532 = call double @llvm.fabs.f64(double %531)
%533 = load double, double* @mp_lmpar.p1
%534 = load double, double* %21
%535 = fmul double %533, %534
%536 = fcmp ole double %532, %535
br i1 %536, label %552, label %537
537: ; preds = %522
%538 = load double, double* %41
%539 = load double, double* @mp_lmpar.zero
%540 = fcmp oeq double %538, %539
br i1 %540, label %541, label %549
541: ; preds = %537
%542 = load double, double* %38
%543 = load double, double* %44
%544 = fcmp ole double %542, %543
br i1 %544, label %545, label %549
545: ; preds = %541
%546 = load double, double* %44
%547 = load double, double* @mp_lmpar.zero
%548 = fcmp olt double %546, %547
br i1 %548, label %552, label %549
549: ; preds = %545, %541, %537
%550 = load i32, i32* %28
%551 = icmp eq i32 %550, 10
br i1 %551, label %552, label %553
552: ; preds = %549, %545, %522
br label %695
553: ; preds = %549
store i32 0, i32* %31
br label %554
554: ; preds = %585, %553
%555 = load i32, i32* %31
%556 = load i32, i32* %14
%557 = icmp slt i32 %555, %556
br i1 %557, label %558, label %588
558: ; preds = %554
%559 = load i32*, i32** %17
%560 = load i32, i32* %31
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds i32, i32* %559, i64 %561
%563 = load i32, i32* %562
store i32 %563, i32* %35
%564 = load double*, double** %19
%565 = load i32*, i32** %18
%566 = load i32, i32* %35
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i32, i32* %565, i64 %567
%569 = load i32, i32* %568
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds double, double* %564, i64 %570
%572 = load double, double* %571
%573 = load double*, double** %26
%574 = load i32, i32* %35
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double, double* %573, i64 %575
%577 = load double, double* %576
%578 = load double, double* %37
%579 = fdiv double %577, %578
%580 = fmul double %572, %579
%581 = load double*, double** %25
%582 = load i32, i32* %31
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %581, i64 %583
store double %580, double* %584
br label %585
585: ; preds = %558
%586 = load i32, i32* %31
%587 = add nsw i32 %586, 1
store i32 %587, i32* %31
br label %554
588: ; preds = %554
store i32 0, i32* %30
store i32 0, i32* %31
br label %589
589: ; preds = %652, %588
%590 = load i32, i32* %31
%591 = load i32, i32* %14
%592 = icmp slt i32 %590, %591
br i1 %592, label %593, label %655
593: ; preds = %589
%594 = load double*, double** %25
%595 = load i32, i32* %31
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = load double*, double** %24
%600 = load i32, i32* %31
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %599, i64 %601
%603 = load double, double* %602
%604 = fdiv double %598, %603
%605 = load double*, double** %25
%606 = load i32, i32* %31
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %605, i64 %607
store double %604, double* %608
%609 = load double*, double** %25
%610 = load i32, i32* %31
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
%613 = load double, double* %612
store double %613, double* %44
%614 = load i32, i32* %31
%615 = add nsw i32 %614, 1
store i32 %615, i32* %33
%616 = load i32, i32* %33
%617 = load i32, i32* %14
%618 = icmp slt i32 %616, %617
br i1 %618, label %619, label %648
619: ; preds = %593
%620 = load i32, i32* %33
%621 = load i32, i32* %30
%622 = add nsw i32 %620, %621
store i32 %622, i32* %29
%623 = load i32, i32* %33
store i32 %623, i32* %27
br label %624
624: ; preds = %644, %619
%625 = load i32, i32* %27
%626 = load i32, i32* %14
%627 = icmp slt i32 %625, %626
br i1 %627, label %628, label %647
628: ; preds = %624
%629 = load double*, double** %15
%630 = load i32, i32* %29
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds double, double* %629, i64 %631
%633 = load double, double* %632
%634 = load double, double* %44
%635 = load double*, double** %25
%636 = load i32, i32* %27
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
%639 = load double, double* %638
%640 = fneg double %633
%641 = call double @llvm.fmuladd.f64(double %640, double %634, double %639)
store double %641, double* %638
%642 = load i32, i32* %29
%643 = add nsw i32 %642, 1
store i32 %643, i32* %29
br label %644
644: ; preds = %628
%645 = load i32, i32* %27
%646 = add nsw i32 %645, 1
store i32 %646, i32* %27
br label %624
647: ; preds = %624
br label %648
648: ; preds = %647, %593
%649 = load i32, i32* %16
%650 = load i32, i32* %30
%651 = add nsw i32 %650, %649
store i32 %651, i32* %30
br label %652
652: ; preds = %648
%653 = load i32, i32* %31
%654 = add nsw i32 %653, 1
store i32 %654, i32* %31
br label %589
655: ; preds = %589
%656 = load i32, i32* %14
%657 = load double*, double** %25
%658 = call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %656, double* %657)
%659 = sitofp i32 %658 to double
store double %659, double* %44
%660 = load double, double* %38
%661 = load double, double* %21
%662 = fdiv double %660, %661
%663 = load double, double* %44
%664 = fdiv double %662, %663
%665 = load double, double* %44
%666 = fdiv double %664, %665
store double %666, double* %40
%667 = load double, double* %38
%668 = load double, double* @mp_lmpar.zero
%669 = fcmp ogt double %667, %668
br i1 %669, label %670, label %676
670: ; preds = %655
%671 = load double, double* %41
%672 = load double*, double** %22
%673 = load double, double* %672
%674 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %671, double %673)
%675 = sitofp i32 %674 to double
store double %675, double* %41
br label %676
676: ; preds = %670, %655
%677 = load double, double* %38
%678 = load double, double* @mp_lmpar.zero
%679 = fcmp olt double %677, %678
br i1 %679, label %680, label %686
680: ; preds = %676
%681 = load double, double* %42
%682 = load double*, double** %22
%683 = load double, double* %682
%684 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %681, double %683)
%685 = sitofp i32 %684 to double
store double %685, double* %42
br label %686
686: ; preds = %680, %676
%687 = load double, double* %41
%688 = load double*, double** %22
%689 = load double, double* %688
%690 = load double, double* %40
%691 = fadd double %689, %690
%692 = call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %687, double %691)
%693 = sitofp i32 %692 to double
%694 = load double*, double** %22
store double %693, double* %694
br label %443
695: ; preds = %552, %229
%696 = load i32, i32* %28
%697 = icmp eq i32 %696, 0
br i1 %697, label %698, label %701
698: ; preds = %695
%699 = load double, double* @mp_lmpar.zero
%700 = load double*, double** %22
store double %699, double* %700
br label %701
701: ; preds = %698, %695
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 i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %12)
%261 = sitofp i32 %260 to double
%262 = fsub double %261, %7
%263 = fmul double %7, 1.000000e-01
%264 = fcmp ugt double %262, %263
br i1 %264, label %265, label %843
265: ; preds = %258
%266 = icmp slt i32 %259, %0
br i1 %266, label %414, label %267
267: ; preds = %265
br i1 %14, label %268, label %408
268: ; preds = %267
%269 = zext i32 %0 to i64
%270 = and i64 %269, 1
%271 = icmp eq i32 %0, 1
br i1 %271, label %274, label %272
272: ; preds = %268
%273 = and i64 %269, 4294967294
br label %295
274: ; preds = %295, %268
%275 = phi i64 [ 0, %268 ], [ %325, %295 ]
%276 = icmp eq i64 %270, 0
br i1 %276, label %291, label %277
277: ; preds = %274
%278 = getelementptr inbounds i32, i32* %3, i64 %275
%279 = load i32, i32* %278
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %4, i64 %280
%282 = load i32, i32* %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %5, i64 %283
%285 = load double, double* %284
%286 = getelementptr inbounds double, double* %12, i64 %280
%287 = load double, double* %286
%288 = fdiv double %287, %261
%289 = fmul double %285, %288
%290 = getelementptr inbounds double, double* %11, i64 %275
store double %289, double* %290
br label %291
291: ; preds = %274, %277
br i1 %14, label %292, label %408
292: ; preds = %291
%293 = sext i32 %2 to i64
%294 = zext i32 %0 to i64
br label %328
295: ; preds = %295, %272
%296 = phi i64 [ 0, %272 ], [ %325, %295 ]
%297 = phi i64 [ 0, %272 ], [ %326, %295 ]
%298 = getelementptr inbounds i32, i32* %3, i64 %296
%299 = load i32, i32* %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %4, i64 %300
%302 = load i32, i32* %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %5, i64 %303
%305 = load double, double* %304
%306 = getelementptr inbounds double, double* %12, i64 %300
%307 = load double, double* %306
%308 = fdiv double %307, %261
%309 = fmul double %305, %308
%310 = getelementptr inbounds double, double* %11, i64 %296
store double %309, double* %310
%311 = or i64 %296, 1
%312 = getelementptr inbounds i32, i32* %3, i64 %311
%313 = load i32, i32* %312
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %4, i64 %314
%316 = load i32, i32* %315
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %5, i64 %317
%319 = load double, double* %318
%320 = getelementptr inbounds double, double* %12, i64 %314
%321 = load double, double* %320
%322 = fdiv double %321, %261
%323 = fmul double %319, %322
%324 = getelementptr inbounds double, double* %11, i64 %311
store double %323, double* %324
%325 = add nuw nsw i64 %296, 2
%326 = add i64 %297, 2
%327 = icmp eq i64 %326, %273
br i1 %327, label %274, label %295
328: ; preds = %292, %394
%329 = phi i64 [ 0, %292 ], [ %406, %394 ]
%330 = phi i64 [ 0, %292 ], [ %405, %394 ]
%331 = trunc i64 %329 to i32
%332 = icmp eq i64 %329, 0
br i1 %332, label %394, label %333
333: ; preds = %328
%334 = add nsw i64 %329, -1
%335 = and i64 %329, 3
%336 = icmp ult i64 %334, 3
br i1 %336, label %374, label %337
337: ; preds = %333
%338 = and i64 %329, 9223372036854775804
br label %339
339: ; preds = %339, %337
%340 = phi i64 [ %330, %337 ], [ %370, %339 ]
%341 = phi i64 [ 0, %337 ], [ %371, %339 ]
%342 = phi double [ 0.000000e+00, %337 ], [ %369, %339 ]
%343 = phi i64 [ 0, %337 ], [ %372, %339 ]
%344 = getelementptr inbounds double, double* %1, i64 %340
%345 = load double, double* %344
%346 = getelementptr inbounds double, double* %11, i64 %341
%347 = load double, double* %346
%348 = tail call double @llvm.fmuladd.f64(double %345, double %347, double %342)
%349 = add nsw i64 %340, 1
%350 = or i64 %341, 1
%351 = getelementptr inbounds double, double* %1, i64 %349
%352 = load double, double* %351
%353 = getelementptr inbounds double, double* %11, i64 %350
%354 = load double, double* %353
%355 = tail call double @llvm.fmuladd.f64(double %352, double %354, double %348)
%356 = add nsw i64 %340, 2
%357 = or i64 %341, 2
%358 = getelementptr inbounds double, double* %1, i64 %356
%359 = load double, double* %358
%360 = getelementptr inbounds double, double* %11, i64 %357
%361 = load double, double* %360
%362 = tail call double @llvm.fmuladd.f64(double %359, double %361, double %355)
%363 = add nsw i64 %340, 3
%364 = or i64 %341, 3
%365 = getelementptr inbounds double, double* %1, i64 %363
%366 = load double, double* %365
%367 = getelementptr inbounds double, double* %11, i64 %364
%368 = load double, double* %367
%369 = tail call double @llvm.fmuladd.f64(double %366, double %368, double %362)
%370 = add nsw i64 %340, 4
%371 = add nuw nsw i64 %341, 4
%372 = add i64 %343, 4
%373 = icmp eq i64 %372, %338
br i1 %373, label %374, label %339
374: ; preds = %339, %333
%375 = phi double [ undef, %333 ], [ %369, %339 ]
%376 = phi i64 [ %330, %333 ], [ %370, %339 ]
%377 = phi i64 [ 0, %333 ], [ %371, %339 ]
%378 = phi double [ 0.000000e+00, %333 ], [ %369, %339 ]
%379 = icmp eq i64 %335, 0
br i1 %379, label %394, label %380
380: ; preds = %374, %380
%381 = phi i64 [ %390, %380 ], [ %376, %374 ]
%382 = phi i64 [ %391, %380 ], [ %377, %374 ]
%383 = phi double [ %389, %380 ], [ %378, %374 ]
%384 = phi i64 [ %392, %380 ], [ 0, %374 ]
%385 = getelementptr inbounds double, double* %1, i64 %381
%386 = load double, double* %385
%387 = getelementptr inbounds double, double* %11, i64 %382
%388 = load double, double* %387
%389 = tail call double @llvm.fmuladd.f64(double %386, double %388, double %383)
%390 = add nsw i64 %381, 1
%391 = add nuw nsw i64 %382, 1
%392 = add i64 %384, 1
%393 = icmp eq i64 %392, %335
br i1 %393, label %394, label %380
394: ; preds = %374, %380, %328
%395 = phi double [ 0.000000e+00, %328 ], [ %375, %374 ], [ %389, %380 ]
%396 = getelementptr inbounds double, double* %11, i64 %329
%397 = load double, double* %396
%398 = fsub double %397, %395
%399 = mul nsw i32 %331, %2
%400 = sext i32 %399 to i64
%401 = add nsw i64 %329, %400
%402 = getelementptr inbounds double, double* %1, i64 %401
%403 = load double, double* %402
%404 = fdiv double %398, %403
store double %404, double* %396
%405 = add nsw i64 %330, %293
%406 = add nuw nsw i64 %329, 1
%407 = icmp eq i64 %406, %294
br i1 %407, label %408, label %328
408: ; preds = %394, %267, %291
%409 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %11)
%410 = sitofp i32 %409 to double
%411 = fdiv double %262, %7
%412 = fdiv double %411, %410
%413 = fdiv double %412, %410
br label %414
414: ; preds = %408, %265
%415 = phi double [ %413, %408 ], [ 0.000000e+00, %265 ]
br i1 %14, label %416, label %498
416: ; preds = %414
%417 = sext i32 %2 to i64
%418 = zext i32 %0 to i64
br label %419
419: ; preds = %416, %482
%420 = phi i64 [ 0, %416 ], [ %495, %482 ]
%421 = phi i64 [ 1, %416 ], [ %496, %482 ]
%422 = phi i64 [ 0, %416 ], [ %494, %482 ]
%423 = and i64 %421, 3
%424 = icmp ult i64 %420, 3
br i1 %424, label %462, label %425
425: ; preds = %419
%426 = and i64 %421, 9223372036854775804
br label %427
427: ; preds = %427, %425
%428 = phi i64 [ %422, %425 ], [ %458, %427 ]
%429 = phi i64 [ 0, %425 ], [ %459, %427 ]
%430 = phi double [ 0.000000e+00, %425 ], [ %457, %427 ]
%431 = phi i64 [ 0, %425 ], [ %460, %427 ]
%432 = getelementptr inbounds double, double* %1, i64 %428
%433 = load double, double* %432
%434 = getelementptr inbounds double, double* %6, i64 %429
%435 = load double, double* %434
%436 = tail call double @llvm.fmuladd.f64(double %433, double %435, double %430)
%437 = add nsw i64 %428, 1
%438 = or i64 %429, 1
%439 = getelementptr inbounds double, double* %1, i64 %437
%440 = load double, double* %439
%441 = getelementptr inbounds double, double* %6, i64 %438
%442 = load double, double* %441
%443 = tail call double @llvm.fmuladd.f64(double %440, double %442, double %436)
%444 = add nsw i64 %428, 2
%445 = or i64 %429, 2
%446 = getelementptr inbounds double, double* %1, i64 %444
%447 = load double, double* %446
%448 = getelementptr inbounds double, double* %6, i64 %445
%449 = load double, double* %448
%450 = tail call double @llvm.fmuladd.f64(double %447, double %449, double %443)
%451 = add nsw i64 %428, 3
%452 = or i64 %429, 3
%453 = getelementptr inbounds double, double* %1, i64 %451
%454 = load double, double* %453
%455 = getelementptr inbounds double, double* %6, i64 %452
%456 = load double, double* %455
%457 = tail call double @llvm.fmuladd.f64(double %454, double %456, double %450)
%458 = add nsw i64 %428, 4
%459 = add nuw nsw i64 %429, 4
%460 = add i64 %431, 4
%461 = icmp eq i64 %460, %426
br i1 %461, label %462, label %427
462: ; preds = %427, %419
%463 = phi double [ undef, %419 ], [ %457, %427 ]
%464 = phi i64 [ %422, %419 ], [ %458, %427 ]
%465 = phi i64 [ 0, %419 ], [ %459, %427 ]
%466 = phi double [ 0.000000e+00, %419 ], [ %457, %427 ]
%467 = icmp eq i64 %423, 0
br i1 %467, label %482, label %468
468: ; preds = %462, %468
%469 = phi i64 [ %478, %468 ], [ %464, %462 ]
%470 = phi i64 [ %479, %468 ], [ %465, %462 ]
%471 = phi double [ %477, %468 ], [ %466, %462 ]
%472 = phi i64 [ %480, %468 ], [ 0, %462 ]
%473 = getelementptr inbounds double, double* %1, i64 %469
%474 = load double, double* %473
%475 = getelementptr inbounds double, double* %6, i64 %470
%476 = load double, double* %475
%477 = tail call double @llvm.fmuladd.f64(double %474, double %476, double %471)
%478 = add nsw i64 %469, 1
%479 = add nuw nsw i64 %470, 1
%480 = add i64 %472, 1
%481 = icmp eq i64 %480, %423
br i1 %481, label %482, label %468
482: ; preds = %468, %462
%483 = phi double [ %463, %462 ], [ %477, %468 ]
%484 = getelementptr inbounds i32, i32* %3, i64 %420
%485 = load i32, i32* %484
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i32, i32* %4, i64 %486
%488 = load i32, i32* %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %5, i64 %489
%491 = load double, double* %490
%492 = fdiv double %483, %491
%493 = getelementptr inbounds double, double* %11, i64 %420
store double %492, double* %493
%494 = add nsw i64 %422, %417
%495 = add nuw nsw i64 %420, 1
%496 = add nuw nsw i64 %421, 1
%497 = icmp eq i64 %495, %418
br i1 %497, label %498, label %419
498: ; preds = %482, %414
%499 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %11)
%500 = sitofp i32 %499 to double
%501 = fdiv double %500, %7
%502 = fcmp oeq double %501, 0.000000e+00
br i1 %502, label %503, label %507
503: ; preds = %498
%504 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %7, double 1.000000e-01)
%505 = sitofp i32 %504 to double
%506 = fdiv double 0x10000005017817, %505
br label %507
507: ; preds = %503, %498
%508 = phi double [ %506, %503 ], [ %501, %498 ]
%509 = load double, double* %8
%510 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %509, double %415)
%511 = sitofp i32 %510 to double
store double %511, double* %8
%512 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %511, double %508)
%513 = sitofp i32 %512 to double
%514 = icmp eq i32 %512, 0
%515 = fdiv double %500, %261
%516 = select i1 %514, double %515, double %513
%517 = add i32 %2, 1
%518 = sext i32 %0 to i64
%519 = zext i32 %0 to i64
%520 = zext i32 %0 to i64
%521 = getelementptr double, double* %11, i64 %519
%522 = add nsw i64 %520, -1
%523 = and i64 %520, 3
%524 = icmp ult i64 %522, 3
%525 = and i64 %520, 4294967292
%526 = icmp eq i64 %523, 0
%527 = and i64 %520, 1
%528 = icmp eq i64 %522, 0
%529 = and i64 %520, 4294967294
%530 = icmp eq i64 %527, 0
%531 = and i64 %520, 1
%532 = icmp eq i64 %522, 0
%533 = and i64 %520, 4294967294
%534 = icmp eq i64 %531, 0
%535 = sub nsw i64 0, %520
br label %536
536: ; preds = %837, %507
%537 = phi double [ %516, %507 ], [ %842, %837 ]
%538 = phi double [ %262, %507 ], [ %649, %837 ]
%539 = phi i32 [ 0, %507 ], [ %542, %837 ]
%540 = phi double [ %415, %507 ], [ %831, %837 ]
%541 = phi double [ %508, %507 ], [ %838, %837 ]
store double %537, double* %8
%542 = add nuw nsw i32 %539, 1
%543 = fcmp oeq double %537, 0.000000e+00
br i1 %543, label %544, label %548
544: ; preds = %536
%545 = fmul double %541, 1.000000e-03
%546 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double 0x10000005017817, double %545)
%547 = sitofp i32 %546 to double
store double %547, double* %8
br label %548
548: ; preds = %544, %536
%549 = phi double [ %547, %544 ], [ %537, %536 ]
%550 = tail call double @sqrt(double %549)
br i1 %14, label %551, label %552
551: ; preds = %548
br i1 %524, label %591, label %554
552: ; preds = %548
%553 = tail call i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @mp_qrsolv to i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...)*)(i32 %0, double* %1, i32 %2, i32* %3, double* %11, double* %6, double* %9, double* %10, double* %12)
br label %646
554: ; preds = %551, %554
%555 = phi i64 [ %588, %554 ], [ 0, %551 ]
%556 = phi i64 [ %589, %554 ], [ 0, %551 ]
%557 = getelementptr inbounds i32, i32* %4, i64 %555
%558 = load i32, i32* %557
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds double, double* %5, i64 %559
%561 = load double, double* %560
%562 = fmul double %550, %561
%563 = getelementptr inbounds double, double* %11, i64 %555
store double %562, double* %563
%564 = or i64 %555, 1
%565 = getelementptr inbounds i32, i32* %4, i64 %564
%566 = load i32, i32* %565
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %5, i64 %567
%569 = load double, double* %568
%570 = fmul double %550, %569
%571 = getelementptr inbounds double, double* %11, i64 %564
store double %570, double* %571
%572 = or i64 %555, 2
%573 = getelementptr inbounds i32, i32* %4, i64 %572
%574 = load i32, i32* %573
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double, double* %5, i64 %575
%577 = load double, double* %576
%578 = fmul double %550, %577
%579 = getelementptr inbounds double, double* %11, i64 %572
store double %578, double* %579
%580 = or i64 %555, 3
%581 = getelementptr inbounds i32, i32* %4, i64 %580
%582 = load i32, i32* %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %5, i64 %583
%585 = load double, double* %584
%586 = fmul double %550, %585
%587 = getelementptr inbounds double, double* %11, i64 %580
store double %586, double* %587
%588 = add nuw nsw i64 %555, 4
%589 = add i64 %556, 4
%590 = icmp eq i64 %589, %525
br i1 %590, label %591, label %554
591: ; preds = %554, %551
%592 = phi i64 [ 0, %551 ], [ %588, %554 ]
br i1 %526, label %606, label %593
593: ; preds = %591, %593
%594 = phi i64 [ %603, %593 ], [ %592, %591 ]
%595 = phi i64 [ %604, %593 ], [ 0, %591 ]
%596 = getelementptr inbounds i32, i32* %4, i64 %594
%597 = load i32, i32* %596
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %5, i64 %598
%600 = load double, double* %599
%601 = fmul double %550, %600
%602 = getelementptr inbounds double, double* %11, i64 %594
store double %601, double* %602
%603 = add nuw nsw i64 %594, 1
%604 = add i64 %595, 1
%605 = icmp eq i64 %604, %523
br i1 %605, label %606, label %593
606: ; preds = %593, %591
%607 = tail call i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @mp_qrsolv to i32 (i32, double*, i32, i32*, double*, double*, double*, double*, double*, ...)*)(i32 %0, double* %1, i32 %2, i32* %3, double* %11, double* %6, double* %9, double* %10, double* %12)
br i1 %14, label %608, label %646
608: ; preds = %606
br i1 %528, label %634, label %609
609: ; preds = %608, %609
%610 = phi i64 [ %631, %609 ], [ 0, %608 ]
%611 = phi i64 [ %632, %609 ], [ 0, %608 ]
%612 = getelementptr inbounds i32, i32* %4, i64 %610
%613 = load i32, i32* %612
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %5, i64 %614
%616 = load double, double* %615
%617 = getelementptr inbounds double, double* %9, i64 %610
%618 = load double, double* %617
%619 = fmul double %616, %618
%620 = getelementptr inbounds double, double* %12, i64 %610
store double %619, double* %620
%621 = or i64 %610, 1
%622 = getelementptr inbounds i32, i32* %4, i64 %621
%623 = load i32, i32* %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %5, i64 %624
%626 = load double, double* %625
%627 = getelementptr inbounds double, double* %9, i64 %621
%628 = load double, double* %627
%629 = fmul double %626, %628
%630 = getelementptr inbounds double, double* %12, i64 %621
store double %629, double* %630
%631 = add nuw nsw i64 %610, 2
%632 = add i64 %611, 2
%633 = icmp eq i64 %632, %529
br i1 %633, label %634, label %609
634: ; preds = %609, %608
%635 = phi i64 [ 0, %608 ], [ %631, %609 ]
br i1 %530, label %646, label %636
636: ; preds = %634
%637 = getelementptr inbounds i32, i32* %4, i64 %635
%638 = load i32, i32* %637
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds double, double* %5, i64 %639
%641 = load double, double* %640
%642 = getelementptr inbounds double, double* %9, i64 %635
%643 = load double, double* %642
%644 = fmul double %641, %643
%645 = getelementptr inbounds double, double* %12, i64 %635
store double %644, double* %645
br label %646
646: ; preds = %636, %634, %552, %606
%647 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %12)
%648 = sitofp i32 %647 to double
%649 = fsub double %648, %7
%650 = tail call double @llvm.fabs.f64(double %649)
%651 = fcmp ugt double %650, %263
br i1 %651, label %652, label %844
652: ; preds = %646
%653 = fcmp une double %540, 0.000000e+00
%654 = fcmp ugt double %649, %538
%655 = select i1 %653, i1 true, i1 %654
br i1 %655, label %660, label %656
656: ; preds = %652
%657 = fcmp olt double %538, 0.000000e+00
%658 = icmp eq i32 %542, 10
%659 = select i1 %657, i1 true, i1 %658
br i1 %659, label %844, label %662
660: ; preds = %652
%661 = icmp eq i32 %542, 10
br i1 %661, label %844, label %662
662: ; preds = %656, %660
br i1 %14, label %663, label %819
663: ; preds = %662
br i1 %532, label %664, label %681
664: ; preds = %681, %663
%665 = phi i64 [ 0, %663 ], [ %711, %681 ]
br i1 %534, label %680, label %666
666: ; preds = %664
%667 = getelementptr inbounds i32, i32* %3, i64 %665
%668 = load i32, i32* %667
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds i32, i32* %4, i64 %669
%671 = load i32, i32* %670
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %5, i64 %672
%674 = load double, double* %673
%675 = getelementptr inbounds double, double* %12, i64 %669
%676 = load double, double* %675
%677 = fdiv double %676, %648
%678 = fmul double %674, %677
%679 = getelementptr inbounds double, double* %11, i64 %665
store double %678, double* %679
br label %680
680: ; preds = %664, %666
br i1 %14, label %714, label %819
681: ; preds = %663, %681
%682 = phi i64 [ %711, %681 ], [ 0, %663 ]
%683 = phi i64 [ %712, %681 ], [ 0, %663 ]
%684 = getelementptr inbounds i32, i32* %3, i64 %682
%685 = load i32, i32* %684
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds i32, i32* %4, i64 %686
%688 = load i32, i32* %687
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %5, i64 %689
%691 = load double, double* %690
%692 = getelementptr inbounds double, double* %12, i64 %686
%693 = load double, double* %692
%694 = fdiv double %693, %648
%695 = fmul double %691, %694
%696 = getelementptr inbounds double, double* %11, i64 %682
store double %695, double* %696
%697 = or i64 %682, 1
%698 = getelementptr inbounds i32, i32* %3, i64 %697
%699 = load i32, i32* %698
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i32, i32* %4, i64 %700
%702 = load i32, i32* %701
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds double, double* %5, i64 %703
%705 = load double, double* %704
%706 = getelementptr inbounds double, double* %12, i64 %700
%707 = load double, double* %706
%708 = fdiv double %707, %648
%709 = fmul double %705, %708
%710 = getelementptr inbounds double, double* %11, i64 %697
store double %709, double* %710
%711 = add nuw nsw i64 %682, 2
%712 = add i64 %683, 2
%713 = icmp eq i64 %712, %533
br i1 %713, label %664, label %681
714: ; preds = %680, %815
%715 = phi i64 [ %732, %815 ], [ 0, %680 ]
%716 = phi i32 [ %817, %815 ], [ 1, %680 ]
%717 = phi i64 [ %816, %815 ], [ 1, %680 ]
%718 = xor i64 %715, -1
%719 = add nsw i64 %718, %519
%720 = getelementptr double, double* %11, i64 %717
%721 = sext i32 %716 to i64
%722 = getelementptr double, double* %1, i64 %721
%723 = xor i64 %715, -1
%724 = add nsw i64 %723, %519
%725 = getelementptr double, double* %1, i64 %724
%726 = getelementptr double, double* %725, i64 %721
%727 = getelementptr inbounds double, double* %11, i64 %715
%728 = load double, double* %727
%729 = getelementptr inbounds double, double* %10, i64 %715
%730 = load double, double* %729
%731 = fdiv double %728, %730
store double %731, double* %727
%732 = add nuw nsw i64 %715, 1
%733 = icmp slt i64 %732, %518
br i1 %733, label %734, label %815
734: ; preds = %714
%735 = sext i32 %716 to i64
%736 = icmp ult i64 %719, 4
br i1 %736, label %775, label %737
737: ; preds = %734
%738 = icmp ult double* %720, %726
%739 = icmp ult double* %722, %521
%740 = and i1 %738, %739
br i1 %740, label %775, label %741
741: ; preds = %737
%742 = and i64 %719, -4
%743 = add i64 %742, %735
%744 = add i64 %717, %742
%745 = insertelement <2 x double> poison, double %731, i64 0
%746 = shufflevector <2 x double> %745, <2 x double> poison, <2 x i32> zeroinitializer
%747 = insertelement <2 x double> poison, double %731, i64 0
%748 = shufflevector <2 x double> %747, <2 x double> poison, <2 x i32> zeroinitializer
br label %749
749: ; preds = %749, %741
%750 = phi i64 [ 0, %741 ], [ %771, %749 ]
%751 = add i64 %750, %735
%752 = add i64 %717, %750
%753 = getelementptr inbounds double, double* %1, i64 %751
%754 = bitcast double* %753 to <2 x double>*
%755 = load <2 x double>, <2 x double>* %754
%756 = getelementptr inbounds double, double* %753, i64 2
%757 = bitcast double* %756 to <2 x double>*
%758 = load <2 x double>, <2 x double>* %757
%759 = getelementptr inbounds double, double* %11, i64 %752
%760 = bitcast double* %759 to <2 x double>*
%761 = load <2 x double>, <2 x double>* %760
%762 = getelementptr inbounds double, double* %759, i64 2
%763 = bitcast double* %762 to <2 x double>*
%764 = load <2 x double>, <2 x double>* %763
%765 = fneg <2 x double> %755
%766 = fneg <2 x double> %758
%767 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %765, <2 x double> %746, <2 x double> %761)
%768 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %766, <2 x double> %748, <2 x double> %764)
%769 = bitcast double* %759 to <2 x double>*
store <2 x double> %767, <2 x double>* %769
%770 = bitcast double* %762 to <2 x double>*
store <2 x double> %768, <2 x double>* %770
%771 = add nuw i64 %750, 4
%772 = icmp eq i64 %771, %742
br i1 %772, label %773, label %749
773: ; preds = %749
%774 = icmp eq i64 %719, %742
br i1 %774, label %815, label %775
775: ; preds = %737, %734, %773
%776 = phi i64 [ %735, %737 ], [ %735, %734 ], [ %743, %773 ]
%777 = phi i64 [ %717, %737 ], [ %717, %734 ], [ %744, %773 ]
%778 = sub i64 %520, %777
%779 = xor i64 %777, -1
%780 = and i64 %778, 1
%781 = icmp eq i64 %780, 0
br i1 %781, label %791, label %782
782: ; preds = %775
%783 = getelementptr inbounds double, double* %1, i64 %776
%784 = load double, double* %783
%785 = getelementptr inbounds double, double* %11, i64 %777
%786 = load double, double* %785
%787 = fneg double %784
%788 = tail call double @llvm.fmuladd.f64(double %787, double %731, double %786)
store double %788, double* %785
%789 = add nsw i64 %776, 1
%790 = add nuw nsw i64 %777, 1
br label %791
791: ; preds = %782, %775
%792 = phi i64 [ %776, %775 ], [ %789, %782 ]
%793 = phi i64 [ %777, %775 ], [ %790, %782 ]
%794 = icmp eq i64 %779, %535
br i1 %794, label %815, label %795
795: ; preds = %791, %795
%796 = phi i64 [ %812, %795 ], [ %792, %791 ]
%797 = phi i64 [ %813, %795 ], [ %793, %791 ]
%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 %731, double %801)
store double %803, double* %800
%804 = add nsw i64 %796, 1
%805 = add nuw nsw i64 %797, 1
%806 = getelementptr inbounds double, double* %1, i64 %804
%807 = load double, double* %806
%808 = getelementptr inbounds double, double* %11, i64 %805
%809 = load double, double* %808
%810 = fneg double %807
%811 = tail call double @llvm.fmuladd.f64(double %810, double %731, double %809)
store double %811, double* %808
%812 = add nsw i64 %796, 2
%813 = add nuw nsw i64 %797, 2
%814 = icmp eq i64 %813, %520
br i1 %814, label %815, label %795
815: ; preds = %791, %795, %773, %714
%816 = add nuw nsw i64 %717, 1
%817 = add i32 %716, %517
%818 = icmp eq i64 %732, %520
br i1 %818, label %819, label %714
819: ; preds = %815, %662, %680
%820 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @mp_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %11)
%821 = sitofp i32 %820 to double
%822 = fdiv double %649, %7
%823 = fdiv double %822, %821
%824 = fdiv double %823, %821
%825 = fcmp ogt double %649, 0.000000e+00
br i1 %825, label %826, label %830
826: ; preds = %819
%827 = load double, double* %8
%828 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %540, double %827)
%829 = sitofp i32 %828 to double
br label %830
830: ; preds = %826, %819
%831 = phi double [ %829, %826 ], [ %540, %819 ]
%832 = fcmp olt double %649, 0.000000e+00
br i1 %832, label %833, label %837
833: ; preds = %830
%834 = load double, double* %8
%835 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmin1 to i32 (double, double, ...)*)(double %541, double %834)
%836 = sitofp i32 %835 to double
br label %837
837: ; preds = %833, %830
%838 = phi double [ %836, %833 ], [ %541, %830 ]
%839 = load double, double* %8
%840 = fadd double %824, %839
%841 = tail call i32 (double, double, ...) bitcast (i32 (...)* @mp_dmax1 to i32 (double, double, ...)*)(double %831, double %840)
%842 = sitofp i32 %841 to double
br label %536
843: ; preds = %258
store double 0.000000e+00, double* %8
br label %844
844: ; preds = %660, %656, %646, %843
ret void
}