void lmpar(int n, double *r, int ldr, const int *ipvt, const double *diag,
           const double *qtb, double delta, double *par, double *x,
           double *sdiag, double *wa1, double *wa2) {
  double d1, d2;
  int j, l;
  double fp;
  double parc, parl;
  int iter;
  double temp, paru, dwarf;
  int nsing;
  double gnorm;
  double dxnorm;
  dwarf = 2.2250738585072014e-308;
  nsing = n;
  for (j = 0; j < n; ++j) {
    wa1[j] = qtb[j];
    if (r[j + j * ldr] == 0. && nsing == n) {
      nsing = j;
    }
    if (nsing < n) {
      wa1[j] = 0.;
    }
  }
  if (nsing >= 1) {
    int k;
    for (k = 1; k <= nsing; ++k) {
      j = nsing - k;
      wa1[j] /= r[j + j * ldr];
      temp = wa1[j];
      if (j >= 1) {
        int i;
        for (i = 0; i < j; ++i) {
          wa1[i] -= r[i + j * ldr] * temp;
        }
      }
    }
  }
  for (j = 0; j < n; ++j) {
    l = ipvt[j] - 1;
    x[l] = wa1[j];
  }
  iter = 0;
  for (j = 0; j < n; ++j) {
    wa2[j] = diag[j] * x[j];
  }
  dxnorm = enorm(n, wa2);
  fp = dxnorm - delta;
  if (fp <= .1 * delta) {
    goto TERMINATE;
  }
  parl = 0.;
  if (nsing >= n) {
    for (j = 0; j < n; ++j) {
      l = ipvt[j] - 1;
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      double sum = 0.;
      if (j >= 1) {
        int i;
        for (i = 0; i < j; ++i) {
          sum += r[i + j * ldr] * wa1[i];
        }
      }
      wa1[j] = (wa1[j] - sum) / r[j + j * ldr];
    }
    temp = enorm(n, wa1);
    parl = fp / delta / temp / temp;
  }
  for (j = 0; j < n; ++j) {
    double sum = 0.;
    int i;
    for (i = 0; i <= j; ++i) {
      sum += r[i + j * ldr] * qtb[i];
    }
    l = ipvt[j] - 1;
    wa1[j] = sum / diag[l];
  }
  gnorm = enorm(n, wa1);
  paru = gnorm / delta;
  if (paru == 0.) {
    paru = dwarf / ((delta) <= ((double).1) ? (delta) : ((double).1));
  }
  *par = ((*par) >= (parl) ? (*par) : (parl));
  *par = ((*par) <= (paru) ? (*par) : (paru));
  if (*par == 0.) {
    *par = gnorm / dxnorm;
  }
  for (;;) {
    ++iter;
    if (*par == 0.) {
      d1 = dwarf, d2 = .001 * paru;
      *par = ((d1) >= (d2) ? (d1) : (d2));
    }
    temp = sqrt(*par);
    for (j = 0; j < n; ++j) {
      wa1[j] = temp * diag[j];
    }
    qrsolv(n, r, ldr, ipvt, wa1, qtb, x, sdiag, wa2);
    for (j = 0; j < n; ++j) {
      wa2[j] = diag[j] * x[j];
    }
    dxnorm = enorm(n, wa2);
    temp = fp;
    fp = dxnorm - delta;
    if (fabs(fp) <= .1 * delta || (parl == 0. && fp <= temp && temp < 0.) ||
        iter == 10) {
      goto TERMINATE;
    }
    for (j = 0; j < n; ++j) {
      l = ipvt[j] - 1;
      wa1[j] = diag[l] * (wa2[l] / dxnorm);
    }
    for (j = 0; j < n; ++j) {
      wa1[j] /= sdiag[j];
      temp = wa1[j];
      if (n > j + 1) {
        int i;
        for (i = j + 1; i < n; ++i) {
          wa1[i] -= r[i + j * ldr] * temp;
        }
      }
    }
    temp = enorm(n, wa1);
    parc = fp / delta / temp / temp;
    if (fp > 0.) {
      parl = ((parl) >= (*par) ? (parl) : (*par));
    }
    if (fp < 0.) {
      paru = ((paru) <= (*par) ? (paru) : (*par));
    }
    d1 = parl, d2 = *par + parc;
    *par = ((d1) >= (d2) ? (d1) : (d2));
  }
TERMINATE:
  if (iter == 0) {
    *par = 0.;
  }
}


x86 assembly (clang, -O0):
<lmpar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  0xe8e(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x4(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1225 <lmpar+0xf5>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f3 <lmpar+0xc3>
jp     11f3 <lmpar+0xc3>
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    11f3 <lmpar+0xc3>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1212 <lmpar+0xe2>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1217 <lmpar+0xe7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    118a <lmpar+0x5a>
cmpl   $0x1,-0x8c(%rbp)
jl     134b <lmpar+0x21b>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jg     1346 <lmpar+0x216>
mov    -0x8c(%rbp),%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x1,-0x4c(%rbp)
jl     132d <lmpar+0x1fd>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1328 <lmpar+0x1f8>
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xa8(%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    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    12b1 <lmpar+0x181>
jmp    132d <lmpar+0x1fd>
jmp    1332 <lmpar+0x202>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    123c <lmpar+0x10c>
jmp    134b <lmpar+0x21b>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1397 <lmpar+0x267>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1352 <lmpar+0x222>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13e6 <lmpar+0x2b6>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%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    13a5 <lmpar+0x275>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1040 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  0xbe9(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1433 <lmpar+0x303>
jmp    1c8a <lmpar+0xb5a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jl     15c4 <lmpar+0x494>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14af <lmpar+0x37f>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1451 <lmpar+0x321>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1594 <lmpar+0x464>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
cmpl   $0x1,-0x4c(%rbp)
jl     154c <lmpar+0x41c>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1547 <lmpar+0x417>
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    14e1 <lmpar+0x3b1>
jmp    154c <lmpar+0x41c>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14b6 <lmpar+0x386>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1693 <lmpar+0x563>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1652 <lmpar+0x522>
mov    -0x10(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    15ec <lmpar+0x4bc>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15cb <lmpar+0x49b>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    173a <lmpar+0x60a>
jp     173a <lmpar+0x60a>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x919(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jb     170c <lmpar+0x5dc>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1721 <lmpar+0x5f1>
movsd  0x8f4(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1721 <lmpar+0x5f1>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     1762 <lmpar+0x632>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    176f <lmpar+0x63f>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     17ab <lmpar+0x67b>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    17b8 <lmpar+0x688>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17fb <lmpar+0x6cb>
jp     17fb <lmpar+0x6cb>
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1800 <lmpar+0x6d0>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1882 <lmpar+0x752>
jp     1882 <lmpar+0x752>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  0x7d7(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1865 <lmpar+0x735>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1872 <lmpar+0x742>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18d4 <lmpar+0x7a4>
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    189b <lmpar+0x76b>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x18(%rbp),%r11
mov    0x20(%rbp),%r10
mov    0x30(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1030 <qrsolv@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1953 <lmpar+0x823>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%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    1912 <lmpar+0x7e2>
mov    -0x4(%rbp),%edi
mov    0x30(%rbp),%rsi
mov    $0x0,%al
call   1040 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movaps 0x68b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x667(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jae    19f4 <lmpar+0x8c4>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19ea <lmpar+0x8ba>
jp     19ea <lmpar+0x8ba>
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     19ea <lmpar+0x8ba>
xorps  %xmm0,%xmm0
ucomisd -0x78(%rbp),%xmm0
ja     19f4 <lmpar+0x8c4>
cmpl   $0xa,-0x6c(%rbp)
jne    19f9 <lmpar+0x8c9>
jmp    1c8a <lmpar+0xb5a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a5e <lmpar+0x92e>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a00 <lmpar+0x8d0>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b52 <lmpar+0xa22>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    1b3f <lmpar+0xa0f>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b3a <lmpar+0xa0a>
mov    -0x10(%rbp),%rax
mov    -0xc8(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0xc8(%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    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1ac3 <lmpar+0x993>
jmp    1b3f <lmpar+0xa0f>
jmp    1b44 <lmpar+0xa14>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a65 <lmpar+0x935>
mov    -0x4(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1bd6 <lmpar+0xaa6>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jb     1bb9 <lmpar+0xa89>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1bc9 <lmpar+0xa99>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1c2a <lmpar+0xafa>
movsd  -0x80(%rbp),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1c0d <lmpar+0xadd>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1c1d <lmpar+0xaed>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jb     1c68 <lmpar+0xb38>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1c75 <lmpar+0xb45>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1800 <lmpar+0x6d0>
cmpl   $0x0,-0x6c(%rbp)
jne    1c9f <lmpar+0xb6f>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmpar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
movsd  %xmm0,0x38(%rsp)
mov    %r8,%r15
mov    %rcx,%r8
mov    %rsi,0x10(%rsp)
mov    %edi,%r12d
mov    0x170(%rsp),%rbx
mov    0x168(%rsp),%r13
mov    %edi,%eax
mov    %rax,0x20(%rsp)
mov    %edi,%r14d
test   %edi,%edi
mov    %r9,0x68(%rsp)
mov    %edx,0x1c(%rsp)
mov    %rcx,0x28(%rsp)
mov    %edi,0x34(%rsp)
jle    167a <lmpar+0x54a>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    %r12d,%r14d
mov    0x10(%rsp),%rbp
jmp    11ad <lmpar+0x7d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %edx,%eax
cmp    %rcx,0x20(%rsp)
je     11eb <lmpar+0xbb>
mov    %r14d,%edi
movslq %eax,%rsi
movsd  (%r9,%rcx,8),%xmm1
add    %rcx,%rsi
cmp    %r12d,%r14d
mov    %ecx,%r14d
cmovne %edi,%r14d
movsd  %xmm1,0x0(%r13,%rcx,8)
ucomisd 0x0(%rbp,%rsi,8),%xmm0
cmovne %edi,%r14d
cmovp  %edi,%r14d
cmp    %r12d,%r14d
jge    11a0 <lmpar+0x70>
movq   $0x0,0x0(%r13,%rcx,8)
jmp    11a0 <lmpar+0x70>
test   %r14d,%r14d
jle    13fe <lmpar+0x2ce>
mov    %r14d,%eax
movslq 0x1c(%rsp),%rdx
lea    0x1(%r14),%ecx
mov    %rcx,0x78(%rsp)
lea    -0x1(%r14),%esi
mov    %rax,0x48(%rsp)
add    $0xffffffffffffffff,%rax
imul   %rdx,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
add    $0x10,%rdi
mov    %rdx,%r12
lea    0x0(,%rdx,8),%rdx
neg    %rdx
mov    %rdx,0x40(%rsp)
lea    (%rcx,%rax,8),%rdx
add    $0x8,%rdx
mov    $0x1,%eax
xor    %ecx,%ecx
mov    %esi,0x50(%rsp)
mov    %esi,%r8d
mov    0x10(%rsp),%rbx
jmp    1282 <lmpar+0x152>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
add    $0x1,%rcx
mov    0x40(%rsp),%rsi
add    %rsi,%rdi
add    $0xffffffff,%r8d
add    %rsi,%rdx
cmp    0x78(%rsp),%rax
je     13fe <lmpar+0x2ce>
mov    %r8d,%r8d
mov    0x48(%rsp),%rsi
sub    %rax,%rsi
mov    %rsi,%r9
imul   %r12,%r9
lea    (%r9,%rsi,1),%rbp
movsd  0x0(%r13,%rsi,8),%xmm0
divsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
test   %rsi,%rsi
jle    1260 <lmpar+0x130>
mov    0x50(%rsp),%esi
mov    %esi,%r11d
sub    %ecx,%r11d
cmp    $0x4,%r11d
jb     1300 <lmpar+0x1d0>
mov    %rcx,%rsi
not    %rsi
add    0x48(%rsp),%rsi
imul   %r12,%rsi
mov    0x10(%rsp),%rbp
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
lea    (%rsi,%r11,8),%rbp
cmp    %r13,%rbp
jbe    1395 <lmpar+0x265>
lea    0x0(,%r11,8),%rbp
add    %r13,%rbp
cmp    %rbp,%rsi
jae    1395 <lmpar+0x265>
xor    %r10d,%r10d
mov    %r10,%rbp
test   $0x1,%r11b
je     1337 <lmpar+0x207>
add    %r10,%r9
movsd  0x0(%r13,%r10,8),%xmm1
mov    0x10(%rsp),%rsi
movsd  (%rsi,%r9,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%r10,8)
mov    %r10,%rbp
or     $0x1,%rbp
not    %r10
add    %r11,%r10
je     1260 <lmpar+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rbp,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rbp,8),%xmm1
movsd  %xmm2,0x0(%r13,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r8
jne    1350 <lmpar+0x220>
jmp    1260 <lmpar+0x130>
mov    %r8d,%ebp
and    $0xfffffffc,%ebp
mov    %r11d,%r10d
and    $0xfffffffc,%r10d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rdi,%rsi,8),%xmm2
movupd (%rdi,%rsi,8),%xmm3
movupd 0x0(%r13,%rsi,8),%xmm4
movupd 0x10(%r13,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%rsi,8)
movupd %xmm5,0x10(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    13b0 <lmpar+0x280>
cmp    %r11,%r10
je     1260 <lmpar+0x130>
jmp    1303 <lmpar+0x1d3>
mov    0x34(%rsp),%r12d
test   %r12d,%r12d
mov    0x158(%rsp),%rsi
jle    142b <lmpar+0x2fb>
mov    0x20(%rsp),%rcx
cmp    $0x1,%ecx
jne    1438 <lmpar+0x308>
xor    %eax,%eax
mov    0x170(%rsp),%rbx
mov    0x28(%rsp),%r8
jmp    147c <lmpar+0x34c>
mov    0x170(%rsp),%rbx
jmp    167a <lmpar+0x54a>
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x170(%rsp),%rbx
mov    0x28(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movslq (%r8,%rax,4),%rdx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movslq 0x4(%r8,%rax,4),%rdx
movsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1450 <lmpar+0x320>
testb  $0x1,0x20(%rsp)
je     1494 <lmpar+0x364>
movslq (%r8,%rax,4),%rcx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rcx,8)
test   %r12d,%r12d
jle    167a <lmpar+0x54a>
cmp    $0x4,%r12d
jae    1547 <lmpar+0x417>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
mov    0x20(%rsp),%rdx
add    %rdx,%rcx
and    $0x3,%rdx
je     14da <lmpar+0x3aa>
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    14c0 <lmpar+0x390>
cmp    $0x3,%rcx
jb     167a <lmpar+0x54a>
mov    0x20(%rsp),%rcx
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    14f0 <lmpar+0x3c0>
jmp    167a <lmpar+0x54a>
mov    0x20(%rsp),%rdx
lea    (%rbx,%rdx,8),%rax
lea    (%r15,%rdx,8),%rcx
cmp    %rbx,%rcx
seta   %dil
lea    (%rsi,%rdx,8),%rcx
cmp    %r15,%rax
seta   %dl
cmp    %rbx,%rcx
seta   %cl
cmp    %rsi,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1625 <lmpar+0x4f5>
and    %sil,%cl
mov    0x158(%rsp),%rsi
jne    14a9 <lmpar+0x379>
mov    0x20(%rsp),%rax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1632 <lmpar+0x502>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    0x158(%rsp),%rdi
nop
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm0
movupd 0x30(%r15,%rcx,8),%xmm1
movupd 0x20(%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm0,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15c0 <lmpar+0x490>
jmp    163c <lmpar+0x50c>
mov    0x158(%rsp),%rsi
jmp    14a9 <lmpar+0x379>
xor    %ecx,%ecx
mov    0x158(%rsp),%rdi
test   $0x1,%dl
mov    %rdi,%rsi
je     166f <lmpar+0x53f>
movupd (%r15,%rcx,8),%xmm0
movupd 0x10(%r15,%rcx,8),%xmm1
movupd (%rsi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
cmp    0x20(%rsp),%rax
jne    14a9 <lmpar+0x379>
mov    0x150(%rsp),%rbp
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <enorm@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movapd %xmm3,%xmm2
movsd  0x38(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  0x1954(%rip),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
jae    1707 <lmpar+0x5d7>
movsd  %xmm1,0xe8(%rsp)
xorpd  %xmm1,%xmm1
movslq 0x1c(%rsp),%rax
mov    %rax,0x40(%rsp)
cmp    %r12d,%r14d
mov    0x20(%rsp),%r14
movsd  %xmm2,0x80(%rsp)
movsd  %xmm3,0x48(%rsp)
jl     18e7 <lmpar+0x7b7>
test   %r12d,%r12d
mov    0x1c(%rsp),%r9d
jle    18bc <lmpar+0x78c>
cmp    $0x1,%r12d
jne    1721 <lmpar+0x5f1>
xor    %eax,%eax
mov    0x28(%rsp),%rsi
jmp    1772 <lmpar+0x642>
movq   $0x0,0x0(%rbp)
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x28(%rsp),%rsi
xchg   %ax,%ax
movslq (%rsi,%rax,4),%rdx
movsd  -0x8(%rbx,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  -0x8(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movslq 0x4(%rsi,%rax,4),%rdx
movsd  -0x8(%rbx,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  -0x8(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1730 <lmpar+0x600>
test   $0x1,%r14b
je     1794 <lmpar+0x664>
movslq (%rsi,%rax,4),%rcx
movsd  -0x8(%rbx,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
mulsd  -0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
test   %r12d,%r12d
jle    18bc <lmpar+0x78c>
mov    0x10(%rsp),%rsi
lea    0x18(%rsi),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
xor    %ebp,%ebp
jmp    17ff <lmpar+0x6cf>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  0x0(%r13,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
mov    %ebp,%ecx
imul   %r9d,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
mov    0x10(%rsp),%rdx
divsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    %r8,%rax
add    %r8,%rsi
cmp    %r14,%rbp
je     18bc <lmpar+0x78c>
test   %rbp,%rbp
je     17c0 <lmpar+0x690>
lea    -0x1(%rbp),%rcx
cmp    $0x3,%rcx
jae    1820 <lmpar+0x6f0>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    187c <lmpar+0x74c>
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   (%rax)
movsd  -0x18(%rax,%rdi,8),%xmm1
movsd  -0x10(%rax,%rdi,8),%xmm2
mulsd  0x0(%r13,%rdi,8),%xmm1
mulsd  0x8(%r13,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rax,%rdi,8),%xmm3
mulsd  0x10(%r13,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x18(%r13,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1830 <lmpar+0x700>
test   $0x3,%bpl
je     17c4 <lmpar+0x694>
mov    %ebp,%edx
and    $0x3,%edx
lea    0x0(,%rdi,8),%rbx
add    %r13,%rbx
lea    (%rsi,%rdi,8),%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    18a0 <lmpar+0x770>
jmp    17c4 <lmpar+0x694>
mov    %r12d,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x80(%rsp),%xmm1
divsd  0x38(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x90(%rsp)
test   %r12d,%r12d
mov    0x68(%rsp),%rbx
jle    19fd <lmpar+0x8cd>
mov    0x10(%rsp),%r9
lea    0x18(%r9),%rax
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%r8
mov    $0x1,%r10d
xor    %esi,%esi
jmp    194e <lmpar+0x81e>
xchg   %ax,%ax
mov    0x28(%rsp),%rcx
movslq (%rcx,%rsi,4),%rcx
divsd  -0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x1,%rsi
add    $0x1,%r10
add    %r8,%rax
add    %r8,%r9
cmp    %r14,%rsi
je     19fd <lmpar+0x8cd>
cmp    $0x3,%rsi
jae    1960 <lmpar+0x830>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    19b7 <lmpar+0x887>
nopl   0x0(%rax)
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movsd  -0x18(%rax,%rbp,8),%xmm1
movsd  -0x10(%rax,%rbp,8),%xmm2
mulsd  (%rbx,%rbp,8),%xmm1
mulsd  0x8(%rbx,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rax,%rbp,8),%xmm3
mulsd  0x10(%rbx,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%rbx,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    1970 <lmpar+0x840>
test   $0x3,%r10b
je     1920 <lmpar+0x7f0>
mov    %r10d,%edx
and    $0x3,%edx
lea    (%rbx,%rbp,8),%rcx
lea    (%r9,%rbp,8),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    19e0 <lmpar+0x8b0>
jmp    1920 <lmpar+0x7f0>
mov    %r12d,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm6
movsd  0x38(%rsp),%xmm1
divsd  %xmm1,%xmm6
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm6
jne    1a3f <lmpar+0x90f>
jp     1a3f <lmpar+0x90f>
minsd  0x15cd(%rip),%xmm1
movsd  0x15cd(%rip),%xmm6
divsd  %xmm1,%xmm6
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x60(%rsp)
mov    0x150(%rsp),%rsi
movsd  (%rsi),%xmm1
movapd 0x90(%rsp),%xmm5
movapd %xmm5,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm5,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm3,%xmm1
cmplesd %xmm6,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm3,%xmm4
andnpd %xmm6,%xmm1
orpd   %xmm4,%xmm1
ucomisd %xmm2,%xmm1
mov    0x170(%rsp),%rdi
jne    1aab <lmpar+0x97b>
jp     1aab <lmpar+0x97b>
divsd  0x48(%rsp),%xmm0
movapd %xmm0,%xmm1
movslq %r12d,%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%r14,8),%rbx
add    %r13,%rbx
mov    0x10(%rsp),%r8
lea    0x8(%r8),%rax
mov    %rax,0xc8(%rsp)
mov    0x40(%rsp),%r10
lea    0x0(,%r10,8),%rax
mov    %rax,0x78(%rsp)
lea    (%rdi,%r14,8),%rbp
lea    (%r15,%r14,8),%rcx
mov    %r14d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xb8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xb0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r13,%rcx
seta   %al
mov    %rbx,0xf0(%rsp)
cmp    %r15,%rbx
seta   %bl
and    %al,%bl
mov    %bl,0xf(%rsp)
mov    %rdx,%rbx
mov    %rdx,0xa8(%rsp)
and    %rdx,0x60(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0xc0(%rsp)
cmp    %rdi,%rcx
seta   %cl
mov    0x158(%rsp),%r9
lea    (%r9,%r14,8),%rdx
cmp    %r15,%rbp
seta   %bl
and    %cl,%bl
cmp    %rdi,%rdx
seta   %cl
lea    0x8(,%r10,8),%rax
mov    %rax,0x50(%rsp)
cmp    %r9,%rbp
seta   %al
lea    -0x1(%r14),%rdx
mov    %rdx,0x70(%rsp)
and    %cl,%al
or     %bl,%al
mov    %al,0xe(%rsp)
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xe0(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0xf8(%rsp)
lea    0x18(%r8),%rax
mov    %rax,0xd8(%rsp)
xorpd  %xmm7,%xmm7
lea    0x18(%r13),%rax
mov    %rax,0xd0(%rsp)
movl   $0x0,0x5c(%rsp)
jmp    1c7c <lmpar+0xb4c>
nopl   0x0(%rax)
mov    0x150(%rsp),%rsi
movsd  (%rsi),%xmm0
movapd %xmm0,%xmm1
movapd 0x90(%rsp),%xmm5
cmplesd %xmm5,%xmm1
andpd  %xmm1,%xmm5
andnpd %xmm0,%xmm1
orpd   %xmm1,%xmm5
movsd  0x38(%rsp),%xmm1
movapd 0x100(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm6,%xmm2
divsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
movsd  (%rsi),%xmm0
movapd %xmm4,%xmm1
cmplesd %xmm0,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm4,%xmm3
andnpd %xmm0,%xmm1
orpd   %xmm3,%xmm1
movapd %xmm6,%xmm3
cmpltsd %xmm7,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm4,%xmm3
orpd   %xmm1,%xmm3
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm1
cmplesd %xmm5,%xmm1
movapd %xmm1,%xmm0
andnpd %xmm2,%xmm0
andpd  %xmm5,%xmm1
orpd   %xmm0,%xmm1
movsd  %xmm6,0x80(%rsp)
movapd %xmm3,%xmm6
movapd %xmm5,0x90(%rsp)
movapd %xmm6,%xmm0
mulsd  0x137f(%rip),%xmm0
movsd  0x136f(%rip),%xmm2
maxsd  %xmm0,%xmm2
movapd %xmm1,%xmm0
cmpeqsd %xmm7,%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movlpd %xmm0,(%rsi)
ucomisd %xmm7,%xmm0
movapd %xmm6,0x100(%rsp)
jb     1cd0 <lmpar+0xba0>
sqrtsd %xmm0,%xmm0
jmp    1cd5 <lmpar+0xba5>
nopl   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
mov    0x68(%rsp),%r9
mov    0x1c(%rsp),%edx
mov    0x170(%rsp),%rbx
mov    0x28(%rsp),%rcx
mov    0x160(%rsp),%rbp
test   %r12d,%r12d
jle    1d10 <lmpar+0xbe0>
cmp    $0x4,%r12d
setb   %al
or     0xf(%rsp),%al
je     1d40 <lmpar+0xc10>
xor    %eax,%eax
jmp    1df2 <lmpar+0xcc2>
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    0x18(%rsp),%rsi
mov    %r13,%r8
xor    %eax,%eax
push   %rbx
push   %rbp
push   0x170(%rsp)
call   1030 <qrsolv@plt>
add    $0x20,%rsp
jmp    2040 <lmpar+0xf10>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xb0(%rsp)
je     23f2 <lmpar+0x12c2>
mov    0x60(%rsp),%rsi
xor    %eax,%eax
xchg   %ax,%ax
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm2
movupd 0x30(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm3,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    1d60 <lmpar+0xc30>
testb  $0x1,0xa8(%rsp)
01
je     1dde <lmpar+0xcae>
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
mov    0xb8(%rsp),%rsi
mov    %rsi,%rax
cmp    %r14,%rsi
je     1e90 <lmpar+0xd60>
mov    0x70(%rsp),%rdi
sub    %rax,%rdi
mov    0xc0(%rsp),%rsi
test   %rsi,%rsi
je     1e2b <lmpar+0xcfb>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1e10 <lmpar+0xce0>
cmp    $0x3,%rdi
jb     1e90 <lmpar+0xd60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1e40 <lmpar+0xd10>
sub    $0x8,%rsp
mov    %r12d,%edi
mov    0x18(%rsp),%rsi
mov    %r13,%r8
xor    %eax,%eax
push   %rbx
push   %rbp
mov    0x170(%rsp),%rbp
push   %rbp
call   1030 <qrsolv@plt>
add    $0x20,%rsp
test   %r12d,%r12d
jle    2040 <lmpar+0xf10>
mov    %rbp,%rsi
cmp    $0x4,%r12d
setb   %al
or     0xe(%rsp),%al
je     1ed5 <lmpar+0xda5>
xor    %eax,%eax
jmp    1f9c <lmpar+0xe6c>
cmpq   $0x0,0xb0(%rsp)
je     2407 <lmpar+0x12d7>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm0,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1ef0 <lmpar+0xdc0>
testb  $0x1,0xa8(%rsp)
01
je     1f88 <lmpar+0xe58>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0xb8(%rsp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
je     2040 <lmpar+0xf10>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
test   $0x3,%r14b
je     1fda <lmpar+0xeaa>
mov    0xc0(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1fc0 <lmpar+0xe90>
cmp    $0x3,%rcx
jb     2040 <lmpar+0xf10>
movsd  (%r15,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1fe0 <lmpar+0xeb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm3
subsd  0x38(%rsp),%xmm3
movapd %xmm3,%xmm1
andpd  0xfb6(%rip),%xmm1
movsd  0xe8(%rsp),%xmm2
ucomisd %xmm1,%xmm2
movapd 0x90(%rsp),%xmm1
mov    0x50(%rsp),%rbp
xorpd  %xmm2,%xmm2
mov    0x5c(%rsp),%edx
jae    170f <lmpar+0x5df>
add    $0x1,%edx
ucomisd %xmm2,%xmm1
jne    20bd <lmpar+0xf8d>
jp     20bd <lmpar+0xf8d>
movsd  0x80(%rsp),%xmm1
ucomisd %xmm3,%xmm1
setae  %al
ucomisd %xmm1,%xmm2
seta   %cl
test   %al,%cl
jne    170f <lmpar+0x5df>
cmp    $0xa,%edx
je     170f <lmpar+0x5df>
movapd %xmm3,0x80(%rsp)
mov    %edx,0x5c(%rsp)
test   %r12d,%r12d
mov    0x160(%rsp),%r11
jle    2380 <lmpar+0x1250>
cmpq   $0x0,0x70(%rsp)
je     23d0 <lmpar+0x12a0>
xor    %eax,%eax
mov    0x34(%rsp),%edx
mov    0x170(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0xe0(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movslq (%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    2110 <lmpar+0xfe0>
test   $0x1,%r14b
je     2174 <lmpar+0x1044>
movslq (%rdi,%rax,4),%rcx
movsd  -0x8(%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %edx,%edx
jle    2380 <lmpar+0x1250>
mov    $0x1,%r12d
mov    0xc8(%rsp),%rcx
mov    0xd0(%rsp),%rdx
mov    0xd8(%rsp),%rsi
mov    0x70(%rsp),%r10
xor    %r8d,%r8d
jmp    21cd <lmpar+0x109d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0xffffffffffffffff,%r10
add    %rbp,%rsi
add    $0x8,%rdx
add    0x78(%rsp),%rcx
cmp    %r14,%r8
je     2380 <lmpar+0x1250>
mov    %r8,%rbx
movsd  0x0(%r13,%r8,8),%xmm0
divsd  (%r11,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%r8,8)
add    $0x1,%r8
cmp    0x48(%rsp),%r8
jge    21b0 <lmpar+0x1080>
mov    %rbx,%rdi
not    %rdi
add    %r14,%rdi
mov    %rbx,%r9
imul   0x40(%rsp),%r9
mov    %r12,%rax
cmp    $0x4,%rdi
jb     22e0 <lmpar+0x11b0>
lea    0x0(,%r12,8),%r11
add    %r13,%r11
lea    (%r9,%r14,1),%rax
mov    0x10(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x160(%rsp),%rbp
cmp    %rax,%r11
mov    %rbp,%r11
mov    0x50(%rsp),%rbp
jae    225f <lmpar+0x112f>
imul   %rbp,%rbx
add    0xc8(%rsp),%rbx
mov    %r12,%rax
cmp    0xf0(%rsp),%rbx
jb     22e0 <lmpar+0x11b0>
mov    %r10,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rdi,%r11
and    $0xfffffffffffffffc,%r11
lea    (%r12,%r11,1),%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %r14d,%r14d
nopl   0x0(%rax)
movupd -0x10(%rsi,%r14,8),%xmm2
movupd (%rsi,%r14,8),%xmm3
movupd -0x10(%rdx,%r14,8),%xmm4
movupd (%rdx,%r14,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdx,%r14,8)
movupd %xmm5,(%rdx,%r14,8)
add    $0x4,%r14
cmp    %r14,%rbx
jne    2280 <lmpar+0x1150>
cmp    %r11,%rdi
mov    0x20(%rsp),%r14
mov    0x50(%rsp),%rbp
mov    0x160(%rsp),%r11
je     21b0 <lmpar+0x1080>
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ebx
sub    %eax,%ebx
mov    %rax,%rdi
test   $0x1,%bl
je     2315 <lmpar+0x11e5>
add    %rax,%r9
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x10(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
lea    0x1(%rax),%rdi
not    %rax
cmp    0xf8(%rsp),%rax
je     21b0 <lmpar+0x1080>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%r13,%rdi,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%r13,%rdi,8),%xmm1
movsd  %xmm2,0x0(%r13,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r14
jne    2330 <lmpar+0x1200>
jmp    21b0 <lmpar+0x1080>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x34(%rsp),%r12d
mov    %r12d,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <enorm@plt>
xorpd  %xmm7,%xmm7
movapd 0x80(%rsp),%xmm6
ucomisd %xmm7,%xmm6
ja     1bd0 <lmpar+0xaa0>
movsd  0x38(%rsp),%xmm1
mov    0x150(%rsp),%rsi
movapd 0x90(%rsp),%xmm5
jmp    1c00 <lmpar+0xad0>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
mov    0x34(%rsp),%edx
mov    0x170(%rsp),%rsi
mov    0x28(%rsp),%rdi
test   $0x1,%r14b
jne    2158 <lmpar+0x1028>
jmp    2174 <lmpar+0x1044>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    1dbb <lmpar+0xc8b>
jmp    1dde <lmpar+0xcae>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    1f5d <lmpar+0xe2d>
jmp    1f88 <lmpar+0xe58>

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

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