int lmdif(int (*func)(void *d, int n, int m, double *p, double *hx, int iflag),
          void *d, 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 *nfev, double *fjac,
          int ldfjac, int *ipvt, double *qtf, double *wa1, double *wa2,
          double *wa3, double *wa4) {
  double d1, d2;
  int i, j, l;
  double par, sum;
  int iter;
  double temp, temp1, temp2;
  int iflag;
  double delta = 0.;
  double ratio;
  double fnorm, gnorm;
  double pnorm, xnorm = 0., fnorm1, actred, dirder, epsmch, prered;
  int info;
  epsmch = 2.2204460492503131e-16;
  info = 0;
  iflag = 0;
  *nfev = 0;
  if (n <= 0 || m < n || ldfjac < m || ftol < 0. || xtol < 0. || gtol < 0. ||
      maxfev <= 0 || factor <= 0.) {
    goto TERMINATE;
  }
  if (mode == 2) {
    for (j = 0; j < n; ++j) {
      if (diag[j] <= 0.) {
        goto TERMINATE;
      }
    }
  }
  iflag = func(d, m, n, x, fvec, 1);
  *nfev = 1;
  if (iflag < 0) {
    goto TERMINATE;
  }
  fnorm = enorm(m, fvec);
  par = 0.;
  iter = 1;
  for (;;) {
    iflag = fdjac2(func, d, m, n, x, fvec, fjac, ldfjac, epsfcn, wa4);
    *nfev += n;
    if (iflag < 0) {
      goto TERMINATE;
    }
    if (nprint > 0) {
      iflag = 0;
      if ((iter - 1) % nprint == 0) {
        iflag = func(d, m, n, x, fvec, 0);
      }
      if (iflag < 0) {
        goto TERMINATE;
      }
    }
    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] == 0.) {
            diag[j] = 1.;
          }
        }
      }
      for (j = 0; j < n; ++j) {
        wa3[j] = diag[j] * x[j];
      }
      xnorm = enorm(n, wa3);
      delta = factor * xnorm;
      if (delta == 0.) {
        delta = factor;
      }
    }
    for (i = 0; i < m; ++i) {
      wa4[i] = fvec[i];
    }
    for (j = 0; j < n; ++j) {
      if (fjac[j + j * ldfjac] != 0.) {
        sum = 0.;
        for (i = j; i < m; ++i) {
          sum += fjac[i + j * ldfjac] * wa4[i];
        }
        temp = -sum / fjac[j + j * ldfjac];
        for (i = j; i < m; ++i) {
          wa4[i] += fjac[i + j * ldfjac] * temp;
        }
      }
      fjac[j + j * ldfjac] = wa1[j];
      qtf[j] = wa4[j];
    }
    gnorm = 0.;
    if (fnorm != 0.) {
      for (j = 0; j < n; ++j) {
        l = ipvt[j] - 1;
        if (wa2[l] != 0.) {
          sum = 0.;
          for (i = 0; i <= j; ++i) {
            sum += fjac[i + j * ldfjac] * (qtf[i] / fnorm);
          }
          d1 = fabs(sum / wa2[l]);
          gnorm = ((gnorm) >= (d1) ? (gnorm) : (d1));
        }
      }
    }
    if (gnorm <= gtol) {
      info = 4;
    }
    if (info != 0) {
      goto TERMINATE;
    }
    if (mode != 2) {
      for (j = 0; j < n; ++j) {
        d1 = diag[j], d2 = wa2[j];
        diag[j] = ((d1) >= (d2) ? (d1) : (d2));
      }
    }
    do {
      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 = ((delta) <= (pnorm) ? (delta) : (pnorm));
      }
      iflag = func(d, m, n, wa2, wa4, 1);
      ++(*nfev);
      if (iflag < 0) {
        goto TERMINATE;
      }
      fnorm1 = enorm(m, wa4);
      actred = -1.;
      if (.1 * fnorm1 < fnorm) {
        d1 = fnorm1 / fnorm;
        actred = 1. - d1 * d1;
      }
      for (j = 0; j < n; ++j) {
        wa3[j] = 0.;
        l = ipvt[j] - 1;
        temp = wa1[l];
        for (i = 0; i <= j; ++i) {
          wa3[i] += fjac[i + j * ldfjac] * temp;
        }
      }
      temp1 = enorm(n, wa3) / fnorm;
      temp2 = (sqrt(par) * pnorm) / fnorm;
      prered = temp1 * temp1 + temp2 * temp2 / .5;
      dirder = -(temp1 * temp1 + temp2 * temp2);
      ratio = 0.;
      if (prered != 0.) {
        ratio = actred / prered;
      }
      if (ratio <= .25) {
        if (actred >= 0.) {
          temp = .5;
        } else {
          temp = .5 * dirder / (dirder + .5 * actred);
        }
        if (.1 * fnorm1 >= fnorm || temp < .1) {
          temp = .1;
        }
        d1 = pnorm / .1;
        delta = temp * ((delta) <= (d1) ? (delta) : (d1));
        par /= temp;
      } else {
        if (par == 0. || ratio >= .75) {
          delta = pnorm / .5;
          par = .5 * par;
        }
      }
      if (ratio >= 1e-4) {
        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;
      }
      if (fabs(actred) <= ftol && prered <= ftol && .5 * ratio <= 1.) {
        info = 1;
      }
      if (delta <= xtol * xnorm) {
        info = 2;
      }
      if (fabs(actred) <= ftol && prered <= ftol && .5 * ratio <= 1. &&
          info == 2) {
        info = 3;
      }
      if (info != 0) {
        goto TERMINATE;
      }
      if (*nfev >= maxfev) {
        info = 5;
      }
      if (fabs(actred) <= epsmch && prered <= epsmch && .5 * ratio <= 1.) {
        info = 6;
      }
      if (delta <= epsmch * xnorm) {
        info = 7;
      }
      if (gnorm <= epsmch) {
        info = 8;
      }
      if (info != 0) {
        goto TERMINATE;
      }
    } while (ratio < 1e-4);
  }
TERMINATE:
  if (iflag < 0) {
    info = iflag;
  }
  if (nprint > 0) {
    func(d, m, n, x, fvec, 0);
  }
  return info;
}


x86 assembly (clang, -O0):
<lmdif>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x160,%rsp
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),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
mov    %ecx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movsd  %xmm0,-0x40(%rbp)
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm2,-0x50(%rbp)
movsd  %xmm3,-0x58(%rbp)
movsd  %xmm4,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  0x1e25(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movl   $0x0,-0x114(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
cmpl   $0x0,-0x28(%rbp)
jle    1265 <lmdif+0x115>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1265 <lmdif+0x115>
mov    0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     1265 <lmdif+0x115>
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
ja     1265 <lmdif+0x115>
xorps  %xmm0,%xmm0
ucomisd -0x48(%rbp),%xmm0
ja     1265 <lmdif+0x115>
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
ja     1265 <lmdif+0x115>
cmpl   $0x0,0x10(%rbp)
jle    1265 <lmdif+0x115>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     126a <lmdif+0x11a>
jmp    2249 <lmdif+0x10f9>
cmpl   $0x2,0x20(%rbp)
jne    12ba <lmdif+0x16a>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12b5 <lmdif+0x165>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     12a2 <lmdif+0x152>
jmp    2249 <lmdif+0x10f9>
jmp    12a7 <lmdif+0x157>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    127b <lmdif+0x12b>
jmp    12ba <lmdif+0x16a>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    $0x1,%r9d
call   *%rax
mov    %eax,-0xb4(%rbp)
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x0,-0xb4(%rbp)
jge    12fa <lmdif+0x1aa>
jmp    2249 <lmdif+0x10f9>
mov    -0x24(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x1,-0x94(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
mov    0x38(%rbp),%r11
mov    0x40(%rbp),%r10d
movsd  -0x58(%rbp),%xmm0
mov    0x70(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x1,%al
call   1040 <fdjac2@plt>
mov    %eax,-0xb4(%rbp)
mov    -0x28(%rbp),%ecx
mov    0x30(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0xb4(%rbp)
jge    1388 <lmdif+0x238>
jmp    2249 <lmdif+0x10f9>
cmpl   $0x0,0x28(%rbp)
jle    13ea <lmdif+0x29a>
movl   $0x0,-0xb4(%rbp)
mov    -0x94(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  0x28(%rbp)
cmp    $0x0,%edx
jne    13d3 <lmdif+0x283>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
xor    %r9d,%r9d
call   *%rax
mov    %eax,-0xb4(%rbp)
cmpl   $0x0,-0xb4(%rbp)
jge    13e5 <lmdif+0x295>
jmp    2249 <lmdif+0x10f9>
jmp    13ea <lmdif+0x29a>
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
mov    0x38(%rbp),%rdx
mov    0x40(%rbp),%ecx
mov    0x48(%rbp),%r9
mov    -0x28(%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)
mov    $0x0,%al
call   1030 <qrfac@plt>
cmpl   $0x1,-0x94(%rbp)
jne    155e <lmdif+0x40e>
cmpl   $0x2,0x20(%rbp)
je     14ba <lmdif+0x36a>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14b5 <lmdif+0x365>
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14a2 <lmdif+0x352>
jp     14a2 <lmdif+0x352>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0x1b7b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14a7 <lmdif+0x357>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1447 <lmdif+0x2f7>
jmp    14ba <lmdif+0x36a>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1502 <lmdif+0x3b2>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%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    14c1 <lmdif+0x371>
mov    -0x28(%rbp),%edi
mov    0x68(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1559 <lmdif+0x409>
jp     1559 <lmdif+0x409>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    155e <lmdif+0x40e>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1599 <lmdif+0x449>
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1565 <lmdif+0x415>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    172f <lmdif+0x5df>
mov    0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15dc <lmdif+0x48c>
jp     15dc <lmdif+0x48c>
jmp    16e2 <lmdif+0x592>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1644 <lmdif+0x4f4>
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    15ed <lmdif+0x49d>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16dd <lmdif+0x58d>
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1689 <lmdif+0x539>
jmp    16e2 <lmdif+0x592>
mov    0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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    15a0 <lmdif+0x450>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    175a <lmdif+0x60a>
jp     175a <lmdif+0x60a>
jmp    1896 <lmdif+0x746>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1891 <lmdif+0x741>
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17a3 <lmdif+0x653>
jp     17a3 <lmdif+0x653>
jmp    187e <lmdif+0x72e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     1814 <lmdif+0x6c4>
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
divsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    17b5 <lmdif+0x665>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x1810(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd -0x68(%rbp),%xmm0
jb     1861 <lmdif+0x711>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
jmp    186e <lmdif+0x71e>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1883 <lmdif+0x733>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1761 <lmdif+0x611>
jmp    1896 <lmdif+0x746>
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     18b7 <lmdif+0x767>
movl   $0x4,-0x114(%rbp)
cmpl   $0x0,-0x114(%rbp)
je     18c9 <lmdif+0x779>
jmp    2249 <lmdif+0x10f9>
cmpl   $0x2,0x20(%rbp)
je     1961 <lmdif+0x811>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    195c <lmdif+0x80c>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jb     192c <lmdif+0x7dc>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1939 <lmdif+0x7e9>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18da <lmdif+0x78a>
jmp    1961 <lmdif+0x811>
jmp    1966 <lmdif+0x816>
mov    -0x28(%rbp),%edi
mov    0x38(%rbp),%rsi
mov    0x40(%rbp),%edx
mov    0x48(%rbp),%rcx
mov    0x18(%rbp),%r8
mov    0x50(%rbp),%r9
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rbx
mov    0x60(%rbp),%r11
mov    0x68(%rbp),%r10
mov    0x70(%rbp),%rax
lea    -0x88(%rbp),%r14
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1050 <lmpar@plt>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a5a <lmdif+0x90a>
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    -0x30(%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    0x18(%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    19c1 <lmdif+0x871>
mov    -0x28(%rbp),%edi
mov    0x68(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
cmpl   $0x1,-0x94(%rbp)
jne    1ad0 <lmdif+0x980>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1ab0 <lmdif+0x960>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1ac0 <lmdif+0x970>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    0x60(%rbp),%rcx
mov    0x70(%rbp),%r8
mov    $0x1,%r9d
call   *%rax
mov    %eax,-0xb4(%rbp)
mov    0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0xb4(%rbp)
jge    1b11 <lmdif+0x9c1>
jmp    2249 <lmdif+0x10f9>
mov    -0x24(%rbp),%edi
mov    0x70(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0x14dd(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0x14c5(%rip),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1bab <lmdif+0xa5b>
movsd  -0xf0(%rbp),%xmm0
ff
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1479(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c62 <lmdif+0xb12>
mov    0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     1c4f <lmdif+0xaff>
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mov    0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1bfb <lmdif+0xaab>
jmp    1c54 <lmdif+0xb04>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1bb2 <lmdif+0xa62>
mov    -0x28(%rbp),%edi
mov    0x68(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1070 <sqrt@plt>
mulsd  -0xe0(%rbp),%xmm0
ff
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  0x134f(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d57 <lmdif+0xc07>
jp     1d57 <lmdif+0xc07>
jmp    1d6f <lmdif+0xc1f>
movsd  -0xf8(%rbp),%xmm0
ff
divsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x12b1(%rip),%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jb     1ece <lmdif+0xd7e>
movsd  -0xf8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1daf <lmdif+0xc5f>
movsd  0x127e(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1deb <lmdif+0xc9b>
movsd  0x1269(%rip),%xmm0
mulsd  -0x100(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  0x1249(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x1215(%rip),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
ucomisd -0xd0(%rbp),%xmm0
ff
jae    1e1f <lmdif+0xccf>
movsd  0x11f7(%rip),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1e2f <lmdif+0xcdf>
movsd  0x11e1(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0x11c9(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1e84 <lmdif+0xd34>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
jmp    1e91 <lmdif+0xd41>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1f41 <lmdif+0xdf1>
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1eee <lmdif+0xd9e>
jp     1eee <lmdif+0xd9e>
jmp    1f08 <lmdif+0xdb8>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x1132(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1f3c <lmdif+0xdec>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0x1108(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x10f4(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1f41 <lmdif+0xdf1>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x10e7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     2031 <lmdif+0xee1>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1fbd <lmdif+0xe6d>
mov    0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%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    1f62 <lmdif+0xe12>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1ff8 <lmdif+0xea8>
mov    0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1fc4 <lmdif+0xe74>
mov    -0x28(%rbp),%edi
mov    0x60(%rbp),%rsi
mov    $0x0,%al
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
movsd  -0xf8(%rbp),%xmm1
ff
movaps 0x1000(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2096 <lmdif+0xf46>
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2096 <lmdif+0xf46>
movsd  0xfae(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0xf96(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     2096 <lmdif+0xf46>
movl   $0x1,-0x114(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     20bf <lmdif+0xf6f>
movl   $0x2,-0x114(%rbp)
movsd  -0xf8(%rbp),%xmm1
ff
movaps 0xf72(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2131 <lmdif+0xfe1>
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2131 <lmdif+0xfe1>
movsd  0xf20(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0xf08(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     2131 <lmdif+0xfe1>
cmpl   $0x2,-0x114(%rbp)
jne    2131 <lmdif+0xfe1>
movl   $0x3,-0x114(%rbp)
cmpl   $0x0,-0x114(%rbp)
je     2143 <lmdif+0xff3>
jmp    2249 <lmdif+0x10f9>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
cmp    0x10(%rbp),%eax
jl     215c <lmdif+0x100c>
movl   $0x5,-0x114(%rbp)
movsd  -0xf8(%rbp),%xmm1
ff
movaps 0xed5(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     21c7 <lmdif+0x1077>
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     21c7 <lmdif+0x1077>
movsd  0xe7d(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0xe65(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     21c7 <lmdif+0x1077>
movl   $0x6,-0x114(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     21f3 <lmdif+0x10a3>
movl   $0x7,-0x114(%rbp)
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2217 <lmdif+0x10c7>
movl   $0x8,-0x114(%rbp)
cmpl   $0x0,-0x114(%rbp)
je     2229 <lmdif+0x10d9>
jmp    2249 <lmdif+0x10f9>
jmp    222e <lmdif+0x10de>
movsd  0xe02(%rip),%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
ja     1966 <lmdif+0x816>
jmp    1329 <lmdif+0x1d9>
cmpl   $0x0,-0xb4(%rbp)
jge    2262 <lmdif+0x1112>
mov    -0xb4(%rbp),%eax
mov    %eax,-0x114(%rbp)
cmpl   $0x0,0x28(%rbp)
jle    2287 <lmdif+0x1137>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
xor    %r9d,%r9d
call   *%rax
mov    -0x114(%rbp),%eax
add    $0x160,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<lmdif>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
movsd  %xmm0,0x150(%rsp)
mov    %r9,%r13
mov    %r8,%r10
mov    %edx,%eax
mov    %rsi,%rbp
mov    %rdi,0x58(%rsp)
mov    0x220(%rsp),%rsi
mov    0x218(%rsp),%edx
movl   $0x0,(%rsi)
xor    %r15d,%r15d
test   %ecx,%ecx
mov    %rcx,0x18(%rsp)
jle    2d72 <lmdif+0x1c22>
cmp    %ecx,%eax
jl     2d72 <lmdif+0x1c22>
xorpd  %xmm0,%xmm0
ucomisd %xmm4,%xmm0
jae    2d72 <lmdif+0x1c22>
cmpl   $0x0,0x200(%rsp)
jle    2d72 <lmdif+0x1c22>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
ja     2d72 <lmdif+0x1c22>
ucomisd %xmm1,%xmm0
ja     2d72 <lmdif+0x1c22>
xorpd  %xmm0,%xmm0
ucomisd 0x150(%rsp),%xmm0
ja     2d72 <lmdif+0x1c22>
mov    0x230(%rsp),%ecx
cmp    %eax,%ecx
jl     2d72 <lmdif+0x1c22>
mov    %eax,0x8(%rsp)
mov    0x208(%rsp),%rsi
cmpl   $0x2,0x210(%rsp)
02
mov    0x220(%rsp),%r12
jne    1244 <lmdif+0xf4>
mov    0x18(%rsp),%eax
xor    %r15d,%r15d
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
ucomisd (%rsi,%rcx,8),%xmm0
jae    2d24 <lmdif+0x1bd4>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1230 <lmdif+0xe0>
movsd  %xmm1,0x1b0(%rsp)
movsd  %xmm2,0xa0(%rsp)
movsd  %xmm3,0x138(%rsp)
movsd  %xmm4,0x190(%rsp)
mov    %rbp,%rdi
mov    0x8(%rsp),%r15d
mov    %r15d,%esi
mov    0x18(%rsp),%r14
mov    %r14d,%edx
mov    %r10,%rcx
mov    %r13,%r8
mov    $0x1,%r9d
mov    %r10,0x10(%rsp)
mov    0x58(%rsp),%rbx
call   *%rbx
movl   $0x1,(%r12)
test   %eax,%eax
js     2d11 <lmdif+0x1bc1>
mov    %r15d,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
mov    %eax,0x60(%rsp)
movq   $0x0,0x38(%rsp)
sub    $0x8,%rsp
mov    %rbx,%rdi
mov    %rbp,0x30(%rsp)
mov    %rbp,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
mov    0x18(%rsp),%r8
mov    %r13,%r9
movsd  0x140(%rsp),%xmm0
mov    $0x1,%al
push   0x268(%rsp)
mov    0x240(%rsp),%ebp
push   %rbp
push   0x240(%rsp)
call   1040 <fdjac2@plt>
add    $0x20,%rsp
mov    %eax,%esi
add    %r14d,(%r12)
test   %eax,%eax
js     2d2a <lmdif+0x1bda>
mov    0x258(%rsp),%r12
mov    0x250(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x60(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
mov    %r14d,%r14d
mov    %r15d,%r9d
lea    (%rax,%r14,8),%rbp
mov    %rax,%rdi
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x128(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x120(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %esi,0x24(%rsp)
mov    0x208(%rsp),%r8
cmp    %r8,%rbp
seta   %dl
lea    (%r8,%r14,8),%r10
cmp    %rdi,%r10
seta   %dil
and    %dl,%dil
mov    %r14d,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x158(%rsp)
mov    %r14,%rdx
neg    %rdx
mov    %rdx,0xa8(%rsp)
cmp    %r12,%r10
seta   %dl
lea    (%r12,%r14,8),%rsi
cmp    %r8,%rsi
seta   %bl
and    %dl,%bl
mov    0x10(%rsp),%r8
lea    (%r8,%r14,8),%r15
cmp    %r12,%r15
seta   %r11b
cmp    %r8,%rsi
seta   %dl
and    %r11b,%dl
mov    0x250(%rsp),%r11
or     %bl,%dl
mov    %dl,0xe(%rsp)
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rax,%rsi
mov    %rax,0x88(%rsp)
and    %rax,%rdx
mov    %rdx,0x80(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0x168(%rsp)
lea    0x0(,%r9,8),%rax
add    %r13,%rax
mov    0x260(%rsp),%rdx
cmp    %rdx,%rax
seta   %al
lea    (%rdx,%r9,8),%rdx
mov    %rdx,0x198(%rsp)
cmp    %r13,%rdx
seta   %dl
and    %al,%dl
mov    %dl,0xd(%rsp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rcx,%rax
mov    %rcx,0x188(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x108(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x130(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x1a0(%rsp)
cmp    %r8,%rbp
seta   %al
cmp    %r11,%r15
seta   %bl
and    %al,%bl
cmp    %r8,%r10
seta   %al
cmp    0x208(%rsp),%r15
mov    0x24(%rsp),%esi
seta   %cl
and    %al,%cl
or     %bl,%cl
mov    %dil,0xc(%rsp)
or     %dil,%cl
mov    %cl,0xf(%rsp)
lea    0x0(,%r14,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0x170(%rsp)
mov    %rdx,0x160(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x140(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xb8(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
mov    0x8(%rsp),%edi
movslq %edi,%rax
mov    %rax,0x148(%rsp)
mov    0x230(%rsp),%eax
cltq
mov    0x228(%rsp),%rdx
lea    0x8(%rdx),%rcx
mov    %rcx,0x68(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x60(%rsp)
mov    %rax,0xc8(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0xc0(%rsp)
mov    0x260(%rsp),%rax
lea    0x10(%rax),%rax
mov    %rax,0x118(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0x110(%rsp)
mov    %r9,0x30(%rsp)
lea    -0x4(%r9),%rax
mov    %rax,0x178(%rsp)
lea    0x30(%rdx),%rax
mov    %rax,0x1a8(%rsp)
mov    $0x1,%eax
mov    %rax,0x50(%rsp)
mov    %r8,%r10
mov    %edi,%eax
mov    0x28(%rsp),%rbp
mov    0x218(%rsp),%edx
mov    %r13,0x180(%rsp)
mov    %r14,0x1c0(%rsp)
test   %edx,%edx
jle    1611 <lmdif+0x4c1>
mov    0x50(%rsp),%rax
add    $0xffffffff,%eax
cltd
idivl  0x218(%rsp)
mov    0x8(%rsp),%eax
xor    %esi,%esi
test   %edx,%edx
jne    1611 <lmdif+0x4c1>
mov    %rbp,%rdi
mov    %eax,%esi
mov    0x18(%rsp),%rdx
mov    %r10,%rcx
mov    %r13,%r8
xor    %r9d,%r9d
call   *0x58(%rsp)
mov    0x250(%rsp),%r11
mov    0x218(%rsp),%edx
mov    0x10(%rsp),%r10
mov    %eax,%esi
mov    0x8(%rsp),%eax
test   %esi,%esi
js     2d6f <lmdif+0x1c1f>
mov    %esi,0x24(%rsp)
mov    %eax,%edi
mov    0x18(%rsp),%r15
mov    %r15d,%esi
mov    0x228(%rsp),%rdx
mov    0x230(%rsp),%ecx
mov    $0x1,%r8d
mov    0x238(%rsp),%r9
mov    %eax,%ebp
xor    %eax,%eax
push   %r12
push   %r11
push   0x258(%rsp)
push   %r15
call   1030 <qrfac@plt>
movsd  0xc0(%rsp),%xmm8
add    $0x20,%rsp
cmpl   $0x1,0x50(%rsp)
mov    0x130(%rsp),%r8
xorpd  %xmm7,%xmm7
movapd 0x40(%rsp),%xmm10
jne    1965 <lmdif+0x815>
cmpl   $0x2,0x210(%rsp)
02
mov    0x10(%rsp),%rsi
mov    0x208(%rsp),%rdi
mov    0x250(%rsp),%rdx
mov    0x170(%rsp),%rbp
xorpd  %xmm1,%xmm1
movabs $0x3ff0000000000000,%rbx
je     174d <lmdif+0x5fd>
cmp    $0x2,%r15d
setb   %al
or     0xc(%rsp),%al
je     16c8 <lmdif+0x578>
xor    %ecx,%ecx
jmp    1715 <lmdif+0x5c5>
xor    %eax,%eax
jmp    16d9 <lmdif+0x589>
nopl   0x0(%rax)
add    $0x10,%rax
cmp    %rax,%rbp
je     1705 <lmdif+0x5b5>
movupd (%rdx,%rax,1),%xmm0
movupd %xmm0,(%rdi,%rax,1)
ucomisd %xmm7,%xmm0
jne    16ef <lmdif+0x59f>
jp     16ef <lmdif+0x59f>
mov    %rbx,(%rdi,%rax,1)
cmpeqpd %xmm1,%xmm0
pextrw $0x4,%xmm0,%ecx
test   $0x1,%cl
je     16d0 <lmdif+0x580>
mov    %rbx,0x8(%rdi,%rax,1)
jmp    16d0 <lmdif+0x580>
mov    0x158(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     174d <lmdif+0x5fd>
mov    %rcx,%rax
test   $0x1,%r14b
je     1740 <lmdif+0x5f0>
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
ucomisd %xmm7,%xmm0
jne    1739 <lmdif+0x5e9>
jp     1739 <lmdif+0x5e9>
mov    %rbx,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xa8(%rsp),%rcx
jne    1779 <lmdif+0x629>
cmp    $0x4,%r15d
setb   %al
or     0xe(%rsp),%al
je     17b5 <lmdif+0x665>
mov    %r8,%rbx
xor    %eax,%eax
jmp    1883 <lmdif+0x733>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%r14
je     174d <lmdif+0x5fd>
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
ucomisd %xmm7,%xmm0
jne    1794 <lmdif+0x644>
jp     1794 <lmdif+0x644>
mov    %rbx,(%rdi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
ucomisd %xmm7,%xmm0
jne    1770 <lmdif+0x620>
jp     1770 <lmdif+0x620>
mov    %rbx,0x8(%rdi,%rax,8)
jmp    1770 <lmdif+0x620>
cmpq   $0x0,0x90(%rsp)
je     1835 <lmdif+0x6e5>
mov    0x80(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rax,8)
movupd %xmm0,0x10(%r12,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r12,%rax,8)
movupd %xmm0,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    17d0 <lmdif+0x680>
jmp    1837 <lmdif+0x6e7>
xor    %eax,%eax
mov    %r8,%rbx
testb  $0x1,0x88(%rsp)
01
je     186f <lmdif+0x71f>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rax,8)
movupd %xmm0,0x10(%r12,%rax,8)
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
cmp    %r14,%rcx
je     1912 <lmdif+0x7c2>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
mov    0x168(%rsp),%rdx
test   %rdx,%rdx
je     18ba <lmdif+0x76a>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18a0 <lmdif+0x750>
cmp    $0x3,%rcx
jb     1912 <lmdif+0x7c2>
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r12,%rax,8)
movsd  0x18(%rdi,%rax,8),%xmm0
mulsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    18c0 <lmdif+0x770>
mov    %r15d,%edi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm1,%xmm10
movsd  0x190(%rsp),%xmm0
mulsd  %xmm0,%xmm10
xorpd  %xmm7,%xmm7
ucomisd %xmm7,%xmm10
movsd  %xmm1,0xb8(%rsp)
jne    1954 <lmdif+0x804>
jp     1954 <lmdif+0x804>
movapd %xmm0,%xmm10
mov    0x8(%rsp),%ebp
movsd  0xa0(%rsp),%xmm8
mov    %rbx,%r8
test   %ebp,%ebp
mov    0x260(%rsp),%rsi
mov    0x228(%rsp),%rbp
mov    0x30(%rsp),%rdi
mov    0x140(%rsp),%rbx
movapd 0x1673(%rip),%xmm9
jle    1afc <lmdif+0x9ac>
cmpl   $0x4,0x8(%rsp)
setb   %al
or     0xd(%rsp),%al
je     19a8 <lmdif+0x858>
xor    %eax,%eax
jmp    1a8f <lmdif+0x93f>
cmpq   $0xc,0x120(%rsp)
jae    19b7 <lmdif+0x867>
xor    %eax,%eax
jmp    1a35 <lmdif+0x8e5>
mov    0x108(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rax,8),%xmm0
movups 0x10(%r13,%rax,8),%xmm1
movups %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
movups 0x20(%r13,%rax,8),%xmm0
movups 0x30(%r13,%rax,8),%xmm1
movups %xmm0,0x20(%rsi,%rax,8)
movups %xmm1,0x30(%rsi,%rax,8)
movups 0x40(%r13,%rax,8),%xmm0
movups 0x50(%r13,%rax,8),%xmm1
movups %xmm0,0x40(%rsi,%rax,8)
movups %xmm1,0x50(%rsi,%rax,8)
movupd 0x60(%r13,%rax,8),%xmm0
movupd 0x70(%r13,%rax,8),%xmm1
movupd %xmm0,0x60(%rsi,%rax,8)
movupd %xmm1,0x70(%rsi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    19d0 <lmdif+0x880>
cmpq   $0x0,0x160(%rsp)
je     1a7f <lmdif+0x92f>
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x110(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   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,%rbx
jne    1a60 <lmdif+0x910>
mov    0x128(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1afc <lmdif+0x9ac>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   %r8,%r8
je     1ab6 <lmdif+0x966>
mov    %r8,%rdx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1aa0 <lmdif+0x950>
cmp    $0x3,%rcx
jb     1afc <lmdif+0x9ac>
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rax,8)
movsd  0x18(%r13,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1ac0 <lmdif+0x970>
mov    0x68(%rsp),%rax
mov    0x178(%rsp),%r15
mov    %rdi,%rdx
mov    %rbp,%rdi
xor    %r10d,%r10d
mov    0x148(%rsp),%r13
jmp    1b87 <lmdif+0xa37>
nopl   0x0(%rax)
mov    0x248(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm0
mov    0x228(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%r11,8)
mov    0x260(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm0
mov    0x240(%rsp),%rcx
movsd  %xmm0,(%rcx,%r10,8)
add    $0x1,%r10
add    0xc0(%rsp),%rdi
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%r15
add    0x60(%rsp),%rax
mov    0x1c0(%rsp),%r14
cmp    %r14,%r10
je     1e31 <lmdif+0xce1>
mov    %r10d,%ecx
mov    0x230(%rsp),%ebx
imul   %ebx,%ecx
movslq %ecx,%r11
add    %r10,%r11
movsd  0x0(%rbp,%r11,8),%xmm1
ucomisd %xmm7,%xmm1
jne    1bad <lmdif+0xa5d>
jnp    1b20 <lmdif+0x9d0>
cmp    %r13,%r10
jge    1b20 <lmdif+0x9d0>
mov    %r15,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x30(%rsp),%r13
mov    %r13,%rbp
sub    %r10,%rbp
mov    %rbp,0x40(%rsp)
lea    -0x4(%rbp),%r14
mov    %r14,0xf0(%rsp)
shr    $0x2,%r14
add    $0x1,%r14
mov    0x260(%rsp),%rbx
lea    (%rbx,%r10,8),%rbp
mov    %rbp,0xd0(%rsp)
mov    0xc0(%rsp),%r8
imul   %r10,%r8
mov    0x228(%rsp),%rbp
add    %rbp,%r8
mov    %r10,%r9
imul   0xc8(%rsp),%r9
mov    %r9,%rbx
mov    %r9,0xe0(%rsp)
lea    (%r9,%r13,1),%rbx
lea    0x0(%rbp,%rbx,8),%rbp
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,8),%xmm2
mulsd  (%rsi,%rbx,8),%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1c40 <lmdif+0xaf0>
mov    0x148(%rsp),%r13
cmp    %r13,%r10
jge    1b20 <lmdif+0x9d0>
mov    %rbp,%rbx
xorpd  %xmm9,%xmm0
divsd  %xmm1,%xmm0
mov    %r10,%rbp
mov    0x40(%rsp),%r9
cmp    $0x4,%r9
jb     1d9a <lmdif+0xc4a>
cmp    %rbx,0xd0(%rsp)
jae    1ca1 <lmdif+0xb51>
mov    %r10,%rbp
cmp    0x198(%rsp),%r8
jb     1d9a <lmdif+0xc4a>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0xf0(%rsp)
jae    1cb8 <lmdif+0xb68>
xor    %ebx,%ebx
jmp    1d2f <lmdif+0xbdf>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rsi,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rsi,%rbx,8),%xmm2
movupd 0x20(%rsi,%rbx,8),%xmm5
movupd 0x30(%rsi,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rsi,%rbx,8)
movupd %xmm3,0x10(%rsi,%rbx,8)
movupd 0x20(%rdi,%rbx,8),%xmm2
movupd 0x30(%rdi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rsi,%rbx,8)
movupd %xmm3,0x30(%rsi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1cc0 <lmdif+0xb70>
mov    %r9,%rbp
and    $0xfffffffffffffffc,%rbp
test   $0x1,%r14b
je     1d8e <lmdif+0xc3e>
add    %r10,%rbx
mov    0xe0(%rsp),%rcx
lea    (%rbx,%rcx,1),%r8
mov    0x228(%rsp),%rcx
movupd (%rcx,%r8,8),%xmm2
movupd 0x10(%rcx,%r8,8),%xmm3
mov    0x260(%rsp),%rcx
movupd (%rcx,%rbx,8),%xmm4
movupd 0x10(%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rbx,8)
movupd %xmm3,0x10(%rcx,%rbx,8)
cmp    %rbp,%r9
je     1b20 <lmdif+0x9d0>
add    %r10,%rbp
mov    0x30(%rsp),%rbx
sub    %ebp,%ebx
mov    %rbp,%rcx
test   $0x1,%bl
je     1ddb <lmdif+0xc8b>
mov    0xe0(%rsp),%rbx
add    %rbp,%rbx
mov    0x228(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x260(%rsp),%rcx
addsd  (%rcx,%rbp,8),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
lea    0x1(%rbp),%rcx
not    %rbp
cmp    0x1a0(%rsp),%rbp
je     1b20 <lmdif+0x9d0>
nopl   0x0(%rax)
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x260(%rsp),%rbx
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,0x30(%rsp)
jne    1df0 <lmdif+0xca0>
jmp    1b20 <lmdif+0x9d0>
xorpd  %xmm9,%xmm9
movsd  0x70(%rsp),%xmm5
ucomisd %xmm9,%xmm5
mov    0x180(%rsp),%r13
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%r11
mov    0x208(%rsp),%r8
mov    0x250(%rsp),%rbp
mov    0x240(%rsp),%r9
jne    1ea0 <lmdif+0xd50>
jp     1ea0 <lmdif+0xd50>
ucomisd %xmm9,%xmm8
jae    2d51 <lmdif+0x1c01>
cmpl   $0x2,0x210(%rsp)
02
je     2199 <lmdif+0x1049>
cmp    $0x4,%r11d
setb   %al
or     0xc(%rsp),%al
je     1fad <lmdif+0xe5d>
xor    %ecx,%ecx
jmp    20f5 <lmdif+0xfa5>
xorpd  %xmm9,%xmm9
mov    $0x1,%eax
mov    0x68(%rsp),%rcx
xor    %edx,%edx
jmp    1f02 <lmdif+0xdb2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
divsd  %xmm0,%xmm1
andpd  0x1144(%rip),%xmm1
movapd %xmm1,%xmm0
cmplesd %xmm9,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm9,%xmm0
orpd   %xmm2,%xmm0
movapd %xmm0,%xmm9
add    $0x1,%rdx
add    $0x1,%rax
add    0x60(%rsp),%rcx
cmp    %r14,%rdx
je     1e6f <lmdif+0xd1f>
mov    0x238(%rsp),%rsi
movslq (%rsi,%rdx,4),%rsi
movsd  -0x8(%rbp,%rsi,8),%xmm0
ucomisd %xmm7,%xmm0
jne    1f1c <lmdif+0xdcc>
jnp    1eec <lmdif+0xd9c>
test   %rdx,%rdx
je     1f70 <lmdif+0xe20>
mov    %rax,%rdi
and    $0xfffffffffffffffe,%rdi
xorpd  %xmm2,%xmm2
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%r9,%rsi,8),%xmm3
divsd  %xmm5,%xmm3
mulsd  -0x8(%rcx,%rsi,8),%xmm3
movsd  0x8(%r9,%rsi,8),%xmm1
divsd  %xmm5,%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rsi
movapd %xmm1,%xmm2
cmp    %rsi,%rdi
jne    1f30 <lmdif+0xde0>
test   $0x1,%al
je     1ec0 <lmdif+0xd70>
jmp    1f7e <lmdif+0xe2e>
nop
xorpd  %xmm1,%xmm1
xor    %esi,%esi
test   $0x1,%al
je     1ec0 <lmdif+0xd70>
mov    %rdx,%rdi
imul   0xc8(%rsp),%rdi
add    %rsi,%rdi
movsd  (%r9,%rsi,8),%xmm2
divsd  %xmm5,%xmm2
mov    0x228(%rsp),%rsi
mulsd  (%rsi,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
jmp    1ec0 <lmdif+0xd70>
cmpq   $0x0,0x90(%rsp)
je     2085 <lmdif+0xf35>
mov    0x80(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm1
movupd 0x10(%rbp,%rax,8),%xmm8
movupd (%r8,%rax,8),%xmm3
movupd 0x10(%r8,%rax,8),%xmm4
movupd 0x20(%r8,%rax,8),%xmm2
movupd 0x30(%r8,%rax,8),%xmm0
movapd %xmm1,%xmm6
cmplepd %xmm3,%xmm6
movapd %xmm8,%xmm7
cmplepd %xmm4,%xmm7
andpd  %xmm6,%xmm3
andnpd %xmm1,%xmm6
orpd   %xmm3,%xmm6
andpd  %xmm7,%xmm4
andnpd %xmm8,%xmm7
orpd   %xmm4,%xmm7
movupd %xmm6,(%r8,%rax,8)
movupd %xmm7,0x10(%r8,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm1
movupd 0x30(%rbp,%rax,8),%xmm6
movapd %xmm1,%xmm3
cmplepd %xmm2,%xmm3
movapd %xmm6,%xmm4
cmplepd %xmm0,%xmm4
andpd  %xmm3,%xmm2
andnpd %xmm1,%xmm3
orpd   %xmm2,%xmm3
andpd  %xmm4,%xmm0
andnpd %xmm6,%xmm4
orpd   %xmm0,%xmm4
movupd %xmm3,0x20(%r8,%rax,8)
movupd %xmm4,0x30(%r8,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1fd0 <lmdif+0xe80>
jmp    2087 <lmdif+0xf37>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
je     20e1 <lmdif+0xf91>
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
movapd %xmm2,%xmm4
cmplepd %xmm0,%xmm4
movapd %xmm3,%xmm6
cmplepd %xmm1,%xmm6
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
andpd  %xmm6,%xmm1
andnpd %xmm3,%xmm6
orpd   %xmm1,%xmm6
movupd %xmm4,(%r8,%rax,8)
movupd %xmm6,0x10(%r8,%rax,8)
mov    0x98(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     2199 <lmdif+0x1049>
mov    %rcx,%rax
test   $0x1,%r14b
je     212c <lmdif+0xfdc>
movsd  (%r8,%rcx,8),%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm0,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movlpd %xmm2,(%r8,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xa8(%rsp),%rcx
je     2199 <lmdif+0x1049>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%r8,%rax,8),%xmm1
movsd  0x8(%r8,%rax,8),%xmm2
movapd %xmm0,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm0,%xmm3
orpd   %xmm1,%xmm3
movlpd %xmm3,(%r8,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
cmplesd %xmm2,%xmm1
andpd  %xmm1,%xmm2
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movlpd %xmm1,0x8(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    2140 <lmdif+0xff0>
movapd %xmm9,0xf0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm5,0x70(%rsp)
sub    $0x8,%rsp
mov    %r11d,%edi
mov    0x230(%rsp),%rsi
mov    0x238(%rsp),%edx
mov    0x240(%rsp),%rcx
movapd %xmm10,0x48(%rsp)
movapd %xmm10,%xmm0
mov    $0x1,%al
push   %rbx
push   %r12
push   %rbp
mov    0x268(%rsp),%rbx
push   %rbx
lea    0x60(%rsp),%rbp
push   %rbp
call   1050 <lmpar@plt>
mov    0x280(%rsp),%rsi
mov    0x238(%rsp),%rdx
mov    0x40(%rsp),%rcx
add    $0x30,%rsp
xor    %eax,%eax
movapd 0xde3(%rip),%xmm2
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
movlpd %xmm1,(%rbx,%rax,8)
movsd  (%rcx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    2220 <lmdif+0x10d0>
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
cmpl   $0x1,0x50(%rsp)
mov    0x58(%rsp),%rax
movapd %xmm3,0xd0(%rsp)
jne    22a9 <lmdif+0x1159>
movapd 0x40(%rsp),%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm3,%xmm0
movapd %xmm0,%xmm1
andnpd %xmm3,%xmm1
andpd  %xmm2,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm0,0x40(%rsp)
mov    0x260(%rsp),%r8
mov    0x250(%rsp),%rcx
mov    0x28(%rsp),%rdi
mov    0x8(%rsp),%ebp
mov    %ebp,%esi
mov    0x18(%rsp),%rdx
mov    $0x1,%r9d
mov    %r8,%rbx
call   *%rax
mov    %eax,%esi
mov    0x220(%rsp),%rax
addl   $0x1,(%rax)
test   %esi,%esi
js     2d34 <lmdif+0x1be4>
mov    %esi,0x24(%rsp)
mov    %ebp,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
cvtsi2sd %eax,%xmm8
movapd %xmm8,%xmm2
movsd  0xd15(%rip),%xmm0
mulsd  %xmm0,%xmm2
movsd  0x70(%rsp),%xmm1
movsd  %xmm2,0x1b8(%rsp)
ucomisd %xmm2,%xmm1
movsd  0xcfe(%rip),%xmm7
jbe    2345 <lmdif+0x11f5>
movapd %xmm8,%xmm0
divsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm0
movsd  0xcef(%rip),%xmm7
subsd  %xmm0,%xmm7
mov    $0x1,%eax
mov    $0xfffffffffffffffd,%r10
mov    0x68(%rsp),%rdx
mov    0x1a8(%rsp),%rsi
xor    %r8d,%r8d
mov    0x228(%rsp),%rbp
jmp    238c <lmdif+0x123c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    0x60(%rsp),%rcx
add    %rcx,%rsi
add    $0x1,%r10
add    %rcx,%rdx
cmp    %r14,%r8
je     2590 <lmdif+0x1440>
mov    %r8,%rdi
lea    -0x3(%r8),%r9
add    $0x1,%r8
mov    %rdi,%r11
imul   0xc8(%rsp),%r11
mov    %rdi,%rcx
movq   $0x0,(%r12,%rdi,8)
mov    0x238(%rsp),%rbx
movslq (%rbx,%rdi,4),%rbx
mov    0x248(%rsp),%r15
movsd  -0x8(%r15,%rbx,8),%xmm0
sub    $0x3,%rcx
jb     2409 <lmdif+0x12b9>
mov    0xc0(%rsp),%rbx
imul   %rdi,%rbx
add    0x68(%rsp),%rbx
cmp    %r12,%rbx
jbe    2480 <lmdif+0x1330>
lea    0x0(,%r11,8),%rbx
add    %rbp,%rbx
lea    (%r12,%rdi,8),%rbp
add    $0x8,%rbp
cmp    %rbp,%rbx
mov    0x228(%rsp),%rbp
jae    2480 <lmdif+0x1330>
xor    %ebx,%ebx
mov    %rbx,%rcx
test   $0x1,%al
je     2433 <lmdif+0x12e3>
add    %rbx,%r11
movsd  0x0(%rbp,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rbx,8),%xmm1
movsd  %xmm1,(%r12,%rbx,8)
mov    %rbx,%rcx
or     $0x1,%rcx
cmp    %rbx,%rdi
je     2370 <lmdif+0x1220>
nopl   0x0(%rax)
movsd  -0x8(%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%r12,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r12,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    2440 <lmdif+0x12f0>
jmp    2370 <lmdif+0x1220>
nopl   0x0(%rax,%rax,1)
shr    $0x2,%r9
add    $0x1,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x4,%rcx
jae    249d <lmdif+0x134d>
xor    %ebp,%ebp
jmp    2527 <lmdif+0x13d7>
mov    %r10,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebp,%ebp
xchg   %ax,%ax
movupd -0x30(%rsi,%rbp,8),%xmm2
movupd -0x20(%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r12,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r12,%rbp,8),%xmm2
movupd 0x20(%r12,%rbp,8),%xmm5
movupd 0x30(%r12,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r12,%rbp,8)
movupd %xmm3,0x10(%r12,%rbp,8)
movupd -0x10(%rsi,%rbp,8),%xmm2
movupd (%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r12,%rbp,8)
movupd %xmm3,0x30(%r12,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    24b0 <lmdif+0x1360>
mov    %r8,%rbx
and    $0xfffffffffffffffc,%rbx
test   $0x1,%r9b
je     2577 <lmdif+0x1427>
lea    (%r11,%rbp,1),%r9
mov    0x228(%rsp),%rcx
movupd (%rcx,%r9,8),%xmm2
movupd 0x10(%rcx,%r9,8),%xmm3
movupd (%r12,%rbp,8),%xmm4
movupd 0x10(%r12,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r12,%rbp,8)
movupd %xmm3,0x10(%r12,%rbp,8)
cmp    %rbx,%r8
mov    0x228(%rsp),%rbp
je     2370 <lmdif+0x1220>
jmp    240b <lmdif+0x12bb>
nopl   (%rax)
movapd %xmm7,0xe0(%rsp)
movsd  %xmm8,0xb0(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
mov    %eax,%ebx
movsd  0x38(%rsp),%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jb     25d0 <lmdif+0x1480>
sqrtsd %xmm0,%xmm0
jmp    25d9 <lmdif+0x1489>
nopw   0x0(%rax,%rax,1)
call   1070 <sqrt@plt>
xorpd  %xmm2,%xmm2
mov    0x10(%rsp),%r10
mov    0x208(%rsp),%r8
mov    0x250(%rsp),%rbp
mov    0x30(%rsp),%r11
movapd 0xa05(%rip),%xmm3
mov    0x240(%rsp),%r9
movsd  0x70(%rsp),%xmm11
movapd 0x40(%rsp),%xmm10
movapd 0xf0(%rsp),%xmm9
movapd 0xe0(%rsp),%xmm6
movapd 0xd0(%rsp),%xmm5
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd  %xmm11,%xmm1
mulsd  %xmm5,%xmm0
divsd  %xmm11,%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm7
addsd  %xmm0,%xmm7
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm7
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm7
mov    0x18(%rsp),%rdi
jne    2669 <lmdif+0x1519>
jnp    2673 <lmdif+0x1523>
movapd %xmm6,%xmm8
divsd  %xmm7,%xmm8
movsd  0x9bd(%rip),%xmm4
ucomisd %xmm8,%xmm4
jae    26d0 <lmdif+0x1580>
movsd  0x38(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jne    2694 <lmdif+0x1544>
jnp    279b <lmdif+0x164b>
ucomisd 0x9b3(%rip),%xmm8
jae    279b <lmdif+0x164b>
ucomisd 0x9ac(%rip),%xmm8
jae    2780 <lmdif+0x1630>
movapd %xmm11,%xmm4
movsd  0xb8(%rsp),%xmm3
jmp    2b4a <lmdif+0x19fa>
cs nopw 0x0(%rax,%rax,1)
nop
ucomisd %xmm2,%xmm6
movsd  0x964(%rip),%xmm2
jae    270a <lmdif+0x15ba>
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
xorpd  %xmm3,%xmm0
mulsd  0x956(%rip),%xmm1
movapd %xmm6,%xmm2
mulsd  0x942(%rip),%xmm2
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
movsd  0x90e(%rip),%xmm3
movapd %xmm3,%xmm0
maxsd  %xmm2,%xmm0
movapd %xmm11,%xmm1
cmplesd 0x1b8(%rsp),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
andpd  %xmm3,%xmm1
orpd   %xmm2,%xmm1
divsd  %xmm3,%xmm5
movapd %xmm10,%xmm0
cmplesd %xmm5,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm5,%xmm2
andpd  %xmm10,%xmm0
orpd   %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x38(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x38(%rsp)
movapd %xmm0,%xmm10
ucomisd 0x8de(%rip),%xmm8
jb     26b2 <lmdif+0x1562>
cmp    $0x4,%edi
setb   %al
or     0xf(%rsp),%al
mov    0x260(%rsp),%rsi
je     27c2 <lmdif+0x1672>
xor    %ecx,%ecx
jmp    28b4 <lmdif+0x1764>
addsd  %xmm5,%xmm5
mulsd  0x899(%rip),%xmm0
movsd  %xmm0,0x38(%rsp)
movapd %xmm5,%xmm10
ucomisd 0x89d(%rip),%xmm8
jae    2780 <lmdif+0x1630>
jmp    26b2 <lmdif+0x1562>
cmpq   $0x0,0x90(%rsp)
je     297c <lmdif+0x182c>
mov    0x80(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd %xmm0,(%r10,%rax,8)
movupd %xmm1,0x10(%r10,%rax,8)
movupd (%r8,%rax,8),%xmm2
movupd 0x10(%r8,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm0
movupd 0x30(%rbp,%rax,8),%xmm1
movupd %xmm0,0x20(%r10,%rax,8)
movupd %xmm1,0x30(%r10,%rax,8)
movupd 0x20(%r8,%rax,8),%xmm2
movupd 0x30(%r8,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rbp,%rax,8)
movupd %xmm3,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    27e0 <lmdif+0x1690>
testb  $0x1,0x88(%rsp)
01
je     28a4 <lmdif+0x1754>
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd %xmm0,(%r10,%rax,8)
movupd %xmm1,0x10(%r10,%rax,8)
movupd (%r8,%rax,8),%xmm2
movupd 0x10(%r8,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
mov    0x98(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     292b <lmdif+0x17db>
mov    %rcx,%rax
test   $0x1,%r14b
je     28dc <lmdif+0x178c>
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
mulsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xa8(%rsp),%rcx
je     292b <lmdif+0x17db>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%r10,%rax,8)
mulsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    28f0 <lmdif+0x17a0>
movsd  %xmm7,0xd0(%rsp)
movapd %xmm8,0x70(%rsp)
movapd %xmm10,0x40(%rsp)
cmpl   $0x0,0x8(%rsp)
mov    0x140(%rsp),%rbx
jle    2adc <lmdif+0x198c>
cmpl   $0x4,0x8(%rsp)
setb   %al
or     0xd(%rsp),%al
je     296a <lmdif+0x181a>
xor    %eax,%eax
jmp    2a5f <lmdif+0x190f>
cmpq   $0xc,0x120(%rsp)
jae    2991 <lmdif+0x1841>
xor    %eax,%eax
jmp    2a05 <lmdif+0x18b5>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
jne    286a <lmdif+0x171a>
jmp    28a4 <lmdif+0x1754>
mov    0x108(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,8),%xmm0
movups 0x10(%rsi,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
movups 0x20(%rsi,%rax,8),%xmm0
movups 0x30(%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%r13,%rax,8)
movups %xmm1,0x30(%r13,%rax,8)
movups 0x40(%rsi,%rax,8),%xmm0
movups 0x50(%rsi,%rax,8),%xmm1
movups %xmm0,0x40(%r13,%rax,8)
movups %xmm1,0x50(%r13,%rax,8)
movupd 0x60(%rsi,%rax,8),%xmm0
movupd 0x70(%rsi,%rax,8),%xmm1
movupd %xmm0,0x60(%r13,%rax,8)
movupd %xmm1,0x70(%r13,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    29a0 <lmdif+0x1850>
testb  $0x3,0x188(%rsp)
03
je     2a4f <lmdif+0x18ff>
mov    0x110(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x118(%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,%rbx
jne    2a30 <lmdif+0x18e0>
mov    0x128(%rsp),%rcx
mov    %rcx,%rax
cmp    %r11,%rcx
je     2adc <lmdif+0x198c>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
test   $0x3,%r11b
je     2a96 <lmdif+0x1946>
mov    0x130(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2a80 <lmdif+0x1930>
cmp    $0x3,%rcx
jb     2adc <lmdif+0x198c>
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    2aa0 <lmdif+0x1950>
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <enorm@plt>
mov    0x250(%rsp),%rbp
mov    0x208(%rsp),%r8
mov    0x10(%rsp),%r10
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x50(%rsp)
mov    0x240(%rsp),%r9
movapd 0x40(%rsp),%xmm10
movapd 0xf0(%rsp),%xmm9
movsd  0xb0(%rsp),%xmm4
movapd 0xe0(%rsp),%xmm6
movapd 0x70(%rsp),%xmm8
movsd  0xd0(%rsp),%xmm7
andpd  0x4be(%rip),%xmm6
movsd  0x150(%rsp),%xmm0
ucomisd %xmm6,%xmm0
setb   %al
ucomisd %xmm7,%xmm0
setb   %cl
or     %al,%cl
movapd %xmm8,%xmm0
mulsd  0x4c8(%rip),%xmm0
movsd  0x4b0(%rip),%xmm1
ucomisd %xmm0,%xmm1
setb   %al
or     %cl,%al
mov    %eax,%edx
xor    $0x1,%dl
movapd %xmm3,%xmm1
mulsd  0x1b0(%rsp),%xmm1
ucomisd %xmm10,%xmm1
movzbl %dl,%r15d
mov    $0x2,%edx
cmovae %edx,%r15d
test   %cl,%cl
jne    2bc9 <lmdif+0x1a79>
movsd  0x477(%rip),%xmm2
ucomisd %xmm0,%xmm2
jb     2bc9 <lmdif+0x1a79>
cmp    $0x2,%r15d
je     2d49 <lmdif+0x1bf9>
ucomisd %xmm10,%xmm1
setb   %cl
and    %al,%cl
cmp    $0x1,%cl
jne    2d57 <lmdif+0x1c07>
xor    %eax,%eax
mov    0x220(%rsp),%rcx
mov    0x200(%rsp),%edx
cmp    %edx,(%rcx)
setge  %al
movsd  0x436(%rip),%xmm1
ucomisd %xmm0,%xmm1
lea    (%rax,%rax,4),%eax
mov    $0x6,%r15d
cmovb  %eax,%r15d
movsd  0x44d(%rip),%xmm1
ucomisd %xmm7,%xmm1
cmovb  %eax,%r15d
ucomisd %xmm6,%xmm1
cmovb  %eax,%r15d
movapd %xmm3,%xmm0
mulsd  %xmm1,%xmm0
ucomisd %xmm10,%xmm0
mov    $0x7,%eax
cmovae %eax,%r15d
ucomisd %xmm9,%xmm1
mov    $0x8,%eax
cmovae %eax,%r15d
test   %r15d,%r15d
jne    2d57 <lmdif+0x1c07>
movsd  %xmm3,0xb8(%rsp)
movsd  0x3f7(%rip),%xmm0
ucomisd %xmm8,%xmm0
movapd %xmm4,%xmm5
mov    0x18(%rsp),%r11
mov    0x260(%rsp),%rbx
ja     21b0 <lmdif+0x1060>
movapd %xmm10,0x40(%rsp)
sub    $0x8,%rsp
mov    0x60(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%ebp
mov    %ebp,%edx
mov    %r11d,%ecx
mov    %r10,%r8
mov    %r13,%r9
movsd  0x140(%rsp),%xmm0
mov    $0x1,%al
push   %rbx
mov    0x240(%rsp),%ebx
push   %rbx
push   0x240(%rsp)
mov    %r11,%rbx
movsd  %xmm4,0xd0(%rsp)
call   1040 <fdjac2@plt>
mov    0x270(%rsp),%r11
mov    0x30(%rsp),%r10
add    $0x20,%rsp
mov    %eax,%esi
mov    %ebp,%eax
mov    0x28(%rsp),%rbp
mov    0x220(%rsp),%rcx
add    %ebx,(%rcx)
movsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
test   %esi,%esi
mov    0x218(%rsp),%edx
jns    15ba <lmdif+0x46a>
jmp    2d6f <lmdif+0x1c1f>
mov    %eax,%esi
mov    0x10(%rsp),%r10
mov    %r15d,%eax
mov    0x218(%rsp),%edx
jmp    2d6f <lmdif+0x1c1f>
mov    0x8(%rsp),%eax
jmp    2d72 <lmdif+0x1c22>
mov    0x10(%rsp),%r10
mov    %r15d,%eax
jmp    2d3b <lmdif+0x1beb>
mov    0x10(%rsp),%r10
mov    %ebp,%eax
mov    0x28(%rsp),%rbp
mov    0x218(%rsp),%edx
jmp    2d6f <lmdif+0x1c1f>
mov    $0x3,%r15d
jmp    2d57 <lmdif+0x1c07>
mov    $0x4,%r15d
mov    0x24(%rsp),%esi
test   %esi,%esi
mov    0x8(%rsp),%eax
mov    0x218(%rsp),%edx
mov    0x28(%rsp),%rbp
jns    2d72 <lmdif+0x1c22>
mov    %esi,%r15d
test   %edx,%edx
jle    2d8d <lmdif+0x1c3d>
mov    %rbp,%rdi
mov    %eax,%esi
mov    0x18(%rsp),%rdx
mov    %r10,%rcx
mov    %r13,%r8
xor    %r9d,%r9d
call   *0x58(%rsp)
mov    %r15d,%eax
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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