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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double enorm(double *, int);
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double pmax(double, double);
double pmin(double, double);
int /*<<< orphan*/ qrsolv(double *, int, int, int *, double *, double *,
                          double *, double *);
double sqrt(double);
void lmpar(double *r, int ldr, int N, int *ipvt, double *diag, double *qtb,
           double delta, double *par, double *x, double *sdiag) {
  int i, iter, j, jm1, jp1, k, l, nsing;
  double dxnorm, dwarf, fp, gnorm, parc, parl, paru, p1, p001, sum, temp, zero;
  double *wa1, *wa2;
  wa1 = (double *)malloc(sizeof(double) * N);
  wa2 = (double *)malloc(sizeof(double) * N);
  p1 = 1.0e-01;
  p001 = 1.0e-03;
  zero = 0.0;
  dwarf = 2.22507385852e-308;
  nsing = N;
  for (j = 1; j <= N; ++j) {
    wa1[j - 1] = qtb[j - 1];
    if (r[(j - 1) * N + j - 1] == zero && nsing == N) {
      nsing = j - 1;
    }
    if (nsing < N) {
      wa1[j - 1] = zero;
    }
  }
  if (nsing >= 1) {
    for (k = 1; k <= nsing; ++k) {
      j = nsing - k + 1;
      wa1[j - 1] = wa1[j - 1] / r[(j - 1) * N + j - 1];
      temp = wa1[j - 1];
      jm1 = j - 1;
      if (jm1 >= 1) {
        for (i = 1; i <= jm1; ++i) {
          wa1[i - 1] = wa1[i - 1] - r[(i - 1) * N + j - 1] * temp;
        }
      }
    }
  }
  for (j = 0; j < N; ++j) {
    l = ipvt[j];
    x[l] = wa1[j];
  }
  iter = 0;
  for (j = 0; j < N; ++j) {
    wa2[j] = diag[j] * x[j];
  }
  dxnorm = enorm(wa2, N);
  fp = dxnorm - delta;
  if (fp > p1 * delta) {
    parl = zero;
    if (nsing >= N) {
      for (j = 0; j < N; ++j) {
        l = ipvt[j];
        wa1[j] = diag[l] * (wa2[l] / dxnorm);
      }
      for (j = 0; j < N; ++j) {
        sum = zero;
        jm1 = j - 1;
        if (jm1 >= 0) {
          for (i = 0; i <= jm1; ++i) {
            sum = sum + r[i * N + j] * wa1[i];
          }
        }
        wa1[j] = (wa1[j] - sum) / r[j * N + j];
      }
      temp = enorm(wa1, N);
      parl = ((fp / delta) / temp) / temp;
    }
    for (j = 0; j < N; ++j) {
      sum = zero;
      for (i = 0; i <= j; ++i) {
        sum = sum + r[i * N + j] * qtb[i];
      }
      l = ipvt[j];
      wa1[j] = sum / diag[l];
    }
    gnorm = enorm(wa1, N);
    paru = gnorm / delta;
    if (paru == zero) {
      paru = dwarf / pmin(delta, p1);
    }
    *par = pmax(*par, parl);
    *par = pmin(*par, paru);
    if (*par == zero) {
      *par = gnorm / dxnorm;
    }
    while (1) {
      iter++;
      if (*par == zero) {
        *par = pmax(dwarf, p001 * paru);
      }
      temp = sqrt(*par);
      for (j = 0; j < N; ++j) {
        wa1[j] = temp * diag[j];
      }
      qrsolv(r, ldr, N, ipvt, wa1, qtb, x, sdiag);
      for (j = 0; j < N; ++j) {
        wa2[j] = diag[j] * x[j];
      }
      dxnorm = enorm(wa2, N);
      temp = fp;
      fp = dxnorm - delta;
      if (fabs(fp) <= p1 * delta) {
        break;
      }
      if (iter == 10) {
        break;
      }
      if (parl == zero && fp <= temp && temp < zero) {
        break;
      }
      for (j = 0; j < N; ++j) {
        l = ipvt[j];
        wa1[j] = diag[l] * (wa2[l] / dxnorm);
      }
      for (j = 0; j < N; ++j) {
        wa1[j] = wa1[j] / sdiag[j];
        temp = wa1[j];
        jp1 = j + 1;
        if (N >= jp1 + 1) {
          for (i = jp1; i < N; ++i) {
            wa1[i] = wa1[i] - r[i * N + j] * temp;
          }
        }
      }
      temp = enorm(wa1, N);
      parc = ((fp / delta) / temp) / temp;
      if (fp > zero) {
        parl = pmax(parl, *par);
      }
      if (fp < zero) {
        paru = pmin(paru, *par);
      }
      *par = pmax(parl, *par + parc);
    }
  }
  if (iter == 0) {
    *par = zero;
  }
  free(wa1);
  free(wa2);
}


x86 assembly (clang, -O0):
<lmpar>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movsd  0xe3a(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe22(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xdff(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     12c7 <lmpar+0x157>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jne    128b <lmpar+0x11b>
jp     128b <lmpar+0x11b>
mov    -0x50(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    128b <lmpar+0x11b>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12b4 <lmpar+0x144>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12b9 <lmpar+0x149>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1213 <lmpar+0xa3>
cmpl   $0x1,-0x50(%rbp)
jl     1411 <lmpar+0x2a1>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     140c <lmpar+0x29c>
mov    -0x50(%rbp),%eax
sub    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x1,-0x40(%rbp)
jl     13f9 <lmpar+0x289>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     13f4 <lmpar+0x284>
mov    -0xb8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    136d <lmpar+0x1fd>
jmp    13f9 <lmpar+0x289>
jmp    13fe <lmpar+0x28e>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12d8 <lmpar+0x168>
jmp    1411 <lmpar+0x2a1>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    145d <lmpar+0x2ed>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1418 <lmpar+0x2a8>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14af <lmpar+0x33f>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    146b <lmpar+0x2fb>
mov    -0xc0(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1c29 <lmpar+0xab9>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1688 <lmpar+0x518>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    156c <lmpar+0x3fc>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    150e <lmpar+0x39e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1652 <lmpar+0x4e2>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1606 <lmpar+0x496>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1601 <lmpar+0x491>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15a9 <lmpar+0x439>
jmp    1606 <lmpar+0x496>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1573 <lmpar+0x403>
mov    -0xb8(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1748 <lmpar+0x5d8>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1707 <lmpar+0x597>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b2 <lmpar+0x542>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    168f <lmpar+0x51f>
mov    -0xb8(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
jne    17c0 <lmpar+0x650>
jp     17c0 <lmpar+0x650>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <pmin@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x80(%rbp),%xmm1
call   1050 <pmax@plt>
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
call   1060 <pmin@plt>
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jne    1825 <lmpar+0x6b5>
jp     1825 <lmpar+0x6b5>
movsd  -0x70(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    182a <lmpar+0x6ba>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jne    1871 <lmpar+0x701>
jp     1871 <lmpar+0x701>
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
call   1050 <pmax@plt>
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    18cc <lmpar+0x75c>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    188d <lmpar+0x71d>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0xb8(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x18(%rbp),%r10
mov    0x20(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <qrsolv@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1946 <lmpar+0x7d6>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1902 <lmpar+0x792>
mov    -0xc0(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movaps 0x69e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     19a2 <lmpar+0x832>
jmp    1c24 <lmpar+0xab4>
cmpl   $0xa,-0x38(%rbp)
jne    19b1 <lmpar+0x841>
jmp    1c24 <lmpar+0xab4>
movsd  -0x80(%rbp),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jne    1a00 <lmpar+0x890>
jp     1a00 <lmpar+0x890>
movsd  -0x68(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1a00 <lmpar+0x890>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1a00 <lmpar+0x890>
jmp    1c24 <lmpar+0xab4>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a65 <lmpar+0x8f5>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a07 <lmpar+0x897>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b6c <lmpar+0x9fc>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1b59 <lmpar+0x9e9>
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b54 <lmpar+0x9e4>
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1add <lmpar+0x96d>
jmp    1b59 <lmpar+0x9e9>
jmp    1b5e <lmpar+0x9ee>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a6c <lmpar+0x8fc>
mov    -0xb8(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    1bcc <lmpar+0xa5c>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
call   1050 <pmax@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c00 <lmpar+0xa90>
movsd  -0x88(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
call   1060 <pmin@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
addsd  -0x78(%rbp),%xmm1
call   1050 <pmax@plt>
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    182a <lmpar+0x6ba>
jmp    1c29 <lmpar+0xab9>
cmpl   $0x0,-0x38(%rbp)
jne    1c43 <lmpar+0xad3>
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmpar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
movsd  %xmm0,0x70(%rsp)
mov    %r9,0x80(%rsp)
mov    %r8,%r12
mov    %rcx,0x38(%rsp)
mov    %edx,%ebp
mov    %esi,0x8c(%rsp)
mov    %rdi,0x18(%rsp)
mov    0x140(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    0x138(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x130(%rsp),%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rbp,8),%ebx
mov    %ebx,%edi
call   1080 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1080 <malloc@plt>
mov    %rbp,%r10
xor    %ebp,%ebp
test   %r10d,%r10d
mov    %r10,0x10(%rsp)
mov    %rax,0x20(%rsp)
jle    1505 <lmpar+0x395>
lea    0x1(%r10),%r8d
lea    -0x1(%r8),%rcx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    %r10d,%r14d
mov    0x80(%rsp),%rsi
mov    0x18(%rsp),%rbx
jmp    122c <lmpar+0xbc>
nop
add    %r8d,%ebp
add    $0x1,%rdx
cmp    %rdx,%rcx
je     1265 <lmpar+0xf5>
mov    %r14d,%eax
movsd  (%rsi,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
cmp    %r10d,%r14d
mov    %edx,%r14d
cmovne %eax,%r14d
movslq %ebp,%rdi
ucomisd (%rbx,%rdi,8),%xmm0
cmovne %eax,%r14d
cmovp  %eax,%r14d
cmp    %r10d,%r14d
jge    1220 <lmpar+0xb0>
movq   $0x0,0x0(%r13,%rdx,8)
jmp    1220 <lmpar+0xb0>
test   %r14d,%r14d
jle    14df <lmpar+0x36f>
mov    %r14d,%eax
mov    %rax,0x90(%rsp)
lea    0x1(%r14),%eax
mov    %rax,0x28(%rsp)
lea    -0x1(%r14),%esi
lea    -0x8(%r13),%rax
mov    %rax,0x60(%rsp)
lea    -0x8(%rbx),%rax
mov    %rax,0x68(%rsp)
lea    0x0(,%r10,4),%eax
mov    %eax,0x78(%rsp)
lea    (%r10,%r10,1),%r15d
mov    $0x1,%edi
xor    %r8d,%r8d
mov    %esi,0x30(%rsp)
mov    %r14d,%ecx
jmp    12d9 <lmpar+0x169>
nopl   0x0(%rax)
add    $0x1,%rdi
add    $0xffffffff,%ecx
add    $0x1,%r8d
add    $0xffffffff,%esi
cmp    0x28(%rsp),%rdi
je     14df <lmpar+0x36f>
mov    %ecx,%ecx
mov    0x90(%rsp),%r11
sub    %rdi,%r11
mov    %r14d,%eax
sub    %edi,%eax
movsd  0x0(%r13,%r11,8),%xmm0
imul   %r10d,%eax
add    %r11d,%eax
cltq
divsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%r11,8)
test   %r11,%r11
jle    12c0 <lmpar+0x150>
mov    %r14d,%eax
sub    %r8d,%eax
lea    -0x1(%rax),%rdx
mov    $0x1,%r9d
cmp    $0x4,%rdx
jae    13d0 <lmpar+0x260>
mov    %r9,%rbp
test   $0x1,%cl
jne    135a <lmpar+0x1ea>
lea    -0x1(%r9),%rax
movsd  -0x8(%r13,%r9,8),%xmm1
imul   %r10d,%eax
add    %r11d,%eax
cltq
movsd  (%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%r13,%r9,8)
lea    0x1(%r9),%rbp
not    %r9
add    %rcx,%r9
je     12c0 <lmpar+0x150>
mov    %r10d,%eax
imul   %ebp,%eax
add    %esi,%eax
lea    -0x1(%rbp),%edx
imul   %r10d,%edx
add    %esi,%edx
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
movsd  (%rbx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  -0x8(%r13,%rbp,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x0(%r13,%rbp,8),%xmm1
movsd  %xmm2,-0x8(%r13,%rbp,8)
cltq
movsd  (%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
add    $0x2,%rbp
add    %r15d,%eax
add    %r15d,%edx
cmp    %rbp,%rcx
jne    1380 <lmpar+0x210>
jmp    12c0 <lmpar+0x150>
nop
cmp    $0x1,%r10d
jne    1326 <lmpar+0x1b6>
mov    %rdx,0x40(%rsp)
mov    0x30(%rsp),%edx
sub    %r8d,%edx
lea    -0x2(%rax),%rbp
lea    (%rdx,%rbp,1),%r10d
cmp    %edx,%r10d
jl     14d0 <lmpar+0x360>
shr    $0x20,%rbp
jne    14d0 <lmpar+0x360>
movslq %edx,%rdx
lea    (%rdx,%rax,1),%rbp
mov    0x68(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
cmp    %rbp,%r13
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%rbx
jae    143d <lmpar+0x2cd>
mov    0x60(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
lea    (%rbx,%rdx,8),%rdx
cmp    %rax,%rdx
jb     1326 <lmpar+0x1b6>
lea    -0x1(%rcx),%rax
and    $0xfffffffffffffffc,%rax
mov    0x40(%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x58(%rsp)
lea    0x1(%rdx),%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %esi,%ebp
xor    %edx,%edx
mov    0x78(%rsp),%r10d
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
movslq %ebp,%rbp
movupd (%rbx,%rbp,8),%xmm4
movupd 0x10(%rbx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,0x0(%r13,%rdx,8)
movupd %xmm3,0x10(%r13,%rdx,8)
add    $0x4,%rdx
add    %r10d,%ebp
cmp    %rdx,%rax
jne    1470 <lmpar+0x300>
mov    0x58(%rsp),%rax
cmp    %rax,0x40(%rsp)
mov    0x10(%rsp),%r10
je     12c0 <lmpar+0x150>
jmp    1326 <lmpar+0x1b6>
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%rbx
jmp    1326 <lmpar+0x1b6>
test   %r10d,%r10d
jle    150d <lmpar+0x39d>
mov    %r10d,%r9d
lea    -0x1(%r9),%rdx
mov    %r9d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1519 <lmpar+0x3a9>
xor    %edx,%edx
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rax
jmp    157d <lmpar+0x40d>
mov    %r10d,%r14d
jmp    1666 <lmpar+0x4f6>
xor    %ebp,%ebp
mov    0x20(%rsp),%rax
jmp    1666 <lmpar+0x4f6>
mov    %r9d,%ebx
and    $0xfffffffc,%ebx
xor    %edx,%edx
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rax
mov    0x38(%rsp),%rbp
movslq 0x0(%rbp,%rdx,4),%rdi
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movslq 0x4(%rbp,%rdx,4),%rdi
movsd  0x8(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movslq 0x8(%rbp,%rdx,4),%rdi
movsd  0x10(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movslq 0xc(%rbp,%rdx,4),%rdi
movsd  0x18(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1530 <lmpar+0x3c0>
test   %rcx,%rcx
je     15b7 <lmpar+0x447>
lea    0x0(,%rdx,8),%rbx
add    %r13,%rbx
mov    0x38(%rsp),%rdi
lea    (%rdi,%rdx,4),%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movslq (%rdx,%rdi,4),%rbp
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    15a0 <lmpar+0x430>
test   %r10d,%r10d
jle    1664 <lmpar+0x4f4>
cmp    $0x4,%r10d
jae    173e <lmpar+0x5ce>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rdi
and    $0x3,%rdi
je     15fa <lmpar+0x48a>
xchg   %ax,%ax
movsd  (%r12,%rcx,8),%xmm0
mulsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    15e0 <lmpar+0x470>
mov    $0x1,%bpl
cmp    $0x3,%rdx
jb     1666 <lmpar+0x4f6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rcx,8),%xmm0
mulsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm0
mulsd  0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%r12,%rcx,8),%xmm0
mulsd  0x10(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%r12,%rcx,8),%xmm0
mulsd  0x18(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1610 <lmpar+0x4a0>
jmp    1666 <lmpar+0x4f6>
xor    %ebp,%ebp
mov    %rax,%rdi
mov    %r10d,%esi
mov    %r10,%rbx
call   1070 <enorm@plt>
movapd %xmm0,%xmm1
movsd  0x70(%rsp),%xmm3
subsd  %xmm3,%xmm1
movsd  0x1976(%rip),%xmm2
mulsd  %xmm3,%xmm2
ucomisd %xmm2,%xmm1
jbe    16d7 <lmpar+0x567>
movapd %xmm1,%xmm3
movslq %ebx,%r15
cmp    %ebx,%r14d
mov    %rbx,%rsi
movsd  %xmm2,0xf0(%rsp)
movsd  %xmm1,0x30(%rsp)
movsd  %xmm0,0x90(%rsp)
jge    1706 <lmpar+0x596>
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x40(%rsp)
test   %bpl,%bpl
je     1731 <lmpar+0x5c1>
mov    0x80(%rsp),%rbx
jmp    19d1 <lmpar+0x861>
mov    0x48(%rsp),%rax
movq   $0x0,(%rax)
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
test   %bpl,%bpl
mov    0x18(%rsp),%r10
mov    0x48(%rsp),%rbx
je     1999 <lmpar+0x829>
mov    %esi,%r8d
cmp    $0x1,%esi
jne    1845 <lmpar+0x6d5>
xor    %ecx,%ecx
mov    0x20(%rsp),%rdi
jmp    189e <lmpar+0x72e>
movl   $0x0,0x28(%rsp)
jmp    1aa8 <lmpar+0x938>
lea    (%rax,%r9,8),%rcx
lea    (%r12,%r9,8),%rdx
cmp    %rdx,%rax
setb   %dil
cmp    %r12,%rcx
seta   %r8b
lea    (%rsi,%r9,8),%rdx
cmp    %rdx,%rax
setb   %dl
cmp    %rsi,%rcx
seta   %bl
xor    %ecx,%ecx
test   %r8b,%dil
jne    15cc <lmpar+0x45c>
and    %bl,%dl
jne    15cc <lmpar+0x45c>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     22f1 <lmpar+0x1181>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movupd (%r12,%rdx,8),%xmm0
movupd 0x10(%r12,%rdx,8),%xmm1
movupd (%rsi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rax,%rdx,8)
movupd %xmm0,0x10(%rax,%rdx,8)
movupd 0x20(%r12,%rdx,8),%xmm0
movupd 0x30(%r12,%rdx,8),%xmm1
movupd 0x20(%rsi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rax,%rdx,8)
movupd %xmm0,0x30(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    17a0 <lmpar+0x630>
test   $0x1,%bpl
je     1834 <lmpar+0x6c4>
movupd (%r12,%rdx,8),%xmm0
movupd 0x10(%r12,%rdx,8),%xmm1
movupd (%rsi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rax,%rdx,8)
movupd %xmm0,0x10(%rax,%rdx,8)
mov    $0x1,%bpl
cmp    %r9,%rcx
jne    15cc <lmpar+0x45c>
jmp    1666 <lmpar+0x4f6>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ecx,%ecx
mov    0x20(%rsp),%rdi
mov    0x38(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movslq (%rax,%rcx,4),%rdx
movsd  (%rdi,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movslq 0x4(%rax,%rcx,4),%rdx
movsd  (%rdi,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1860 <lmpar+0x6f0>
test   $0x1,%r8b
je     18c3 <lmpar+0x753>
mov    0x38(%rsp),%rax
movslq (%rax,%rcx,4),%rax
movsd  (%rdi,%rax,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
test   %bpl,%bpl
je     1999 <lmpar+0x829>
mov    %r15,%rcx
shl    $0x4,%rcx
xor    %eax,%eax
mov    %r10,%r9
jmp    1918 <lmpar+0x7a8>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm3,%xmm3
movsd  0x0(%r13,%rax,8),%xmm1
subsd  %xmm3,%xmm1
mov    %eax,%edx
imul   %esi,%edx
movslq %edx,%rdx
add    %rax,%rdx
divsd  (%r10,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0x8,%r9
cmp    %r8,%rax
je     1999 <lmpar+0x829>
test   %rax,%rax
je     18e0 <lmpar+0x770>
cmp    $0x1,%rax
jne    1930 <lmpar+0x7c0>
xorpd  %xmm3,%xmm3
xor    %edi,%edi
jmp    196c <lmpar+0x7fc>
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm3,%xmm3
mov    %r9,%rbx
xor    %edi,%edi
movsd  (%rbx),%xmm1
mulsd  0x0(%r13,%rdi,8),%xmm1
addsd  %xmm3,%xmm1
movsd  (%rbx,%r15,8),%xmm3
mulsd  0x8(%r13,%rdi,8),%xmm3
addsd  %xmm1,%xmm3
add    $0x2,%rdi
add    %rcx,%rbx
cmp    %rdi,%rdx
jne    1940 <lmpar+0x7d0>
test   $0x1,%al
mov    0x48(%rsp),%rbx
je     18e4 <lmpar+0x774>
mov    %rdi,%rdx
imul   %r15,%rdx
add    %rax,%rdx
movsd  (%r10,%rdx,8),%xmm1
mulsd  0x0(%r13,%rdi,8),%xmm1
addsd  %xmm1,%xmm3
jmp    18e4 <lmpar+0x774>
mov    %r13,%rdi
call   1070 <enorm@plt>
movsd  0x30(%rsp),%xmm1
divsd  0x70(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
test   %bpl,%bpl
je     1aaf <lmpar+0x93f>
mov    0x80(%rsp),%rbx
mov    0x10(%rsp),%rsi
mov    %esi,%r8d
mov    %r15,%rcx
shl    $0x4,%rcx
mov    $0x1,%r10d
xor    %eax,%eax
mov    0x18(%rsp),%r9
jmp    1a1b <lmpar+0x8ab>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdx
movslq (%rdx,%rax,4),%rdx
divsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0x1,%r10
add    $0x8,%r9
cmp    %r8,%rax
je     1aa2 <lmpar+0x932>
test   %rax,%rax
je     1a70 <lmpar+0x900>
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm0,%xmm0
mov    %r9,%rdi
xor    %ebp,%ebp
movsd  (%rdi),%xmm1
mulsd  (%rbx,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%r15,8),%xmm0
mulsd  0x8(%rbx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rbp
add    %rcx,%rdi
cmp    %rbp,%rdx
jne    1a30 <lmpar+0x8c0>
test   $0x1,%r10b
je     19f0 <lmpar+0x880>
jmp    1a80 <lmpar+0x910>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
test   $0x1,%r10b
je     19f0 <lmpar+0x880>
mov    %rbp,%rdx
imul   %r15,%rdx
add    %rax,%rdx
mov    0x18(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm1
mulsd  (%rbx,%rbp,8),%xmm1
addsd  %xmm1,%xmm0
jmp    19f0 <lmpar+0x880>
mov    $0x1,%al
mov    %eax,0x28(%rsp)
mov    0x48(%rsp),%rbx
jmp    1abc <lmpar+0x94c>
movl   $0x0,0x28(%rsp)
mov    0x10(%rsp),%rsi
mov    %r13,%rdi
call   1070 <enorm@plt>
movsd  %xmm0,0x68(%rsp)
movapd %xmm0,%xmm1
movsd  0x70(%rsp),%xmm0
divsd  %xmm0,%xmm1
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jne    1afd <lmpar+0x98d>
jp     1afd <lmpar+0x98d>
movsd  0x1514(%rip),%xmm1
call   1060 <pmin@plt>
movsd  0x150f(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0xa8(%rsp)
movsd  (%rbx),%xmm0
movsd  0x40(%rsp),%xmm1
call   1050 <pmax@plt>
movsd  %xmm0,(%rbx)
movsd  0x60(%rsp),%xmm1
call   1060 <pmin@plt>
ucomisd 0x14dd(%rip),%xmm0
jne    1b4e <lmpar+0x9de>
jp     1b4e <lmpar+0x9de>
movsd  0x68(%rsp),%xmm0
divsd  0x90(%rsp),%xmm0
mov    0x10(%rsp),%rax
mov    0x18(%rsp),%r8
mov    0x50(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    %eax,%ebp
mov    %rbp,0x58(%rsp)
lea    (%rdi,%rbp,8),%r11
lea    (%r12,%rbp,8),%r14
lea    (%r10,%rbp,8),%r9
lea    0x0(,%rbp,8),%rsi
add    %r13,%rsi
mov    %ebp,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xc8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r14,%r13
setb   %al
cmp    %r12,%rsi
seta   %cl
and    %al,%cl
mov    %cl,0xf(%rsp)
mov    %rdx,%rsi
mov    %rdx,0xb8(%rsp)
and    %rdx,0xa8(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x78(%rsp)
cmp    %r14,%rdi
setb   %cl
cmp    %r12,%r11
seta   %dl
and    %cl,%dl
cmp    %r9,%rdi
setb   %cl
cmp    %r10,%r11
seta   %al
lea    -0x1(%rbp),%rsi
mov    %rsi,0xd0(%rsp)
and    %cl,%al
or     %dl,%al
mov    %al,0xe(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0xe0(%rsp)
lea    (%r8,%r15,8),%rax
mov    %rax,0xd8(%rsp)
lea    0x0(,%r15,8),%r14
lea    0x8(,%r15,8),%rax
mov    %rax,0xe8(%rsp)
xor    %eax,%eax
mov    %rax,0x68(%rsp)
jmp    1c7f <lmpar+0xb0f>
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp),%xmm0
movsd  0x30(%rsp),%xmm2
movapd 0x90(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
divsd  %xmm2,%xmm1
addsd  (%rbx),%xmm1
movsd  0x40(%rsp),%xmm0
call   1050 <pmax@plt>
movapd 0x90(%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  %xmm0,(%rbx)
ucomisd 0x138d(%rip),%xmm0
jne    1cae <lmpar+0xb3e>
jp     1cae <lmpar+0xb3e>
movsd  0x60(%rsp),%xmm1
mulsd  0x1373(%rip),%xmm1
movsd  0x1363(%rip),%xmm0
call   1050 <pmax@plt>
movsd  %xmm0,(%rbx)
ucomisd 0x1362(%rip),%xmm0
jb     1cc0 <lmpar+0xb50>
sqrtsd %xmm0,%xmm0
jmp    1cc5 <lmpar+0xb55>
xchg   %ax,%ax
call   1090 <sqrt@plt>
mov    0x80(%rsp),%r9
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rdi
mov    0x50(%rsp),%rbp
mov    0x28(%rsp),%ecx
mov    0x78(%rsp),%rsi
test   %cl,%cl
mov    %ecx,0x28(%rsp)
je     1d10 <lmpar+0xba0>
cmp    $0x4,%edx
setb   %al
or     0xf(%rsp),%al
je     1d40 <lmpar+0xbd0>
xor    %eax,%eax
mov    0x58(%rsp),%rbx
jmp    1e02 <lmpar+0xc92>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8c(%rsp),%esi
mov    0x38(%rsp),%rcx
mov    %r13,%r8
push   0xb0(%rsp)
push   %rbp
call   1040 <qrsolv@plt>
mov    0x20(%rsp),%rsi
add    $0x10,%rsp
mov    0x20(%rsp),%rdi
jmp    2070 <lmpar+0xf00>
nop
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xc0(%rsp)
je     22c2 <lmpar+0x1152>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
mov    0x58(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm3,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d70 <lmpar+0xc00>
testb  $0x1,0xb8(%rsp)
01
je     1dee <lmpar+0xc7e>
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
mov    0xc8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     1ea0 <lmpar+0xd30>
mov    0xd0(%rsp),%rcx
sub    %rax,%rcx
test   %rsi,%rsi
je     1e3b <lmpar+0xccb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1e20 <lmpar+0xcb0>
cmp    $0x3,%rcx
jb     1ea0 <lmpar+0xd30>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1e50 <lmpar+0xce0>
mov    0x8c(%rsp),%esi
mov    0x38(%rsp),%rcx
mov    %r13,%r8
push   0xb0(%rsp)
push   %rbp
call   1040 <qrsolv@plt>
mov    0x68(%rsp),%rbx
mov    0x60(%rsp),%rbp
mov    0x20(%rsp),%rsi
add    $0x10,%rsp
cmpb   $0x0,0x28(%rsp)
mov    0x20(%rsp),%rdi
je     2070 <lmpar+0xf00>
cmp    $0x4,%esi
setb   %al
or     0xe(%rsp),%al
je     1ef2 <lmpar+0xd82>
xor    %eax,%eax
jmp    1fbe <lmpar+0xe4e>
cmpq   $0x0,0xc0(%rsp)
je     22dc <lmpar+0x116c>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm0,0x10(%rdi,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm0
movupd 0x30(%r12,%rax,8),%xmm1
movupd 0x20(%rbp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbp,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm0,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f10 <lmpar+0xda0>
testb  $0x1,0xb8(%rsp)
01
je     1faa <lmpar+0xe3a>
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm0,0x10(%rdi,%rax,8)
mov    0xc8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     2070 <lmpar+0xf00>
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
test   $0x3,%bl
je     1ffb <lmpar+0xe8b>
mov    0x78(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1fe0 <lmpar+0xe70>
cmp    $0x3,%rcx
jb     2070 <lmpar+0xf00>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
mulsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm0
mulsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    2010 <lmpar+0xea0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1070 <enorm@plt>
movapd %xmm0,%xmm1
subsd  0x70(%rsp),%xmm1
movapd %xmm1,0x90(%rsp)
andpd  0xf90(%rip),%xmm1
movsd  0xf0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
mov    0x68(%rsp),%rax
jae    16e3 <lmpar+0x573>
add    $0x1,%eax
cmp    $0xa,%eax
je     16e3 <lmpar+0x573>
movsd  0x40(%rsp),%xmm1
ucomisd 0xf56(%rip),%xmm1
jne    20e7 <lmpar+0xf77>
jp     20e7 <lmpar+0xf77>
movsd  0x30(%rsp),%xmm1
ucomisd 0x90(%rsp),%xmm1
jb     20e7 <lmpar+0xf77>
xorpd  %xmm1,%xmm1
ucomisd 0x30(%rsp),%xmm1
ja     16e3 <lmpar+0x573>
mov    %rax,0x68(%rsp)
cmpb   $0x0,0x28(%rsp)
mov    0x10(%rsp),%rsi
mov    0xb0(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    0x58(%rsp),%r9
mov    0xe8(%rsp),%r10
je     2240 <lmpar+0x10d0>
cmpq   $0x0,0xd0(%rsp)
je     2170 <lmpar+0x1000>
xor    %eax,%eax
mov    0x38(%rsp),%rdi
mov    0xe0(%rsp),%rbp
movslq (%rdi,%rax,4),%rcx
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movslq 0x4(%rdi,%rax,4),%rcx
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    2130 <lmpar+0xfc0>
jmp    2177 <lmpar+0x1007>
xor    %eax,%eax
mov    0x38(%rsp),%rdi
test   $0x1,%r9b
mov    0x28(%rsp),%ebp
je     219b <lmpar+0x102b>
movslq (%rdi,%rax,4),%rcx
movsd  (%rdx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
test   %bpl,%bpl
je     2240 <lmpar+0x10d0>
mov    %r9,%rax
mov    %r13,%rcx
mov    0xd8(%rsp),%rbp
xor    %ebx,%ebx
jmp    21d0 <lmpar+0x1060>
cs nopw 0x0(%rax,%rax,1)
add    %r10,%rbp
add    $0x8,%rcx
add    $0xffffffffffffffff,%rax
cmp    %r9,%rbx
je     2240 <lmpar+0x10d0>
mov    %rbx,%rdx
movsd  0x0(%r13,%rbx,8),%xmm0
divsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
add    $0x1,%rbx
add    $0x2,%rdx
cmp    %r15,%rdx
jg     21c0 <lmpar+0x1050>
cmp    %r15,%rbx
jge    21c0 <lmpar+0x1050>
mov    $0x1,%edi
mov    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm1
movsd  (%rdx),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    %r14,%rdx
add    $0x1,%rdi
cmp    %rdi,%rax
jne    2210 <lmpar+0x10a0>
jmp    21c0 <lmpar+0x1050>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rdi
call   1070 <enorm@plt>
movapd %xmm0,%xmm1
movapd 0x90(%rsp),%xmm0
ucomisd 0xdbb(%rip),%xmm0
movsd  %xmm1,0x30(%rsp)
jbe    2290 <lmpar+0x1120>
mov    0x48(%rsp),%rbx
movsd  (%rbx),%xmm1
movsd  0x40(%rsp),%xmm0
call   1050 <pmax@plt>
movsd  %xmm0,0x40(%rsp)
jmp    2295 <lmpar+0x1125>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rbx
xorpd  %xmm0,%xmm0
ucomisd 0x90(%rsp),%xmm0
jbe    1c40 <lmpar+0xad0>
movsd  (%rbx),%xmm1
movsd  0x60(%rsp),%xmm0
call   1060 <pmin@plt>
movsd  %xmm0,0x60(%rsp)
jmp    1c40 <lmpar+0xad0>
xor    %eax,%eax
mov    0x58(%rsp),%rbx
testb  $0x1,0xb8(%rsp)
01
jne    1dcb <lmpar+0xc5b>
jmp    1dee <lmpar+0xc7e>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
jne    1f7e <lmpar+0xe0e>
jmp    1faa <lmpar+0xe3a>
xor    %edx,%edx
test   $0x1,%bpl
jne    1809 <lmpar+0x699>
jmp    1834 <lmpar+0x6c4>

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

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