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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double dmax1(double, double);
double dmin1(double, double);
double enorm(int, double *);
double fabs(double);
int /*<<< orphan*/ fdjac2(void (*)(int, int, double *, double *, int *, void *),
                          int, int, double *, double *, double *, int, int *,
                          double, double *, void *);
int /*<<< orphan*/ lmpar(int, double *, int, int *, double *, double *, double,
                         double *, double *, double *, double *, double *);
scalar_t__ mod(int, int);
int /*<<< orphan*/ qrfac(int, int, double *, int, int, int *, int, double *,
                         double *, double *);
double sqrt(double);
void lmdif_C(void (*fcn)(int, int, double[], double[], int *, void *), 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 nprint, int *info, int *nfev, double fjac[],
             int ldfjac, int ipvt[], double qtf[], double wa1[], double wa2[],
             double wa3[], double wa4[], void *data) {
  int i;
  int iflag;
  int ij;
  int jj;
  int iter;
  int j;
  int l;
  double actred;
  double delta;
  double dirder;
  double fnorm;
  double fnorm1;
  double gnorm;
  double par;
  double pnorm;
  double prered;
  double ratio;
  double sum;
  double temp;
  double temp1;
  double temp2;
  double temp3;
  double xnorm;
  static double one = 1.0;
  static double p1 = 0.1;
  static double p5 = 0.5;
  static double p25 = 0.25;
  static double p75 = 0.75;
  static double p0001 = 1.0e-4;
  static double zero = 0.0;
  static double p05 = 0.05;
  *info = 0;
  iflag = 0;
  *nfev = 0;
  if ((n <= 0) || (m < n) || (ldfjac < m) || (ftol < zero) || (xtol < zero) ||
      (gtol < zero) || (maxfev <= 0) || (factor <= zero))
    goto L300;
  if (mode == 2) {
    for (j = 0; j < n; j++) {
      if (diag[j] <= 0.0)
        goto L300;
    }
  }
  iflag = 1;
  fcn(m, n, x, fvec, &iflag, data);
  *nfev = 1;
  if (iflag < 0)
    goto L300;
  fnorm = enorm(m, fvec);
  par = zero;
  iter = 1;
L30:
  iflag = 2;
  fdjac2(fcn, m, n, x, fvec, fjac, ldfjac, &iflag, epsfcn, wa4, data);
  if (iflag < 0)
    goto L300;
  if (nprint > 0) {
    iflag = 0;
    if (mod(iter - 1, nprint) == 0) {
      fcn(m, n, x, fvec, &iflag, data);
      if (iflag < 0)
        goto L300;
    }
  }
  qrfac(m, n, fjac, ldfjac, 1, ipvt, n, wa1, wa2, wa3);
  if (iter == 1) {
    if (mode != 2) {
      for (j = 0; j < n; j++) {
        diag[j] = wa2[j];
        if (wa2[j] == zero)
          diag[j] = one;
      }
    }
    for (j = 0; j < n; j++)
      wa3[j] = diag[j] * x[j];
    xnorm = enorm(n, wa3);
    delta = factor * xnorm;
    if (fabs(delta) <= 1e-4)
      delta = factor;
  }
  for (i = 0; i < m; i++)
    wa4[i] = fvec[i];
  jj = 0;
  for (j = 0; j < n; j++) {
    temp3 = fjac[jj];
    if (temp3 != zero) {
      sum = zero;
      ij = jj;
      for (i = j; i < m; i++) {
        sum += fjac[ij] * wa4[i];
        ij += 1;
      }
      temp = -sum / temp3;
      ij = jj;
      for (i = j; i < m; i++) {
        wa4[i] += fjac[ij] * temp;
        ij += 1;
      }
    }
    fjac[jj] = wa1[j];
    jj += m + 1;
    qtf[j] = wa4[j];
  }
  gnorm = zero;
  if (fnorm != zero) {
    jj = 0;
    for (j = 0; j < n; j++) {
      l = ipvt[j];
      if (wa2[l] != zero) {
        sum = zero;
        ij = jj;
        for (i = 0; i <= j; i++) {
          sum += fjac[ij] * (qtf[i] / fnorm);
          ij += 1;
        }
        gnorm = dmax1(gnorm, fabs(sum / wa2[l]));
      }
      jj += m;
    }
  }
  if (gnorm <= gtol)
    *info = 4;
  if (*info != 0)
    goto L300;
  if (mode != 2) {
    for (j = 0; j < n; j++)
      diag[j] = dmax1(diag[j], wa2[j]);
  }
L200:
  lmpar(n, fjac, ldfjac, ipvt, diag, qtf, delta, &par, wa1, wa2, wa3, wa4);
  for (j = 0; j < n; j++) {
    wa1[j] = -wa1[j];
    wa2[j] = x[j] + wa1[j];
    wa3[j] = diag[j] * wa1[j];
  }
  pnorm = enorm(n, wa3);
  if (iter == 1)
    delta = dmin1(delta, pnorm);
  iflag = 1;
  fcn(m, n, wa2, wa4, &iflag, data);
  *nfev += 1;
  if (iflag < 0)
    goto L300;
  fnorm1 = enorm(m, wa4);
  actred = -one;
  if ((p1 * fnorm1) < fnorm) {
    temp = fnorm1 / fnorm;
    actred = one - temp * temp;
  }
  jj = 0;
  for (j = 0; j < n; j++) {
    wa3[j] = zero;
    l = ipvt[j];
    temp = wa1[l];
    ij = jj;
    for (i = 0; i <= j; i++) {
      wa3[i] += fjac[ij] * temp;
      ij += 1;
    }
    jj += m;
  }
  temp1 = enorm(n, wa3) / fnorm;
  temp2 = (sqrt(par) * pnorm) / fnorm;
  prered = temp1 * temp1 + (temp2 * temp2) / p5;
  dirder = -(temp1 * temp1 + temp2 * temp2);
  ratio = zero;
  if (prered != zero)
    ratio = actred / prered;
  if (ratio <= p25) {
    if (actred >= zero)
      temp = p5;
    else
      temp = p5 * dirder / (dirder + p5 * actred);
    if (((p1 * fnorm1) >= fnorm) || (temp < p1))
      temp = p1;
    delta = temp * dmin1(delta, pnorm / p1);
    par = par / temp;
  } else {
    if ((par == zero) || (ratio >= p75)) {
      delta = pnorm / p5;
      par = p5 * par;
    }
  }
  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 = enorm(n, wa2);
    fnorm = fnorm1;
    iter += 1;
  }
  if ((fabs(actred) <= ftol) && (prered <= ftol) && (p5 * ratio <= one)) {
    *info = 1;
  }
  if (delta <= xtol * xnorm)
    *info = 2;
  if ((fabs(actred) <= ftol) && (prered <= ftol) && (p5 * ratio <= one) &&
      (*info == 2)) {
    *info = 3;
  }
  if (*info != 0)
    goto L300;
  if (*nfev >= maxfev)
    *info = 5;
  if ((fabs(actred) <= 1.2e-16) && (prered <= 1.2e-16) && (p5 * ratio <= one)) {
    *info = 6;
  }
  if (delta <= 1.2e-16 * xnorm)
    *info = 7;
  if (gnorm <= 1.2e-16)
    *info = 8;
  if (*info != 0)
    goto L300;
  if (ratio < p0001)
    goto L200;
  goto L30;
L300:
  if (iflag < 0)
    *info = iflag;
  iflag = 0;
  if (nprint > 0)
    fcn(m, n, x, fvec, &iflag, data);
}


x86 assembly (clang, -O0):
<lmdif_C>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x120,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
mov    %r9d,-0x4c(%rbp)
movsd  %xmm3,-0x58(%rbp)
movsd  %xmm4,-0x60(%rbp)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x68(%rbp)
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
cmpl   $0x0,-0x20(%rbp)
jle    1295 <lmdif_C+0x115>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1295 <lmdif_C+0x115>
mov    0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     1295 <lmdif_C+0x115>
movsd  -0x38(%rbp),%xmm1
movsd  0x3e64(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1295 <lmdif_C+0x115>
movsd  -0x40(%rbp),%xmm1
movsd  0x3e4d(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1295 <lmdif_C+0x115>
movsd  -0x48(%rbp),%xmm1
movsd  0x3e36(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1295 <lmdif_C+0x115>
cmpl   $0x0,-0x4c(%rbp)
jle    1295 <lmdif_C+0x115>
movsd  -0x60(%rbp),%xmm1
movsd  0x3e15(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     129a <lmdif_C+0x11a>
jmp    21ad <lmdif_C+0x102d>
cmpl   $0x2,0x18(%rbp)
jne    12ea <lmdif_C+0x16a>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12e5 <lmdif_C+0x165>
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     12d2 <lmdif_C+0x152>
jmp    21ad <lmdif_C+0x102d>
jmp    12d7 <lmdif_C+0x157>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    12ab <lmdif_C+0x12b>
jmp    12ea <lmdif_C+0x16a>
movl   $0x1,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x78(%rbp),%r9
lea    -0x68(%rbp),%r8
call   *%rax
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x0,-0x68(%rbp)
jge    1326 <lmdif_C+0x1a6>
jmp    21ad <lmdif_C+0x102d>
mov    -0x1c(%rbp),%edi
mov    -0x30(%rbp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x3d5e(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x1,-0x74(%rbp)
movl   $0x2,-0x68(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    0x38(%rbp),%r9
mov    0x40(%rbp),%ebx
movsd  -0x58(%rbp),%xmm0
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
lea    -0x68(%rbp),%r11
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1050 <fdjac2@plt>
cmpl   $0x0,-0x68(%rbp)
jge    13a8 <lmdif_C+0x228>
jmp    21ad <lmdif_C+0x102d>
cmpl   $0x0,0x20(%rbp)
jle    1406 <lmdif_C+0x286>
movl   $0x0,-0x68(%rbp)
mov    -0x74(%rbp),%edi
sub    $0x1,%edi
mov    0x20(%rbp),%esi
call   1030 <mod@plt>
cmp    $0x0,%rax
jne    1401 <lmdif_C+0x281>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x78(%rbp),%r9
lea    -0x68(%rbp),%r8
call   *%rax
cmpl   $0x0,-0x68(%rbp)
jge    13fc <lmdif_C+0x27c>
jmp    21ad <lmdif_C+0x102d>
jmp    1401 <lmdif_C+0x281>
jmp    1406 <lmdif_C+0x286>
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    0x38(%rbp),%rdx
mov    0x40(%rbp),%ecx
mov    0x48(%rbp),%r9
mov    -0x20(%rbp),%ebx
mov    0x58(%rbp),%r11
mov    0x60(%rbp),%r10
mov    0x68(%rbp),%rax
mov    $0x1,%r8d
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1040 <qrfac@plt>
cmpl   $0x1,-0x74(%rbp)
jne    157a <lmdif_C+0x3fa>
cmpl   $0x2,0x18(%rbp)
je     14d2 <lmdif_C+0x352>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14cd <lmdif_C+0x34d>
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x3c07(%rip),%xmm0
jne    14ba <lmdif_C+0x33a>
jp     14ba <lmdif_C+0x33a>
movsd  0x3bb3(%rip),%xmm0
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14bf <lmdif_C+0x33f>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    145e <lmdif_C+0x2de>
jmp    14d2 <lmdif_C+0x352>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    151a <lmdif_C+0x39a>
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14d9 <lmdif_C+0x359>
mov    -0x20(%rbp),%edi
mov    0x68(%rbp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x1abe(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1aa2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1575 <lmdif_C+0x3f5>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    157a <lmdif_C+0x3fa>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15b5 <lmdif_C+0x435>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1581 <lmdif_C+0x401>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1756 <lmdif_C+0x5d6>
mov    0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
ucomisd 0x3aac(%rip),%xmm0
jne    1605 <lmdif_C+0x485>
jp     1605 <lmdif_C+0x485>
jmp    1708 <lmdif_C+0x588>
movsd  0x3a93(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1676 <lmdif_C+0x4f6>
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%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    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1621 <lmdif_C+0x4a1>
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    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1703 <lmdif_C+0x583>
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    16b1 <lmdif_C+0x531>
jmp    1708 <lmdif_C+0x588>
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    15c3 <lmdif_C+0x443>
movsd  0x3942(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd 0x392a(%rip),%xmm0
jne    1787 <lmdif_C+0x607>
jp     1787 <lmdif_C+0x607>
jmp    18a0 <lmdif_C+0x720>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    189b <lmdif_C+0x71b>
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x38dc(%rip),%xmm0
jne    17d5 <lmdif_C+0x655>
jp     17d5 <lmdif_C+0x655>
jmp    1884 <lmdif_C+0x704>
movsd  0x38c3(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     184f <lmdif_C+0x6cf>
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
divsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17f2 <lmdif_C+0x672>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movaps 0x179d(%rip),%xmm2
pand   %xmm2,%xmm1
call   1080 <dmax1@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1795 <lmdif_C+0x615>
jmp    18a0 <lmdif_C+0x720>
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     18c1 <lmdif_C+0x741>
mov    0x28(%rbp),%rax
movl   $0x4,(%rax)
mov    0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     18d3 <lmdif_C+0x753>
jmp    21ad <lmdif_C+0x102d>
cmpl   $0x2,0x18(%rbp)
je     192f <lmdif_C+0x7af>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    192a <lmdif_C+0x7aa>
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1080 <dmax1@plt>
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18e4 <lmdif_C+0x764>
jmp    192f <lmdif_C+0x7af>
jmp    1934 <lmdif_C+0x7b4>
mov    -0x20(%rbp),%edi
mov    0x38(%rbp),%rsi
mov    0x40(%rbp),%edx
mov    0x48(%rbp),%rcx
mov    0x10(%rbp),%r8
mov    0x50(%rbp),%r9
movsd  -0x90(%rbp),%xmm0
ff
mov    0x58(%rbp),%rbx
mov    0x60(%rbp),%r11
mov    0x68(%rbp),%r10
mov    0x70(%rbp),%rax
lea    -0xb8(%rbp),%r14
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1060 <lmpar@plt>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1a26 <lmdif_C+0x8a6>
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    198d <lmdif_C+0x80d>
mov    -0x20(%rbp),%edi
mov    0x68(%rbp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
cmpl   $0x1,-0x74(%rbp)
jne    1a61 <lmdif_C+0x8e1>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
call   1090 <dmin1@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    0x60(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x78(%rbp),%r9
lea    -0x68(%rbp),%r8
call   *%rax
mov    0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0x68(%rbp)
jge    1a9e <lmdif_C+0x91e>
jmp    21ad <lmdif_C+0x102d>
mov    -0x1c(%rbp),%edi
mov    0x70(%rbp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x35a6(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x3587(%rip),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1b52 <lmdif_C+0x9d2>
movsd  -0xa8(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x3545(%rip),%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1c1a <lmdif_C+0xa9a>
movsd  0x352c(%rip),%xmm0
mov    0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     1c03 <lmdif_C+0xa83>
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    0x68(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1bb1 <lmdif_C+0xa31>
mov    -0x1c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1b60 <lmdif_C+0x9e0>
mov    -0x20(%rbp),%edi
mov    0x68(%rbp),%rsi
call   1070 <enorm@plt>
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
mulsd  -0xc0(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
divsd  0x33ed(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%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,-0x98(%rbp)
ff
movsd  0x33be(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd 0x33a6(%rip),%xmm0
jne    1d0b <lmdif_C+0xb8b>
jp     1d0b <lmdif_C+0xb8b>
jmp    1d23 <lmdif_C+0xba3>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  0x3345(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1e4d <lmdif_C+0xccd>
movsd  -0x88(%rbp),%xmm0
ff
ucomisd 0x3353(%rip),%xmm0
jb     1d68 <lmdif_C+0xbe8>
movsd  0x3315(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1da4 <lmdif_C+0xc24>
movsd  0x3300(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x32e8(%rip),%xmm1
movsd  -0x88(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x32bc(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jae    1ddc <lmdif_C+0xc5c>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  0x3296(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1dec <lmdif_C+0xc6c>
movsd  0x3284(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
divsd  0x3254(%rip),%xmm1
call   1090 <dmin1@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1eb9 <lmdif_C+0xd39>
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd 0x3243(%rip),%xmm0
jne    1e6e <lmdif_C+0xcee>
jp     1e6e <lmdif_C+0xcee>
jmp    1e84 <lmdif_C+0xd04>
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd 0x3202(%rip),%xmm0
jb     1eb4 <lmdif_C+0xd34>
movsd  -0xc0(%rbp),%xmm0
ff
divsd  0x31dc(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x31cc(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1eb9 <lmdif_C+0xd39>
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd 0x31bf(%rip),%xmm0
jb     1f99 <lmdif_C+0xe19>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1f31 <lmdif_C+0xdb1>
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1ed6 <lmdif_C+0xd56>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1f6c <lmdif_C+0xdec>
mov    0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1f38 <lmdif_C+0xdb8>
mov    -0x20(%rbp),%edi
mov    0x60(%rbp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x1068(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1ffe <lmdif_C+0xe7e>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1ffe <lmdif_C+0xe7e>
movsd  0x3096(%rip),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
movsd  0x3076(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1ffe <lmdif_C+0xe7e>
mov    0x28(%rbp),%rax
movl   $0x1,(%rax)
movsd  -0x90(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2027 <lmdif_C+0xea7>
mov    0x28(%rbp),%rax
movl   $0x2,(%rax)
movsd  -0x88(%rbp),%xmm1
ff
movaps 0xfda(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2099 <lmdif_C+0xf19>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2099 <lmdif_C+0xf19>
movsd  0x3008(%rip),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
movsd  0x2fe8(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     2099 <lmdif_C+0xf19>
mov    0x28(%rbp),%rax
cmpl   $0x2,(%rax)
jne    2099 <lmdif_C+0xf19>
mov    0x28(%rbp),%rax
movl   $0x3,(%rax)
mov    0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     20ab <lmdif_C+0xf2b>
jmp    21ad <lmdif_C+0x102d>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
cmp    -0x4c(%rbp),%eax
jl     20c4 <lmdif_C+0xf44>
mov    0x28(%rbp),%rax
movl   $0x5,(%rax)
movsd  -0x88(%rbp),%xmm1
ff
movaps 0xf3d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xf29(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     212b <lmdif_C+0xfab>
movsd  0xf17(%rip),%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jb     212b <lmdif_C+0xfab>
movsd  0x2f69(%rip),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
movsd  0x2f49(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     212b <lmdif_C+0xfab>
mov    0x28(%rbp),%rax
movl   $0x6,(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  0xecd(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2157 <lmdif_C+0xfd7>
mov    0x28(%rbp),%rax
movl   $0x7,(%rax)
movsd  0xea9(%rip),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jb     2177 <lmdif_C+0xff7>
mov    0x28(%rbp),%rax
movl   $0x8,(%rax)
mov    0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     2189 <lmdif_C+0x1009>
jmp    21ad <lmdif_C+0x102d>
movsd  -0xd0(%rbp),%xmm1
ff
movsd  0x2eef(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    21a8 <lmdif_C+0x1028>
jmp    1934 <lmdif_C+0x7b4>
jmp    1351 <lmdif_C+0x1d1>
cmpl   $0x0,-0x68(%rbp)
jge    21c0 <lmdif_C+0x1040>
mov    -0x68(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x68(%rbp)
cmpl   $0x0,0x20(%rbp)
jle    21ed <lmdif_C+0x106d>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x78(%rbp),%r9
lea    -0x68(%rbp),%r8
call   *%rax
add    $0x120,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmdif_C>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
movsd  %xmm4,0x120(%rsp)
movsd  %xmm3,0x118(%rsp)
mov    %r9d,0x6c(%rsp)
movsd  %xmm2,0x128(%rsp)
movsd  %xmm0,0x130(%rsp)
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdx,0x8(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,0x40(%rsp)
mov    0x250(%rsp),%rcx
mov    0x248(%rsp),%rax
movl   $0x0,(%rax)
movl   $0x0,(%rsp)
movl   $0x0,(%rcx)
xorpd  %xmm0,%xmm0
movsd  %xmm1,0x1d0(%rsp)
ucomisd %xmm1,%xmm0
ja     2c61 <lmdif_C+0x1ae1>
ucomisd 0x130(%rsp),%xmm0
ja     2c61 <lmdif_C+0x1ae1>
cmpl   $0x0,0x8(%rsp)
jle    2c61 <lmdif_C+0x1ae1>
mov    0x10(%rsp),%rax
cmp    0x8(%rsp),%eax
jl     2c61 <lmdif_C+0x1ae1>
mov    0x260(%rsp),%eax
cmp    0x10(%rsp),%eax
jl     2c61 <lmdif_C+0x1ae1>
xorpd  %xmm0,%xmm0
ucomisd 0x128(%rsp),%xmm0
ja     2c61 <lmdif_C+0x1ae1>
cmpl   $0x0,0x6c(%rsp)
jle    2c61 <lmdif_C+0x1ae1>
xorpd  %xmm0,%xmm0
ucomisd 0x120(%rsp),%xmm0
jae    2c61 <lmdif_C+0x1ae1>
mov    0x230(%rsp),%rdx
cmpl   $0x2,0x238(%rsp)
02
jne    12a4 <lmdif_C+0x124>
mov    0x8(%rsp),%eax
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
ucomisd (%rdx,%rcx,8),%xmm0
jae    2c61 <lmdif_C+0x1ae1>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1290 <lmdif_C+0x110>
movl   $0x1,(%rsp)
mov    %rsp,%r8
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    0x298(%rsp),%r9
call   *0x40(%rsp)
mov    0x250(%rsp),%rax
movl   $0x1,(%rax)
mov    (%rsp),%eax
test   %eax,%eax
js     2c68 <lmdif_C+0x1ae8>
mov    0x290(%rsp),%r15
mov    0x258(%rsp),%rbp
mov    0x10(%rsp),%rbx
mov    %ebx,%edi
mov    %r14,%rsi
call   1070 <enorm@plt>
movsd  %xmm0,0x20(%rsp)
movq   $0x0,0x48(%rsp)
movl   $0x2,(%rsp)
mov    0x40(%rsp),%rdi
mov    %ebx,%esi
mov    0x8(%rsp),%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    %rbp,%r9
movsd  0x118(%rsp),%xmm0
push   0x298(%rsp)
push   %r15
lea    0x10(%rsp),%rax
push   %rax
mov    0x278(%rsp),%eax
push   %rax
call   1050 <fdjac2@plt>
add    $0x20,%rsp
mov    (%rsp),%eax
test   %eax,%eax
js     2c68 <lmdif_C+0x1ae8>
mov    0x288(%rsp),%r13
mov    0x280(%rsp),%rcx
mov    0x8(%rsp),%edi
mov    0x10(%rsp),%r9d
lea    (%rcx,%rdi,8),%rbx
mov    %rbx,0x28(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0xe8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe0(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r9d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xc8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    0x230(%rsp),%rsi
cmp    %rsi,%rbx
seta   %bl
lea    (%rsi,%rdi,8),%rbp
mov    %rsi,%r11
cmp    %rcx,%rbp
seta   %r10b
and    %bl,%r10b
mov    %edi,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x168(%rsp)
mov    %rdi,%rsi
neg    %rsi
mov    %rsi,0xf0(%rsp)
cmp    %r13,%rbp
seta   %r8b
lea    0x0(,%rdi,8),%rsi
add    %r13,%rsi
cmp    %r11,%rsi
seta   %bl
and    %r8b,%bl
lea    (%r12,%rdi,8),%r8
cmp    %r13,%r8
mov    %r15,%r11
seta   %r15b
cmp    %r12,%rsi
seta   %cl
and    %r15b,%cl
mov    %r11,%r15
or     %bl,%cl
mov    %cl,0x1e(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rax,%rsi
mov    %rax,0xd8(%rsp)
and    %rax,%rcx
mov    %rcx,0xb8(%rsp)
mov    %edi,%eax
and    $0x3,%eax
mov    %rax,0x178(%rsp)
lea    (%r14,%r9,8),%rax
cmp    %r11,%rax
seta   %al
lea    (%r11,%r9,8),%rcx
mov    %rcx,0x188(%rsp)
cmp    %r14,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdx,%rax
mov    %rdx,0x190(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x88(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0xd0(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x1b8(%rsp)
cmp    %r12,0x28(%rsp)
seta   %al
cmp    0x280(%rsp),%r8
seta   %bl
and    %al,%bl
cmp    %r12,%rbp
seta   %al
cmp    0x230(%rsp),%r8
seta   %dl
and    %al,%dl
or     %bl,%dl
mov    0x10(%rsp),%rbp
lea    0x1(%rbp),%eax
movslq %eax,%rsi
mov    %r10b,0x1d(%rsp)
or     %r10b,%dl
mov    %dl,0x1f(%rsp)
mov    %rdi,0x28(%rsp)
lea    0x0(,%rdi,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0x180(%rsp)
mov    %rcx,0x170(%rsp)
shl    $0x5,%rcx
mov    %rcx,0xf8(%rsp)
mov    0x278(%rsp),%rbx
movslq %ebp,%rcx
mov    0x258(%rsp),%rax
lea    0x8(%rax),%rdx
mov    %rdx,0x78(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0x138(%rsp)
mov    %rcx,0x80(%rsp)
lea    0x8(,%rcx,8),%rcx
mov    %rcx,0x1f0(%rsp)
lea    (%rax,%r9,8),%rcx
mov    %rcx,0x1b0(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x1d8(%rsp)
mov    %rsi,0x1e0(%rsp)
lea    -0x8(,%rsi,8),%rcx
ff
mov    %rcx,0x1a8(%rsp)
lea    -0x1(%r9),%rcx
mov    %rcx,0xb0(%rsp)
lea    0x10(%r11),%rcx
mov    %rcx,0x98(%rsp)
lea    0x10(%r14),%rcx
mov    %rcx,0x90(%rsp)
mov    %r9,0x30(%rsp)
lea    -0x5(%r9),%rcx
mov    %rcx,0x198(%rsp)
lea    0x8(%r11),%rcx
mov    %rcx,0x1a0(%rsp)
add    $0x30,%rax
mov    %rax,0x1c0(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0x1e8(%rsp)
mov    $0x1,%eax
mov    %rax,0x60(%rsp)
mov    %r14,0xa8(%rsp)
mov    %r12,0xa0(%rsp)
cmpl   $0x0,0x240(%rsp)
jle    1673 <lmdif_C+0x4f3>
movl   $0x0,(%rsp)
mov    0x60(%rsp),%rax
lea    -0x1(%rax),%edi
mov    0x240(%rsp),%esi
call   1030 <mod@plt>
test   %rax,%rax
jne    1673 <lmdif_C+0x4f3>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %rsp,%r8
mov    0x298(%rsp),%r9
call   *0x40(%rsp)
mov    (%rsp),%eax
test   %eax,%eax
js     2c68 <lmdif_C+0x1ae8>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x258(%rsp),%rdx
mov    0x260(%rsp),%ecx
mov    $0x1,%r8d
mov    0x268(%rsp),%r9
push   %r13
push   0x288(%rsp)
push   %rbx
push   %rsi
call   1040 <qrfac@plt>
add    $0x20,%rsp
cmpl   $0x1,0x60(%rsp)
mov    %r15,%r11
movsd  0x20(%rsp),%xmm7
xorpd  %xmm8,%xmm8
jne    19d6 <lmdif_C+0x856>
cmpl   $0x2,0x238(%rsp)
02
mov    0x230(%rsp),%rsi
mov    0x280(%rsp),%rdx
mov    0x28(%rsp),%rdi
mov    0x180(%rsp),%rbp
xorpd  %xmm1,%xmm1
movabs $0x3ff0000000000000,%rbx
je     179f <lmdif_C+0x61f>
cmpl   $0x2,0x8(%rsp)
setb   %al
or     0x1d(%rsp),%al
je     1712 <lmdif_C+0x592>
xor    %ecx,%ecx
jmp    1766 <lmdif_C+0x5e6>
xor    %eax,%eax
jmp    1729 <lmdif_C+0x5a9>
cs nopw 0x0(%rax,%rax,1)
add    $0x10,%rax
cmp    %rax,%rbp
je     1756 <lmdif_C+0x5d6>
movupd (%rdx,%rax,1),%xmm0
movupd %xmm0,(%rsi,%rax,1)
ucomisd %xmm8,%xmm0
jne    1740 <lmdif_C+0x5c0>
jp     1740 <lmdif_C+0x5c0>
mov    %rbx,(%rsi,%rax,1)
cmpeqpd %xmm1,%xmm0
pextrw $0x4,%xmm0,%ecx
test   $0x1,%cl
je     1720 <lmdif_C+0x5a0>
mov    %rbx,0x8(%rsi,%rax,1)
jmp    1720 <lmdif_C+0x5a0>
mov    0x168(%rsp),%rax
mov    %rax,%rcx
cmp    %rdi,%rax
je     179f <lmdif_C+0x61f>
mov    %rcx,%rax
test   $0x1,%dil
je     1792 <lmdif_C+0x612>
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
ucomisd %xmm8,%xmm0
jne    178b <lmdif_C+0x60b>
jp     178b <lmdif_C+0x60b>
mov    %rbx,(%rsi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
jne    17c9 <lmdif_C+0x649>
cmpl   $0x4,0x8(%rsp)
setb   %al
or     0x1e(%rsp),%al
je     1807 <lmdif_C+0x687>
xor    %eax,%eax
jmp    18d8 <lmdif_C+0x758>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%rdi
je     179f <lmdif_C+0x61f>
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
ucomisd %xmm8,%xmm0
jne    17e5 <lmdif_C+0x665>
jp     17e5 <lmdif_C+0x665>
mov    %rbx,(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
ucomisd %xmm8,%xmm0
jne    17c0 <lmdif_C+0x640>
jp     17c0 <lmdif_C+0x640>
mov    %rbx,0x8(%rsi,%rax,8)
jmp    17c0 <lmdif_C+0x640>
cmpq   $0x0,0xe0(%rsp)
je     188a <lmdif_C+0x70a>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%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(%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r12,%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    1820 <lmdif_C+0x6a0>
jmp    188c <lmdif_C+0x70c>
xor    %eax,%eax
testb  $0x1,0xd8(%rsp)
01
je     18c4 <lmdif_C+0x744>
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
mov    0xe8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1977 <lmdif_C+0x7f7>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    0x178(%rsp),%rdx
test   %rdx,%rdx
je     190c <lmdif_C+0x78c>
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18f0 <lmdif_C+0x770>
cmp    $0x3,%rcx
jb     1977 <lmdif_C+0x7f7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
mulsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
mulsd  0x18(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1920 <lmdif_C+0x7a0>
mov    0x8(%rsp),%rdi
mov    %r13,%rsi
call   1070 <enorm@plt>
movsd  %xmm0,0x70(%rsp)
movapd %xmm0,%xmm3
movsd  0x120(%rsp),%xmm1
mulsd  %xmm1,%xmm3
movapd %xmm3,%xmm0
andpd  0x1659(%rip),%xmm0
movsd  0x1671(%rip),%xmm2
ucomisd %xmm0,%xmm2
jae    19bd <lmdif_C+0x83d>
movapd %xmm3,0x50(%rsp)
jmp    19c3 <lmdif_C+0x843>
movapd %xmm1,0x50(%rsp)
mov    0x290(%rsp),%r11
movsd  0x20(%rsp),%xmm7
xorpd  %xmm8,%xmm8
cmpl   $0x0,0x10(%rsp)
mov    0x230(%rsp),%r8
mov    0x258(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0xf8(%rsp),%rbp
jle    1b7f <lmdif_C+0x9ff>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0x7(%rsp),%al
je     1a13 <lmdif_C+0x893>
xor    %eax,%eax
jmp    1b03 <lmdif_C+0x983>
cmpq   $0xc,0xc0(%rsp)
jae    1a25 <lmdif_C+0x8a5>
xor    %eax,%eax
jmp    1a9c <lmdif_C+0x91c>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
nop
movups (%r14,%rax,8),%xmm0
movups 0x10(%r14,%rax,8),%xmm1
movups %xmm0,(%r11,%rax,8)
movups %xmm1,0x10(%r11,%rax,8)
movups 0x20(%r14,%rax,8),%xmm0
movups 0x30(%r14,%rax,8),%xmm1
movups %xmm0,0x20(%r11,%rax,8)
movups %xmm1,0x30(%r11,%rax,8)
movups 0x40(%r14,%rax,8),%xmm0
movups 0x50(%r14,%rax,8),%xmm1
movups %xmm0,0x40(%r11,%rax,8)
movups %xmm1,0x50(%r11,%rax,8)
movupd 0x60(%r14,%rax,8),%xmm0
movupd 0x70(%r14,%rax,8),%xmm1
movupd %xmm0,0x60(%r11,%rax,8)
movupd %xmm1,0x70(%r11,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1a30 <lmdif_C+0x8b0>
cmpq   $0x0,0x170(%rsp)
je     1aef <lmdif_C+0x96f>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
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    1ad0 <lmdif_C+0x950>
mov    0xc8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     1b7f <lmdif_C+0x9ff>
mov    0xb0(%rsp),%rcx
sub    %rax,%rcx
mov    0xd0(%rsp),%rdx
test   %rdx,%rdx
je     1b36 <lmdif_C+0x9b6>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1b20 <lmdif_C+0x9a0>
cmp    $0x3,%rcx
jb     1b7f <lmdif_C+0x9ff>
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%r11,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%r11,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%r11,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1b40 <lmdif_C+0x9c0>
mov    0x198(%rsp),%r14
mov    %rdi,%rcx
mov    %r11,%rdx
xor    %r15d,%r15d
xor    %ebp,%ebp
jmp    1bf9 <lmdif_C+0xa79>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x278(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0x258(%rsp),%rdi
movsd  %xmm0,(%rdi,%r15,8)
add    0x1e0(%rsp),%r15
movsd  (%r11,%rbp,8),%xmm0
mov    0x270(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
add    $0x8,%rdx
add    0x1d8(%rsp),%rcx
add    $0xffffffffffffffff,%r14
cmp    0x28(%rsp),%rbp
je     1ed4 <lmdif_C+0xd54>
movsd  (%rdi,%r15,8),%xmm1
ucomisd %xmm8,%xmm1
jne    1c08 <lmdif_C+0xa88>
jnp    1ba0 <lmdif_C+0xa20>
cmp    0x80(%rsp),%rbp
jge    1ba0 <lmdif_C+0xa20>
movsd  (%r11,%rbp,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm8,%xmm0
lea    0x1(%rbp),%r12
cmp    0x30(%rsp),%r12
je     1c57 <lmdif_C+0xad7>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm2
mulsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rax
cmp    %rax,%rsi
jne    1c40 <lmdif_C+0xac0>
cmp    0x80(%rsp),%rbp
jge    1ba0 <lmdif_C+0xa20>
xorpd  0x13a3(%rip),%xmm0
divsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm1
addsd  (%r11,%rbp,8),%xmm1
movsd  %xmm1,(%r11,%rbp,8)
cmp    0x30(%rsp),%r12
je     1ba0 <lmdif_C+0xa20>
mov    %rbp,%r11
not    %r11
mov    0x30(%rsp),%rbx
add    %rbx,%r11
lea    0x1(%r15),%r9
cmp    $0x4,%r11
jb     1cef <lmdif_C+0xb6f>
mov    0x1a8(%rsp),%rax
imul   %rbp,%rax
add    0x1b0(%rsp),%rax
mov    0x290(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdi
add    $0x8,%rdi
cmp    %rdi,%rax
jbe    1d97 <lmdif_C+0xc17>
mov    0x258(%rsp),%rax
lea    (%rax,%r15,8),%rax
add    $0x8,%rax
cmp    0x188(%rsp),%rax
jae    1d97 <lmdif_C+0xc17>
mov    0x290(%rsp),%r11
mov    %ebx,%eax
sub    %r12d,%eax
test   $0x1,%al
jne    1d05 <lmdif_C+0xb85>
mov    %r12,%rax
jmp    1d2c <lmdif_C+0xbac>
mov    0x258(%rsp),%rax
movsd  (%rax,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r11,%r12,8),%xmm1
movsd  %xmm1,(%r11,%r12,8)
add    $0x1,%r9
lea    0x1(%r12),%rax
not    %r12
cmp    0x1b8(%rsp),%r12
je     1ba0 <lmdif_C+0xa20>
mov    0x30(%rsp),%r10
sub    %rax,%r10
mov    0x1a0(%rsp),%rdi
lea    (%rdi,%rax,8),%rbx
mov    0x78(%rsp),%rax
lea    (%rax,%r9,8),%rax
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdi,8)
movsd  (%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    1d60 <lmdif_C+0xbe0>
jmp    1ba0 <lmdif_C+0xa20>
mov    0xb0(%rsp),%rax
sub    %rbp,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rax
jae    1dc6 <lmdif_C+0xc46>
xor    %ebx,%ebx
jmp    1e52 <lmdif_C+0xcd2>
mov    %r14,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd 0x8(%rcx,%rbx,8),%xmm2
movupd 0x18(%rcx,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd 0x8(%rdx,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x18(%rdx,%rbx,8),%xmm2
movupd 0x28(%rdx,%rbx,8),%xmm5
movupd 0x38(%rdx,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,0x8(%rdx,%rbx,8)
movupd %xmm3,0x18(%rdx,%rbx,8)
movupd 0x28(%rcx,%rbx,8),%xmm2
movupd 0x38(%rcx,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x28(%rdx,%rbx,8)
movupd %xmm3,0x38(%rdx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1de0 <lmdif_C+0xc60>
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%r10b
je     1eab <lmdif_C+0xd2b>
lea    (%r12,%rbx,1),%r8
add    %r9,%rbx
mov    0x258(%rsp),%rdi
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
mov    0x290(%rsp),%rbx
movupd (%rbx,%r8,8),%xmm4
movupd 0x10(%rbx,%r8,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%r8,8)
movupd %xmm3,0x10(%rbx,%r8,8)
cmp    %rax,%r11
mov    0x230(%rsp),%r8
mov    0x290(%rsp),%r11
je     1ba0 <lmdif_C+0xa20>
add    %rax,%r12
add    %rax,%r9
mov    0x30(%rsp),%rbx
jmp    1cf7 <lmdif_C+0xb77>
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm7
mov    0x280(%rsp),%r10
jne    2adb <lmdif_C+0x195b>
jp     2adb <lmdif_C+0x195b>
movsd  0x128(%rsp),%xmm0
ucomisd %xmm4,%xmm0
jae    2cb4 <lmdif_C+0x1b34>
movsd  %xmm4,0x100(%rsp)
mov    0x248(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0xa8(%rsp),%r14
mov    0xa0(%rsp),%r12
mov    0x258(%rsp),%r15
jne    2c61 <lmdif_C+0x1ae1>
cmpl   $0x2,0x238(%rsp)
02
mov    0x28(%rsp),%rbp
je     1f80 <lmdif_C+0xe00>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r8,%rbx,8),%xmm0
movsd  (%r10,%rbx,8),%xmm1
call   1080 <dmax1@plt>
mov    0x280(%rsp),%r10
mov    0x230(%rsp),%r8
movsd  %xmm0,(%r8,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1f50 <lmdif_C+0xdd0>
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
mov    0x290(%rsp),%rbp
movapd 0x50(%rsp),%xmm8
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
mov    0x268(%rsp),%edx
mov    0x270(%rsp),%rcx
mov    0x278(%rsp),%r9
movapd %xmm8,0x58(%rsp)
movapd %xmm8,%xmm0
push   %rbp
push   %r13
push   %r10
mov    0x298(%rsp),%rbx
push   %rbx
lea    0x70(%rsp),%rax
push   %rax
call   1060 <lmpar@plt>
mov    0x2b0(%rsp),%rdx
mov    0x260(%rsp),%rcx
add    $0x30,%rsp
xor    %eax,%eax
mov    0x28(%rsp),%rsi
movapd 0x1005(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,(%rbx,%rax,8)
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2010 <lmdif_C+0xe90>
mov    0x8(%rsp),%rdi
mov    %r13,%rsi
call   1070 <enorm@plt>
cmpl   $0x1,0x60(%rsp)
movsd  %xmm0,0x110(%rsp)
jne    207d <lmdif_C+0xefd>
movapd %xmm0,%xmm1
movapd 0x50(%rsp),%xmm0
call   1090 <dmin1@plt>
movapd %xmm0,0x50(%rsp)
mov    0x290(%rsp),%rcx
movl   $0x1,(%rsp)
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x280(%rsp),%rdx
mov    %rsp,%r8
mov    0x298(%rsp),%r9
mov    %rcx,%rbx
call   *0x40(%rsp)
mov    0x250(%rsp),%rax
addl   $0x1,(%rax)
mov    (%rsp),%eax
test   %eax,%eax
js     2c68 <lmdif_C+0x1ae8>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
call   1070 <enorm@plt>
movapd %xmm0,%xmm2
movsd  0xf49(%rip),%xmm1
mulsd  %xmm1,%xmm2
movsd  0x38(%rsp),%xmm1
movsd  %xmm2,0x1c8(%rsp)
ucomisd %xmm2,%xmm1
movsd  0xf32(%rip),%xmm2
jbe    211a <lmdif_C+0xf9a>
movapd %xmm0,%xmm1
divsd  0x38(%rsp),%xmm1
mulsd  %xmm1,%xmm1
movsd  0xf22(%rip),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,0x150(%rsp)
mov    $0x1,%r11d
mov    $0xfffffffffffffffd,%r10
mov    0x1c0(%rsp),%rdx
xor    %r8d,%r8d
xor    %esi,%esi
mov    0x258(%rsp),%r15
jmp    2176 <lmdif_C+0xff6>
nopw   0x0(%rax,%rax,1)
add    0x80(%rsp),%rsi
add    $0x1,%r11
add    0x138(%rsp),%rdx
add    $0x1,%r10
mov    0x28(%rsp),%rbx
cmp    %rbx,%r8
je     23a0 <lmdif_C+0x1220>
mov    %r8,%rdi
lea    -0x3(%r8),%r9
add    $0x1,%r8
mov    %rdi,%rcx
movq   $0x0,0x0(%r13,%rdi,8)
mov    0x268(%rsp),%rax
movslq (%rax,%rdi,4),%rax
mov    0x278(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm7
sub    $0x3,%rcx
jb     21d6 <lmdif_C+0x1056>
mov    0x1f0(%rsp),%rax
imul   %rdi,%rax
add    0x78(%rsp),%rax
cmp    %r13,%rax
jbe    2200 <lmdif_C+0x1080>
lea    (%r15,%rsi,8),%rax
lea    0x8(,%rdi,8),%rbx
add    %r13,%rbx
cmp    %rbx,%rax
jae    2200 <lmdif_C+0x1080>
mov    %rsi,%rcx
xor    %eax,%eax
test   $0x1,%r11b
jne    2310 <lmdif_C+0x1190>
mov    %rax,%rbx
cmp    %rax,%rdi
je     2150 <lmdif_C+0xfd0>
jmp    233c <lmdif_C+0x11bc>
cs nopw 0x0(%rax,%rax,1)
shr    $0x2,%r9
add    $0x1,%r9
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
cmp    $0x4,%rcx
jae    221d <lmdif_C+0x109d>
xor    %ebp,%ebp
jmp    22a9 <lmdif_C+0x1129>
mov    %r10,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebp,%ebp
xchg   %ax,%ax
movupd -0x30(%rdx,%rbp,8),%xmm2
movupd -0x20(%rdx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd 0x0(%r13,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r13,%rbp,8),%xmm2
movupd 0x20(%r13,%rbp,8),%xmm5
movupd 0x30(%r13,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,0x0(%r13,%rbp,8)
movupd %xmm3,0x10(%r13,%rbp,8)
movupd -0x10(%rdx,%rbp,8),%xmm2
movupd (%rdx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r13,%rbp,8)
movupd %xmm3,0x30(%r13,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    2230 <lmdif_C+0x10b0>
mov    %r8,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%r9b
je     22f3 <lmdif_C+0x1173>
lea    (%rsi,%rbp,1),%rcx
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
movupd 0x0(%r13,%rbp,8),%xmm4
movupd 0x10(%r13,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,0x0(%r13,%rbp,8)
movupd %xmm3,0x10(%r13,%rbp,8)
cmp    %rax,%r8
je     2150 <lmdif_C+0xfd0>
lea    (%rsi,%rax,1),%rcx
test   $0x1,%r11b
je     21e5 <lmdif_C+0x1065>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rcx
mov    %rax,%rbx
or     $0x1,%rbx
cmp    %rax,%rdi
je     2150 <lmdif_C+0xfd0>
mov    0x78(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
mov    %r11,%rdi
sub    %rbx,%rdi
mov    0x1e8(%rsp),%rax
lea    (%rax,%rbx,8),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rbx,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  -0x8(%rbp,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    2360 <lmdif_C+0x11e0>
jmp    2150 <lmdif_C+0xfd0>
nopl   0x0(%rax)
movsd  %xmm0,0x20(%rsp)
mov    0x8(%rsp),%rdi
mov    %r13,%rsi
call   1070 <enorm@plt>
movapd %xmm0,%xmm7
movsd  0x48(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     23d0 <lmdif_C+0x1250>
sqrtsd %xmm0,%xmm0
jmp    23eb <lmdif_C+0x126b>
nopl   (%rax)
movapd %xmm7,0x140(%rsp)
call   10a0 <sqrt@plt>
movapd 0x140(%rsp),%xmm7
xorpd  %xmm1,%xmm1
mov    0x290(%rsp),%rbp
mov    0x280(%rsp),%r10
movapd 0xc0c(%rip),%xmm9
movapd 0x50(%rsp),%xmm8
movsd  0x70(%rsp),%xmm2
movapd 0x150(%rsp),%xmm6
movsd  0x110(%rsp),%xmm5
movsd  0x38(%rsp),%xmm3
divsd  %xmm3,%xmm7
mulsd  %xmm5,%xmm0
divsd  %xmm3,%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm4
addsd  %xmm0,%xmm4
mulsd  %xmm7,%xmm7
addsd  %xmm7,%xmm4
xorpd  %xmm10,%xmm10
ucomisd %xmm10,%xmm4
jne    2457 <lmdif_C+0x12d7>
jnp    2461 <lmdif_C+0x12e1>
movapd %xmm6,%xmm10
divsd  %xmm4,%xmm10
movsd  0xbd7(%rip),%xmm3
ucomisd %xmm10,%xmm3
movapd %xmm10,0x140(%rsp)
movsd  %xmm4,0x108(%rsp)
jae    24c0 <lmdif_C+0x1340>
movsd  0x48(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jne    2495 <lmdif_C+0x1315>
jnp    25c1 <lmdif_C+0x1441>
ucomisd 0xbba(%rip),%xmm10
jae    25c1 <lmdif_C+0x1441>
ucomisd 0xb73(%rip),%xmm10
jae    25a4 <lmdif_C+0x1424>
movsd  0x38(%rsp),%xmm3
jmp    2953 <lmdif_C+0x17d3>
xchg   %ax,%ax
ucomisd %xmm1,%xmm6
movsd  0xb7c(%rip),%xmm1
jae    24fb <lmdif_C+0x137b>
addsd  %xmm0,%xmm7
movapd %xmm7,%xmm0
xorpd  %xmm9,%xmm0
mulsd  0xb6d(%rip),%xmm7
movapd %xmm6,%xmm1
mulsd  0xb59(%rip),%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm7
movapd %xmm7,%xmm1
movsd  0xb25(%rip),%xmm2
movapd %xmm2,%xmm0
maxsd  %xmm1,%xmm0
movsd  0x38(%rsp),%xmm3
cmplesd 0x1c8(%rsp),%xmm3
movapd %xmm3,%xmm1
andnpd %xmm0,%xmm1
andpd  %xmm2,%xmm3
orpd   %xmm1,%xmm3
movapd %xmm3,0x50(%rsp)
divsd  %xmm2,%xmm5
movapd %xmm8,%xmm0
movapd %xmm5,%xmm1
call   1090 <dmin1@plt>
movapd 0x150(%rsp),%xmm6
movapd %xmm0,%xmm8
movapd 0x50(%rsp),%xmm1
mulsd  %xmm1,%xmm8
movsd  0x48(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0x290(%rsp),%rbp
mov    0x280(%rsp),%r10
movsd  0x70(%rsp),%xmm2
movapd 0x140(%rsp),%xmm10
movsd  0x108(%rsp),%xmm4
ucomisd 0xa82(%rip),%xmm10
jb     24b3 <lmdif_C+0x1333>
cmpl   $0x4,0x8(%rsp)
setb   %al
or     0x1f(%rsp),%al
mov    0x230(%rsp),%rdx
je     25e8 <lmdif_C+0x1468>
xor    %ecx,%ecx
jmp    26ea <lmdif_C+0x156a>
addsd  %xmm5,%xmm5
mulsd  0xa7b(%rip),%xmm0
movsd  %xmm0,0x48(%rsp)
movapd %xmm5,%xmm8
ucomisd 0xa3f(%rip),%xmm10
jae    25a4 <lmdif_C+0x1424>
jmp    24b3 <lmdif_C+0x1333>
cmpq   $0x0,0xe0(%rsp)
je     27a1 <lmdif_C+0x1621>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r10,%rax,8),%xmm0
movupd 0x10(%r10,%rax,8),%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r10,%rax,8)
movupd %xmm3,0x10(%r10,%rax,8)
movupd 0x20(%r10,%rax,8),%xmm0
movupd 0x30(%r10,%rax,8),%xmm1
movupd %xmm0,0x20(%r12,%rax,8)
movupd %xmm1,0x30(%r12,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm2
movupd 0x30(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r10,%rax,8)
movupd %xmm3,0x30(%r10,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2610 <lmdif_C+0x1490>
testb  $0x1,0xd8(%rsp)
01
je     26da <lmdif_C+0x155a>
movupd (%r10,%rax,8),%xmm0
movupd 0x10(%r10,%rax,8),%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd (%rdx,%rax,8),%xmm2
movupd 0x10(%rdx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r10,%rax,8)
movupd %xmm3,0x10(%r10,%rax,8)
mov    0xe8(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     275b <lmdif_C+0x15db>
mov    %rcx,%rax
test   $0x1,%bl
je     2710 <lmdif_C+0x1590>
movsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mulsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
je     275b <lmdif_C+0x15db>
nopl   (%rax)
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
mulsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r10,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    2720 <lmdif_C+0x15a0>
movapd %xmm8,0x50(%rsp)
cmpl   $0x0,0x10(%rsp)
mov    0x30(%rsp),%rsi
mov    0xf8(%rsp),%rdi
jle    28fc <lmdif_C+0x177c>
cmpl   $0x4,0x10(%rsp)
setb   %al
or     0x7(%rsp),%al
je     278f <lmdif_C+0x160f>
xor    %eax,%eax
jmp    287f <lmdif_C+0x16ff>
cmpq   $0xc,0xc0(%rsp)
jae    27b6 <lmdif_C+0x1636>
xor    %eax,%eax
jmp    2825 <lmdif_C+0x16a5>
xor    %eax,%eax
testb  $0x1,0xd8(%rsp)
01
jne    26a0 <lmdif_C+0x1520>
jmp    26da <lmdif_C+0x155a>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups 0x20(%rbp,%rax,8),%xmm0
movups 0x30(%rbp,%rax,8),%xmm1
movups %xmm0,0x20(%r14,%rax,8)
movups %xmm1,0x30(%r14,%rax,8)
movups 0x40(%rbp,%rax,8),%xmm0
movups 0x50(%rbp,%rax,8),%xmm1
movups %xmm0,0x40(%r14,%rax,8)
movups %xmm1,0x50(%r14,%rax,8)
movupd 0x60(%rbp,%rax,8),%xmm0
movupd 0x70(%rbp,%rax,8),%xmm1
movupd %xmm0,0x60(%r14,%rax,8)
movupd %xmm1,0x70(%r14,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    27c0 <lmdif_C+0x1640>
testb  $0x3,0x190(%rsp)
03
je     286f <lmdif_C+0x16ef>
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x98(%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,%rdi
jne    2850 <lmdif_C+0x16d0>
mov    0xc8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     28fc <lmdif_C+0x177c>
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
test   $0x3,%sil
je     28b6 <lmdif_C+0x1736>
mov    0xd0(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    28a0 <lmdif_C+0x1720>
cmp    $0x3,%rcx
jb     28fc <lmdif_C+0x177c>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    28c0 <lmdif_C+0x1740>
mov    0x8(%rsp),%rdi
mov    %r10,%rsi
call   1070 <enorm@plt>
mov    0x280(%rsp),%r10
mov    0x290(%rsp),%rbp
movapd %xmm0,%xmm2
mov    0x60(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x60(%rsp)
movsd  0x20(%rsp),%xmm3
movapd 0x50(%rsp),%xmm8
movapd 0x150(%rsp),%xmm6
movapd 0x140(%rsp),%xmm10
movsd  0x108(%rsp),%xmm4
andpd  0x6a5(%rip),%xmm6
movsd  0x130(%rsp),%xmm0
ucomisd %xmm6,%xmm0
setb   %al
ucomisd %xmm4,%xmm0
setb   %cl
or     %al,%cl
movapd %xmm10,%xmm0
mulsd  0x6c7(%rip),%xmm0
movsd  0x6af(%rip),%xmm1
ucomisd %xmm0,%xmm1
setb   %al
or     %cl,%al
movapd %xmm2,%xmm1
mulsd  0x1d0(%rsp),%xmm1
cmp    $0x1,%al
jne    29aa <lmdif_C+0x182a>
ucomisd %xmm8,%xmm1
jb     29c1 <lmdif_C+0x1841>
ucomisd %xmm8,%xmm1
mov    $0x2,%ecx
sbb    $0x0,%ecx
mov    0x248(%rsp),%rdx
mov    %ecx,(%rdx)
mov    0x248(%rsp),%rcx
mov    (%rcx),%ecx
test   %al,%al
mov    0x230(%rsp),%r8
jne    29e0 <lmdif_C+0x1860>
cmp    $0x2,%ecx
je     2c20 <lmdif_C+0x1aa0>
test   %ecx,%ecx
jne    2c61 <lmdif_C+0x1ae1>
movsd  0x648(%rip),%xmm1
ucomisd %xmm0,%xmm1
setb   %al
movsd  0x661(%rip),%xmm1
ucomisd 0x100(%rsp),%xmm1
setb   %cl
ucomisd %xmm6,%xmm1
setb   %dl
ucomisd %xmm4,%xmm1
setb   %bl
or     %dl,%bl
or     %al,%bl
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
ucomisd %xmm8,%xmm0
setb   %al
and    %cl,%al
and    %bl,%al
cmp    $0x1,%al
jne    2c27 <lmdif_C+0x1aa7>
mov    0x6c(%rsp),%ecx
mov    0x250(%rsp),%rdx
cmp    %ecx,(%rdx)
jge    2c27 <lmdif_C+0x1aa7>
movsd  %xmm2,0x70(%rsp)
movsd  0x5c5(%rip),%xmm0
ucomisd %xmm10,%xmm0
movsd  %xmm3,0x38(%rsp)
ja     1fa0 <lmdif_C+0xe20>
movapd %xmm8,0x50(%rsp)
movsd  %xmm3,0x20(%rsp)
movl   $0x2,(%rsp)
mov    0x40(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    %r15,%r9
movsd  0x118(%rsp),%xmm0
push   0x298(%rsp)
push   %rbp
lea    0x10(%rsp),%rax
push   %rax
mov    0x278(%rsp),%eax
push   %rax
mov    %rbp,%r15
call   1050 <fdjac2@plt>
add    $0x20,%rsp
mov    (%rsp),%eax
test   %eax,%eax
mov    0x278(%rsp),%rbx
jns    161f <lmdif_C+0x49f>
jmp    2c68 <lmdif_C+0x1ae8>
xorpd  %xmm4,%xmm4
mov    $0x1,%ebp
mov    0x78(%rsp),%r15
xor    %ebx,%ebx
xor    %r12d,%r12d
xor    %r14d,%r14d
jmp    2b77 <lmdif_C+0x19f7>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm2
divsd  %xmm7,%xmm2
mov    0x258(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
andpd  0x4da(%rip),%xmm1
movapd %xmm4,%xmm0
call   1080 <dmax1@plt>
movsd  0x20(%rsp),%xmm7
movapd %xmm0,%xmm4
mov    0x230(%rsp),%r8
mov    0x280(%rsp),%r10
xorpd  %xmm8,%xmm8
mov    0x80(%rsp),%rax
add    %rax,%r14
add    $0x1,%r12
add    $0x1,%rbp
sub    %rax,%rbx
add    0x138(%rsp),%r15
cmp    0x28(%rsp),%r12
je     1ef0 <lmdif_C+0xd70>
mov    0x268(%rsp),%rax
movslq (%rax,%r12,4),%rax
movsd  (%r10,%rax,8),%xmm0
ucomisd %xmm8,%xmm0
jne    2b92 <lmdif_C+0x1a12>
jnp    2b4e <lmdif_C+0x19ce>
test   %r12,%r12
je     2c00 <lmdif_C+0x1a80>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x270(%rsp),%rdx
nopl   0x0(%rax)
movsd  (%rdx,%rax,8),%xmm2
divsd  %xmm7,%xmm2
mulsd  -0x8(%r15,%rax,8),%xmm2
movsd  0x8(%rdx,%rax,8),%xmm3
divsd  %xmm7,%xmm3
mulsd  (%r15,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movapd %xmm3,%xmm1
addsd  %xmm2,%xmm1
add    $0x2,%rax
cmp    %rax,%rcx
jne    2bb0 <lmdif_C+0x1a30>
mov    %rax,%rcx
sub    %rbx,%rcx
test   $0x1,%bpl
je     2b1a <lmdif_C+0x199a>
jmp    2b00 <lmdif_C+0x1980>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    %r14,%rcx
xor    %eax,%eax
mov    0x270(%rsp),%rdx
test   $0x1,%bpl
je     2b1a <lmdif_C+0x199a>
jmp    2b00 <lmdif_C+0x1980>
mov    $0x3,%eax
jmp    2c57 <lmdif_C+0x1ad7>
ucomisd %xmm8,%xmm0
mov    $0x7,%ecx
sbb    $0x0,%ecx
movsd  0x424(%rip),%xmm0
ucomisd 0x100(%rsp),%xmm0
mov    $0x8,%edx
cmovb  %ecx,%edx
test   %al,%al
mov    $0x5,%eax
cmove  %edx,%eax
mov    0x248(%rsp),%rcx
mov    %eax,(%rcx)
mov    (%rsp),%eax
test   %eax,%eax
jns    2c72 <lmdif_C+0x1af2>
mov    0x248(%rsp),%rcx
mov    %eax,(%rcx)
movl   $0x0,(%rsp)
cmpl   $0x0,0x240(%rsp)
jle    2ca2 <lmdif_C+0x1b22>
mov    %rsp,%r8
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    0x298(%rsp),%r9
call   *0x40(%rsp)
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x4,%eax
mov    0xa8(%rsp),%r14
mov    0xa0(%rsp),%r12
jmp    2c57 <lmdif_C+0x1ad7>

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

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