void lm_lmdif(int m, int n, double *x, double *fvec, double ftol, double xtol,
              double gtol, int maxfev, double epsfcn, double *diag, int mode,
              double factor, int *info, int *nfev, double *fjac, int *ipvt,
              double *qtf, double *wa1, double *wa2, double *wa3, double *wa4,
              void (*evaluate)(const double *par, int m_dat, const void *data,
                               double *fvec, int *info),
              void (*printout)(int n_par, const double *par, int m_dat,
                               const void *data, const double *fvec,
                               int printflags, int iflag, int iter, int nfev),
              int printflags, const void *data) {
  int i, iter, j;
  double actred, delta, dirder, eps, fnorm, fnorm1, gnorm, par, pnorm, prered,
      ratio, step, sum, temp, temp1, temp2, temp3, xnorm;
  static double p1 = 0.1;
  static double p0001 = 1.0e-4;
  *nfev = 0;
  iter = 0;
  par = 0;
  delta = 0;
  xnorm = 0;
  temp = (((epsfcn) >= (1.2e-16)) ? (epsfcn) : (1.2e-16));
  eps = sqrt(temp);
  if ((n <= 0) || (m < n) || (ftol < 0.) || (xtol < 0.) || (gtol < 0.) ||
      (maxfev <= 0) || (factor <= 0.)) {
    *info = 10;
    return;
  }
  if (mode == 2) {
    for (j = 0; j < n; j++) {
      if (diag[j] <= 0.0) {
        *info = 10;
        return;
      }
    }
  }
  *info = 0;
  (*evaluate)(x, m, data, fvec, info);
  ++(*nfev);
  if (printout)
    (*printout)(n, x, m, data, fvec, printflags, 0, 0, *nfev);
  if (*info < 0)
    return;
  fnorm = lm_enorm(m, fvec);
  if (fnorm <= 1.0e-38) {
    *info = 0;
    return;
  }
  do {
    for (j = 0; j < n; j++) {
      temp = x[j];
      step = (((eps * eps) >= (eps * fabs(temp))) ? (eps * eps)
                                                  : (eps * fabs(temp)));
      x[j] = temp + step;
      *info = 0;
      (*evaluate)(x, m, data, wa4, info);
      ++(*nfev);
      if (printout)
        (*printout)(n, x, m, data, wa4, printflags, 1, iter, *nfev);
      if (*info < 0)
        return;
      for (i = 0; i < m; i++)
        fjac[j * m + i] = (wa4[i] - fvec[i]) / step;
      x[j] = temp;
    }
    lm_qrfac(m, n, fjac, 1, ipvt, wa1, wa2, wa3);
    if (!iter) {
      if (mode != 2) {
        for (j = 0; j < n; j++) {
          diag[j] = wa2[j];
          if (wa2[j] == 0.)
            diag[j] = 1.;
        }
      }
      for (j = 0; j < n; j++)
        wa3[j] = diag[j] * x[j];
      xnorm = lm_enorm(n, wa3);
      delta = factor * xnorm;
      if (delta == 0.)
        delta = factor;
    } else {
      if (mode != 2) {
        for (j = 0; j < n; j++)
          diag[j] = (((diag[j]) >= (wa2[j])) ? (diag[j]) : (wa2[j]));
      }
    }
    for (i = 0; i < m; i++)
      wa4[i] = fvec[i];
    for (j = 0; j < n; j++) {
      temp3 = fjac[j * m + j];
      if (temp3 != 0.) {
        sum = 0;
        for (i = j; i < m; i++)
          sum += fjac[j * m + i] * wa4[i];
        temp = -sum / temp3;
        for (i = j; i < m; i++)
          wa4[i] += fjac[j * m + i] * temp;
      }
      fjac[j * m + j] = wa1[j];
      qtf[j] = wa4[j];
    }
    gnorm = 0;
    for (j = 0; j < n; j++) {
      if (wa2[ipvt[j]] == 0)
        continue;
      sum = 0.;
      for (i = 0; i <= j; i++)
        sum += fjac[j * m + i] * qtf[i];
      gnorm = (((gnorm) >= (fabs(sum / wa2[ipvt[j]] / fnorm)))
                   ? (gnorm)
                   : (fabs(sum / wa2[ipvt[j]] / fnorm)));
    }
    if (gnorm <= gtol) {
      *info = 4;
      return;
    }
    do {
      lm_lmpar(n, fjac, m, ipvt, diag, qtf, delta, &par, wa1, wa2, wa4, wa3);
      for (j = 0; j < n; j++)
        wa2[j] = x[j] - wa1[j];
      pnorm = lm_enorm(n, wa3);
      if (*nfev <= 1 + n)
        delta = (((delta) <= (pnorm)) ? (delta) : (pnorm));
      *info = 0;
      (*evaluate)(wa2, m, data, wa4, info);
      ++(*nfev);
      if (printout)
        (*printout)(n, wa2, m, data, wa4, printflags, 2, iter, *nfev);
      if (*info < 0)
        return;
      fnorm1 = lm_enorm(m, wa4);
      if (p1 * fnorm1 < fnorm)
        actred = 1 - (fnorm1 / fnorm) * (fnorm1 / fnorm);
      else
        actred = -1;
      for (j = 0; j < n; j++) {
        wa3[j] = 0;
        for (i = 0; i <= j; i++)
          wa3[i] -= fjac[j * m + i] * wa1[ipvt[j]];
      }
      temp1 = lm_enorm(n, wa3) / fnorm;
      temp2 = sqrt(par) * pnorm / fnorm;
      prered = (temp1) * (temp1) + 2 * (temp2) * (temp2);
      dirder = -((temp1) * (temp1) + (temp2) * (temp2));
      ratio = prered != 0 ? actred / prered : 0;
      if (ratio <= 0.25) {
        if (actred >= 0.)
          temp = 0.5;
        else
          temp = 0.5 * dirder / (dirder + 0.55 * actred);
        if (p1 * fnorm1 >= fnorm || temp < p1)
          temp = p1;
        delta = temp * (((delta) <= (pnorm / p1)) ? (delta) : (pnorm / p1));
        par /= temp;
      } else if (par == 0. || ratio >= 0.75) {
        delta = pnorm / 0.5;
        par *= 0.5;
      }
      if (ratio >= p0001) {
        for (j = 0; j < n; j++) {
          x[j] = wa2[j];
          wa2[j] = diag[j] * x[j];
        }
        for (i = 0; i < m; i++)
          fvec[i] = wa4[i];
        xnorm = lm_enorm(n, wa2);
        fnorm = fnorm1;
        iter++;
      }
      if (fnorm <= 1.0e-38) {
        *info = 0;
        return;
      }
      *info = 0;
      if (fabs(actred) <= ftol && prered <= ftol && 0.5 * ratio <= 1)
        *info = 1;
      if (delta <= xtol * xnorm)
        *info += 2;
      if (*info != 0)
        return;
      if (*nfev >= maxfev) {
        *info = 5;
        return;
      }
      if (fabs(actred) <= 1.2e-16 && prered <= 1.2e-16 && 0.5 * ratio <= 1) {
        *info = 6;
        return;
      }
      if (delta <= 1.2e-16 * xnorm) {
        *info = 7;
        return;
      }
      if (gnorm <= 1.2e-16) {
        *info = 8;
        return;
      }
    } while (ratio < p0001);
  } while (1);
}


x86 assembly (clang, -O0):
<lm_lmdif>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x160,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%eax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
mov    %r8d,-0x44(%rbp)
movsd  %xmm3,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
movsd  %xmm4,-0x60(%rbp)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  0x1e11(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     120b <lm_lmdif+0xcb>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1220 <lm_lmdif+0xe0>
movsd  0x1ded(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1220 <lm_lmdif+0xe0>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
cmpl   $0x0,-0x18(%rbp)
jle    129d <lm_lmdif+0x15d>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     129d <lm_lmdif+0x15d>
xorps  %xmm0,%xmm0
ucomisd -0x30(%rbp),%xmm0
ja     129d <lm_lmdif+0x15d>
xorps  %xmm0,%xmm0
ucomisd -0x38(%rbp),%xmm0
ja     129d <lm_lmdif+0x15d>
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
ja     129d <lm_lmdif+0x15d>
cmpl   $0x0,-0x44(%rbp)
jle    129d <lm_lmdif+0x15d>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     12ac <lm_lmdif+0x16c>
mov    0x18(%rbp),%rax
movl   $0xa,(%rax)
jmp    235f <lm_lmdif+0x121f>
cmpl   $0x2,0x10(%rbp)
jne    1306 <lm_lmdif+0x1c6>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1301 <lm_lmdif+0x1c1>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     12ee <lm_lmdif+0x1ae>
mov    0x18(%rbp),%rax
movl   $0xa,(%rax)
jmp    235f <lm_lmdif+0x121f>
jmp    12f3 <lm_lmdif+0x1b3>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12bd <lm_lmdif+0x17d>
jmp    1306 <lm_lmdif+0x1c6>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    0x60(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    0x78(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    0x18(%rbp),%r8
call   *%rax
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpq   $0x0,0x68(%rbp)
je     1379 <lm_lmdif+0x239>
mov    0x68(%rbp),%rax
mov    -0x18(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    0x78(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    0x70(%rbp),%r9d
mov    0x20(%rbp),%r10
mov    (%r10),%r10d
xor    %r11d,%r11d
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jge    138b <lm_lmdif+0x24b>
jmp    235f <lm_lmdif+0x121f>
mov    -0x14(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1c5b(%rip),%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     13ca <lm_lmdif+0x28a>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
jmp    235f <lm_lmdif+0x121f>
jmp    13cf <lm_lmdif+0x28f>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15a0 <lm_lmdif+0x460>
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
movaps 0x1c32(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     144d <lm_lmdif+0x30d>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1474 <lm_lmdif+0x334>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
movaps 0x1bec(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    0x60(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    0x78(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x18(%rbp),%r8
call   *%rax
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpq   $0x0,0x68(%rbp)
je     1512 <lm_lmdif+0x3d2>
mov    0x68(%rbp),%rax
mov    -0x18(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    0x78(%rbp),%rcx
mov    0x58(%rbp),%r8
mov    0x70(%rbp),%r9d
mov    -0x68(%rbp),%r11d
mov    0x20(%rbp),%r10
mov    (%r10),%r10d
movl   $0x1,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1524 <lm_lmdif+0x3e4>
jmp    235f <lm_lmdif+0x121f>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    157d <lm_lmdif+0x43d>
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xd0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    152b <lm_lmdif+0x3eb>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13d6 <lm_lmdif+0x296>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    0x28(%rbp),%rdx
mov    0x30(%rbp),%r8
mov    0x40(%rbp),%r9
mov    0x48(%rbp),%r10
mov    0x50(%rbp),%rax
mov    $0x1,%ecx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <lm_qrfac@plt>
cmpl   $0x0,-0x68(%rbp)
jne    16f8 <lm_lmdif+0x5b8>
cmpl   $0x2,0x10(%rbp)
je     165d <lm_lmdif+0x51d>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1658 <lm_lmdif+0x518>
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1645 <lm_lmdif+0x505>
jp     1645 <lm_lmdif+0x505>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  0x19d0(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    164a <lm_lmdif+0x50a>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15ea <lm_lmdif+0x4aa>
jmp    165d <lm_lmdif+0x51d>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16a5 <lm_lmdif+0x565>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1664 <lm_lmdif+0x524>
mov    -0x18(%rbp),%edi
mov    0x50(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16f3 <lm_lmdif+0x5b3>
jp     16f3 <lm_lmdif+0x5b3>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1791 <lm_lmdif+0x651>
cmpl   $0x2,0x10(%rbp)
je     178c <lm_lmdif+0x64c>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1787 <lm_lmdif+0x647>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     174f <lm_lmdif+0x60f>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1764 <lm_lmdif+0x624>
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1709 <lm_lmdif+0x5c9>
jmp    178c <lm_lmdif+0x64c>
jmp    1791 <lm_lmdif+0x651>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17cc <lm_lmdif+0x68c>
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1798 <lm_lmdif+0x658>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    195a <lm_lmdif+0x81a>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    181d <lm_lmdif+0x6dd>
jp     181d <lm_lmdif+0x6dd>
jmp    190f <lm_lmdif+0x7cf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1883 <lm_lmdif+0x743>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    182e <lm_lmdif+0x6ee>
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    190a <lm_lmdif+0x7ca>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18b8 <lm_lmdif+0x778>
jmp    190f <lm_lmdif+0x7cf>
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    17d3 <lm_lmdif+0x693>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1ab9 <lm_lmdif+0x979>
mov    0x48(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19a5 <lm_lmdif+0x865>
jp     19a5 <lm_lmdif+0x865>
jmp    1aab <lm_lmdif+0x96b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     1a0c <lm_lmdif+0x8cc>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    19b7 <lm_lmdif+0x877>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
divsd  (%rax,%rcx,8),%xmm1
divsd  -0x98(%rbp),%xmm1
ff
movaps 0x1610(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     1a63 <lm_lmdif+0x923>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
jmp    1a9b <lm_lmdif+0x95b>
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
divsd  (%rax,%rcx,8),%xmm0
divsd  -0x98(%rbp),%xmm0
ff
movaps 0x15c1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    196c <lm_lmdif+0x82c>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1adf <lm_lmdif+0x99f>
mov    0x18(%rbp),%rax
movl   $0x4,(%rax)
jmp    235f <lm_lmdif+0x121f>
jmp    1ae4 <lm_lmdif+0x9a4>
mov    -0x18(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    0x30(%rbp),%rcx
mov    -0x58(%rbp),%r8
mov    0x38(%rbp),%r9
movsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x58(%rbp),%r10
mov    0x50(%rbp),%rax
lea    -0xb0(%rbp),%r14
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1050 <lm_lmpar@plt>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b7d <lm_lmdif+0xa3d>
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1b3c <lm_lmdif+0x9fc>
mov    -0x18(%rbp),%edi
mov    0x50(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1bf1 <lm_lmdif+0xab1>
movsd  -0x80(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1bd4 <lm_lmdif+0xa94>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1be4 <lm_lmdif+0xaa4>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    0x60(%rbp),%rax
mov    0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    0x78(%rbp),%rdx
mov    0x58(%rbp),%rcx
mov    0x18(%rbp),%r8
call   *%rax
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpq   $0x0,0x68(%rbp)
je     1c62 <lm_lmdif+0xb22>
mov    0x68(%rbp),%rax
mov    -0x18(%rbp),%edi
mov    0x48(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    0x78(%rbp),%rcx
mov    0x58(%rbp),%r8
mov    0x70(%rbp),%r9d
mov    -0x68(%rbp),%r11d
mov    0x20(%rbp),%r10
mov    (%r10),%r10d
movl   $0x2,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
call   *%rax
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1c74 <lm_lmdif+0xb34>
jmp    235f <lm_lmdif+0x121f>
mov    -0x14(%rbp),%edi
mov    0x58(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x33aa(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1d01 <lm_lmdif+0xbc1>
movsd  -0xa0(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
divsd  -0x98(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x131d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1d0e <lm_lmdif+0xbce>
movsd  0x130f(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1dc1 <lm_lmdif+0xc81>
mov    0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     1dae <lm_lmdif+0xc6e>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1d38 <lm_lmdif+0xbf8>
jmp    1db3 <lm_lmdif+0xc73>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1d15 <lm_lmdif+0xbd5>
mov    -0x18(%rbp),%edi
mov    0x50(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
mulsd  -0xb8(%rbp),%xmm0
ff
divsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  0x1200(%rip),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ea7 <lm_lmdif+0xd67>
jp     1ea7 <lm_lmdif+0xd67>
jmp    1ec1 <lm_lmdif+0xd81>
movsd  -0x78(%rbp),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1ed1 <lm_lmdif+0xd91>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1ed1 <lm_lmdif+0xd91>
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x113f(%rip),%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jb     2032 <lm_lmdif+0xef2>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1f1e <lm_lmdif+0xdde>
movsd  0x1127(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1f57 <lm_lmdif+0xe17>
movsd  0x1112(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
movsd  0x10fd(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x30e1(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jae    1f8f <lm_lmdif+0xe4f>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x30bb(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f9f <lm_lmdif+0xe5f>
movsd  0x30a9(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
divsd  0x307c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1fe0 <lm_lmdif+0xea0>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    1ff8 <lm_lmdif+0xeb8>
movsd  -0xb8(%rbp),%xmm0
ff
divsd  0x3050(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    20a2 <lm_lmdif+0xf62>
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2052 <lm_lmdif+0xf12>
jp     2052 <lm_lmdif+0xf12>
jmp    206c <lm_lmdif+0xf2c>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0xfce(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     209d <lm_lmdif+0xf5d>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0xfbc(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xfab(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    20a2 <lm_lmdif+0xf62>
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd 0x2f96(%rip),%xmm0
jb     2188 <lm_lmdif+0x1048>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    211a <lm_lmdif+0xfda>
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    20bf <lm_lmdif+0xf7f>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2155 <lm_lmdif+0x1015>
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2121 <lm_lmdif+0xfe1>
mov    -0x18(%rbp),%edi
mov    0x48(%rbp),%rsi
mov    $0x0,%al
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movsd  0xe78(%rip),%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     21ad <lm_lmdif+0x106d>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
jmp    235f <lm_lmdif+0x121f>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
movsd  -0x78(%rbp),%xmm1
movaps 0xe8d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2219 <lm_lmdif+0x10d9>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2219 <lm_lmdif+0x10d9>
movsd  0xe43(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0xe0b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     2219 <lm_lmdif+0x10d9>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
movsd  -0x80(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2240 <lm_lmdif+0x1100>
mov    0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x2,%ecx
mov    %ecx,(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     2252 <lm_lmdif+0x1112>
jmp    235f <lm_lmdif+0x121f>
mov    0x20(%rbp),%rax
mov    (%rax),%eax
cmp    -0x44(%rbp),%eax
jl     2270 <lm_lmdif+0x1130>
mov    0x18(%rbp),%rax
movl   $0x5,(%rax)
jmp    235f <lm_lmdif+0x121f>
movsd  -0x78(%rbp),%xmm1
movaps 0xdd4(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xd78(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     22d9 <lm_lmdif+0x1199>
movsd  0xd66(%rip),%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jb     22d9 <lm_lmdif+0x1199>
movsd  0xd88(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0xd50(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     22d9 <lm_lmdif+0x1199>
mov    0x18(%rbp),%rax
movl   $0x6,(%rax)
jmp    235f <lm_lmdif+0x121f>
movsd  -0x80(%rbp),%xmm1
movsd  0xd1a(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2307 <lm_lmdif+0x11c7>
mov    0x18(%rbp),%rax
movl   $0x7,(%rax)
jmp    235f <lm_lmdif+0x121f>
movsd  0xcf1(%rip),%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jb     232c <lm_lmdif+0x11ec>
mov    0x18(%rbp),%rax
movl   $0x8,(%rax)
jmp    235f <lm_lmdif+0x121f>
jmp    2331 <lm_lmdif+0x11f1>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0x2d07(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1ae4 <lm_lmdif+0x9a4>
jmp    2350 <lm_lmdif+0x1210>
mov    $0x1,%al
test   $0x1,%al
jne    13cf <lm_lmdif+0x28f>
jmp    235f <lm_lmdif+0x121f>
add    $0x160,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<lm_lmdif>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x208,%rsp
mov    %r9,%rbp
mov    %r8d,%r15d
movsd  %xmm0,0x178(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,%rbx
mov    %esi,%r13d
mov    0x250(%rsp),%rax
movl   $0x0,(%rax)
maxsd  0x2e7f(%rip),%xmm3
movq   $0x0,0x68(%rsp)
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
mov    %edi,0x4(%rsp)
jb     11a3 <lm_lmdif+0x63>
mov    %edi,%esi
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    11e0 <lm_lmdif+0xa0>
movapd %xmm3,%xmm0
movsd  %xmm4,0x108(%rsp)
movsd  %xmm2,0x40(%rsp)
movsd  %xmm1,0x110(%rsp)
call   1060 <sqrt@plt>
mov    0x4(%rsp),%esi
movsd  0x110(%rsp),%xmm1
movsd  0x40(%rsp),%xmm2
movsd  0x108(%rsp),%xmm4
movsd  %xmm0,0x118(%rsp)
mov    0x248(%rsp),%r8
mov    $0xa,%r14d
test   %r13d,%r13d
jle    322b <lm_lmdif+0x20eb>
cmp    %r13d,%esi
jl     322b <lm_lmdif+0x20eb>
xorpd  %xmm0,%xmm0
ucomisd 0x178(%rsp),%xmm0
ja     322b <lm_lmdif+0x20eb>
ucomisd %xmm1,%xmm0
ja     322b <lm_lmdif+0x20eb>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
ja     322b <lm_lmdif+0x20eb>
test   %r15d,%r15d
jle    322b <lm_lmdif+0x20eb>
xorpd  %xmm0,%xmm0
ucomisd %xmm4,%xmm0
jae    322b <lm_lmdif+0x20eb>
cmpl   $0x2,0x240(%rsp)
02
jne    1275 <lm_lmdif+0x135>
mov    %r13d,%eax
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
ucomisd 0x0(%rbp,%rcx,8),%xmm0
jae    322b <lm_lmdif+0x20eb>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1260 <lm_lmdif+0x120>
movsd  %xmm1,0x110(%rsp)
movsd  %xmm2,0x40(%rsp)
mov    %r15d,0x12c(%rsp)
mov    %rbp,0x20(%rsp)
movsd  %xmm4,0x108(%rsp)
mov    0x2a8(%rsp),%r14
mov    0x298(%rsp),%r15
movl   $0x0,(%r8)
mov    %rbx,%rdi
mov    %r14,%rdx
mov    0x60(%rsp),%r12
mov    %r12,%rcx
mov    %esi,%ebp
call   *0x290(%rsp)
mov    0x250(%rsp),%rcx
mov    (%rcx),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
test   %r15,%r15
je     1302 <lm_lmdif+0x1c2>
sub    $0x8,%rsp
mov    %r13d,%edi
mov    %rbx,%rsi
mov    %ebp,%edx
mov    %r14,%rcx
mov    %r12,%r8
mov    0x2a8(%rsp),%r9d
push   %rax
push   $0x0
push   $0x0
call   *%r15
add    $0x20,%rsp
mov    %r13,0x10(%rsp)
mov    0x248(%rsp),%rax
cmpl   $0x0,(%rax)
js     322e <lm_lmdif+0x20ee>
mov    %rbx,0x38(%rsp)
xor    %r14d,%r14d
mov    %ebp,%edi
mov    %r12,%rsi
xor    %eax,%eax
mov    %ebp,%ebx
call   1040 <lm_enorm@plt>
mov    0x248(%rsp),%r8
test   %eax,%eax
jle    322b <lm_lmdif+0x20eb>
mov    0x278(%rsp),%rcx
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
mov    0x10(%rsp),%r9d
mov    %ebx,%ebp
lea    (%rcx,%r9,8),%r12
mov    %rcx,%rdi
mov    %ebp,%eax
and    $0xfffffffe,%eax
mov    %rax,0x1d8(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x1d0(%rsp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xb0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xa8(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x150(%rsp)
lea    -0x4(%rax),%rcx
mov    %rcx,0x148(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rdx,%rax
mov    %rdx,0x1c8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x1c0(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x170(%rsp)
mov    0x20(%rsp),%r15
cmp    %r15,%r12
seta   %dl
lea    (%r15,%r9,8),%r14
cmp    %rdi,%r14
seta   %r11b
and    %dl,%r11b
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rsi,%rax
mov    %rsi,0xa0(%rsp)
and    %rsi,%rdx
mov    %rdx,0x98(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0xf8(%rsp)
mov    %r9d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x190(%rsp)
mov    0x280(%rsp),%r13
cmp    %r13,%r14
seta   %dl
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
cmp    %r15,%rsi
seta   %bl
and    %dl,%bl
mov    0x38(%rsp),%rdi
lea    (%rdi,%r9,8),%r10
cmp    %r13,%r10
seta   %al
cmp    %rdi,%rsi
seta   %dl
and    %al,%dl
or     %bl,%dl
mov    %dl,0xd(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x158(%rsp)
mov    0x288(%rsp),%rdx
mov    0x60(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x1e0(%rsp)
cmp    %rdx,%rax
seta   %al
lea    (%rdx,%rbp,8),%rsi
mov    %rsi,0x168(%rsp)
cmp    0x60(%rsp),%rsi
seta   %bl
and    %al,%bl
mov    %bl,0xc(%rsp)
mov    %ecx,%esi
and    $0x3,%esi
mov    %rcx,%rax
mov    %rcx,0x1a8(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x130(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x28(%rsp)
mov    0x278(%rsp),%rdx
cmp    %rdx,%r10
seta   %al
cmp    %rdi,%r12
seta   %bl
and    %al,%bl
mov    0x270(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
cmp    %rdx,%rax
seta   %al
cmp    %rcx,%r12
seta   %dl
and    %al,%dl
or     %bl,%dl
mov    %dl,0xf(%rsp)
cmp    %rdi,%r14
seta   %al
cmp    %r15,%r10
mov    0x60(%rsp),%r15
mov    %rbp,%r12
seta   %dl
and    %al,%dl
or     %bl,%dl
movsd  0x118(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm0,0x1f0(%rsp)
mov    %r11b,0xb(%rsp)
or     %r11b,%dl
mov    %dl,0xe(%rsp)
mov    %r9,0x48(%rsp)
lea    0x0(,%r9,8),%rax
mov    0x288(%rsp),%rbp
and    $0xfffffffffffffff0,%rax
mov    %rax,0x1a0(%rsp)
mov    %rsi,0x198(%rsp)
shl    $0x5,%rsi
mov    %rsi,0x30(%rsp)
mov    0x258(%rsp),%rax
mov    0x10(%rsp),%rdx
add    $0x1,%edx
mov    %edx,0x128(%rsp)
mov    0x4(%rsp),%r11d
movslq %r11d,%rdx
lea    0x8(%rax),%rsi
mov    %rsi,0xc0(%rsp)
lea    0x0(,%rdx,8),%rsi
mov    %rsi,0xc8(%rsp)
mov    %rdx,0x90(%rsp)
lea    0x8(,%rdx,8),%rdx
mov    %rdx,0x120(%rsp)
lea    0x8(%rcx),%rcx
mov    %rcx,0x1e8(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x160(%rsp)
lea    0x10(%rbp),%rcx
mov    %rcx,0x140(%rsp)
lea    0x10(%r15),%rcx
mov    %rcx,0x138(%rsp)
lea    -0x4(%r12),%rcx
mov    %rcx,0x1b8(%rsp)
add    $0x18,%rax
mov    %rax,0x1b0(%rsp)
xor    %eax,%eax
mov    %rax,0x88(%rsp)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
movsd  %xmm1,0xb8(%rsp)
mov    %r12,0x18(%rsp)
movapd %xmm0,0x50(%rsp)
movsd  %xmm2,0x80(%rsp)
mov    0xc0(%rsp),%rbx
mov    0x160(%rsp),%r14
xor    %esi,%esi
jmp    169b <lm_lmdif+0x55b>
xchg   %ax,%ax
movapd 0xe0(%rsp),%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%rsi
mov    0xc8(%rsp),%rax
add    %rax,%r14
add    %rax,%rbx
cmp    0x48(%rsp),%rsi
je     197f <lm_lmdif+0x83f>
movsd  (%rdi,%rsi,8),%xmm3
movapd %xmm3,%xmm0
andpd  0x29b4(%rip),%xmm0
mulsd  0x118(%rsp),%xmm0
movapd %xmm0,%xmm4
movapd 0x1f0(%rsp),%xmm2
cmplesd %xmm2,%xmm4
movapd %xmm4,%xmm1
andnpd %xmm0,%xmm1
andpd  %xmm2,%xmm4
orpd   %xmm1,%xmm4
movapd %xmm3,0xe0(%rsp)
movapd %xmm3,%xmm0
movapd %xmm4,0xd0(%rsp)
addsd  %xmm4,%xmm0
mov    %rsi,0x70(%rsp)
movsd  %xmm0,(%rdi,%rsi,8)
movl   $0x0,(%r8)
mov    %r11d,%esi
mov    0x2a8(%rsp),%rdx
mov    %rbp,%rcx
mov    %rdi,%r15
mov    %r11d,%r12d
call   *0x290(%rsp)
mov    0x250(%rsp),%rcx
mov    (%rcx),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
mov    0x298(%rsp),%r10
test   %r10,%r10
je     176c <lm_lmdif+0x62c>
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    0x2b0(%rsp),%rcx
mov    %rbp,%r8
mov    0x2a8(%rsp),%r9d
push   %rax
push   0x98(%rsp)
push   $0x1
call   *%r10
add    $0x20,%rsp
mov    0x248(%rsp),%r8
cmpl   $0x0,(%r8)
mov    %r15,%rdi
mov    0x60(%rsp),%r15
js     322e <lm_lmdif+0x20ee>
mov    %r12d,%r11d
test   %r12d,%r12d
mov    0x18(%rsp),%r12
mov    0x70(%rsp),%rsi
movapd 0xd0(%rsp),%xmm3
jle    1670 <lm_lmdif+0x530>
mov    %rsi,%rax
imul   0x90(%rsp),%rax
cmp    $0x1,%r11d
jne    17c0 <lm_lmdif+0x680>
xor    %edx,%edx
jmp    18e0 <lm_lmdif+0x7a0>
xchg   %ax,%ax
lea    (%rax,%r12,1),%rcx
mov    0x258(%rsp),%rsi
lea    (%rsi,%rax,8),%rdx
lea    (%rsi,%rcx,8),%rsi
cmp    0x168(%rsp),%rdx
setb   %r10b
cmp    %rbp,%rsi
seta   %r9b
cmp    0x1e0(%rsp),%rdx
setb   %cl
cmp    %r15,%rsi
seta   %sil
test   %r9b,%r10b
jne    18c4 <lm_lmdif+0x784>
mov    $0x0,%edx
and    %sil,%cl
mov    0x288(%rsp),%rbp
mov    0x70(%rsp),%rsi
jne    18e0 <lm_lmdif+0x7a0>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0x1d0(%rsp)
je     196a <lm_lmdif+0x82a>
mov    0x1c0(%rsp),%rdx
xor    %ecx,%ecx
xchg   %ax,%ax
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r14,%rcx,8)
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd 0x10(%r15,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r14,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1840 <lm_lmdif+0x700>
testb  $0x1,0x1c8(%rsp)
01
je     18ae <lm_lmdif+0x76e>
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
subpd  %xmm2,%xmm1
divpd  %xmm0,%xmm1
add    %rax,%rcx
mov    0x258(%rsp),%rdx
movupd %xmm1,(%rdx,%rcx,8)
mov    0x1d8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r12,%rcx
je     1670 <lm_lmdif+0x530>
jmp    18e0 <lm_lmdif+0x7a0>
xor    %edx,%edx
mov    0x288(%rsp),%rbp
mov    0x70(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rcx
test   $0x1,%r12b
je     1910 <lm_lmdif+0x7d0>
movsd  0x0(%rbp,%rdx,8),%xmm0
subsd  (%r15,%rdx,8),%xmm0
divsd  %xmm3,%xmm0
add    %rdx,%rax
mov    0x258(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x170(%rsp),%rdx
je     1670 <lm_lmdif+0x530>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
subsd  0x8(%r15,%rcx,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    1930 <lm_lmdif+0x7f0>
jmp    1670 <lm_lmdif+0x530>
xor    %ecx,%ecx
testb  $0x1,0x1c8(%rsp)
01
jne    188a <lm_lmdif+0x74a>
jmp    18ae <lm_lmdif+0x76e>
mov    %r11d,%edi
mov    0x10(%rsp),%rsi
mov    0x258(%rsp),%rdx
mov    $0x1,%ecx
mov    0x260(%rsp),%r8
mov    0x270(%rsp),%r9
xor    %eax,%eax
push   %r13
mov    0x280(%rsp),%rbx
push   %rbx
call   1030 <lm_qrfac@plt>
add    $0x10,%rsp
cmpl   $0x0,0x88(%rsp)
je     19f1 <lm_lmdif+0x8b1>
cmpl   $0x2,0x240(%rsp)
02
jne    1a39 <lm_lmdif+0x8f9>
movsd  0x40(%rsp),%xmm8
mov    0x4(%rsp),%r8d
mov    0x288(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x30(%rsp),%rbp
jmp    1f3f <lm_lmdif+0xdff>
cmpl   $0x2,0x240(%rsp)
02
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rbp
mov    0x1a0(%rsp),%rdx
movabs $0x3ff0000000000000,%r8
je     1be1 <lm_lmdif+0xaa1>
cmpl   $0x2,0x10(%rsp)
setb   %al
or     0xb(%rsp),%al
je     1b54 <lm_lmdif+0xa14>
xor    %ecx,%ecx
jmp    1ba5 <lm_lmdif+0xa65>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0xb(%rsp),%al
mov    0x48(%rsp),%rsi
je     1a71 <lm_lmdif+0x931>
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
movsd  0x40(%rsp),%xmm8
mov    0x4(%rsp),%r8d
mov    0x288(%rsp),%rdi
mov    0x30(%rsp),%rbp
jmp    1ea5 <lm_lmdif+0xd65>
cmpq   $0x0,0xa8(%rsp)
je     1e1c <lm_lmdif+0xcdc>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x20(%rsp),%rdx
movsd  0x40(%rsp),%xmm8
mov    0x4(%rsp),%r8d
mov    0x288(%rsp),%rdi
mov    0x30(%rsp),%rbp
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm3
movupd 0x10(%rdx,%rax,8),%xmm4
movupd 0x20(%rdx,%rax,8),%xmm5
movupd 0x30(%rdx,%rax,8),%xmm0
movapd %xmm1,%xmm6
cmplepd %xmm3,%xmm6
movapd %xmm2,%xmm7
cmplepd %xmm4,%xmm7
andpd  %xmm6,%xmm3
andnpd %xmm1,%xmm6
orpd   %xmm3,%xmm6
andpd  %xmm7,%xmm4
andnpd %xmm2,%xmm7
orpd   %xmm4,%xmm7
movupd %xmm6,(%rdx,%rax,8)
movupd %xmm7,0x10(%rdx,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
movapd %xmm1,%xmm3
cmplepd %xmm5,%xmm3
movapd %xmm2,%xmm4
cmplepd %xmm0,%xmm4
andpd  %xmm3,%xmm5
andnpd %xmm1,%xmm3
orpd   %xmm5,%xmm3
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
movupd %xmm3,0x20(%rdx,%rax,8)
movupd %xmm4,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1aa8 <lm_lmdif+0x968>
jmp    1e3c <lm_lmdif+0xcfc>
xor    %eax,%eax
jmp    1b61 <lm_lmdif+0xa21>
add    $0x10,%rax
cmp    %rax,%rdx
je     1b95 <lm_lmdif+0xa55>
movupd (%rbx,%rax,1),%xmm0
movupd %xmm0,(%rsi,%rax,1)
ucomisd 0x24e5(%rip),%xmm0
jne    1b7b <lm_lmdif+0xa3b>
jp     1b7b <lm_lmdif+0xa3b>
mov    %r8,(%rsi,%rax,1)
cmpeqpd 0x24fc(%rip),%xmm0
pextrw $0x4,%xmm0,%ecx
test   $0x1,%cl
je     1b58 <lm_lmdif+0xa18>
mov    %r8,0x8(%rsi,%rax,1)
jmp    1b58 <lm_lmdif+0xa18>
mov    0x190(%rsp),%rax
mov    %rax,%rcx
cmp    %rbp,%rax
je     1be1 <lm_lmdif+0xaa1>
mov    %rcx,%rax
test   $0x1,%bpl
je     1bd4 <lm_lmdif+0xa94>
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
ucomisd 0x2493(%rip),%xmm0
jne    1bcd <lm_lmdif+0xa8d>
jp     1bcd <lm_lmdif+0xa8d>
mov    %r8,(%rsi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf8(%rsp),%rcx
jne    1c04 <lm_lmdif+0xac4>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0xd(%rsp),%al
je     1c48 <lm_lmdif+0xb08>
xor    %eax,%eax
mov    0x28(%rsp),%rbx
jmp    1d19 <lm_lmdif+0xbd9>
add    $0x2,%rax
cmp    %rax,%rbp
je     1be1 <lm_lmdif+0xaa1>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
ucomisd 0x243d(%rip),%xmm0
jne    1c23 <lm_lmdif+0xae3>
jp     1c23 <lm_lmdif+0xae3>
mov    %r8,(%rsi,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
ucomisd 0x241b(%rip),%xmm0
jne    1bfb <lm_lmdif+0xabb>
jp     1bfb <lm_lmdif+0xabb>
mov    %r8,0x8(%rsi,%rax,8)
jmp    1bfb <lm_lmdif+0xabb>
cmpq   $0x0,0xa8(%rsp)
je     1cc8 <lm_lmdif+0xb88>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x28(%rsp),%rbx
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm0
movupd 0x30(%rsi,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm0,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c62 <lm_lmdif+0xb22>
jmp    1ccf <lm_lmdif+0xb8f>
xor    %eax,%eax
mov    0x28(%rsp),%rbx
testb  $0x1,0xa0(%rsp)
01
je     1d05 <lm_lmdif+0xbc5>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     1db3 <lm_lmdif+0xc73>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    0x158(%rsp),%rdx
test   %rdx,%rdx
je     1d4b <lm_lmdif+0xc0b>
nop
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1d30 <lm_lmdif+0xbf0>
cmp    $0x3,%rcx
jb     1db3 <lm_lmdif+0xc73>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
mulsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
mulsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1d60 <lm_lmdif+0xc20>
mov    0x10(%rsp),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0xb8(%rsp)
movsd  0x108(%rsp),%xmm0
mulsd  %xmm0,%xmm1
ucomisd 0x2271(%rip),%xmm1
jne    1df3 <lm_lmdif+0xcb3>
jp     1df3 <lm_lmdif+0xcb3>
movapd %xmm0,0x50(%rsp)
jmp    1df9 <lm_lmdif+0xcb9>
movapd %xmm1,0x50(%rsp)
movsd  0x40(%rsp),%xmm8
mov    0x4(%rsp),%r8d
mov    0x18(%rsp),%r12
mov    0x288(%rsp),%rdi
mov    0x30(%rsp),%rbp
jmp    1f3f <lm_lmdif+0xdff>
xor    %eax,%eax
mov    0x20(%rsp),%rdx
movsd  0x40(%rsp),%xmm8
mov    0x4(%rsp),%r8d
mov    0x288(%rsp),%rdi
mov    0x30(%rsp),%rbp
testb  $0x1,0xa0(%rsp)
01
je     1e91 <lm_lmdif+0xd51>
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
movapd %xmm2,%xmm4
cmplepd %xmm0,%xmm4
movapd %xmm3,%xmm5
cmplepd %xmm1,%xmm5
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
andpd  %xmm5,%xmm1
andnpd %xmm3,%xmm5
orpd   %xmm1,%xmm5
movupd %xmm4,(%rdx,%rax,8)
movupd %xmm5,0x10(%rdx,%rax,8)
mov    0xb0(%rsp),%rax
mov    %rax,%rcx
cmp    %rsi,%rax
je     1f3a <lm_lmdif+0xdfa>
mov    %rcx,%rax
test   $0x1,%sil
je     1ed9 <lm_lmdif+0xd99>
movsd  (%rdx,%rcx,8),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movlpd %xmm2,(%rdx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf8(%rsp),%rcx
je     1f3a <lm_lmdif+0xdfa>
movsd  (%rbx,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
movsd  0x8(%rdx,%rax,8),%xmm2
movapd %xmm0,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm0,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,(%rdx,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
cmplesd %xmm2,%xmm1
andpd  %xmm1,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movlpd %xmm1,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1ee6 <lm_lmdif+0xda6>
mov    0x28(%rsp),%rbx
test   %r8d,%r8d
jle    20ab <lm_lmdif+0xf6b>
cmp    $0x4,%r8d
setb   %al
or     0xc(%rsp),%al
je     1f5c <lm_lmdif+0xe1c>
xor    %eax,%eax
jmp    203f <lm_lmdif+0xeff>
cmpq   $0xc,0x148(%rsp)
jae    1f6b <lm_lmdif+0xe2b>
xor    %eax,%eax
jmp    1fe4 <lm_lmdif+0xea4>
mov    0x130(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
movups 0x20(%r15,%rax,8),%xmm0
movups 0x30(%r15,%rax,8),%xmm1
movups %xmm0,0x20(%rdi,%rax,8)
movups %xmm1,0x30(%rdi,%rax,8)
movups 0x40(%r15,%rax,8),%xmm0
movups 0x50(%r15,%rax,8),%xmm1
movups %xmm0,0x40(%rdi,%rax,8)
movups %xmm1,0x50(%rdi,%rax,8)
movupd 0x60(%r15,%rax,8),%xmm0
movupd 0x70(%r15,%rax,8),%xmm1
movupd %xmm0,0x60(%rdi,%rax,8)
movupd %xmm1,0x70(%rdi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1f80 <lm_lmdif+0xe40>
cmpq   $0x0,0x198(%rsp)
je     202f <lm_lmdif+0xeef>
mov    0x140(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x138(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    2010 <lm_lmdif+0xed0>
mov    0x150(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     20ab <lm_lmdif+0xf6b>
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %rbx,%rbx
je     2065 <lm_lmdif+0xf25>
mov    %rbx,%rdx
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2050 <lm_lmdif+0xf10>
cmp    $0x3,%rcx
jb     20ab <lm_lmdif+0xf6b>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    2070 <lm_lmdif+0xf30>
mov    0xc0(%rsp),%rax
mov    0x1b8(%rsp),%r14
mov    %r12,%rdx
mov    %rdi,%rsi
mov    0x258(%rsp),%rdi
mov    %rdi,%r9
mov    %r8d,%ebx
xor    %r11d,%r11d
jmp    214a <lm_lmdif+0x100a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x270(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm0
mov    0x258(%rsp),%rdi
movsd  %xmm0,(%rdi,%r10,8)
mov    0x288(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm0
mov    0x268(%rsp),%rcx
movsd  %xmm0,(%rcx,%r11,8)
add    $0x1,%r11
add    0x120(%rsp),%r9
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%r14
add    0xc8(%rsp),%rax
mov    0x48(%rsp),%r10
cmp    %r10,%r11
mov    0x4(%rsp),%ebx
je     2421 <lm_lmdif+0x12e1>
mov    %r11d,%ecx
imul   %ebx,%ecx
movslq %ecx,%r10
add    %r11,%r10
movsd  (%rdi,%r10,8),%xmm1
ucomisd 0x1ef4(%rip),%xmm1
jne    216c <lm_lmdif+0x102c>
jnp    20e0 <lm_lmdif+0xfa0>
cmp    0x90(%rsp),%r11
jge    20e0 <lm_lmdif+0xfa0>
mov    %r14,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %r12,%rdi
sub    %r11,%rdi
mov    %rdi,0x70(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x100(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,0x180(%rsp)
mov    0x288(%rsp),%rbp
lea    0x0(,%r11,8),%rdi
add    %rbp,%rdi
mov    %rdi,0xd0(%rsp)
mov    0x120(%rsp),%r8
imul   %r11,%r8
mov    0x258(%rsp),%rdi
add    %rdi,%r8
mov    %r11,%r15
imul   0x90(%rsp),%r15
mov    %r15,%rbx
mov    %r15,0xe0(%rsp)
lea    (%r15,%r12,1),%rbp
lea    (%rdi,%rbp,8),%rdi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%r9,%rbp,8),%xmm2
mulsd  (%rsi,%rbp,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    2210 <lm_lmdif+0x10d0>
cmp    0x90(%rsp),%r11
mov    0x18(%rsp),%r12
jge    20e0 <lm_lmdif+0xfa0>
xorpd  0x1e2d(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %r11,%rbx
mov    0x70(%rsp),%r15
cmp    $0x4,%r15
jb     2383 <lm_lmdif+0x1243>
cmp    %rdi,0xd0(%rsp)
jae    2274 <lm_lmdif+0x1134>
mov    %r11,%rbx
cmp    0x168(%rsp),%r8
jb     2383 <lm_lmdif+0x1243>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x100(%rsp)
jae    2296 <lm_lmdif+0x1156>
xor    %ebp,%ebp
mov    0x180(%rsp),%r8
jmp    2313 <lm_lmdif+0x11d3>
xor    %ebp,%ebp
mov    0x180(%rsp),%r8
movupd (%r9,%rbp,8),%xmm2
movupd 0x10(%r9,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rsi,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rsi,%rbp,8),%xmm2
movupd 0x20(%rsi,%rbp,8),%xmm5
movupd 0x30(%rsi,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rsi,%rbp,8)
movupd %xmm3,0x10(%rsi,%rbp,8)
movupd 0x20(%r9,%rbp,8),%xmm2
movupd 0x30(%r9,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rsi,%rbp,8)
movupd %xmm3,0x30(%rsi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    22a0 <lm_lmdif+0x1160>
mov    %r15,%rbx
and    $0xfffffffffffffffc,%rbx
test   $0x1,%r8b
je     2372 <lm_lmdif+0x1232>
add    %r11,%rbp
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rbp,1),%r8
mov    0x258(%rsp),%rcx
movupd (%rcx,%r8,8),%xmm2
movupd 0x10(%rcx,%r8,8),%xmm3
mov    0x288(%rsp),%rcx
movupd (%rcx,%rbp,8),%xmm4
movupd 0x10(%rcx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rbp,8)
movupd %xmm3,0x10(%rcx,%rbp,8)
cmp    %rbx,%r15
mov    0x18(%rsp),%r12
je     20e0 <lm_lmdif+0xfa0>
add    %r11,%rbx
mov    %r12d,%ebp
sub    %ebx,%ebp
mov    %rbx,%rcx
test   $0x1,%bpl
je     23c3 <lm_lmdif+0x1283>
mov    0xe0(%rsp),%rdi
add    %rbx,%rdi
mov    0x258(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x288(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
lea    0x1(%rbx),%rcx
not    %rbx
cmp    0x170(%rsp),%rbx
mov    0x18(%rsp),%r12
je     20e0 <lm_lmdif+0xfa0>
nopl   0x0(%rax)
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x288(%rsp),%rbp
addsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    23e0 <lm_lmdif+0x12a0>
jmp    20e0 <lm_lmdif+0xfa0>
xorpd  %xmm5,%xmm5
mov    $0x1,%ebp
mov    %rdi,%r14
mov    0x1b0(%rsp),%rdx
xor    %esi,%esi
mov    0x248(%rsp),%r8
mov    0x20(%rsp),%r15
mov    0x278(%rsp),%rcx
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%r12
mov    %ebx,%r11d
jmp    24c9 <lm_lmdif+0x1389>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
divsd  %xmm0,%xmm1
divsd  0x80(%rsp),%xmm1
andpd  0x1bdb(%rip),%xmm1
movapd %xmm1,%xmm0
cmplesd %xmm5,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm5,%xmm0
orpd   %xmm2,%xmm0
movapd %xmm0,%xmm5
mov    0x278(%rsp),%rcx
add    $0x1,%rsi
add    $0x1,%rbp
mov    0xc8(%rsp),%rax
add    %rax,%rdx
add    %rax,%r14
cmp    %r10,%rsi
je     258c <lm_lmdif+0x144c>
movslq (%r12,%rsi,4),%rax
movsd  (%rcx,%rax,8),%xmm0
ucomisd 0x1b7e(%rip),%xmm0
jne    24de <lm_lmdif+0x139e>
jnp    24aa <lm_lmdif+0x136a>
cmp    $0x3,%rsi
jae    24ec <lm_lmdif+0x13ac>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    254b <lm_lmdif+0x140b>
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
xorpd  %xmm1,%xmm1
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x18(%rdx,%rdi,8),%xmm2
movsd  -0x10(%rdx,%rdi,8),%xmm3
mulsd  (%r9,%rdi,8),%xmm2
mulsd  0x8(%r9,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%rdx,%rdi,8),%xmm4
mulsd  0x10(%r9,%rdi,8),%xmm4
addsd  %xmm2,%xmm3
movsd  (%rdx,%rdi,8),%xmm1
mulsd  0x18(%r9,%rdi,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rdi
cmp    %rdi,%rax
jne    2500 <lm_lmdif+0x13c0>
test   $0x3,%bpl
je     2470 <lm_lmdif+0x1330>
mov    %ebp,%eax
and    $0x3,%eax
lea    (%r9,%rdi,8),%rbx
lea    (%r14,%rdi,8),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rcx,8),%xmm2
mulsd  (%rbx,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2570 <lm_lmdif+0x1430>
jmp    2470 <lm_lmdif+0x1330>
ucomisd %xmm5,%xmm8
movapd 0x50(%rsp),%xmm0
jae    3225 <lm_lmdif+0x20e5>
movsd  0x80(%rsp),%xmm1
mov    0x288(%rsp),%rbp
mov    %r15,%rax
movapd %xmm5,0x180(%rsp)
movsd  %xmm1,0x70(%rsp)
mov    0x10(%rsp),%rdi
cmp    $0x4,%edi
setb   %bl
sub    $0x8,%rsp
mov    0x260(%rsp),%rsi
mov    %r11d,%edx
mov    0x268(%rsp),%rcx
mov    %rax,%r8
movapd %xmm0,0x58(%rsp)
mov    $0x1,%al
push   %r13
push   %rbp
push   0x290(%rsp)
push   0x290(%rsp)
lea    0x90(%rsp),%rbp
push   %rbp
call   1050 <lm_lmpar@plt>
add    $0x30,%rsp
or     0xf(%rsp),%bl
je     2647 <lm_lmdif+0x1507>
xor    %eax,%eax
mov    0x38(%rsp),%rsi
mov    0x2a8(%rsp),%rbp
mov    0x298(%rsp),%r12
mov    0x278(%rsp),%r14
mov    0x48(%rsp),%rdx
mov    0x270(%rsp),%rdi
jmp    2741 <lm_lmdif+0x1601>
cmpq   $0x0,0xa8(%rsp)
je     2eba <lm_lmdif+0x1d7a>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
mov    0x38(%rsp),%rsi
mov    0x2a8(%rsp),%rbp
mov    0x298(%rsp),%r12
mov    0x278(%rsp),%r14
mov    0x270(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm0
movupd 0x30(%rsi,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x30(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2690 <lm_lmdif+0x1550>
testb  $0x1,0xa0(%rsp)
01
je     2728 <lm_lmdif+0x15e8>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rdi,%rax,8),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
mov    0x48(%rsp),%rdx
cmp    %rdx,%rcx
je     27e2 <lm_lmdif+0x16a2>
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
test   $0x3,%dl
je     277a <lm_lmdif+0x163a>
mov    0x158(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
subsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2760 <lm_lmdif+0x1620>
cmp    $0x3,%rcx
mov    0x48(%rsp),%rcx
jb     27e2 <lm_lmdif+0x16a2>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rax,8),%xmm0
subsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
subsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
subsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
subsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    2790 <lm_lmdif+0x1650>
mov    0x10(%rsp),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
cvtsi2sd %eax,%xmm3
mov    0x250(%rsp),%rax
mov    0x128(%rsp),%ecx
cmp    %ecx,(%rax)
movapd %xmm3,0xd0(%rsp)
jg     2836 <lm_lmdif+0x16f6>
movapd 0x50(%rsp),%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm3,%xmm0
movapd %xmm0,%xmm1
andnpd %xmm3,%xmm1
andpd  %xmm2,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm0,0x50(%rsp)
mov    0x248(%rsp),%r8
mov    0x4(%rsp),%esi
mov    0x288(%rsp),%rcx
movl   $0x0,(%r8)
mov    %r14,%rdi
mov    %rbp,%rdx
mov    %esi,%ebx
mov    %rcx,%r15
call   *0x290(%rsp)
mov    0x250(%rsp),%rcx
mov    (%rcx),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
test   %r12,%r12
je     28a4 <lm_lmdif+0x1764>
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    %r14,%rsi
mov    %ebx,%edx
mov    %rbp,%rcx
mov    %r15,%r8
mov    0x2a8(%rsp),%r9d
push   %rax
push   0x98(%rsp)
push   $0x2
call   *%r12
add    $0x20,%rsp
mov    0x248(%rsp),%rax
cmpl   $0x0,(%rax)
js     322e <lm_lmdif+0x20ee>
mov    %ebx,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x80(%rsp)
movapd %xmm0,%xmm2
movsd  0x172b(%rip),%xmm0
mulsd  %xmm0,%xmm2
movsd  0x70(%rsp),%xmm1
movsd  %xmm2,0x100(%rsp)
ucomisd %xmm2,%xmm1
movsd  0x1714(%rip),%xmm5
jbe    291b <lm_lmdif+0x17db>
movsd  0x80(%rsp),%xmm0
divsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm0
movsd  0x1701(%rip),%xmm5
subsd  %xmm0,%xmm5
mov    $0x1,%esi
mov    0xc0(%rsp),%rcx
mov    0x160(%rsp),%rdx
xor    %r8d,%r8d
mov    0x48(%rsp),%r15
mov    0x270(%rsp),%r11
mov    0x260(%rsp),%r12
mov    0x258(%rsp),%r14
jmp    297b <lm_lmdif+0x183b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
mov    0xc8(%rsp),%rax
add    %rax,%rdx
add    %rax,%rcx
cmp    %r15,%r8
je     2b45 <lm_lmdif+0x1a05>
mov    %r8,%r10
add    $0x1,%r8
movq   $0x0,0x0(%r13,%r10,8)
mov    %r10,%r9
imul   0x90(%rsp),%r9
movslq (%r12,%r10,4),%rax
lea    (%r11,%rax,8),%rdi
cmp    $0x3,%r10
jae    29b0 <lm_lmdif+0x1870>
xor    %ebx,%ebx
jmp    2ac0 <lm_lmdif+0x1980>
nopl   0x0(%rax)
mov    %r15,%r12
lea    0x8(,%r10,8),%r15
add    %r13,%r15
mov    0x120(%rsp),%rbx
imul   %r10,%rbx
add    0xc0(%rsp),%rbx
lea    (%r14,%r9,8),%r11
mov    0x1e8(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %r13,%rbx
seta   %r14b
cmp    %r15,%r11
setb   %bl
cmp    %r13,%rax
seta   %al
cmp    %r15,%rdi
setb   %r11b
test   %bl,%r14b
jne    2a9b <lm_lmdif+0x195b>
mov    $0x0,%ebx
and    %r11b,%al
mov    0x270(%rsp),%r11
mov    0x258(%rsp),%r14
mov    %r12,%r15
mov    0x260(%rsp),%r12
jne    2ac0 <lm_lmdif+0x1980>
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
mov    %r8,%rbx
and    $0xfffffffffffffffc,%rbx
movsd  (%rdi),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ebp,%ebp
nopl   (%rax)
movupd -0x10(%rdx,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
movupd 0x0(%r13,%rbp,8),%xmm3
movupd 0x10(%r13,%rbp,8),%xmm4
mulpd  %xmm0,%xmm1
subpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm4
movupd %xmm3,0x0(%r13,%rbp,8)
movupd %xmm4,0x10(%r13,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rax
jne    2a50 <lm_lmdif+0x1910>
cmp    %rbx,%r8
je     2960 <lm_lmdif+0x1820>
jmp    2ac0 <lm_lmdif+0x1980>
xor    %ebx,%ebx
mov    0x270(%rsp),%r11
mov    0x258(%rsp),%r14
mov    %r12,%r15
mov    0x260(%rsp),%r12
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rbp
test   $0x1,%sil
je     2aef <lm_lmdif+0x19af>
add    %rbx,%r9
movsd  (%r14,%r9,8),%xmm0
mulsd  (%rdi),%xmm0
movsd  0x0(%r13,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
mov    %rbx,%rbp
or     $0x1,%rbp
cmp    %rbx,%r10
je     2960 <lm_lmdif+0x1820>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbp,8),%xmm0
mulsd  (%rdi),%xmm0
movsd  0x0(%r13,%rbp,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%r13,%rbp,8),%xmm0
movsd  %xmm1,0x0(%r13,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  (%rdi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    2b00 <lm_lmdif+0x19c0>
jmp    2960 <lm_lmdif+0x1820>
movapd %xmm5,0xe0(%rsp)
mov    0x10(%rsp),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
mov    %eax,%ebx
movsd  0x68(%rsp),%xmm0
ucomisd 0x14eb(%rip),%xmm0
jb     2b75 <lm_lmdif+0x1a35>
sqrtsd %xmm0,%xmm0
jmp    2b7a <lm_lmdif+0x1a3a>
call   1060 <sqrt@plt>
mov    0x248(%rsp),%r8
mov    0x20(%rsp),%rdx
mov    0x38(%rsp),%rdi
mov    0x278(%rsp),%rsi
movsd  0x1464(%rip),%xmm4
movapd 0xe0(%rsp),%xmm5
movsd  0x70(%rsp),%xmm9
movapd 0xd0(%rsp),%xmm6
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd  %xmm9,%xmm1
mulsd  %xmm6,%xmm0
divsd  %xmm9,%xmm0
movapd %xmm0,%xmm7
addsd  %xmm0,%xmm7
mulsd  %xmm0,%xmm7
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm7
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm7
jne    2bec <lm_lmdif+0x1aac>
jnp    2bf6 <lm_lmdif+0x1ab6>
movapd %xmm5,%xmm8
divsd  %xmm7,%xmm8
movsd  0x1422(%rip),%xmm2
ucomisd %xmm8,%xmm2
jae    2c53 <lm_lmdif+0x1b13>
movsd  0x68(%rsp),%xmm0
ucomisd 0x1445(%rip),%xmm0
jne    2c17 <lm_lmdif+0x1ad7>
jnp    2c22 <lm_lmdif+0x1ae2>
ucomisd 0x1420(%rip),%xmm8
jb     2c3a <lm_lmdif+0x1afa>
addsd  %xmm6,%xmm6
mulsd  0x13fa(%rip),%xmm0
movsd  %xmm0,0x68(%rsp)
movapd %xmm6,0x50(%rsp)
ucomisd 0x1405(%rip),%xmm8
jae    2d14 <lm_lmdif+0x1bd4>
movapd %xmm9,%xmm1
jmp    30e1 <lm_lmdif+0x1fa1>
ucomisd 0x13fd(%rip),%xmm5
movsd  0x13c5(%rip),%xmm2
jae    2c99 <lm_lmdif+0x1b59>
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
xorpd  0x13f7(%rip),%xmm0
mulsd  0x13af(%rip),%xmm1
movapd %xmm5,%xmm2
mulsd  0x13ab(%rip),%xmm2
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
movsd  0x1367(%rip),%xmm3
movapd %xmm3,%xmm0
maxsd  %xmm2,%xmm0
movapd %xmm9,%xmm1
cmplesd 0x100(%rsp),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
andpd  %xmm3,%xmm1
orpd   %xmm2,%xmm1
divsd  %xmm3,%xmm6
movapd 0x50(%rsp),%xmm3
movapd %xmm3,%xmm0
cmplesd %xmm6,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm6,%xmm2
andpd  %xmm3,%xmm0
orpd   %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x68(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x68(%rsp)
movapd %xmm0,0x50(%rsp)
ucomisd 0x133a(%rip),%xmm8
jb     2c49 <lm_lmdif+0x1b09>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0xe(%rsp),%al
mov    0x4(%rsp),%ebp
mov    0x288(%rsp),%rbx
je     2d35 <lm_lmdif+0x1bf5>
xor    %ecx,%ecx
jmp    2e14 <lm_lmdif+0x1cd4>
cmpq   $0x0,0xa8(%rsp)
je     2f10 <lm_lmdif+0x1dd0>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
xchg   %ax,%ax
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm0
movupd 0x30(%rsi,%rax,8),%xmm1
movupd %xmm0,0x20(%rdi,%rax,8)
movupd %xmm1,0x30(%rdi,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm2
movupd 0x30(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rsi,%rax,8)
movupd %xmm3,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2d50 <lm_lmdif+0x1c10>
testb  $0x1,0xa0(%rsp)
01
je     2e04 <lm_lmdif+0x1cc4>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
mov    0xb0(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
je     2e85 <lm_lmdif+0x1d45>
mov    %rcx,%rax
test   $0x1,%r15b
je     2e38 <lm_lmdif+0x1cf8>
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
mulsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf8(%rsp),%rcx
je     2e85 <lm_lmdif+0x1d45>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mulsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    2e50 <lm_lmdif+0x1d10>
movsd  %xmm7,0xd0(%rsp)
movapd %xmm8,0x70(%rsp)
test   %ebp,%ebp
mov    0x60(%rsp),%r15
jle    307b <lm_lmdif+0x1f3b>
cmp    $0x4,%ebp
setb   %al
or     0xc(%rsp),%al
je     2ef4 <lm_lmdif+0x1db4>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
jmp    2fff <lm_lmdif+0x1ebf>
xor    %eax,%eax
mov    0x38(%rsp),%rsi
mov    0x2a8(%rsp),%rbp
mov    0x298(%rsp),%r12
mov    0x278(%rsp),%r14
mov    0x270(%rsp),%rdi
testb  $0x1,0xa0(%rsp)
01
jne    26fd <lm_lmdif+0x15bd>
jmp    2728 <lm_lmdif+0x15e8>
cmpq   $0xc,0x148(%rsp)
jae    2f25 <lm_lmdif+0x1de5>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rbp
jmp    2fa4 <lm_lmdif+0x1e64>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    2dd0 <lm_lmdif+0x1c90>
jmp    2e04 <lm_lmdif+0x1cc4>
mov    0x130(%rsp),%rcx
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rbp
nopl   0x0(%rax)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
movups 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movups %xmm0,0x20(%r15,%rax,8)
movups %xmm1,0x30(%r15,%rax,8)
movups 0x40(%rbx,%rax,8),%xmm0
movups 0x50(%rbx,%rax,8),%xmm1
movups %xmm0,0x40(%r15,%rax,8)
movups %xmm1,0x50(%r15,%rax,8)
movupd 0x60(%rbx,%rax,8),%xmm0
movupd 0x70(%rbx,%rax,8),%xmm1
movupd %xmm0,0x60(%r15,%rax,8)
movupd %xmm1,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    2f40 <lm_lmdif+0x1e00>
testb  $0x3,0x1a8(%rsp)
03
je     2fef <lm_lmdif+0x1eaf>
mov    0x138(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x140(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    2fd0 <lm_lmdif+0x1e90>
mov    0x150(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     307b <lm_lmdif+0x1f3b>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   $0x3,%dil
je     3035 <lm_lmdif+0x1ef5>
mov    0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    3020 <lm_lmdif+0x1ee0>
cmp    $0x3,%rcx
mov    0x18(%rsp),%rcx
jb     307b <lm_lmdif+0x1f3b>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    3040 <lm_lmdif+0x1f00>
mov    0x10(%rsp),%rdi
xor    %eax,%eax
call   1040 <lm_enorm@plt>
mov    0x38(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    0x88(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x88(%rsp)
mov    0x248(%rsp),%r8
movsd  0xf41(%rip),%xmm4
movsd  0x80(%rsp),%xmm1
movapd 0xe0(%rsp),%xmm5
movapd 0x70(%rsp),%xmm8
movsd  0xd0(%rsp),%xmm7
movsd  0xf67(%rip),%xmm0
ucomisd %xmm1,%xmm0
jae    31f4 <lm_lmdif+0x20b4>
movapd %xmm1,%xmm2
andpd  0xf61(%rip),%xmm5
movsd  0x178(%rsp),%xmm0
ucomisd %xmm5,%xmm0
setb   %al
ucomisd %xmm7,%xmm0
setb   %cl
or     %al,%cl
movapd %xmm8,%xmm0
mulsd  0xf03(%rip),%xmm0
movsd  0xeeb(%rip),%xmm1
ucomisd %xmm0,%xmm1
setb   %al
or     %cl,%al
mov    %eax,%ecx
xor    $0x1,%cl
movzbl %cl,%ecx
mov    %ecx,(%r8)
movsd  0xb8(%rsp),%xmm1
mulsd  0x110(%rsp),%xmm1
ucomisd 0x50(%rsp),%xmm1
jae    31f9 <lm_lmdif+0x20b9>
test   %al,%al
mov    0x4(%rsp),%r11d
mov    0x288(%rsp),%rbp
je     322e <lm_lmdif+0x20ee>
mov    0x12c(%rsp),%eax
mov    0x250(%rsp),%rcx
cmp    %eax,(%rcx)
jge    3203 <lm_lmdif+0x20c3>
ucomisd %xmm5,%xmm4
jb     31a1 <lm_lmdif+0x2061>
ucomisd %xmm7,%xmm4
jb     31a1 <lm_lmdif+0x2061>
movsd  0xe7d(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    320b <lm_lmdif+0x20cb>
movsd  0xb8(%rsp),%xmm0
mulsd  %xmm4,%xmm0
ucomisd 0x50(%rsp),%xmm0
movapd 0x180(%rsp),%xmm5
jae    3213 <lm_lmdif+0x20d3>
ucomisd %xmm5,%xmm4
jae    3213 <lm_lmdif+0x20d3>
movsd  0xe7b(%rip),%xmm0
ucomisd %xmm8,%xmm0
movapd %xmm2,%xmm1
mov    0x20(%rsp),%rax
mov    0x268(%rsp),%r9
movapd 0x50(%rsp),%xmm0
ja     25ba <lm_lmdif+0x147a>
jmp    164b <lm_lmdif+0x50b>
xor    %r14d,%r14d
jmp    322b <lm_lmdif+0x20eb>
movzbl %al,%r14d
xor    $0x3,%r14d
jmp    322b <lm_lmdif+0x20eb>
mov    $0x5,%r14d
jmp    322b <lm_lmdif+0x20eb>
mov    $0x6,%r14d
jmp    322b <lm_lmdif+0x20eb>
ucomisd 0x50(%rsp),%xmm0
mov    $0x8,%r14d
adc    $0xffffffff,%r14d
jmp    322b <lm_lmdif+0x20eb>
mov    $0x4,%r14d
mov    %r14d,(%r8)
add    $0x208,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @lm_lmdif(i32 %0, i32 %1, double* %2, double* %3, double %4, double %5, double %6, i32 %7, double %8, double* %9, i32 %10, double %11, i32* %12, i32* nocapture %13, double* %14, i32* %15, double* %16, double* %17, double* %18, double* %19, double* %20, void (double*, i32, i8*, double*, i32*)* nocapture %21, void (i32, double*, i32, i8*, double*, i32, i32, i32, i32)* %22, i32 %23, i8* %24) {
%26 = bitcast double* %19 to i8*
%27 = bitcast double* %14 to i8*
%28 = alloca double
%29 = bitcast double* %28 to i8*
store i32 0, i32* %13
store double 0.000000e+00, double* %28
%30 = fcmp oge double %8, 1.200000e-16
%31 = select i1 %30, double %8, double 1.200000e-16
%32 = tail call double @sqrt(double %31)
%33 = icmp slt i32 %1, 1
br i1 %33, label %1549, label %34
34: ; preds = %25
%35 = icmp slt i32 %0, %1
%36 = fcmp olt double %4, 0.000000e+00
%37 = or i1 %35, %36
%38 = fcmp olt double %5, 0.000000e+00
%39 = or i1 %37, %38
%40 = fcmp olt double %6, 0.000000e+00
%41 = or i1 %39, %40
%42 = icmp slt i32 %7, 1
%43 = or i1 %41, %42
%44 = fcmp ole double %11, 0.000000e+00
%45 = or i1 %43, %44
br i1 %45, label %1549, label %46
46: ; preds = %34
%47 = icmp eq i32 %10, 2
br i1 %47, label %48, label %58
48: ; preds = %46
%49 = zext i32 %1 to i64
br label %52
50: ; preds = %52
%51 = icmp eq i64 %57, %49
br i1 %51, label %58, label %52
52: ; preds = %48, %50
%53 = phi i64 [ 0, %48 ], [ %57, %50 ]
%54 = getelementptr inbounds double, double* %9, i64 %53
%55 = load double, double* %54
%56 = fcmp ugt double %55, 0.000000e+00
%57 = add nuw nsw i64 %53, 1
br i1 %56, label %50, label %1549
58: ; preds = %50, %46
store i32 0, i32* %12
tail call void %21(double* %2, i32 %0, i8* %24, double* %3, i32* %12)
%59 = load i32, i32* %13
%60 = add nsw i32 %59, 1
store i32 %60, i32* %13
%61 = icmp eq void (i32, double*, i32, i8*, double*, i32, i32, i32, i32)* %22, null
br i1 %61, label %63, label %62
62: ; preds = %58
tail call void %22(i32 %1, double* %2, i32 %0, i8* %24, double* %3, i32 %23, i32 0, i32 0, i32 %60)
br label %63
63: ; preds = %62, %58
%64 = load i32, i32* %12
%65 = icmp slt i32 %64, 0
br i1 %65, label %1551, label %66
66: ; preds = %63
%67 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %3)
%68 = icmp slt i32 %67, 1
br i1 %68, label %1549, label %69
69: ; preds = %66
%70 = sitofp i32 %67 to double
%71 = fmul double %32, %32
%72 = icmp sgt i32 %0, 0
%73 = add nsw i32 %1, 1
%74 = sext i32 %0 to i64
%75 = zext i32 %1 to i64
%76 = zext i32 %0 to i64
%77 = zext i32 %1 to i64
%78 = zext i32 %1 to i64
%79 = zext i32 %1 to i64
%80 = zext i32 %0 to i64
%81 = zext i32 %1 to i64
%82 = zext i32 %0 to i64
%83 = zext i32 %0 to i64
%84 = zext i32 %1 to i64
%85 = zext i32 %1 to i64
%86 = zext i32 %1 to i64
%87 = zext i32 %1 to i64
%88 = zext i32 %0 to i64
%89 = getelementptr double, double* %3, i64 %76
%90 = getelementptr double, double* %20, i64 %76
%91 = getelementptr double, double* %2, i64 %75
%92 = getelementptr double, double* %18, i64 %75
%93 = getelementptr double, double* %9, i64 %75
%94 = getelementptr double, double* %14, i64 1
%95 = bitcast double* %94 to i8*
%96 = shl nsw i64 %74, 3
%97 = add nsw i64 %96, 8
%98 = getelementptr double, double* %17, i64 1
%99 = getelementptr double, double* %18, i64 %75
%100 = getelementptr double, double* %2, i64 %75
%101 = getelementptr double, double* %17, i64 %75
%102 = getelementptr double, double* %20, i64 %76
%103 = bitcast double* %102 to i8*
%104 = shl nsw i64 %74, 3
%105 = add nsw i64 %104, 8
%106 = getelementptr double, double* %20, i64 %76
%107 = getelementptr double, double* %3, i64 %76
%108 = getelementptr double, double* %19, i64 %75
%109 = getelementptr double, double* %9, i64 %75
%110 = getelementptr double, double* %2, i64 %75
%111 = getelementptr double, double* %9, i64 %75
%112 = getelementptr double, double* %18, i64 %75
%113 = getelementptr double, double* %9, i64 %75
%114 = getelementptr double, double* %18, i64 %75
%115 = getelementptr double, double* %20, i64 %76
%116 = getelementptr double, double* %3, i64 %76
%117 = and i64 %76, 4294967294
%118 = add nsw i64 %117, -2
%119 = lshr exact i64 %118, 1
%120 = add nuw i64 %119, 1
%121 = and i64 %86, 4294967292
%122 = add nsw i64 %121, -4
%123 = lshr exact i64 %122, 2
%124 = add nuw nsw i64 %123, 1
%125 = and i64 %76, 4294967292
%126 = add nsw i64 %125, -4
%127 = lshr exact i64 %126, 2
%128 = add nuw nsw i64 %127, 1
%129 = icmp eq i32 %0, 1
%130 = and i64 %76, 4294967294
%131 = and i64 %120, 1
%132 = icmp eq i64 %118, 0
%133 = and i64 %120, -2
%134 = icmp eq i64 %131, 0
%135 = icmp eq i64 %130, %76
%136 = and i64 %76, 1
%137 = icmp eq i64 %136, 0
%138 = sub nsw i64 0, %76
%139 = icmp ult i32 %1, 4
%140 = icmp ugt double* %114, %9
%141 = icmp ugt double* %113, %18
%142 = and i1 %140, %141
%143 = and i64 %75, 4294967292
%144 = and i64 %124, 1
%145 = icmp eq i64 %122, 0
%146 = and i64 %124, 9223372036854775806
%147 = icmp eq i64 %144, 0
%148 = icmp eq i64 %143, %75
%149 = and i64 %86, 1
%150 = icmp eq i64 %149, 0
%151 = sub nsw i64 0, %86
%152 = icmp ult i32 %1, 2
%153 = icmp ugt double* %112, %9
%154 = icmp ugt double* %111, %18
%155 = and i1 %153, %154
%156 = and i64 %75, 4294967294
%157 = icmp eq i64 %156, %75
%158 = and i64 %86, 1
%159 = icmp eq i64 %158, 0
%160 = sub nsw i64 0, %86
%161 = icmp ult i32 %1, 4
%162 = icmp ugt double* %109, %19
%163 = icmp ugt double* %108, %9
%164 = and i1 %162, %163
%165 = icmp ugt double* %110, %19
%166 = icmp ugt double* %108, %2
%167 = and i1 %165, %166
%168 = or i1 %164, %167
%169 = and i64 %75, 4294967292
%170 = and i64 %124, 1
%171 = icmp eq i64 %122, 0
%172 = and i64 %124, 9223372036854775806
%173 = icmp eq i64 %170, 0
%174 = icmp eq i64 %169, %75
%175 = and i64 %86, 3
%176 = icmp eq i64 %175, 0
%177 = icmp ult i32 %0, 4
%178 = icmp ugt double* %107, %20
%179 = icmp ugt double* %106, %3
%180 = and i1 %178, %179
%181 = and i64 %76, 4294967292
%182 = and i64 %128, 3
%183 = icmp ult i64 %126, 12
%184 = and i64 %128, 9223372036854775804
%185 = icmp eq i64 %182, 0
%186 = icmp eq i64 %181, %76
%187 = and i64 %76, 3
%188 = icmp eq i64 %187, 0
%189 = sub nsw i64 0, %76
%190 = icmp ult i32 %1, 4
%191 = icmp ugt double* %100, %18
%192 = icmp ugt double* %99, %2
%193 = and i1 %191, %192
%194 = icmp ugt double* %101, %18
%195 = icmp ugt double* %99, %17
%196 = and i1 %194, %195
%197 = or i1 %193, %196
%198 = and i64 %75, 4294967292
%199 = and i64 %124, 1
%200 = icmp eq i64 %122, 0
%201 = and i64 %124, 9223372036854775806
%202 = icmp eq i64 %199, 0
%203 = icmp eq i64 %198, %75
%204 = and i64 %86, 3
%205 = icmp eq i64 %204, 0
%206 = icmp ult i32 %1, 4
%207 = icmp ugt double* %92, %2
%208 = icmp ugt double* %91, %18
%209 = and i1 %207, %208
%210 = icmp ugt double* %93, %2
%211 = icmp ugt double* %91, %9
%212 = and i1 %210, %211
%213 = or i1 %209, %212
%214 = icmp ugt double* %93, %18
%215 = icmp ugt double* %92, %9
%216 = and i1 %214, %215
%217 = or i1 %213, %216
%218 = and i64 %75, 4294967292
%219 = and i64 %124, 1
%220 = icmp eq i64 %122, 0
%221 = and i64 %124, 9223372036854775806
%222 = icmp eq i64 %219, 0
%223 = icmp eq i64 %218, %75
%224 = and i64 %86, 1
%225 = icmp eq i64 %224, 0
%226 = sub nsw i64 0, %86
%227 = icmp ult i32 %0, 4
%228 = icmp ugt double* %90, %3
%229 = icmp ugt double* %89, %20
%230 = and i1 %228, %229
%231 = and i64 %76, 4294967292
%232 = and i64 %128, 3
%233 = icmp ult i64 %126, 12
%234 = and i64 %128, 9223372036854775804
%235 = icmp eq i64 %232, 0
%236 = icmp eq i64 %231, %76
%237 = and i64 %76, 3
%238 = icmp eq i64 %237, 0
br label %239
239: ; preds = %1545, %69
%240 = phi double [ %70, %69 ], [ %1514, %1545 ]
%241 = phi double [ 0.000000e+00, %69 ], [ %1295, %1545 ]
%242 = phi i32 [ 0, %69 ], [ %1515, %1545 ]
%243 = phi double [ 0.000000e+00, %69 ], [ %1516, %1545 ]
br label %244
244: ; preds = %239, %358
%245 = phi i64 [ 0, %239 ], [ %359, %358 ]
%246 = mul i64 %245, %74
%247 = getelementptr double, double* %14, i64 %246
%248 = add i64 %246, %76
%249 = getelementptr double, double* %14, i64 %248
%250 = getelementptr inbounds double, double* %2, i64 %245
%251 = load double, double* %250
%252 = call double @llvm.fabs.f64(double %251)
%253 = fmul double %32, %252
%254 = fcmp oge double %71, %253
%255 = select i1 %254, double %71, double %253
%256 = fadd double %251, %255
store double %256, double* %250
store i32 0, i32* %12
%257 = load i32, i32* %13
%258 = add nsw i32 %257, 1
store i32 %258, i32* %13
br i1 %61, label %260, label %259
259: ; preds = %244
br label %260
260: ; preds = %259, %244
%261 = load i32, i32* %12
%262 = icmp slt i32 %261, 0
br i1 %262, label %1551, label %263
263: ; preds = %260
br i1 %72, label %264, label %358
264: ; preds = %263
%265 = mul nsw i64 %245, %74
br i1 %129, label %321, label %266
266: ; preds = %264
%267 = icmp ult double* %247, %115
%268 = icmp ugt double* %249, %20
%269 = and i1 %267, %268
%270 = icmp ult double* %247, %116
%271 = icmp ugt double* %249, %3
%272 = and i1 %270, %271
%273 = or i1 %269, %272
br i1 %273, label %321, label %274
274: ; preds = %266
%275 = insertelement <2 x double> poison, double %255, i64 0
%276 = shufflevector <2 x double> %275, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %132, label %306, label %277
277: ; preds = %274, %277
%278 = phi i64 [ %303, %277 ], [ 0, %274 ]
%279 = phi i64 [ %304, %277 ], [ 0, %274 ]
%280 = getelementptr inbounds double, double* %20, i64 %278
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr inbounds double, double* %3, i64 %278
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = fsub <2 x double> %282, %285
%287 = fdiv <2 x double> %286, %276
%288 = add nsw i64 %278, %265
%289 = getelementptr inbounds double, double* %14, i64 %288
%290 = bitcast double* %289 to <2 x double>*
store <2 x double> %287, <2 x double>* %290
%291 = or i64 %278, 2
%292 = getelementptr inbounds double, double* %20, i64 %291
%293 = bitcast double* %292 to <2 x double>*
%294 = load <2 x double>, <2 x double>* %293
%295 = getelementptr inbounds double, double* %3, i64 %291
%296 = bitcast double* %295 to <2 x double>*
%297 = load <2 x double>, <2 x double>* %296
%298 = fsub <2 x double> %294, %297
%299 = fdiv <2 x double> %298, %276
%300 = add nsw i64 %291, %265
%301 = getelementptr inbounds double, double* %14, i64 %300
%302 = bitcast double* %301 to <2 x double>*
store <2 x double> %299, <2 x double>* %302
%303 = add nuw i64 %278, 4
%304 = add nuw i64 %279, 2
%305 = icmp eq i64 %304, %133
br i1 %305, label %306, label %277
306: ; preds = %277, %274
%307 = phi i64 [ 0, %274 ], [ %303, %277 ]
br i1 %134, label %320, label %308
308: ; preds = %306
%309 = getelementptr inbounds double, double* %20, i64 %307
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = getelementptr inbounds double, double* %3, i64 %307
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = fsub <2 x double> %311, %314
%316 = fdiv <2 x double> %315, %276
%317 = add nsw i64 %307, %265
%318 = getelementptr inbounds double, double* %14, i64 %317
%319 = bitcast double* %318 to <2 x double>*
store <2 x double> %316, <2 x double>* %319
br label %320
320: ; preds = %306, %308
br i1 %135, label %358, label %321
321: ; preds = %266, %264, %320
%322 = phi i64 [ 0, %266 ], [ 0, %264 ], [ %130, %320 ]
%323 = xor i64 %322, -1
br i1 %137, label %334, label %324
324: ; preds = %321
%325 = getelementptr inbounds double, double* %20, i64 %322
%326 = load double, double* %325
%327 = getelementptr inbounds double, double* %3, i64 %322
%328 = load double, double* %327
%329 = fsub double %326, %328
%330 = fdiv double %329, %255
%331 = add nsw i64 %322, %265
%332 = getelementptr inbounds double, double* %14, i64 %331
store double %330, double* %332
%333 = or i64 %322, 1
br label %334
334: ; preds = %324, %321
%335 = phi i64 [ %322, %321 ], [ %333, %324 ]
%336 = icmp eq i64 %323, %138
br i1 %336, label %358, label %337
337: ; preds = %334, %337
%338 = phi i64 [ %356, %337 ], [ %335, %334 ]
%339 = getelementptr inbounds double, double* %20, i64 %338
%340 = load double, double* %339
%341 = getelementptr inbounds double, double* %3, i64 %338
%342 = load double, double* %341
%343 = fsub double %340, %342
%344 = fdiv double %343, %255
%345 = add nsw i64 %338, %265
%346 = getelementptr inbounds double, double* %14, i64 %345
store double %344, double* %346
%347 = add nuw nsw i64 %338, 1
%348 = getelementptr inbounds double, double* %20, i64 %347
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %3, i64 %347
%351 = load double, double* %350
%352 = fsub double %349, %351
%353 = fdiv double %352, %255
%354 = add nsw i64 %347, %265
%355 = getelementptr inbounds double, double* %14, i64 %354
store double %353, double* %355
%356 = add nuw nsw i64 %338, 2
%357 = icmp eq i64 %356, %76
br i1 %357, label %358, label %337
358: ; preds = %334, %337, %320, %263
store double %251, double* %250
%359 = add nuw nsw i64 %245, 1
%360 = icmp eq i64 %359, %75
br i1 %360, label %361, label %244
361: ; preds = %358
%362 = call i32 (i32, i32, double*, i32, i32*, double*, double*, double*, ...) bitcast (i32 (...)* @lm_qrfac to i32 (i32, i32, double*, i32, i32*, double*, double*, double*, ...)*)(i32 %0, i32 %1, double* %14, i32 1, i32* %15, double* %17, double* %18, double* %19)
%363 = icmp eq i32 %242, 0
br i1 %363, label %364, label %545
364: ; preds = %361
br i1 %47, label %421, label %365
365: ; preds = %364
%366 = or i1 %152, %155
br i1 %366, label %387, label %367
367: ; preds = %365, %383
%368 = phi i64 [ %384, %383 ], [ 0, %365 ]
%369 = getelementptr inbounds double, double* %18, i64 %368
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = getelementptr inbounds double, double* %9, i64 %368
%373 = bitcast double* %372 to <2 x double>*
store <2 x double> %371, <2 x double>* %373
%374 = fcmp oeq <2 x double> %371, zeroinitializer
%375 = extractelement <2 x i1> %374, i64 0
br i1 %375, label %376, label %378
376: ; preds = %367
%377 = getelementptr inbounds double, double* %9, i64 %368
store double 1.000000e+00, double* %377
br label %378
378: ; preds = %376, %367
%379 = extractelement <2 x i1> %374, i64 1
br i1 %379, label %380, label %383
380: ; preds = %378
%381 = or i64 %368, 1
%382 = getelementptr inbounds double, double* %9, i64 %381
store double 1.000000e+00, double* %382
br label %383
383: ; preds = %380, %378
%384 = add nuw i64 %368, 2
%385 = icmp eq i64 %384, %156
br i1 %385, label %386, label %367
386: ; preds = %383
br i1 %157, label %421, label %387
387: ; preds = %365, %386
%388 = phi i64 [ 0, %365 ], [ %156, %386 ]
%389 = xor i64 %388, -1
br i1 %159, label %399, label %390
390: ; preds = %387
%391 = getelementptr inbounds double, double* %18, i64 %388
%392 = load double, double* %391
%393 = getelementptr inbounds double, double* %9, i64 %388
store double %392, double* %393
%394 = load double, double* %391
%395 = fcmp oeq double %394, 0.000000e+00
br i1 %395, label %396, label %397
396: ; preds = %390
store double 1.000000e+00, double* %393
br label %397
397: ; preds = %396, %390
%398 = or i64 %388, 1
br label %399
399: ; preds = %397, %387
%400 = phi i64 [ %388, %387 ], [ %398, %397 ]
%401 = icmp eq i64 %389, %160
br i1 %401, label %421, label %402
402: ; preds = %399, %418
%403 = phi i64 [ %419, %418 ], [ %400, %399 ]
%404 = getelementptr inbounds double, double* %18, i64 %403
%405 = load double, double* %404
%406 = getelementptr inbounds double, double* %9, i64 %403
store double %405, double* %406
%407 = load double, double* %404
%408 = fcmp oeq double %407, 0.000000e+00
br i1 %408, label %409, label %410
409: ; preds = %402
store double 1.000000e+00, double* %406
br label %410
410: ; preds = %402, %409
%411 = add nuw nsw i64 %403, 1
%412 = getelementptr inbounds double, double* %18, i64 %411
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %9, i64 %411
store double %413, double* %414
%415 = load double, double* %412
%416 = fcmp oeq double %415, 0.000000e+00
br i1 %416, label %417, label %418
417: ; preds = %410
store double 1.000000e+00, double* %414
br label %418
418: ; preds = %417, %410
%419 = add nuw nsw i64 %403, 2
%420 = icmp eq i64 %419, %78
br i1 %420, label %421, label %402
421: ; preds = %399, %418, %386, %364
%422 = or i1 %161, %168
br i1 %422, label %489, label %423
423: ; preds = %421
br i1 %171, label %467, label %424
424: ; preds = %423, %424
%425 = phi i64 [ %464, %424 ], [ 0, %423 ]
%426 = phi i64 [ %465, %424 ], [ 0, %423 ]
%427 = getelementptr inbounds double, double* %9, i64 %425
%428 = bitcast double* %427 to <2 x double>*
%429 = load <2 x double>, <2 x double>* %428
%430 = getelementptr inbounds double, double* %427, i64 2
%431 = bitcast double* %430 to <2 x double>*
%432 = load <2 x double>, <2 x double>* %431
%433 = getelementptr inbounds double, double* %2, i64 %425
%434 = bitcast double* %433 to <2 x double>*
%435 = load <2 x double>, <2 x double>* %434
%436 = getelementptr inbounds double, double* %433, i64 2
%437 = bitcast double* %436 to <2 x double>*
%438 = load <2 x double>, <2 x double>* %437
%439 = fmul <2 x double> %429, %435
%440 = fmul <2 x double> %432, %438
%441 = getelementptr inbounds double, double* %19, i64 %425
%442 = bitcast double* %441 to <2 x double>*
store <2 x double> %439, <2 x double>* %442
%443 = getelementptr inbounds double, double* %441, i64 2
%444 = bitcast double* %443 to <2 x double>*
store <2 x double> %440, <2 x double>* %444
%445 = or i64 %425, 4
%446 = getelementptr inbounds double, double* %9, i64 %445
%447 = bitcast double* %446 to <2 x double>*
%448 = load <2 x double>, <2 x double>* %447
%449 = getelementptr inbounds double, double* %446, i64 2
%450 = bitcast double* %449 to <2 x double>*
%451 = load <2 x double>, <2 x double>* %450
%452 = getelementptr inbounds double, double* %2, i64 %445
%453 = bitcast double* %452 to <2 x double>*
%454 = load <2 x double>, <2 x double>* %453
%455 = getelementptr inbounds double, double* %452, i64 2
%456 = bitcast double* %455 to <2 x double>*
%457 = load <2 x double>, <2 x double>* %456
%458 = fmul <2 x double> %448, %454
%459 = fmul <2 x double> %451, %457
%460 = getelementptr inbounds double, double* %19, i64 %445
%461 = bitcast double* %460 to <2 x double>*
store <2 x double> %458, <2 x double>* %461
%462 = getelementptr inbounds double, double* %460, i64 2
%463 = bitcast double* %462 to <2 x double>*
store <2 x double> %459, <2 x double>* %463
%464 = add nuw i64 %425, 8
%465 = add i64 %426, 2
%466 = icmp eq i64 %465, %172
br i1 %466, label %467, label %424
467: ; preds = %424, %423
%468 = phi i64 [ 0, %423 ], [ %464, %424 ]
br i1 %173, label %488, label %469
469: ; preds = %467
%470 = getelementptr inbounds double, double* %9, i64 %468
%471 = bitcast double* %470 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = getelementptr inbounds double, double* %470, i64 2
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = getelementptr inbounds double, double* %2, i64 %468
%477 = bitcast double* %476 to <2 x double>*
%478 = load <2 x double>, <2 x double>* %477
%479 = getelementptr inbounds double, double* %476, i64 2
%480 = bitcast double* %479 to <2 x double>*
%481 = load <2 x double>, <2 x double>* %480
%482 = fmul <2 x double> %472, %478
%483 = fmul <2 x double> %475, %481
%484 = getelementptr inbounds double, double* %19, i64 %468
%485 = bitcast double* %484 to <2 x double>*
store <2 x double> %482, <2 x double>* %485
%486 = getelementptr inbounds double, double* %484, i64 2
%487 = bitcast double* %486 to <2 x double>*
store <2 x double> %483, <2 x double>* %487
br label %488
488: ; preds = %467, %469
br i1 %174, label %539, label %489
489: ; preds = %421, %488
%490 = phi i64 [ 0, %421 ], [ %169, %488 ]
%491 = xor i64 %490, -1
%492 = add nsw i64 %491, %86
br i1 %176, label %505, label %493
493: ; preds = %489, %493
%494 = phi i64 [ %502, %493 ], [ %490, %489 ]
%495 = phi i64 [ %503, %493 ], [ 0, %489 ]
%496 = getelementptr inbounds double, double* %9, i64 %494
%497 = load double, double* %496
%498 = getelementptr inbounds double, double* %2, i64 %494
%499 = load double, double* %498
%500 = fmul double %497, %499
%501 = getelementptr inbounds double, double* %19, i64 %494
store double %500, double* %501
%502 = add nuw nsw i64 %494, 1
%503 = add i64 %495, 1
%504 = icmp eq i64 %503, %175
br i1 %504, label %505, label %493
505: ; preds = %493, %489
%506 = phi i64 [ %490, %489 ], [ %502, %493 ]
%507 = icmp ult i64 %492, 3
br i1 %507, label %539, label %508
508: ; preds = %505, %508
%509 = phi i64 [ %537, %508 ], [ %506, %505 ]
%510 = getelementptr inbounds double, double* %9, i64 %509
%511 = load double, double* %510
%512 = getelementptr inbounds double, double* %2, i64 %509
%513 = load double, double* %512
%514 = fmul double %511, %513
%515 = getelementptr inbounds double, double* %19, i64 %509
store double %514, double* %515
%516 = add nuw nsw i64 %509, 1
%517 = getelementptr inbounds double, double* %9, i64 %516
%518 = load double, double* %517
%519 = getelementptr inbounds double, double* %2, i64 %516
%520 = load double, double* %519
%521 = fmul double %518, %520
%522 = getelementptr inbounds double, double* %19, i64 %516
store double %521, double* %522
%523 = add nuw nsw i64 %509, 2
%524 = getelementptr inbounds double, double* %9, i64 %523
%525 = load double, double* %524
%526 = getelementptr inbounds double, double* %2, i64 %523
%527 = load double, double* %526
%528 = fmul double %525, %527
%529 = getelementptr inbounds double, double* %19, i64 %523
store double %528, double* %529
%530 = add nuw nsw i64 %509, 3
%531 = getelementptr inbounds double, double* %9, i64 %530
%532 = load double, double* %531
%533 = getelementptr inbounds double, double* %2, i64 %530
%534 = load double, double* %533
%535 = fmul double %532, %534
%536 = getelementptr inbounds double, double* %19, i64 %530
store double %535, double* %536
%537 = add nuw nsw i64 %509, 4
%538 = icmp eq i64 %537, %79
br i1 %538, label %539, label %508
539: ; preds = %505, %508, %488
%540 = call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %1, double* %19)
%541 = sitofp i32 %540 to double
%542 = fmul double %541, %11
%543 = fcmp oeq double %542, 0.000000e+00
br i1 %543, label %544, label %645
544: ; preds = %539
br label %645
545: ; preds = %361
br i1 %47, label %645, label %546
546: ; preds = %545
%547 = or i1 %139, %142
br i1 %547, label %614, label %548
548: ; preds = %546
br i1 %145, label %592, label %549
549: ; preds = %548, %549
%550 = phi i64 [ %589, %549 ], [ 0, %548 ]
%551 = phi i64 [ %590, %549 ], [ 0, %548 ]
%552 = getelementptr inbounds double, double* %9, i64 %550
%553 = bitcast double* %552 to <2 x double>*
%554 = load <2 x double>, <2 x double>* %553
%555 = getelementptr inbounds double, double* %552, i64 2
%556 = bitcast double* %555 to <2 x double>*
%557 = load <2 x double>, <2 x double>* %556
%558 = getelementptr inbounds double, double* %18, i64 %550
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = getelementptr inbounds double, double* %558, i64 2
%562 = bitcast double* %561 to <2 x double>*
%563 = load <2 x double>, <2 x double>* %562
%564 = fcmp oge <2 x double> %554, %560
%565 = fcmp oge <2 x double> %557, %563
%566 = select <2 x i1> %564, <2 x double> %554, <2 x double> %560
%567 = select <2 x i1> %565, <2 x double> %557, <2 x double> %563
%568 = bitcast double* %552 to <2 x double>*
store <2 x double> %566, <2 x double>* %568
%569 = bitcast double* %555 to <2 x double>*
store <2 x double> %567, <2 x double>* %569
%570 = or i64 %550, 4
%571 = getelementptr inbounds double, double* %9, i64 %570
%572 = bitcast double* %571 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = getelementptr inbounds double, double* %571, i64 2
%575 = bitcast double* %574 to <2 x double>*
%576 = load <2 x double>, <2 x double>* %575
%577 = getelementptr inbounds double, double* %18, i64 %570
%578 = bitcast double* %577 to <2 x double>*
%579 = load <2 x double>, <2 x double>* %578
%580 = getelementptr inbounds double, double* %577, i64 2
%581 = bitcast double* %580 to <2 x double>*
%582 = load <2 x double>, <2 x double>* %581
%583 = fcmp oge <2 x double> %573, %579
%584 = fcmp oge <2 x double> %576, %582
%585 = select <2 x i1> %583, <2 x double> %573, <2 x double> %579
%586 = select <2 x i1> %584, <2 x double> %576, <2 x double> %582
%587 = bitcast double* %571 to <2 x double>*
store <2 x double> %585, <2 x double>* %587
%588 = bitcast double* %574 to <2 x double>*
store <2 x double> %586, <2 x double>* %588
%589 = add nuw i64 %550, 8
%590 = add i64 %551, 2
%591 = icmp eq i64 %590, %146
br i1 %591, label %592, label %549
592: ; preds = %549, %548
%593 = phi i64 [ 0, %548 ], [ %589, %549 ]
br i1 %147, label %613, label %594
594: ; preds = %592
%595 = getelementptr inbounds double, double* %9, i64 %593
%596 = bitcast double* %595 to <2 x double>*
%597 = load <2 x double>, <2 x double>* %596
%598 = getelementptr inbounds double, double* %595, i64 2
%599 = bitcast double* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599
%601 = getelementptr inbounds double, double* %18, i64 %593
%602 = bitcast double* %601 to <2 x double>*
%603 = load <2 x double>, <2 x double>* %602
%604 = getelementptr inbounds double, double* %601, i64 2
%605 = bitcast double* %604 to <2 x double>*
%606 = load <2 x double>, <2 x double>* %605
%607 = fcmp oge <2 x double> %597, %603
%608 = fcmp oge <2 x double> %600, %606
%609 = select <2 x i1> %607, <2 x double> %597, <2 x double> %603
%610 = select <2 x i1> %608, <2 x double> %600, <2 x double> %606
%611 = bitcast double* %595 to <2 x double>*
store <2 x double> %609, <2 x double>* %611
%612 = bitcast double* %598 to <2 x double>*
store <2 x double> %610, <2 x double>* %612
br label %613
613: ; preds = %592, %594
br i1 %148, label %645, label %614
614: ; preds = %546, %613
%615 = phi i64 [ 0, %546 ], [ %143, %613 ]
%616 = xor i64 %615, -1
br i1 %150, label %625, label %617
617: ; preds = %614
%618 = getelementptr inbounds double, double* %9, i64 %615
%619 = load double, double* %618
%620 = getelementptr inbounds double, double* %18, i64 %615
%621 = load double, double* %620
%622 = fcmp oge double %619, %621
%623 = select i1 %622, double %619, double %621
store double %623, double* %618
%624 = or i64 %615, 1
br label %625
625: ; preds = %617, %614
%626 = phi i64 [ %615, %614 ], [ %624, %617 ]
%627 = icmp eq i64 %616, %151
br i1 %627, label %645, label %628
628: ; preds = %625, %628
%629 = phi i64 [ %643, %628 ], [ %626, %625 ]
%630 = getelementptr inbounds double, double* %9, i64 %629
%631 = load double, double* %630
%632 = getelementptr inbounds double, double* %18, i64 %629
%633 = load double, double* %632
%634 = fcmp oge double %631, %633
%635 = select i1 %634, double %631, double %633
store double %635, double* %630
%636 = add nuw nsw i64 %629, 1
%637 = getelementptr inbounds double, double* %9, i64 %636
%638 = load double, double* %637
%639 = getelementptr inbounds double, double* %18, i64 %636
%640 = load double, double* %639
%641 = fcmp oge double %638, %640
%642 = select i1 %641, double %638, double %640
store double %642, double* %637
%643 = add nuw nsw i64 %629, 2
%644 = icmp eq i64 %643, %77
br i1 %644, label %645, label %628
645: ; preds = %625, %628, %613, %545, %539, %544
%646 = phi double [ %241, %545 ], [ %11, %544 ], [ %542, %539 ], [ %241, %613 ], [ %241, %628 ], [ %241, %625 ]
%647 = phi double [ %243, %545 ], [ %541, %544 ], [ %541, %539 ], [ %243, %613 ], [ %243, %628 ], [ %243, %625 ]
br i1 %72, label %648, label %754
648: ; preds = %645
%649 = or i1 %177, %180
br i1 %649, label %719, label %650
650: ; preds = %648
br i1 %183, label %700, label %651
651: ; preds = %650, %651
%652 = phi i64 [ %697, %651 ], [ 0, %650 ]
%653 = phi i64 [ %698, %651 ], [ 0, %650 ]
%654 = getelementptr inbounds double, double* %3, i64 %652
%655 = bitcast double* %654 to <2 x double>*
%656 = load <2 x double>, <2 x double>* %655
%657 = getelementptr inbounds double, double* %654, i64 2
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %20, i64 %652
%661 = bitcast double* %660 to <2 x double>*
store <2 x double> %656, <2 x double>* %661
%662 = getelementptr inbounds double, double* %660, i64 2
%663 = bitcast double* %662 to <2 x double>*
store <2 x double> %659, <2 x double>* %663
%664 = or i64 %652, 4
%665 = getelementptr inbounds double, double* %3, i64 %664
%666 = bitcast double* %665 to <2 x double>*
%667 = load <2 x double>, <2 x double>* %666
%668 = getelementptr inbounds double, double* %665, i64 2
%669 = bitcast double* %668 to <2 x double>*
%670 = load <2 x double>, <2 x double>* %669
%671 = getelementptr inbounds double, double* %20, i64 %664
%672 = bitcast double* %671 to <2 x double>*
store <2 x double> %667, <2 x double>* %672
%673 = getelementptr inbounds double, double* %671, i64 2
%674 = bitcast double* %673 to <2 x double>*
store <2 x double> %670, <2 x double>* %674
%675 = or i64 %652, 8
%676 = getelementptr inbounds double, double* %3, i64 %675
%677 = bitcast double* %676 to <2 x double>*
%678 = load <2 x double>, <2 x double>* %677
%679 = getelementptr inbounds double, double* %676, i64 2
%680 = bitcast double* %679 to <2 x double>*
%681 = load <2 x double>, <2 x double>* %680
%682 = getelementptr inbounds double, double* %20, i64 %675
%683 = bitcast double* %682 to <2 x double>*
store <2 x double> %678, <2 x double>* %683
%684 = getelementptr inbounds double, double* %682, i64 2
%685 = bitcast double* %684 to <2 x double>*
store <2 x double> %681, <2 x double>* %685
%686 = or i64 %652, 12
%687 = getelementptr inbounds double, double* %3, i64 %686
%688 = bitcast double* %687 to <2 x double>*
%689 = load <2 x double>, <2 x double>* %688
%690 = getelementptr inbounds double, double* %687, i64 2
%691 = bitcast double* %690 to <2 x double>*
%692 = load <2 x double>, <2 x double>* %691
%693 = getelementptr inbounds double, double* %20, i64 %686
%694 = bitcast double* %693 to <2 x double>*
store <2 x double> %689, <2 x double>* %694
%695 = getelementptr inbounds double, double* %693, i64 2
%696 = bitcast double* %695 to <2 x double>*
store <2 x double> %692, <2 x double>* %696
%697 = add nuw i64 %652, 16
%698 = add nuw i64 %653, 4
%699 = icmp eq i64 %698, %184
br i1 %699, label %700, label %651
700: ; preds = %651, %650
%701 = phi i64 [ 0, %650 ], [ %697, %651 ]
br i1 %185, label %718, label %702
702: ; preds = %700, %702
%703 = phi i64 [ %715, %702 ], [ %701, %700 ]
%704 = phi i64 [ %716, %702 ], [ 0, %700 ]
%705 = getelementptr inbounds double, double* %3, i64 %703
%706 = bitcast double* %705 to <2 x double>*
%707 = load <2 x double>, <2 x double>* %706
%708 = getelementptr inbounds double, double* %705, i64 2
%709 = bitcast double* %708 to <2 x double>*
%710 = load <2 x double>, <2 x double>* %709
%711 = getelementptr inbounds double, double* %20, i64 %703
%712 = bitcast double* %711 to <2 x double>*
store <2 x double> %707, <2 x double>* %712
%713 = getelementptr inbounds double, double* %711, i64 2
%714 = bitcast double* %713 to <2 x double>*
store <2 x double> %710, <2 x double>* %714
%715 = add nuw i64 %703, 4
%716 = add i64 %704, 1
%717 = icmp eq i64 %716, %182
br i1 %717, label %718, label %702
718: ; preds = %702, %700
br i1 %186, label %754, label %719
719: ; preds = %648, %718
%720 = phi i64 [ 0, %648 ], [ %181, %718 ]
%721 = xor i64 %720, -1
%722 = add nsw i64 %721, %76
br i1 %188, label %732, label %723
723: ; preds = %719, %723
%724 = phi i64 [ %729, %723 ], [ %720, %719 ]
%725 = phi i64 [ %730, %723 ], [ 0, %719 ]
%726 = getelementptr inbounds double, double* %3, i64 %724
%727 = load double, double* %726
%728 = getelementptr inbounds double, double* %20, i64 %724
store double %727, double* %728
%729 = add nuw nsw i64 %724, 1
%730 = add i64 %725, 1
%731 = icmp eq i64 %730, %187
br i1 %731, label %732, label %723
732: ; preds = %723, %719
%733 = phi i64 [ %720, %719 ], [ %729, %723 ]
%734 = icmp ult i64 %722, 3
br i1 %734, label %754, label %735
735: ; preds = %732, %735
%736 = phi i64 [ %752, %735 ], [ %733, %732 ]
%737 = getelementptr inbounds double, double* %3, i64 %736
%738 = load double, double* %737
%739 = getelementptr inbounds double, double* %20, i64 %736
store double %738, double* %739
%740 = add nuw nsw i64 %736, 1
%741 = getelementptr inbounds double, double* %3, i64 %740
%742 = load double, double* %741
%743 = getelementptr inbounds double, double* %20, i64 %740
store double %742, double* %743
%744 = add nuw nsw i64 %736, 2
%745 = getelementptr inbounds double, double* %3, i64 %744
%746 = load double, double* %745
%747 = getelementptr inbounds double, double* %20, i64 %744
store double %746, double* %747
%748 = add nuw nsw i64 %736, 3
%749 = getelementptr inbounds double, double* %3, i64 %748
%750 = load double, double* %749
%751 = getelementptr inbounds double, double* %20, i64 %748
store double %750, double* %751
%752 = add nuw nsw i64 %736, 4
%753 = icmp eq i64 %752, %80
br i1 %753, label %754, label %735
754: ; preds = %732, %735, %718, %645
br label %755
755: ; preds = %754, %910
%756 = phi i64 [ %916, %910 ], [ 0, %754 ]
%757 = sub nsw i64 %76, %756
%758 = add i64 %757, -4
%759 = lshr i64 %758, 2
%760 = add nuw nsw i64 %759, 1
%761 = sub nsw i64 %76, %756
%762 = getelementptr double, double* %20, i64 %756
%763 = mul i64 %105, %756
%764 = getelementptr i8, i8* %27, i64 %763
%765 = mul i64 %756, %74
%766 = add i64 %765, %76
%767 = getelementptr double, double* %14, i64 %766
%768 = trunc i64 %756 to i32
%769 = mul nsw i64 %756, %74
%770 = mul nsw i32 %768, %0
%771 = sext i32 %770 to i64
%772 = add nsw i64 %756, %771
%773 = getelementptr inbounds double, double* %14, i64 %772
%774 = load double, double* %773
%775 = fcmp une double %774, 0.000000e+00
br i1 %775, label %776, label %910
776: ; preds = %755
%777 = icmp slt i64 %756, %74
br i1 %777, label %778, label %910
778: ; preds = %776, %778
%779 = phi i64 [ %787, %778 ], [ %756, %776 ]
%780 = phi double [ %786, %778 ], [ 0.000000e+00, %776 ]
%781 = add nsw i64 %779, %769
%782 = getelementptr inbounds double, double* %14, i64 %781
%783 = load double, double* %782
%784 = getelementptr inbounds double, double* %20, i64 %779
%785 = load double, double* %784
%786 = call double @llvm.fmuladd.f64(double %783, double %785, double %780)
%787 = add nuw nsw i64 %779, 1
%788 = icmp eq i64 %787, %82
br i1 %788, label %789, label %778
789: ; preds = %778
%790 = fneg double %786
%791 = fdiv double %790, %774
br i1 %777, label %792, label %910
792: ; preds = %789
%793 = icmp ult i64 %761, 4
br i1 %793, label %876, label %794
794: ; preds = %792
%795 = icmp ult double* %762, %767
%796 = icmp ult i8* %764, %103
%797 = and i1 %795, %796
br i1 %797, label %876, label %798
798: ; preds = %794
%799 = and i64 %761, -4
%800 = add i64 %756, %799
%801 = insertelement <2 x double> poison, double %791, i64 0
%802 = shufflevector <2 x double> %801, <2 x double> poison, <2 x i32> zeroinitializer
%803 = insertelement <2 x double> poison, double %791, i64 0
%804 = shufflevector <2 x double> %803, <2 x double> poison, <2 x i32> zeroinitializer
%805 = and i64 %760, 1
%806 = icmp ult i64 %758, 4
br i1 %806, label %852, label %807
807: ; preds = %798
%808 = and i64 %760, 9223372036854775806
br label %809
809: ; preds = %809, %807
%810 = phi i64 [ 0, %807 ], [ %849, %809 ]
%811 = phi i64 [ 0, %807 ], [ %850, %809 ]
%812 = add i64 %756, %810
%813 = add nsw i64 %812, %769
%814 = getelementptr inbounds double, double* %14, i64 %813
%815 = bitcast double* %814 to <2 x double>*
%816 = load <2 x double>, <2 x double>* %815
%817 = getelementptr inbounds double, double* %814, i64 2
%818 = bitcast double* %817 to <2 x double>*
%819 = load <2 x double>, <2 x double>* %818
%820 = getelementptr inbounds double, double* %20, i64 %812
%821 = bitcast double* %820 to <2 x double>*
%822 = load <2 x double>, <2 x double>* %821
%823 = getelementptr inbounds double, double* %820, i64 2
%824 = bitcast double* %823 to <2 x double>*
%825 = load <2 x double>, <2 x double>* %824
%826 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %816, <2 x double> %802, <2 x double> %822)
%827 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %819, <2 x double> %804, <2 x double> %825)
%828 = bitcast double* %820 to <2 x double>*
store <2 x double> %826, <2 x double>* %828
%829 = bitcast double* %823 to <2 x double>*
store <2 x double> %827, <2 x double>* %829
%830 = or i64 %810, 4
%831 = add i64 %756, %830
%832 = add nsw i64 %831, %769
%833 = getelementptr inbounds double, double* %14, i64 %832
%834 = bitcast double* %833 to <2 x double>*
%835 = load <2 x double>, <2 x double>* %834
%836 = getelementptr inbounds double, double* %833, i64 2
%837 = bitcast double* %836 to <2 x double>*
%838 = load <2 x double>, <2 x double>* %837
%839 = getelementptr inbounds double, double* %20, i64 %831
%840 = bitcast double* %839 to <2 x double>*
%841 = load <2 x double>, <2 x double>* %840
%842 = getelementptr inbounds double, double* %839, i64 2
%843 = bitcast double* %842 to <2 x double>*
%844 = load <2 x double>, <2 x double>* %843
%845 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %835, <2 x double> %802, <2 x double> %841)
%846 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %838, <2 x double> %804, <2 x double> %844)
%847 = bitcast double* %839 to <2 x double>*
store <2 x double> %845, <2 x double>* %847
%848 = bitcast double* %842 to <2 x double>*
store <2 x double> %846, <2 x double>* %848
%849 = add nuw i64 %810, 8
%850 = add i64 %811, 2
%851 = icmp eq i64 %850, %808
br i1 %851, label %852, label %809
852: ; preds = %809, %798
%853 = phi i64 [ 0, %798 ], [ %849, %809 ]
%854 = icmp eq i64 %805, 0
br i1 %854, label %874, label %855
855: ; preds = %852
%856 = add i64 %756, %853
%857 = add nsw i64 %856, %769
%858 = getelementptr inbounds double, double* %14, i64 %857
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = getelementptr inbounds double, double* %858, i64 2
%862 = bitcast double* %861 to <2 x double>*
%863 = load <2 x double>, <2 x double>* %862
%864 = getelementptr inbounds double, double* %20, i64 %856
%865 = bitcast double* %864 to <2 x double>*
%866 = load <2 x double>, <2 x double>* %865
%867 = getelementptr inbounds double, double* %864, i64 2
%868 = bitcast double* %867 to <2 x double>*
%869 = load <2 x double>, <2 x double>* %868
%870 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %860, <2 x double> %802, <2 x double> %866)
%871 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %863, <2 x double> %804, <2 x double> %869)
%872 = bitcast double* %864 to <2 x double>*
store <2 x double> %870, <2 x double>* %872
%873 = bitcast double* %867 to <2 x double>*
store <2 x double> %871, <2 x double>* %873
br label %874
874: ; preds = %852, %855
%875 = icmp eq i64 %761, %799
br i1 %875, label %910, label %876
876: ; preds = %794, %792, %874
%877 = phi i64 [ %756, %794 ], [ %756, %792 ], [ %800, %874 ]
%878 = sub i64 %76, %877
%879 = xor i64 %877, -1
%880 = and i64 %878, 1
%881 = icmp eq i64 %880, 0
br i1 %881, label %890, label %882
882: ; preds = %876
%883 = add nsw i64 %877, %769
%884 = getelementptr inbounds double, double* %14, i64 %883
%885 = load double, double* %884
%886 = getelementptr inbounds double, double* %20, i64 %877
%887 = load double, double* %886
%888 = call double @llvm.fmuladd.f64(double %885, double %791, double %887)
store double %888, double* %886
%889 = add nuw nsw i64 %877, 1
br label %890
890: ; preds = %882, %876
%891 = phi i64 [ %877, %876 ], [ %889, %882 ]
%892 = icmp eq i64 %879, %189
br i1 %892, label %910, label %893
893: ; preds = %890, %893
%894 = phi i64 [ %908, %893 ], [ %891, %890 ]
%895 = add nsw i64 %894, %769
%896 = getelementptr inbounds double, double* %14, i64 %895
%897 = load double, double* %896
%898 = getelementptr inbounds double, double* %20, i64 %894
%899 = load double, double* %898
%900 = call double @llvm.fmuladd.f64(double %897, double %791, double %899)
store double %900, double* %898
%901 = add nuw nsw i64 %894, 1
%902 = add nsw i64 %901, %769
%903 = getelementptr inbounds double, double* %14, i64 %902
%904 = load double, double* %903
%905 = getelementptr inbounds double, double* %20, i64 %901
%906 = load double, double* %905
%907 = call double @llvm.fmuladd.f64(double %904, double %791, double %906)
store double %907, double* %905
%908 = add nuw nsw i64 %894, 2
%909 = icmp eq i64 %908, %83
br i1 %909, label %910, label %893
910: ; preds = %890, %893, %874, %776, %789, %755
%911 = getelementptr inbounds double, double* %17, i64 %756
%912 = load double, double* %911
store double %912, double* %773
%913 = getelementptr inbounds double, double* %20, i64 %756
%914 = load double, double* %913
%915 = getelementptr inbounds double, double* %16, i64 %756
store double %914, double* %915
%916 = add nuw nsw i64 %756, 1
%917 = icmp eq i64 %916, %81
br i1 %917, label %918, label %755
918: ; preds = %910, %993
%919 = phi i64 [ %995, %993 ], [ 0, %910 ]
%920 = phi i64 [ %996, %993 ], [ 1, %910 ]
%921 = phi double [ %994, %993 ], [ 0.000000e+00, %910 ]
%922 = getelementptr inbounds i32, i32* %15, i64 %919
%923 = load i32, i32* %922
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds double, double* %18, i64 %924
%926 = load double, double* %925
%927 = fcmp oeq double %926, 0.000000e+00
br i1 %927, label %993, label %928
928: ; preds = %918
%929 = mul nsw i64 %919, %74
%930 = and i64 %920, 3
%931 = icmp ult i64 %919, 3
br i1 %931, label %968, label %932
932: ; preds = %928
%933 = and i64 %920, 9223372036854775804
br label %934
934: ; preds = %934, %932
%935 = phi i64 [ 0, %932 ], [ %965, %934 ]
%936 = phi double [ 0.000000e+00, %932 ], [ %964, %934 ]
%937 = phi i64 [ 0, %932 ], [ %966, %934 ]
%938 = add nsw i64 %935, %929
%939 = getelementptr inbounds double, double* %14, i64 %938
%940 = load double, double* %939
%941 = getelementptr inbounds double, double* %16, i64 %935
%942 = load double, double* %941
%943 = call double @llvm.fmuladd.f64(double %940, double %942, double %936)
%944 = or i64 %935, 1
%945 = add nsw i64 %944, %929
%946 = getelementptr inbounds double, double* %14, i64 %945
%947 = load double, double* %946
%948 = getelementptr inbounds double, double* %16, i64 %944
%949 = load double, double* %948
%950 = call double @llvm.fmuladd.f64(double %947, double %949, double %943)
%951 = or i64 %935, 2
%952 = add nsw i64 %951, %929
%953 = getelementptr inbounds double, double* %14, i64 %952
%954 = load double, double* %953
%955 = getelementptr inbounds double, double* %16, i64 %951
%956 = load double, double* %955
%957 = call double @llvm.fmuladd.f64(double %954, double %956, double %950)
%958 = or i64 %935, 3
%959 = add nsw i64 %958, %929
%960 = getelementptr inbounds double, double* %14, i64 %959
%961 = load double, double* %960
%962 = getelementptr inbounds double, double* %16, i64 %958
%963 = load double, double* %962
%964 = call double @llvm.fmuladd.f64(double %961, double %963, double %957)
%965 = add nuw nsw i64 %935, 4
%966 = add i64 %937, 4
%967 = icmp eq i64 %966, %933
br i1 %967, label %968, label %934
968: ; preds = %934, %928
%969 = phi double [ undef, %928 ], [ %964, %934 ]
%970 = phi i64 [ 0, %928 ], [ %965, %934 ]
%971 = phi double [ 0.000000e+00, %928 ], [ %964, %934 ]
%972 = icmp eq i64 %930, 0
br i1 %972, label %986, label %973
973: ; preds = %968, %973
%974 = phi i64 [ %983, %973 ], [ %970, %968 ]
%975 = phi double [ %982, %973 ], [ %971, %968 ]
%976 = phi i64 [ %984, %973 ], [ 0, %968 ]
%977 = add nsw i64 %974, %929
%978 = getelementptr inbounds double, double* %14, i64 %977
%979 = load double, double* %978
%980 = getelementptr inbounds double, double* %16, i64 %974
%981 = load double, double* %980
%982 = call double @llvm.fmuladd.f64(double %979, double %981, double %975)
%983 = add nuw nsw i64 %974, 1
%984 = add i64 %976, 1
%985 = icmp eq i64 %984, %930
br i1 %985, label %986, label %973
986: ; preds = %973, %968
%987 = phi double [ %969, %968 ], [ %982, %973 ]
%988 = fdiv double %987, %926
%989 = fdiv double %988, %240
%990 = call double @llvm.fabs.f64(double %989)
%991 = fcmp oge double %921, %990
%992 = select i1 %991, double %921, double %990
br label %993
993: ; preds = %918, %986
%994 = phi double [ %921, %918 ], [ %992, %986 ]
%995 = add nuw nsw i64 %919, 1
%996 = add nuw nsw i64 %920, 1
%997 = icmp eq i64 %995, %84
br i1 %997, label %998, label %918
998: ; preds = %993
%999 = fcmp ugt double %994, %6
br i1 %999, label %1000, label %1549
1000: ; preds = %998
%1001 = fcmp ole double %994, 1.200000e-16
br label %1002
1002: ; preds = %1000, %1545
%1003 = phi double [ %1514, %1545 ], [ %240, %1000 ]
%1004 = phi double [ %1295, %1545 ], [ %646, %1000 ]
%1005 = phi i32 [ %1515, %1545 ], [ %242, %1000 ]
%1006 = phi double [ %1516, %1545 ], [ %647, %1000 ]
%1007 = call i32 (i32, double*, i32, i32*, double*, double*, double, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @lm_lmpar to i32 (i32, double*, i32, i32*, double*, double*, double, double*, double*, double*, double*, double*, ...)*)(i32 %1, double* %14, i32 %0, i32* %15, double* %9, double* %16, double %1004, double* %28, double* %17, double* %18, double* %20, double* %19)
%1008 = or i1 %190, %197
br i1 %1008, label %1075, label %1009
1009: ; preds = %1002
br i1 %200, label %1053, label %1010
1010: ; preds = %1009, %1010
%1011 = phi i64 [ %1050, %1010 ], [ 0, %1009 ]
%1012 = phi i64 [ %1051, %1010 ], [ 0, %1009 ]
%1013 = getelementptr inbounds double, double* %2, i64 %1011
%1014 = bitcast double* %1013 to <2 x double>*
%1015 = load <2 x double>, <2 x double>* %1014
%1016 = getelementptr inbounds double, double* %1013, i64 2
%1017 = bitcast double* %1016 to <2 x double>*
%1018 = load <2 x double>, <2 x double>* %1017
%1019 = getelementptr inbounds double, double* %17, i64 %1011
%1020 = bitcast double* %1019 to <2 x double>*
%1021 = load <2 x double>, <2 x double>* %1020
%1022 = getelementptr inbounds double, double* %1019, i64 2
%1023 = bitcast double* %1022 to <2 x double>*
%1024 = load <2 x double>, <2 x double>* %1023
%1025 = fsub <2 x double> %1015, %1021
%1026 = fsub <2 x double> %1018, %1024
%1027 = getelementptr inbounds double, double* %18, i64 %1011
%1028 = bitcast double* %1027 to <2 x double>*
store <2 x double> %1025, <2 x double>* %1028
%1029 = getelementptr inbounds double, double* %1027, i64 2
%1030 = bitcast double* %1029 to <2 x double>*
store <2 x double> %1026, <2 x double>* %1030
%1031 = or i64 %1011, 4
%1032 = getelementptr inbounds double, double* %2, i64 %1031
%1033 = bitcast double* %1032 to <2 x double>*
%1034 = load <2 x double>, <2 x double>* %1033
%1035 = getelementptr inbounds double, double* %1032, i64 2
%1036 = bitcast double* %1035 to <2 x double>*
%1037 = load <2 x double>, <2 x double>* %1036
%1038 = getelementptr inbounds double, double* %17, i64 %1031
%1039 = bitcast double* %1038 to <2 x double>*
%1040 = load <2 x double>, <2 x double>* %1039
%1041 = getelementptr inbounds double, double* %1038, i64 2
%1042 = bitcast double* %1041 to <2 x double>*
%1043 = load <2 x double>, <2 x double>* %1042
%1044 = fsub <2 x double> %1034, %1040
%1045 = fsub <2 x double> %1037, %1043
%1046 = getelementptr inbounds double, double* %18, i64 %1031
%1047 = bitcast double* %1046 to <2 x double>*
store <2 x double> %1044, <2 x double>* %1047
%1048 = getelementptr inbounds double, double* %1046, i64 2
%1049 = bitcast double* %1048 to <2 x double>*
store <2 x double> %1045, <2 x double>* %1049
%1050 = add nuw i64 %1011, 8
%1051 = add i64 %1012, 2
%1052 = icmp eq i64 %1051, %201
br i1 %1052, label %1053, label %1010
1053: ; preds = %1010, %1009
%1054 = phi i64 [ 0, %1009 ], [ %1050, %1010 ]
br i1 %202, label %1074, label %1055
1055: ; preds = %1053
%1056 = getelementptr inbounds double, double* %2, i64 %1054
%1057 = bitcast double* %1056 to <2 x double>*
%1058 = load <2 x double>, <2 x double>* %1057
%1059 = getelementptr inbounds double, double* %1056, i64 2
%1060 = bitcast double* %1059 to <2 x double>*
%1061 = load <2 x double>, <2 x double>* %1060
%1062 = getelementptr inbounds double, double* %17, i64 %1054
%1063 = bitcast double* %1062 to <2 x double>*
%1064 = load <2 x double>, <2 x double>* %1063
%1065 = getelementptr inbounds double, double* %1062, i64 2
%1066 = bitcast double* %1065 to <2 x double>*
%1067 = load <2 x double>, <2 x double>* %1066
%1068 = fsub <2 x double> %1058, %1064
%1069 = fsub <2 x double> %1061, %1067
%1070 = getelementptr inbounds double, double* %18, i64 %1054
%1071 = bitcast double* %1070 to <2 x double>*
store <2 x double> %1068, <2 x double>* %1071
%1072 = getelementptr inbounds double, double* %1070, i64 2
%1073 = bitcast double* %1072 to <2 x double>*
store <2 x double> %1069, <2 x double>* %1073
br label %1074
1074: ; preds = %1053, %1055
br i1 %203, label %1125, label %1075
1075: ; preds = %1002, %1074
%1076 = phi i64 [ 0, %1002 ], [ %198, %1074 ]
%1077 = xor i64 %1076, -1
%1078 = add nsw i64 %1077, %86
br i1 %205, label %1091, label %1079
1079: ; preds = %1075, %1079
%1080 = phi i64 [ %1088, %1079 ], [ %1076, %1075 ]
%1081 = phi i64 [ %1089, %1079 ], [ 0, %1075 ]
%1082 = getelementptr inbounds double, double* %2, i64 %1080
%1083 = load double, double* %1082
%1084 = getelementptr inbounds double, double* %17, i64 %1080
%1085 = load double, double* %1084
%1086 = fsub double %1083, %1085
%1087 = getelementptr inbounds double, double* %18, i64 %1080
store double %1086, double* %1087
%1088 = add nuw nsw i64 %1080, 1
%1089 = add i64 %1081, 1
%1090 = icmp eq i64 %1089, %204
br i1 %1090, label %1091, label %1079
1091: ; preds = %1079, %1075
%1092 = phi i64 [ %1076, %1075 ], [ %1088, %1079 ]
%1093 = icmp ult i64 %1078, 3
br i1 %1093, label %1125, label %1094
1094: ; preds = %1091, %1094
%1095 = phi i64 [ %1123, %1094 ], [ %1092, %1091 ]
%1096 = getelementptr inbounds double, double* %2, i64 %1095
%1097 = load double, double* %1096
%1098 = getelementptr inbounds double, double* %17, i64 %1095
%1099 = load double, double* %1098
%1100 = fsub double %1097, %1099
%1101 = getelementptr inbounds double, double* %18, i64 %1095
store double %1100, double* %1101
%1102 = add nuw nsw i64 %1095, 1
%1103 = getelementptr inbounds double, double* %2, i64 %1102
%1104 = load double, double* %1103
%1105 = getelementptr inbounds double, double* %17, i64 %1102
%1106 = load double, double* %1105
%1107 = fsub double %1104, %1106
%1108 = getelementptr inbounds double, double* %18, i64 %1102
store double %1107, double* %1108
%1109 = add nuw nsw i64 %1095, 2
%1110 = getelementptr inbounds double, double* %2, i64 %1109
%1111 = load double, double* %1110
%1112 = getelementptr inbounds double, double* %17, i64 %1109
%1113 = load double, double* %1112
%1114 = fsub double %1111, %1113
%1115 = getelementptr inbounds double, double* %18, i64 %1109
store double %1114, double* %1115
%1116 = add nuw nsw i64 %1095, 3
%1117 = getelementptr inbounds double, double* %2, i64 %1116
%1118 = load double, double* %1117
%1119 = getelementptr inbounds double, double* %17, i64 %1116
%1120 = load double, double* %1119
%1121 = fsub double %1118, %1120
%1122 = getelementptr inbounds double, double* %18, i64 %1116
store double %1121, double* %1122
%1123 = add nuw nsw i64 %1095, 4
%1124 = icmp eq i64 %1123, %85
br i1 %1124, label %1125, label %1094
1125: ; preds = %1091, %1094, %1074
%1126 = call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %1, double* %19)
%1127 = sitofp i32 %1126 to double
%1128 = load i32, i32* %13
%1129 = icmp sgt i32 %1128, %73
%1130 = fcmp ole double %1004, %1127
%1131 = select i1 %1129, i1 true, i1 %1130
%1132 = select i1 %1131, double %1004, double %1127
store i32 0, i32* %12
%1133 = load i32, i32* %13
%1134 = add nsw i32 %1133, 1
store i32 %1134, i32* %13
br i1 %61, label %1136, label %1135
1135: ; preds = %1125
br label %1136
1136: ; preds = %1135, %1125
%1137 = load i32, i32* %12
%1138 = icmp slt i32 %1137, 0
br i1 %1138, label %1551, label %1139
1139: ; preds = %1136
%1140 = call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %0, double* %20)
%1141 = sitofp i32 %1140 to double
%1142 = fmul double %1141, 1.000000e-01
%1143 = fcmp olt double %1142, %1003
br i1 %1143, label %1144, label %1148
1144: ; preds = %1139
%1145 = fdiv double %1141, %1003
%1146 = fneg double %1145
%1147 = call double @llvm.fmuladd.f64(double %1146, double %1145, double 1.000000e+00)
br label %1148
1148: ; preds = %1144, %1139
%1149 = phi double [ %1147, %1144 ], [ -1.000000e+00, %1139 ]
br label %1150
1150: ; preds = %1148, %1246
%1151 = phi i64 [ 0, %1148 ], [ %1247, %1246 ]
%1152 = phi i64 [ 1, %1148 ], [ %1248, %1246 ]
%1153 = add nuw i64 %1151, 1
%1154 = add nuw i64 %1151, 1
%1155 = getelementptr double, double* %19, i64 %1154
%1156 = getelementptr inbounds double, double* %19, i64 %1151
store double 0.000000e+00, double* %1156
%1157 = mul nsw i64 %1151, %74
%1158 = getelementptr inbounds i32, i32* %15, i64 %1151
%1159 = load i32, i32* %1158
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds double, double* %17, i64 %1160
%1162 = icmp ult i64 %1151, 3
br i1 %1162, label %1208, label %1163
1163: ; preds = %1150
%1164 = mul i64 %97, %1151
%1165 = getelementptr i8, i8* %95, i64 %1164
%1166 = mul i64 %1151, %74
%1167 = getelementptr double, double* %14, i64 %1166
%1168 = getelementptr double, double* %98, i64 %1160
%1169 = icmp ugt i8* %1165, %26
%1170 = icmp ult double* %1167, %1155
%1171 = and i1 %1169, %1170
%1172 = icmp ugt double* %1168, %19
%1173 = icmp ult double* %1161, %1155
%1174 = and i1 %1172, %1173
%1175 = or i1 %1171, %1174
br i1 %1175, label %1208, label %1176
1176: ; preds = %1163
%1177 = and i64 %1153, -4
%1178 = load double, double* %1161
%1179 = insertelement <2 x double> poison, double %1178, i64 0
%1180 = shufflevector <2 x double> %1179, <2 x double> poison, <2 x i32> zeroinitializer
%1181 = insertelement <2 x double> poison, double %1178, i64 0
%1182 = shufflevector <2 x double> %1181, <2 x double> poison, <2 x i32> zeroinitializer
br label %1183
1183: ; preds = %1183, %1176
%1184 = phi i64 [ 0, %1176 ], [ %1204, %1183 ]
%1185 = add nsw i64 %1184, %1157
%1186 = getelementptr inbounds double, double* %14, i64 %1185
%1187 = bitcast double* %1186 to <2 x double>*
%1188 = load <2 x double>, <2 x double>* %1187
%1189 = getelementptr inbounds double, double* %1186, i64 2
%1190 = bitcast double* %1189 to <2 x double>*
%1191 = load <2 x double>, <2 x double>* %1190
%1192 = getelementptr inbounds double, double* %19, i64 %1184
%1193 = bitcast double* %1192 to <2 x double>*
%1194 = load <2 x double>, <2 x double>* %1193
%1195 = getelementptr inbounds double, double* %1192, i64 2
%1196 = bitcast double* %1195 to <2 x double>*
%1197 = load <2 x double>, <2 x double>* %1196
%1198 = fneg <2 x double> %1188
%1199 = fneg <2 x double> %1191
%1200 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1198, <2 x double> %1180, <2 x double> %1194)
%1201 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1199, <2 x double> %1182, <2 x double> %1197)
%1202 = bitcast double* %1192 to <2 x double>*
store <2 x double> %1200, <2 x double>* %1202
%1203 = bitcast double* %1195 to <2 x double>*
store <2 x double> %1201, <2 x double>* %1203
%1204 = add nuw i64 %1184, 4
%1205 = icmp eq i64 %1204, %1177
br i1 %1205, label %1206, label %1183
1206: ; preds = %1183
%1207 = icmp eq i64 %1153, %1177
br i1 %1207, label %1246, label %1208
1208: ; preds = %1163, %1150, %1206
%1209 = phi i64 [ 0, %1163 ], [ 0, %1150 ], [ %1177, %1206 ]
%1210 = and i64 %1152, 1
%1211 = icmp eq i64 %1210, 0
br i1 %1211, label %1222, label %1212
1212: ; preds = %1208
%1213 = add nsw i64 %1209, %1157
%1214 = getelementptr inbounds double, double* %14, i64 %1213
%1215 = load double, double* %1214
%1216 = load double, double* %1161
%1217 = getelementptr inbounds double, double* %19, i64 %1209
%1218 = load double, double* %1217
%1219 = fneg double %1215
%1220 = call double @llvm.fmuladd.f64(double %1219, double %1216, double %1218)
store double %1220, double* %1217
%1221 = or i64 %1209, 1
br label %1222
1222: ; preds = %1212, %1208
%1223 = phi i64 [ %1209, %1208 ], [ %1221, %1212 ]
%1224 = icmp eq i64 %1151, %1209
br i1 %1224, label %1246, label %1225
1225: ; preds = %1222, %1225
%1226 = phi i64 [ %1244, %1225 ], [ %1223, %1222 ]
%1227 = add nsw i64 %1226, %1157
%1228 = getelementptr inbounds double, double* %14, i64 %1227
%1229 = load double, double* %1228
%1230 = load double, double* %1161
%1231 = getelementptr inbounds double, double* %19, i64 %1226
%1232 = load double, double* %1231
%1233 = fneg double %1229
%1234 = call double @llvm.fmuladd.f64(double %1233, double %1230, double %1232)
store double %1234, double* %1231
%1235 = add nuw nsw i64 %1226, 1
%1236 = add nsw i64 %1235, %1157
%1237 = getelementptr inbounds double, double* %14, i64 %1236
%1238 = load double, double* %1237
%1239 = load double, double* %1161
%1240 = getelementptr inbounds double, double* %19, i64 %1235
%1241 = load double, double* %1240
%1242 = fneg double %1238
%1243 = call double @llvm.fmuladd.f64(double %1242, double %1239, double %1241)
store double %1243, double* %1240
%1244 = add nuw nsw i64 %1226, 2
%1245 = icmp eq i64 %1244, %1152
br i1 %1245, label %1246, label %1225
1246: ; preds = %1222, %1225, %1206
%1247 = add nuw nsw i64 %1151, 1
%1248 = add nuw nsw i64 %1152, 1
%1249 = icmp eq i64 %1247, %86
br i1 %1249, label %1250, label %1150
1250: ; preds = %1246
%1251 = call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %1, double* %19)
%1252 = sitofp i32 %1251 to double
%1253 = fdiv double %1252, %1003
%1254 = load double, double* %28
%1255 = call double @sqrt(double %1254)
%1256 = fmul double %1255, %1127
%1257 = fdiv double %1256, %1003
%1258 = fmul double %1257, 2.000000e+00
%1259 = fmul double %1257, %1258
%1260 = call double @llvm.fmuladd.f64(double %1253, double %1253, double %1259)
%1261 = fmul double %1257, %1257
%1262 = call double @llvm.fmuladd.f64(double %1253, double %1253, double %1261)
%1263 = fneg double %1262
%1264 = fcmp une double %1260, 0.000000e+00
%1265 = fdiv double %1149, %1260
%1266 = select i1 %1264, double %1265, double 0.000000e+00
%1267 = fcmp ugt double %1266, 2.500000e-01
br i1 %1267, label %1286, label %1268
1268: ; preds = %1250
%1269 = fcmp ult double %1149, 0.000000e+00
br i1 %1269, label %1270, label %1274
1270: ; preds = %1268
%1271 = fmul double %1262, -5.000000e-01
%1272 = call double @llvm.fmuladd.f64(double %1149, double 5.500000e-01, double %1263)
%1273 = fdiv double %1271, %1272
br label %1274
1274: ; preds = %1268, %1270
%1275 = phi double [ %1273, %1270 ], [ 5.000000e-01, %1268 ]
%1276 = fcmp oge double %1142, %1003
%1277 = fcmp olt double %1275, 1.000000e-01
%1278 = select i1 %1276, i1 true, i1 %1277
%1279 = select i1 %1278, double 1.000000e-01, double %1275
%1280 = fdiv double %1127, 1.000000e-01
%1281 = fcmp ole double %1132, %1280
%1282 = select i1 %1281, double %1132, double %1280
%1283 = fmul double %1282, %1279
%1284 = load double, double* %28
%1285 = fdiv double %1284, %1279
store double %1285, double* %28
br label %1294
1286: ; preds = %1250
%1287 = load double, double* %28
%1288 = fcmp oeq double %1287, 0.000000e+00
%1289 = fcmp oge double %1266, 7.500000e-01
%1290 = select i1 %1288, i1 true, i1 %1289
br i1 %1290, label %1291, label %1294
1291: ; preds = %1286
%1292 = fmul double %1127, 2.000000e+00
%1293 = fmul double %1287, 5.000000e-01
store double %1293, double* %28
br label %1294
1294: ; preds = %1291, %1286, %1274
%1295 = phi double [ %1283, %1274 ], [ %1292, %1291 ], [ %1132, %1286 ]
%1296 = fcmp ult double %1266, 1.000000e-04
br i1 %1296, label %1513, label %1297
1297: ; preds = %1294
%1298 = or i1 %206, %217
br i1 %1298, label %1371, label %1299
1299: ; preds = %1297
br i1 %220, label %1347, label %1300
1300: ; preds = %1299, %1300
%1301 = phi i64 [ %1344, %1300 ], [ 0, %1299 ]
%1302 = phi i64 [ %1345, %1300 ], [ 0, %1299 ]
%1303 = getelementptr inbounds double, double* %18, i64 %1301
%1304 = bitcast double* %1303 to <2 x double>*
%1305 = load <2 x double>, <2 x double>* %1304
%1306 = getelementptr inbounds double, double* %1303, i64 2
%1307 = bitcast double* %1306 to <2 x double>*
%1308 = load <2 x double>, <2 x double>* %1307
%1309 = getelementptr inbounds double, double* %2, i64 %1301
%1310 = bitcast double* %1309 to <2 x double>*
store <2 x double> %1305, <2 x double>* %1310
%1311 = getelementptr inbounds double, double* %1309, i64 2
%1312 = bitcast double* %1311 to <2 x double>*
store <2 x double> %1308, <2 x double>* %1312
%1313 = getelementptr inbounds double, double* %9, i64 %1301
%1314 = bitcast double* %1313 to <2 x double>*
%1315 = load <2 x double>, <2 x double>* %1314
%1316 = getelementptr inbounds double, double* %1313, i64 2
%1317 = bitcast double* %1316 to <2 x double>*
%1318 = load <2 x double>, <2 x double>* %1317
%1319 = fmul <2 x double> %1305, %1315
%1320 = fmul <2 x double> %1308, %1318
%1321 = bitcast double* %1303 to <2 x double>*
store <2 x double> %1319, <2 x double>* %1321
%1322 = bitcast double* %1306 to <2 x double>*
store <2 x double> %1320, <2 x double>* %1322
%1323 = or i64 %1301, 4
%1324 = getelementptr inbounds double, double* %18, i64 %1323
%1325 = bitcast double* %1324 to <2 x double>*
%1326 = load <2 x double>, <2 x double>* %1325
%1327 = getelementptr inbounds double, double* %1324, i64 2
%1328 = bitcast double* %1327 to <2 x double>*
%1329 = load <2 x double>, <2 x double>* %1328
%1330 = getelementptr inbounds double, double* %2, i64 %1323
%1331 = bitcast double* %1330 to <2 x double>*
store <2 x double> %1326, <2 x double>* %1331
%1332 = getelementptr inbounds double, double* %1330, i64 2
%1333 = bitcast double* %1332 to <2 x double>*
store <2 x double> %1329, <2 x double>* %1333
%1334 = getelementptr inbounds double, double* %9, i64 %1323
%1335 = bitcast double* %1334 to <2 x double>*
%1336 = load <2 x double>, <2 x double>* %1335
%1337 = getelementptr inbounds double, double* %1334, i64 2
%1338 = bitcast double* %1337 to <2 x double>*
%1339 = load <2 x double>, <2 x double>* %1338
%1340 = fmul <2 x double> %1326, %1336
%1341 = fmul <2 x double> %1329, %1339
%1342 = bitcast double* %1324 to <2 x double>*
store <2 x double> %1340, <2 x double>* %1342
%1343 = bitcast double* %1327 to <2 x double>*
store <2 x double> %1341, <2 x double>* %1343
%1344 = add nuw i64 %1301, 8
%1345 = add i64 %1302, 2
%1346 = icmp eq i64 %1345, %221
br i1 %1346, label %1347, label %1300
1347: ; preds = %1300, %1299
%1348 = phi i64 [ 0, %1299 ], [ %1344, %1300 ]
br i1 %222, label %1370, label %1349
1349: ; preds = %1347
%1350 = getelementptr inbounds double, double* %18, i64 %1348
%1351 = bitcast double* %1350 to <2 x double>*
%1352 = load <2 x double>, <2 x double>* %1351
%1353 = getelementptr inbounds double, double* %1350, i64 2
%1354 = bitcast double* %1353 to <2 x double>*
%1355 = load <2 x double>, <2 x double>* %1354
%1356 = getelementptr inbounds double, double* %2, i64 %1348
%1357 = bitcast double* %1356 to <2 x double>*
store <2 x double> %1352, <2 x double>* %1357
%1358 = getelementptr inbounds double, double* %1356, i64 2
%1359 = bitcast double* %1358 to <2 x double>*
store <2 x double> %1355, <2 x double>* %1359
%1360 = getelementptr inbounds double, double* %9, i64 %1348
%1361 = bitcast double* %1360 to <2 x double>*
%1362 = load <2 x double>, <2 x double>* %1361
%1363 = getelementptr inbounds double, double* %1360, i64 2
%1364 = bitcast double* %1363 to <2 x double>*
%1365 = load <2 x double>, <2 x double>* %1364
%1366 = fmul <2 x double> %1352, %1362
%1367 = fmul <2 x double> %1355, %1365
%1368 = bitcast double* %1350 to <2 x double>*
store <2 x double> %1366, <2 x double>* %1368
%1369 = bitcast double* %1353 to <2 x double>*
store <2 x double> %1367, <2 x double>* %1369
br label %1370
1370: ; preds = %1347, %1349
br i1 %223, label %1385, label %1371
1371: ; preds = %1297, %1370
%1372 = phi i64 [ 0, %1297 ], [ %218, %1370 ]
%1373 = xor i64 %1372, -1
br i1 %225, label %1382, label %1374
1374: ; preds = %1371
%1375 = getelementptr inbounds double, double* %18, i64 %1372
%1376 = load double, double* %1375
%1377 = getelementptr inbounds double, double* %2, i64 %1372
store double %1376, double* %1377
%1378 = getelementptr inbounds double, double* %9, i64 %1372
%1379 = load double, double* %1378
%1380 = fmul double %1376, %1379
store double %1380, double* %1375
%1381 = or i64 %1372, 1
br label %1382
1382: ; preds = %1374, %1371
%1383 = phi i64 [ %1372, %1371 ], [ %1381, %1374 ]
%1384 = icmp eq i64 %1373, %226
br i1 %1384, label %1385, label %1473
1385: ; preds = %1382, %1473, %1370
br i1 %72, label %1386, label %1509
1386: ; preds = %1385
%1387 = or i1 %227, %230
br i1 %1387, label %1457, label %1388
1388: ; preds = %1386
br i1 %233, label %1438, label %1389
1389: ; preds = %1388, %1389
%1390 = phi i64 [ %1435, %1389 ], [ 0, %1388 ]
%1391 = phi i64 [ %1436, %1389 ], [ 0, %1388 ]
%1392 = getelementptr inbounds double, double* %20, i64 %1390
%1393 = bitcast double* %1392 to <2 x double>*
%1394 = load <2 x double>, <2 x double>* %1393
%1395 = getelementptr inbounds double, double* %1392, i64 2
%1396 = bitcast double* %1395 to <2 x double>*
%1397 = load <2 x double>, <2 x double>* %1396
%1398 = getelementptr inbounds double, double* %3, i64 %1390
%1399 = bitcast double* %1398 to <2 x double>*
store <2 x double> %1394, <2 x double>* %1399
%1400 = getelementptr inbounds double, double* %1398, i64 2
%1401 = bitcast double* %1400 to <2 x double>*
store <2 x double> %1397, <2 x double>* %1401
%1402 = or i64 %1390, 4
%1403 = getelementptr inbounds double, double* %20, i64 %1402
%1404 = bitcast double* %1403 to <2 x double>*
%1405 = load <2 x double>, <2 x double>* %1404
%1406 = getelementptr inbounds double, double* %1403, i64 2
%1407 = bitcast double* %1406 to <2 x double>*
%1408 = load <2 x double>, <2 x double>* %1407
%1409 = getelementptr inbounds double, double* %3, i64 %1402
%1410 = bitcast double* %1409 to <2 x double>*
store <2 x double> %1405, <2 x double>* %1410
%1411 = getelementptr inbounds double, double* %1409, i64 2
%1412 = bitcast double* %1411 to <2 x double>*
store <2 x double> %1408, <2 x double>* %1412
%1413 = or i64 %1390, 8
%1414 = getelementptr inbounds double, double* %20, i64 %1413
%1415 = bitcast double* %1414 to <2 x double>*
%1416 = load <2 x double>, <2 x double>* %1415
%1417 = getelementptr inbounds double, double* %1414, i64 2
%1418 = bitcast double* %1417 to <2 x double>*
%1419 = load <2 x double>, <2 x double>* %1418
%1420 = getelementptr inbounds double, double* %3, i64 %1413
%1421 = bitcast double* %1420 to <2 x double>*
store <2 x double> %1416, <2 x double>* %1421
%1422 = getelementptr inbounds double, double* %1420, i64 2
%1423 = bitcast double* %1422 to <2 x double>*
store <2 x double> %1419, <2 x double>* %1423
%1424 = or i64 %1390, 12
%1425 = getelementptr inbounds double, double* %20, i64 %1424
%1426 = bitcast double* %1425 to <2 x double>*
%1427 = load <2 x double>, <2 x double>* %1426
%1428 = getelementptr inbounds double, double* %1425, i64 2
%1429 = bitcast double* %1428 to <2 x double>*
%1430 = load <2 x double>, <2 x double>* %1429
%1431 = getelementptr inbounds double, double* %3, i64 %1424
%1432 = bitcast double* %1431 to <2 x double>*
store <2 x double> %1427, <2 x double>* %1432
%1433 = getelementptr inbounds double, double* %1431, i64 2
%1434 = bitcast double* %1433 to <2 x double>*
store <2 x double> %1430, <2 x double>* %1434
%1435 = add nuw i64 %1390, 16
%1436 = add nuw i64 %1391, 4
%1437 = icmp eq i64 %1436, %234
br i1 %1437, label %1438, label %1389
1438: ; preds = %1389, %1388
%1439 = phi i64 [ 0, %1388 ], [ %1435, %1389 ]
br i1 %235, label %1456, label %1440
1440: ; preds = %1438, %1440
%1441 = phi i64 [ %1453, %1440 ], [ %1439, %1438 ]
%1442 = phi i64 [ %1454, %1440 ], [ 0, %1438 ]
%1443 = getelementptr inbounds double, double* %20, i64 %1441
%1444 = bitcast double* %1443 to <2 x double>*
%1445 = load <2 x double>, <2 x double>* %1444
%1446 = getelementptr inbounds double, double* %1443, i64 2
%1447 = bitcast double* %1446 to <2 x double>*
%1448 = load <2 x double>, <2 x double>* %1447
%1449 = getelementptr inbounds double, double* %3, i64 %1441
%1450 = bitcast double* %1449 to <2 x double>*
store <2 x double> %1445, <2 x double>* %1450
%1451 = getelementptr inbounds double, double* %1449, i64 2
%1452 = bitcast double* %1451 to <2 x double>*
store <2 x double> %1448, <2 x double>* %1452
%1453 = add nuw i64 %1441, 4
%1454 = add i64 %1442, 1
%1455 = icmp eq i64 %1454, %232
br i1 %1455, label %1456, label %1440
1456: ; preds = %1440, %1438
br i1 %236, label %1509, label %1457
1457: ; preds = %1386, %1456
%1458 = phi i64 [ 0, %1386 ], [ %231, %1456 ]
%1459 = xor i64 %1458, -1
%1460 = add nsw i64 %1459, %76
br i1 %238, label %1470, label %1461
1461: ; preds = %1457, %1461
%1462 = phi i64 [ %1467, %1461 ], [ %1458, %1457 ]
%1463 = phi i64 [ %1468, %1461 ], [ 0, %1457 ]
%1464 = getelementptr inbounds double, double* %20, i64 %1462
%1465 = load double, double* %1464
%1466 = getelementptr inbounds double, double* %3, i64 %1462
store double %1465, double* %1466
%1467 = add nuw nsw i64 %1462, 1
%1468 = add i64 %1463, 1
%1469 = icmp eq i64 %1468, %237
br i1 %1469, label %1470, label %1461
1470: ; preds = %1461, %1457
%1471 = phi i64 [ %1458, %1457 ], [ %1467, %1461 ]
%1472 = icmp ult i64 %1460, 3
br i1 %1472, label %1509, label %1490
1473: ; preds = %1382, %1473
%1474 = phi i64 [ %1488, %1473 ], [ %1383, %1382 ]
%1475 = getelementptr inbounds double, double* %18, i64 %1474
%1476 = load double, double* %1475
%1477 = getelementptr inbounds double, double* %2, i64 %1474
store double %1476, double* %1477
%1478 = getelementptr inbounds double, double* %9, i64 %1474
%1479 = load double, double* %1478
%1480 = fmul double %1476, %1479
store double %1480, double* %1475
%1481 = add nuw nsw i64 %1474, 1
%1482 = getelementptr inbounds double, double* %18, i64 %1481
%1483 = load double, double* %1482
%1484 = getelementptr inbounds double, double* %2, i64 %1481
store double %1483, double* %1484
%1485 = getelementptr inbounds double, double* %9, i64 %1481
%1486 = load double, double* %1485
%1487 = fmul double %1483, %1486
store double %1487, double* %1482
%1488 = add nuw nsw i64 %1474, 2
%1489 = icmp eq i64 %1488, %87
br i1 %1489, label %1385, label %1473
1490: ; preds = %1470, %1490
%1491 = phi i64 [ %1507, %1490 ], [ %1471, %1470 ]
%1492 = getelementptr inbounds double, double* %20, i64 %1491
%1493 = load double, double* %1492
%1494 = getelementptr inbounds double, double* %3, i64 %1491
store double %1493, double* %1494
%1495 = add nuw nsw i64 %1491, 1
%1496 = getelementptr inbounds double, double* %20, i64 %1495
%1497 = load double, double* %1496
%1498 = getelementptr inbounds double, double* %3, i64 %1495
store double %1497, double* %1498
%1499 = add nuw nsw i64 %1491, 2
%1500 = getelementptr inbounds double, double* %20, i64 %1499
%1501 = load double, double* %1500
%1502 = getelementptr inbounds double, double* %3, i64 %1499
store double %1501, double* %1502
%1503 = add nuw nsw i64 %1491, 3
%1504 = getelementptr inbounds double, double* %20, i64 %1503
%1505 = load double, double* %1504
%1506 = getelementptr inbounds double, double* %3, i64 %1503
store double %1505, double* %1506
%1507 = add nuw nsw i64 %1491, 4
%1508 = icmp eq i64 %1507, %88
br i1 %1508, label %1509, label %1490
1509: ; preds = %1470, %1490, %1456, %1385
%1510 = call i32 (i32, double*, ...) bitcast (i32 (...)* @lm_enorm to i32 (i32, double*, ...)*)(i32 %1, double* %18)
%1511 = sitofp i32 %1510 to double
%1512 = add nsw i32 %1005, 1
br label %1513
1513: ; preds = %1509, %1294
%1514 = phi double [ %1141, %1509 ], [ %1003, %1294 ]
%1515 = phi i32 [ %1512, %1509 ], [ %1005, %1294 ]
%1516 = phi double [ %1511, %1509 ], [ %1006, %1294 ]
%1517 = fcmp ugt double %1514, 0x380B38FB9DAA78E4
br i1 %1517, label %1518, label %1549
1518: ; preds = %1513
%1519 = call double @llvm.fabs.f64(double %1149)
%1520 = fcmp ugt double %1519, %4
%1521 = fcmp ugt double %1260, %4
%1522 = select i1 %1520, i1 true, i1 %1521
%1523 = fmul double %1266, 5.000000e-01
%1524 = fcmp ugt double %1523, 1.000000e+00
%1525 = select i1 %1522, i1 true, i1 %1524
%1526 = xor i1 %1525, true
%1527 = zext i1 %1526 to i32
store i32 %1527, i32* %12
%1528 = fmul double %1516, %5
%1529 = fcmp ugt double %1295, %1528
br i1 %1529, label %1532, label %1530
1530: ; preds = %1518
%1531 = select i1 %1525, i32 2, i32 3
br label %1549
1532: ; preds = %1518
br i1 %1525, label %1533, label %1551
1533: ; preds = %1532
%1534 = load i32, i32* %13
%1535 = icmp slt i32 %1534, %7
br i1 %1535, label %1536, label %1549
1536: ; preds = %1533
%1537 = fcmp ugt double %1519, 1.200000e-16
%1538 = fcmp ugt double %1260, 1.200000e-16
%1539 = select i1 %1537, i1 true, i1 %1538
%1540 = select i1 %1539, i1 true, i1 %1524
br i1 %1540, label %1541, label %1549
1541: ; preds = %1536
%1542 = fmul double %1516, 1.200000e-16
%1543 = fcmp ole double %1295, %1542
%1544 = select i1 %1543, i1 true, i1 %1001
br i1 %1544, label %1547, label %1545
1545: ; preds = %1541
%1546 = fcmp olt double %1266, 1.000000e-04
br i1 %1546, label %1002, label %239
1547: ; preds = %1541
%1548 = select i1 %1543, i32 7, i32 8
br label %1549
1549: ; preds = %52, %998, %1547, %1513, %1533, %1536, %66, %25, %34, %1530
%1550 = phi i32 [ %1531, %1530 ], [ 10, %34 ], [ 10, %25 ], [ 0, %66 ], [ %1548, %1547 ], [ 0, %1513 ], [ 5, %1533 ], [ 6, %1536 ], [ 4, %998 ], [ 10, %52 ]
store i32 %1550, i32* %12
br label %1551
1551: ; preds = %260, %1532, %1136, %1549, %63
ret void
}