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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double Corrector_Out(int, double *, double *);
int /*<<< orphan*/ Derivative_LogGrid(double const *, double *);
int N_LogGrid();
double Norm_LogGrid(int, double, double *);
double Predictor_Out(int, double *, double *);
double *alloc_LogGrid();
int /*<<< orphan*/ dealloc_LogGrid(double *);
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
double log_amesh_LogGrid();
double pow(double, double);
double *r_LogGrid();
double sqrt(double);
int /*<<< orphan*/ stderr;
void R_Dirac_FixedLogDeriv(int n, int l, int s2, double Z, const double *v,
                           int match, double u_logderiv, double *Eig, double *u,
                           double *uprime) {
  int i, j, iteration, node, Ninf, Ngrid;
  double E, de, kappa, Emax, Emin, log_amesh, log_amesh2, fss, gamma, L2, L0,
      r2, sum, a, scale, m1scale, uout, upout, upin, *r, *f_upp, *dv, *frp, *fr,
      *upp;
  E = *Eig;
  L2 = ((double)(l * (l + 1)));
  fss = 1.0 / 137.03602;
  fss = fss * fss;
  kappa = -1;
  if (l) {
    if (s2 > 0) {
      kappa = -(l + 1);
    } else {
      kappa = l;
    }
  }
  gamma = sqrt(kappa * kappa - fss * Z * Z);
  Ngrid = N_LogGrid();
  log_amesh = log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = r_LogGrid();
  f_upp = alloc_LogGrid();
  upp = alloc_LogGrid();
  fr = alloc_LogGrid();
  frp = alloc_LogGrid();
  dv = alloc_LogGrid();
  Emax = E + 20.0;
  Emin = E - 20.0;
  iteration = 0;
  while (iteration < 100) {
    ++iteration;
    for (i = 0; i < Ngrid; ++i) {
      r2 = r[i];
      r2 = r2 * r2;
      f_upp[i] = log_amesh2 * (L2 + 2.0 * (v[i] - E) * r2);
    }
    Derivative_LogGrid(v, dv);
    for (i = 0; i < Ngrid; ++i) {
      r2 = r[i] * r[i];
      fr[i] =
          -log_amesh2 * r2 *
          (fss * (v[i] - E) * (v[i] - E) +
           0.5 * fss * dv[i] * kappa / (r[i] * (1.0 + 0.5 * fss * (E - v[i]))));
      frp[i] = -log_amesh * r[i] * 0.5 * fss * dv[i] /
               (1.0 + 0.5 * fss * (E - v[i]));
    }
    m1scale = 1.0;
    for (i = 0; i < (n - l - 1); ++i)
      m1scale *= -1.0;
    for (i = 0; i < 4; ++i) {
      u[i] = m1scale * pow(r[i], gamma);
      uprime[i] = log_amesh * gamma * u[i];
      upp[i] = (log_amesh + frp[i]) * uprime[i] + (f_upp[i] + fr[i]) * u[i];
    }
    node = 0;
    for (i = 3; i < match; ++i) {
      u[i + 1] = Predictor_Out(i, u, uprime);
      uprime[i + 1] = Predictor_Out(i, uprime, upp);
      for (j = 0; j < 6; ++j) {
        upp[i + 1] = (log_amesh + frp[i + 1]) * uprime[i + 1] +
                     (f_upp[i + 1] + fr[i + 1]) * u[i + 1];
        uprime[i + 1] = Corrector_Out(i, uprime, upp);
        u[i + 1] = Corrector_Out(i, u, uprime);
      }
      if (u[i + 1] * u[i] <= 0)
        node = node + 1;
    }
    uout = u[match];
    upout = uprime[match];
    if ((node - n + l + 1) < 0) {
      Emin = E;
      E = 0.5 * (Emin + Emax);
    } else if ((node - n + l + 1) > 0) {
      Emax = E;
      E = 0.5 * (Emin + Emax);
    } else {
      upin = u_logderiv * uout;
      sum = Norm_LogGrid(match, gamma, u);
      sum = 1.0 / sqrt(sum);
      uout = sum * uout;
      upout = sum * upout;
      upin = sum * upin;
      for (i = 0; i <= match; ++i) {
        u[i] = sum * u[i];
        uprime[i] = sum * uprime[i];
      }
      for (i = match + 1; i < Ngrid; ++i) {
        u[i] = 0.0;
        uprime[i] = 0.0;
      }
      de = 0.5 * uout * (upout - upin) / (log_amesh * r[match]);
      if (fabs(de) < (((fabs(E) > 0.2) ? fabs(E) : 0.2) * 1.0e-10)) {
        *Eig = E;
        dealloc_LogGrid(f_upp);
        dealloc_LogGrid(upp);
        dealloc_LogGrid(fr);
        dealloc_LogGrid(frp);
        dealloc_LogGrid(dv);
        return;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  fprintf(stderr, "Error R_Dirac_Fixed_LogDeriv: More than %d iterations\n",
          100);
  *Eig = E;
  dealloc_LogGrid(f_upp);
  dealloc_LogGrid(upp);
  dealloc_LogGrid(fr);
  dealloc_LogGrid(frp);
  dealloc_LogGrid(dv);
  return;
}


x86 assembly (clang, -O0):
<R_Dirac_FixedLogDeriv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xde9(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xdb9(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x8(%rbp)
je     1287 <R_Dirac_FixedLogDeriv+0xc7>
cmpl   $0x0,-0xc(%rbp)
jle    1278 <R_Dirac_FixedLogDeriv+0xb8>
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1282 <R_Dirac_FixedLogDeriv+0xc2>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1287 <R_Dirac_FixedLogDeriv+0xc7>
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10b0 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   10e0 <N_LogGrid@plt>
mov    %eax,-0x50(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1080 <r_LogGrid@plt>
mov    %rax,-0xf0(%rbp)
mov    $0x0,%al
call   10d0 <alloc_LogGrid@plt>
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   10d0 <alloc_LogGrid@plt>
mov    %rax,-0x118(%rbp)
mov    $0x0,%al
call   10d0 <alloc_LogGrid@plt>
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   10d0 <alloc_LogGrid@plt>
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   10d0 <alloc_LogGrid@plt>
mov    %rax,-0x100(%rbp)
movsd  0xcbd(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xca6(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x64,-0x44(%rbp)
jge    1c73 <R_Dirac_FixedLogDeriv+0xab3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1430 <R_Dirac_FixedLogDeriv+0x270>
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0xc3e(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1394 <R_Dirac_FixedLogDeriv+0x1d4>
mov    -0x20(%rbp),%rdi
mov    -0x100(%rbp),%rsi
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1601 <R_Dirac_FixedLogDeriv+0x441>
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0xb4e(%rip),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
mov    -0x100(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  -0x68(%rbp),%xmm2
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xb19(%rip),%xmm5
mulsd  -0x90(%rbp),%xmm5
ff
movsd  -0x58(%rbp),%xmm6
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0xae3(%rip),%xmm6
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xa97(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x100(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xa73(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xa3d(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1447 <R_Dirac_FixedLogDeriv+0x287>
movsd  0xa0f(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1652 <R_Dirac_FixedLogDeriv+0x492>
movsd  0x9cc(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1618 <R_Dirac_FixedLogDeriv+0x458>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1748 <R_Dirac_FixedLogDeriv+0x588>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x120(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1659 <R_Dirac_FixedLogDeriv+0x499>
movl   $0x0,-0x48(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18dc <R_Dirac_FixedLogDeriv+0x71c>
mov    -0x3c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1060 <Predictor_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   1060 <Predictor_Out@plt>
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    1894 <R_Dirac_FixedLogDeriv+0x6d4>
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   1050 <Corrector_Out@plt>
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1050 <Corrector_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17b0 <R_Dirac_FixedLogDeriv+0x5f0>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     18c9 <R_Dirac_FixedLogDeriv+0x709>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18ce <R_Dirac_FixedLogDeriv+0x70e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1756 <R_Dirac_FixedLogDeriv+0x596>
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    1945 <R_Dirac_FixedLogDeriv+0x785>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x6f1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1c6e <R_Dirac_FixedLogDeriv+0xaae>
mov    -0x48(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1984 <R_Dirac_FixedLogDeriv+0x7c4>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x6b2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1c69 <R_Dirac_FixedLogDeriv+0xaa9>
movsd  -0x30(%rbp),%xmm0
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x24(%rbp),%edi
movsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rsi
call   1090 <Norm_LogGrid@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   10b0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x64b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1a86 <R_Dirac_FixedLogDeriv+0x8c6>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a28 <R_Dirac_FixedLogDeriv+0x868>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1ac9 <R_Dirac_FixedLogDeriv+0x909>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a8f <R_Dirac_FixedLogDeriv+0x8cf>
movsd  0x557(%rip),%xmm0
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x529(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0x511(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x4e5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1b62 <R_Dirac_FixedLogDeriv+0x9a2>
movsd  -0x58(%rbp),%xmm0
movaps 0x4ef(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1b77 <R_Dirac_FixedLogDeriv+0x9b7>
movsd  0x4b6(%rip),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1b77 <R_Dirac_FixedLogDeriv+0x9b7>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  0x4a1(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1beb <R_Dirac_FixedLogDeriv+0xa2b>
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
jmp    1cd6 <R_Dirac_FixedLogDeriv+0xb16>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c0c <R_Dirac_FixedLogDeriv+0xa4c>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1c16 <R_Dirac_FixedLogDeriv+0xa56>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
ja     1c49 <R_Dirac_FixedLogDeriv+0xa89>
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c64 <R_Dirac_FixedLogDeriv+0xaa4>
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x3cd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1c69 <R_Dirac_FixedLogDeriv+0xaa9>
jmp    1c6e <R_Dirac_FixedLogDeriv+0xaae>
jmp    137a <R_Dirac_FixedLogDeriv+0x1ba>
mov    0x2366(%rip),%rax
mov    (%rax),%edi
lea    0x3cd(%rip),%rsi
mov    $0x64,%edx
call   1070 <fprintf@plt>
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
call   10c0 <dealloc_LogGrid@plt>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Dirac_FixedLogDeriv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x268,%rsp
movsd  %xmm1,0x1e0(%rsp)
mov    %r8d,0x4(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edi,0x6c(%rsp)
lea    0x1(%rsi),%eax
imul   %esi,%eax
mov    %esi,%r13d
not    %r13d
mov    %rsi,0xb0(%rsp)
test   %esi,%esi
je     120b <R_Dirac_FixedLogDeriv+0x4b>
test   %edx,%edx
jle    1215 <R_Dirac_FixedLogDeriv+0x55>
cvtsi2sd %r13d,%xmm2
jmp    121e <R_Dirac_FixedLogDeriv+0x5e>
movsd  0x1ded(%rip),%xmm2
jmp    121e <R_Dirac_FixedLogDeriv+0x5e>
cvtsi2sdl 0xb0(%rsp),%xmm2
mov    0x2a8(%rsp),%rbp
mov    0x2a0(%rsp),%rcx
mov    %rcx,0x78(%rsp)
movsd  (%r9),%xmm1
movaps %xmm1,0x80(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd %xmm1,0x110(%rsp)
movsd  0x1db0(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm2,0x130(%rsp)
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %r9,0x190(%rsp)
jb     128d <R_Dirac_FixedLogDeriv+0xcd>
sqrtsd %xmm0,%xmm0
jmp    1292 <R_Dirac_FixedLogDeriv+0xd2>
call   10b0 <sqrt@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
mov    %rax,0xf8(%rsp)
xor    %eax,%eax
call   10e0 <N_LogGrid@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1040 <log_amesh_LogGrid@plt>
movapd %xmm0,0x90(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x100(%rsp)
xor    %eax,%eax
call   1080 <r_LogGrid@plt>
mov    %rax,%r14
xor    %eax,%eax
call   10d0 <alloc_LogGrid@plt>
mov    %rax,%r12
xor    %eax,%eax
call   10d0 <alloc_LogGrid@plt>
mov    %rax,0x58(%rsp)
xor    %eax,%eax
call   10d0 <alloc_LogGrid@plt>
mov    %rax,0x70(%rsp)
xor    %eax,%eax
call   10d0 <alloc_LogGrid@plt>
mov    %rax,0x50(%rsp)
xor    %eax,%eax
call   10d0 <alloc_LogGrid@plt>
movapd 0x100(%rsp),%xmm8
mov    0x6c(%rsp),%ecx
add    %ecx,%r13d
mov    %r13d,0x68(%rsp)
movslq 0x4(%rsp),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x1(%rdx),%esi
mov    %rsi,0xa0(%rsp)
mov    %ebx,%r15d
sub    %edx,%ebx
add    $0xfffffffe,%ebx
mov    %rbx,0xd8(%rsp)
lea    0x1(%rbx),%rdx
lea    (%r14,%r15,8),%rdi
lea    (%r12,%r15,8),%r10
sub    0xb0(%rsp),%ecx
add    $0xfffffffe,%ecx
mov    %ecx,0xbc(%rsp)
mov    %esi,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x1d0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x1c8(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0xc8(%rsp)
movabs $0x1fffffffc,%r13
mov    %rdx,0x1c0(%rsp)
and    %rdx,%r13
mov    %r13,0xc0(%rsp)
lea    -0x4(%r13),%r9
mov    %r9,0x1b8(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
cmp    %rdi,%r12
mov    %rdi,%r11
mov    %rdi,0x20(%rsp)
setb   %dl
cmp    %r10,%r14
setb   %cl
and    %dl,%cl
mov    0x38(%rsp),%rbx
lea    (%rbx,%r15,8),%r13
mov    %r12,0x18(%rsp)
cmp    %r13,%r12
mov    %rbx,%r12
mov    0x70(%rsp),%rsi
setb   %dil
cmp    %rbx,%r10
seta   %dl
mov    %rax,%rbx
and    %dil,%dl
or     %cl,%dl
mov    %dl,0x3(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x1e8(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x1f0(%rsp)
mov    0x50(%rsp),%rdi
lea    (%rdi,%r15,8),%r8
cmp    %r8,%rsi
setb   %dl
lea    (%rsi,%r15,8),%rcx
cmp    %rcx,%rdi
setb   %al
and    %dl,%al
cmp    %r11,%rsi
setb   %r10b
cmp    %rcx,%r14
setb   %dl
and    %r10b,%dl
or     %al,%dl
cmp    %r13,%rsi
setb   %al
cmp    %r12,%rcx
seta   %r11b
and    %al,%r11b
or     %dl,%r11b
lea    (%rbx,%r15,8),%r10
cmp    %r10,%rsi
setb   %dl
cmp    %rcx,%rbx
setb   %cl
and    %dl,%cl
cmp    0x20(%rsp),%rdi
setb   %dl
mov    %r14,0x10(%rsp)
cmp    %r8,%r14
mov    0xa0(%rsp),%r14
setb   %al
and    %dl,%al
or     %cl,%al
cmp    %r13,%rdi
setb   %cl
cmp    %r12,%r8
seta   %dl
and    %cl,%dl
or     %al,%dl
or     %r11b,%dl
cmp    %r10,%rdi
setb   %al
mov    %rbx,0x48(%rsp)
cmp    %r8,%rbx
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x2(%rsp)
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x1f8(%rsp)
mov    0x68(%rsp),%ecx
mov    %ecx,%eax
and    $0x7,%eax
mov    %eax,0x64(%rsp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %eax,0xb8(%rsp)
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
mov    0x78(%rsp),%rdx
cmp    %rdx,%rax
seta   %al
lea    (%rdx,%r14,8),%rcx
cmp    %rbp,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0x1(%rsp)
movabs $0x7ffffffffffffffc,%rbx
ff ff 7f
lea    0x2(%rbx),%rcx
mov    0xc8(%rsp),%rax
and    %rax,%rcx
mov    %rcx,0x188(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x1d8(%rsp)
movslq %r14d,%rsi
lea    (%rdx,%rsi,8),%rdi
mov    0xd8(%rsp),%rax
add    %rsi,%rax
lea    0x8(,%rax,8),%rcx
add    %rbp,%rcx
mov    %rdi,0x1b0(%rsp)
cmp    %rcx,%rdi
lea    0x8(%rdx,%rax,8),%rax
setb   %cl
lea    0x0(,%rsi,8),%rdi
add    %rbp,%rdi
mov    %rdi,0xe0(%rsp)
cmp    %rax,%rdi
setb   %al
mov    %r9d,%edi
and    %rbx,%r9
mov    %r9,0x170(%rsp)
and    %cl,%al
mov    %al,(%rsp)
movsd  0x1a76(%rip),%xmm0
movapd 0x80(%rsp),%xmm5
addsd  %xmm5,%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x1a62(%rip),%xmm10
addsd  %xmm5,%xmm10
movapd 0x1a9d(%rip),%xmm0
movapd %xmm8,%xmm1
xorpd  %xmm0,%xmm1
movapd %xmm1,0x240(%rsp)
movapd 0x90(%rsp),%xmm2
xorpd  %xmm2,%xmm0
mulsd  0x8(%rsp),%xmm2
movapd %xmm2,0x120(%rsp)
movapd 0x110(%rsp),%xmm9
movapd %xmm9,%xmm6
unpcklpd %xmm9,%xmm6
movapd %xmm8,%xmm7
unpcklpd %xmm8,%xmm7
pshufd $0x44,%xmm1,%xmm1
movdqa %xmm1,0x230(%rsp)
movapd 0x130(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x220(%rsp)
movapd %xmm0,0x250(%rsp)
pshufd $0x44,%xmm0,%xmm0
movdqa %xmm0,0x210(%rsp)
and    $0x3,%edi
lea    0x0(,%r15,8),%rcx
and    $0xffffffffffffffe0,%rcx
mov    %rdi,0x1a8(%rsp)
shl    $0x5,%rdi
mov    %rdi,0x1a0(%rsp)
mov    0xa8(%rsp),%rax
mov    %eax,%eax
mov    %rax,0x208(%rsp)
mov    %rsi,0xd0(%rsp)
mov    0xc0(%rsp),%rax
add    %rsi,%rax
mov    %rax,0x198(%rsp)
mov    %r15,%r13
lea    0x10(%rbp),%rax
mov    %rax,0x180(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0x178(%rsp)
movapd %xmm6,0x150(%rsp)
movapd %xmm7,0x140(%rsp)
mov    %rcx,0xf0(%rsp)
mov    %r15,0x200(%rsp)
jmp    171c <R_Dirac_FixedLogDeriv+0x55c>
nopl   0x0(%rax)
movsd  0x40(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0x1946(%rip),%xmm0
movapd %xmm1,%xmm10
movapd %xmm0,%xmm5
mov    0x38(%rsp),%r12
mov    0xf8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0xf8(%rsp)
cmp    $0x64,%eax
je     23d5 <R_Dirac_FixedLogDeriv+0x1215>
test   %r13d,%r13d
movapd %xmm5,0x80(%rsp)
movapd %xmm10,0x160(%rsp)
jle    1760 <R_Dirac_FixedLogDeriv+0x5a0>
cmp    $0x4,%r13d
setb   %al
or     0x3(%rsp),%al
je     1790 <R_Dirac_FixedLogDeriv+0x5d0>
xor    %ecx,%ecx
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rbx
mov    0x48(%rsp),%rsi
jmp    1827 <R_Dirac_FixedLogDeriv+0x667>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    0x48(%rsp),%rsi
call   1030 <Derivative_LogGrid@plt>
movsd  0x18bb(%rip),%xmm7
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    1b1b <R_Dirac_FixedLogDeriv+0x95b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %eax,%eax
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rax,1),%xmm1
movupd 0x10(%rbx,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd (%r12,%rax,1),%xmm3
movupd 0x10(%r12,%rax,1),%xmm4
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
addpd  %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm3
addpd  %xmm6,%xmm4
mulpd  %xmm7,%xmm3
mulpd  %xmm7,%xmm4
movupd %xmm3,(%r15,%rax,1)
movupd %xmm4,0x10(%r15,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    17b0 <R_Dirac_FixedLogDeriv+0x5f0>
mov    0x1e8(%rsp),%rax
mov    %rax,%rcx
cmp    %r13,%rax
mov    0x48(%rsp),%rsi
je     18d2 <R_Dirac_FixedLogDeriv+0x712>
mov    %rcx,%rax
test   $0x1,%r13b
je     1862 <R_Dirac_FixedLogDeriv+0x6a2>
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r12,%rcx,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x1f0(%rsp),%rcx
je     18d2 <R_Dirac_FixedLogDeriv+0x712>
nop
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1870 <R_Dirac_FixedLogDeriv+0x6b0>
mov    %r12,%rdi
call   1030 <Derivative_LogGrid@plt>
mov    0x48(%rsp),%rcx
movapd 0x80(%rsp),%xmm6
test   %r13d,%r13d
movapd 0x130(%rsp),%xmm5
mov    0x50(%rsp),%rdx
mov    0x1f8(%rsp),%rsi
movapd 0x250(%rsp),%xmm8
movapd 0x240(%rsp),%xmm9
movapd 0x230(%rsp),%xmm10
movapd 0x220(%rsp),%xmm11
movapd 0x210(%rsp),%xmm13
movsd  0x16e4(%rip),%xmm12
movsd  0x16e3(%rip),%xmm14
movsd  0x16e3(%rip),%xmm7
movsd  0x16e2(%rip),%xmm15
mov    0x70(%rsp),%rdi
jle    1b1b <R_Dirac_FixedLogDeriv+0x95b>
cmp    $0x1,%r13d
sete   %al
or     0x2(%rsp),%al
test   $0x1,%al
je     1977 <R_Dirac_FixedLogDeriv+0x7b7>
xor    %eax,%eax
jmp    1a80 <R_Dirac_FixedLogDeriv+0x8c0>
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
xor    %eax,%eax
movapd 0x16e7(%rip),%xmm5
movapd 0x16ee(%rip),%xmm15
movapd 0x16f5(%rip),%xmm12
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm2,%xmm3
mulpd  %xmm15,%xmm3
addpd  %xmm12,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm1
mulpd  %xmm10,%xmm1
subpd  %xmm0,%xmm2
movapd %xmm2,%xmm4
mulpd  %xmm5,%xmm4
movupd (%rcx,%rax,8),%xmm5
mulpd  %xmm15,%xmm5
mulpd  %xmm11,%xmm5
divpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movapd 0x1677(%rip),%xmm5
mulpd  %xmm1,%xmm4
movupd %xmm4,(%rdi,%rax,8)
movupd (%rbx,%rax,8),%xmm1
mulpd  %xmm13,%xmm1
mulpd  0x168c(%rip),%xmm1
mulpd  %xmm5,%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
movupd (%r12,%rax,8),%xmm1
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm15,%xmm3
addpd  %xmm12,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    19a0 <R_Dirac_FixedLogDeriv+0x7e0>
mov    %rsi,%rax
cmp    %r13,%rsi
movapd 0x130(%rsp),%xmm5
movsd  0x15b9(%rip),%xmm12
movsd  0x15c8(%rip),%xmm15
je     1b1b <R_Dirac_FixedLogDeriv+0x95b>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
movapd %xmm6,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm7,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm0
mulsd  %xmm9,%xmm0
subsd  %xmm6,%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm12,%xmm3
movsd  (%rcx,%rax,8),%xmm4
mulsd  %xmm14,%xmm4
mulsd  %xmm5,%xmm4
divsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rdi,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm12,%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movapd %xmm6,%xmm1
subsd  (%r12,%rax,8),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm7,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1a80 <R_Dirac_FixedLogDeriv+0x8c0>
mov    %rbp,%r14
movapd %xmm7,%xmm2
cmpl   $0x0,0x68(%rsp)
movsd  0x8(%rsp),%xmm1
movapd 0x152b(%rip),%xmm0
jle    1b79 <R_Dirac_FixedLogDeriv+0x9b9>
mov    0xb8(%rsp),%eax
cmpl   $0x7,0xbc(%rsp)
07
jb     1b55 <R_Dirac_FixedLogDeriv+0x995>
nopl   0x0(%rax,%rax,1)
add    $0xfffffff8,%eax
jne    1b50 <R_Dirac_FixedLogDeriv+0x990>
movapd %xmm7,%xmm2
cmpl   $0x0,0x64(%rsp)
je     1b79 <R_Dirac_FixedLogDeriv+0x9b9>
mov    0x64(%rsp),%eax
movapd %xmm7,%xmm2
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm2
add    $0xffffffff,%eax
jne    1b70 <R_Dirac_FixedLogDeriv+0x9b0>
movapd %xmm2,0x20(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm1,0x8(%rsp)
call   10a0 <pow@plt>
mulsd  0x20(%rsp),%xmm0
mov    0x78(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
mulsd  0x120(%rsp),%xmm0
movsd  %xmm0,(%r14)
mov    %r14,%r12
mov    0x50(%rsp),%r13
movsd  0x0(%r13),%xmm1
addsd  0x90(%rsp),%xmm1
movsd  (%r15),%xmm2
mov    0x70(%rsp),%r14
addsd  (%r14),%xmm2
mulsd  0x0(%rbp),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x58(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%rbx),%xmm0
movsd  0x8(%rsp),%xmm1
call   10a0 <pow@plt>
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp)
mulsd  0x120(%rsp),%xmm0
movsd  %xmm0,0x8(%r12)
mov    %r12,%rbx
movsd  0x8(%r13),%xmm1
addsd  0x90(%rsp),%xmm1
movsd  0x8(%r15),%xmm2
addsd  0x8(%r14),%xmm2
mulsd  0x8(%rbp),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x58(%rsp),%r12
movsd  %xmm1,0x8(%r12)
mov    0x10(%rsp),%rax
movsd  0x10(%rax),%xmm0
movsd  0x8(%rsp),%xmm1
call   10a0 <pow@plt>
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x10(%rbp)
mulsd  0x120(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r13),%xmm1
addsd  0x90(%rsp),%xmm1
movsd  0x10(%r15),%xmm2
addsd  0x10(%r14),%xmm2
mulsd  0x10(%rbp),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%r12)
mov    0x10(%rsp),%rax
movsd  0x18(%rax),%xmm0
movsd  0x8(%rsp),%xmm1
call   10a0 <pow@plt>
xor    %eax,%eax
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x18(%rbp)
mulsd  0x120(%rsp),%xmm0
mov    %rbx,%rcx
movsd  %xmm0,0x18(%rbx)
movsd  0x18(%r13),%xmm1
addsd  0x90(%rsp),%xmm1
movsd  0x18(%r15),%xmm2
mov    %rbp,%rbx
mov    %rcx,%rbp
addsd  0x18(%r14),%xmm2
mulsd  0x18(%rbx),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%r12)
cmpl   $0x4,0x4(%rsp)
jl     1e30 <R_Dirac_FixedLogDeriv+0xc70>
mov    %r14,%r15
xor    %eax,%eax
mov    $0x3,%r12d
jmp    1d5f <R_Dirac_FixedLogDeriv+0xb9f>
nopw   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rbx
movsd  (%rbx,%r12,8),%xmm1
mulsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
mov    0x20(%rsp),%eax
sbb    $0xffffffff,%eax
mov    %r13,%r12
cmp    0x208(%rsp),%r13
je     1e30 <R_Dirac_FixedLogDeriv+0xc70>
mov    %eax,0x20(%rsp)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1060 <Predictor_Out@plt>
lea    0x1(%r12),%r13
movsd  %xmm0,0x8(%rbx,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    0x58(%rsp),%rdx
call   1060 <Predictor_Out@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,0x8(%rbp,%r12,8)
movsd  0x8(%rbx,%r12,8),%xmm0
mov    $0x5,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x50(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
addsd  0x90(%rsp),%xmm2
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm3
addsd  (%r15,%r13,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x58(%rsp),%rdx
movsd  %xmm3,(%rdx,%r13,8)
mov    %r12d,%edi
mov    %rbp,%rsi
call   1050 <Corrector_Out@plt>
movsd  %xmm0,0x0(%rbp,%r13,8)
mov    %r12d,%edi
mov    0x78(%rsp),%r14
mov    %r14,%rsi
mov    %rbp,%rdx
call   1050 <Corrector_Out@plt>
movsd  %xmm0,(%r14,%r13,8)
sub    $0x1,%ebx
jb     1d30 <R_Dirac_FixedLogDeriv+0xb70>
movsd  0x0(%rbp,%r13,8),%xmm1
jmp    1db0 <R_Dirac_FixedLogDeriv+0xbf0>
nopl   0x0(%rax)
sub    0x6c(%rsp),%eax
add    0xb0(%rsp),%eax
cmp    $0xfffffffe,%eax
movapd 0x80(%rsp),%xmm1
movapd 0x110(%rsp),%xmm9
movapd 0x100(%rsp),%xmm8
mov    0x200(%rsp),%r13
movapd 0x150(%rsp),%xmm6
movapd 0x140(%rsp),%xmm7
mov    0xf0(%rsp),%rcx
jle    16e0 <R_Dirac_FixedLogDeriv+0x520>
test   %eax,%eax
js     1ead <R_Dirac_FixedLogDeriv+0xced>
movapd 0x160(%rsp),%xmm10
movapd %xmm10,%xmm0
addsd  %xmm1,%xmm0
mulsd  0x1196(%rip),%xmm0
movsd  %xmm1,0x40(%rsp)
jmp    16f7 <R_Dirac_FixedLogDeriv+0x537>
mov    0xa8(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
movaps %xmm0,0x20(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    0x4(%rsp),%edi
movsd  0x8(%rsp),%xmm0
mov    %rbx,%rsi
call   1090 <Norm_LogGrid@plt>
ucomisd 0x1168(%rip),%xmm0
jb     1ef0 <R_Dirac_FixedLogDeriv+0xd30>
sqrtsd %xmm0,%xmm0
jmp    1ef5 <R_Dirac_FixedLogDeriv+0xd35>
call   10b0 <sqrt@plt>
mov    0x38(%rsp),%r12
movapd 0x80(%rsp),%xmm5
movapd 0x110(%rsp),%xmm9
mov    0x18(%rsp),%rdi
movapd 0x100(%rsp),%xmm8
mov    0x10(%rsp),%r8
mov    0xa0(%rsp),%r14
mov    0xe0(%rsp),%rsi
movapd 0x150(%rsp),%xmm6
movapd 0x140(%rsp),%xmm7
movapd 0x160(%rsp),%xmm10
movsd  0x10db(%rip),%xmm1
movsd  0x10da(%rip),%xmm11
xorpd  %xmm4,%xmm4
movapd 0x20(%rsp),%xmm12
movsd  0xe8(%rsp),%xmm13
divsd  %xmm0,%xmm1
cmpl   $0x0,0x4(%rsp)
js     2137 <R_Dirac_FixedLogDeriv+0xf77>
cmp    $0x4,%r14d
setb   %al
or     0x1(%rsp),%al
je     1f96 <R_Dirac_FixedLogDeriv+0xdd6>
xor    %ecx,%ecx
jmp    20a8 <R_Dirac_FixedLogDeriv+0xee8>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0x1c8(%rsp)
je     23c0 <R_Dirac_FixedLogDeriv+0x1200>
mov    0x188(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm2
movupd 0x30(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm3,0x30(%rbx,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm2
movupd 0x30(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbp,%rax,8)
movupd %xmm3,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1fc0 <R_Dirac_FixedLogDeriv+0xe00>
testb  $0x1,0xc8(%rsp)
01
je     2094 <R_Dirac_FixedLogDeriv+0xed4>
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
mov    0x1d0(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     2137 <R_Dirac_FixedLogDeriv+0xf77>
mov    %rcx,%rax
test   $0x1,%r14b
je     20d6 <R_Dirac_FixedLogDeriv+0xf16>
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x1d8(%rsp),%rcx
je     2137 <R_Dirac_FixedLogDeriv+0xf77>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    20f0 <R_Dirac_FixedLogDeriv+0xf30>
cmp    %r13d,%r14d
jge    22e0 <R_Dirac_FixedLogDeriv+0x1120>
cmpl   $0x3,0xd8(%rsp)
03
setb   %al
or     (%rsp),%al
mov    0xd0(%rsp),%rax
jne    225d <R_Dirac_FixedLogDeriv+0x109d>
cmpq   $0xc,0x1b8(%rsp)
mov    0x1b0(%rsp),%rdx
jae    2173 <R_Dirac_FixedLogDeriv+0xfb3>
xor    %eax,%eax
jmp    21e8 <R_Dirac_FixedLogDeriv+0x1028>
mov    0x170(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movupd %xmm4,(%rdx,%rax,8)
movupd %xmm4,0x10(%rdx,%rax,8)
movupd %xmm4,(%rsi,%rax,8)
movupd %xmm4,0x10(%rsi,%rax,8)
movupd %xmm4,0x20(%rdx,%rax,8)
movupd %xmm4,0x30(%rdx,%rax,8)
movupd %xmm4,0x20(%rsi,%rax,8)
movupd %xmm4,0x30(%rsi,%rax,8)
movupd %xmm4,0x40(%rdx,%rax,8)
movupd %xmm4,0x50(%rdx,%rax,8)
movupd %xmm4,0x40(%rsi,%rax,8)
movupd %xmm4,0x50(%rsi,%rax,8)
movupd %xmm4,0x60(%rdx,%rax,8)
movupd %xmm4,0x70(%rdx,%rax,8)
movupd %xmm4,0x60(%rsi,%rax,8)
movupd %xmm4,0x70(%rsi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    2180 <R_Dirac_FixedLogDeriv+0xfc0>
cmpq   $0x0,0x1a8(%rsp)
mov    0x1a0(%rsp),%rsi
je     223f <R_Dirac_FixedLogDeriv+0x107f>
add    0xd0(%rsp),%rax
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x178(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
movupd %xmm4,-0x10(%rax,%rdx,1)
movupd %xmm4,(%rax,%rdx,1)
movupd %xmm4,-0x10(%rcx,%rdx,1)
movupd %xmm4,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2220 <R_Dirac_FixedLogDeriv+0x1060>
mov    0x198(%rsp),%rax
mov    0x1c0(%rsp),%rcx
cmp    0xc0(%rsp),%rcx
je     22e0 <R_Dirac_FixedLogDeriv+0x1120>
mov    %r13d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r13d,%ecx
and    $0x3,%edx
je     228a <R_Dirac_FixedLogDeriv+0x10ca>
xchg   %ax,%ax
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    2270 <R_Dirac_FixedLogDeriv+0x10b0>
cmp    $0x3,%ecx
jb     22e0 <R_Dirac_FixedLogDeriv+0x1120>
nop
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movq   $0x0,0x8(%rbp,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movq   $0x0,0x10(%rbp,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
movq   $0x0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %eax,%r13d
jne    2290 <R_Dirac_FixedLogDeriv+0x10d0>
movapd %xmm12,%xmm0
mulsd  0x1e0(%rsp),%xmm0
mulsd  %xmm1,%xmm12
mulsd  %xmm1,%xmm13
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm13
mulsd  %xmm11,%xmm12
mulsd  %xmm13,%xmm12
mov    0xa8(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
mulsd  0x90(%rsp),%xmm0
divsd  %xmm0,%xmm12
movapd %xmm12,%xmm0
movapd 0xd7c(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm5,%xmm1
andpd  %xmm2,%xmm1
maxsd  0xcf8(%rip),%xmm1
mulsd  0xcf8(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2406 <R_Dirac_FixedLogDeriv+0x1246>
ucomisd 0xced(%rip),%xmm12
ja     236b <R_Dirac_FixedLogDeriv+0x11ab>
movsd  %xmm5,0x40(%rsp)
xorpd  %xmm0,%xmm0
cmpltsd %xmm12,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm5,%xmm1
andnpd %xmm10,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm0,%xmm10
addsd  %xmm12,%xmm5
ucomisd 0x40(%rsp),%xmm5
mov    0xf0(%rsp),%rcx
ja     23ab <R_Dirac_FixedLogDeriv+0x11eb>
ucomisd %xmm5,%xmm10
jbe    1700 <R_Dirac_FixedLogDeriv+0x540>
movapd %xmm10,%xmm5
addsd  0x40(%rsp),%xmm5
mulsd  %xmm11,%xmm5
jmp    1700 <R_Dirac_FixedLogDeriv+0x540>
xor    %eax,%eax
testb  $0x1,0xc8(%rsp)
01
jne    2056 <R_Dirac_FixedLogDeriv+0xe96>
jmp    2094 <R_Dirac_FixedLogDeriv+0xed4>
mov    0x2c04(%rip),%rax
mov    (%rax),%edi
lea    0xcdb(%rip),%rsi
mov    $0x64,%edx
movapd %xmm5,0x80(%rsp)
call   1070 <fprintf@plt>
movapd 0x80(%rsp),%xmm5
mov    0x18(%rsp),%rdi
mov    0x190(%rsp),%rax
movsd  %xmm5,(%rax)
call   10c0 <dealloc_LogGrid@plt>
mov    0x58(%rsp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    0x70(%rsp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    0x50(%rsp),%rdi
call   10c0 <dealloc_LogGrid@plt>
mov    0x48(%rsp),%rdi
add    $0x268,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10c0 <dealloc_LogGrid@plt>

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

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