#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_In(int, double *, double *);
double Corrector_Out(int, double *, double *);
int /*<<< orphan*/ Derivative_LogGrid(double const *, double *);
int N_LogGrid();
double Norm_LogGrid(int, double, double *);
double Predictor_In(int, double *, double *);
double Predictor_Out(int, double *, double *);
double *alloc_LogGrid();
int /*<<< orphan*/ dealloc_LogGrid(double *);
double exp(double);
double fabs(double);
int floor(double);
double log_amesh_LogGrid();
double pow(double, double);
int /*<<< orphan*/ printf(char *, ...);
double *r_LogGrid();
double sqrt(double);
void R_Dirac(int n, int l, int s2, double Z, const double *v, int *mch,
             double *Eig, double *u, double *uprime) {
  int i, j, iteration, node, match, 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 = v[Ngrid - 1] + 0.5 * L2 / (r[Ngrid - 1] * r[Ngrid - 1]);
  Emin = 0.0;
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i];
    r2 = r2 * r2;
    Emin = ((Emin < (v[i] + 0.5 * L2 / r2)) ? Emin : (v[i] + 0.5 * L2 / r2));
  }
  if (E > Emax)
    E = 1.25 * Emax;
  if (E < Emin)
    E = 0.75 * Emin;
  if (E > Emax)
    E = 0.5 * (Emax + Emin);
  for (i = 0; i < 4; ++i) {
    u[i] = 0.0;
    uprime[i] = 0.0;
    upp[i] = 0.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]));
    }
    match = Ngrid - 1;
    while (f_upp[match - 1] * f_upp[match] > 0.0) {
      match = match - 1;
      if (match < 2) {
        printf("Error in R_Dirac: no turning point\n");
        dealloc_LogGrid(f_upp);
        dealloc_LogGrid(upp);
        dealloc_LogGrid(fr);
        dealloc_LogGrid(frp);
        dealloc_LogGrid(dv);
        return;
      }
    }
    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 {
      Ninf = match + floor(2.3 / log_amesh);
      if ((Ninf + 5) > Ngrid)
        Ninf = Ngrid - 5;
      a = sqrt(L2 / (r[Ninf] * r[Ninf]) + 2.0 * (v[Ninf] - E));
      for (i = Ninf; i <= (Ninf + 4); ++i) {
        u[i] = exp(-a * (r[i] - r[Ninf]));
        uprime[i] = -r[i] * log_amesh * a * u[i];
        upp[i] = (log_amesh + frp[i]) * uprime[i] + (f_upp[i] + fr[i]) * u[i];
      }
      for (i = Ninf; i >= (match + 1); --i) {
        u[i - 1] = Predictor_In(i, u, uprime);
        uprime[i - 1] = Predictor_In(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_In(i, uprime, upp);
          u[i - 1] = Corrector_In(i, u, uprime);
        }
      }
      scale = uout / u[match];
      for (i = match; i <= Ninf; ++i) {
        u[i] = scale * u[i];
        uprime[i] = scale * uprime[i];
      }
      upin = uprime[match];
      sum = Norm_LogGrid(Ninf, gamma, u);
      sum = 1.0 / sqrt(sum);
      uout = sum * uout;
      upout = sum * upout;
      upin = sum * upin;
      for (i = 0; i <= Ninf; ++i) {
        u[i] = sum * u[i];
        uprime[i] = sum * uprime[i];
      }
      for (i = Ninf + 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)) {
        *mch = match;
        *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);
    }
  }
  printf("Error R_Dirac: More than %d iterations\n", 100);
  *mch = match;
  *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>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%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    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%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  0x1dae(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x1d7e(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x8(%rbp)
je     12c2 <R_Dirac+0xc2>
cmpl   $0x0,-0xc(%rbp)
jle    12b3 <R_Dirac+0xb3>
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    12bd <R_Dirac+0xbd>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    12c2 <R_Dirac+0xc2>
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   10e0 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   1110 <N_LogGrid@plt>
mov    %eax,-0x4c(%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   1100 <alloc_LogGrid@plt>
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
mov    %rax,-0x118(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1c70(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mov    -0xf0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    14c0 <R_Dirac+0x2c0>
mov    -0xf0(%rbp),%rax
movslq -0x34(%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  -0x78(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1bcc(%rip),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
divsd  -0xb0(%rbp),%xmm2
ff
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1474 <R_Dirac+0x274>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    14a5 <R_Dirac+0x2a5>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1b87(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
divsd  -0xb0(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ee <R_Dirac+0x1ee>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    14e2 <R_Dirac+0x2e2>
movsd  0x1b40(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1508 <R_Dirac+0x308>
movsd  0x1b22(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1533 <R_Dirac+0x333>
movsd  -0x70(%rbp),%xmm1
addsd  -0x78(%rbp),%xmm1
movsd  0x1ae6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1585 <R_Dirac+0x385>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    153a <R_Dirac+0x33a>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x64,-0x3c(%rbp)
jge    22cf <R_Dirac+0x10cf>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1642 <R_Dirac+0x442>
mov    -0xf0(%rbp),%rax
movslq -0x34(%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 -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0x1a3c(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15a6 <R_Dirac+0x3a6>
mov    -0x20(%rbp),%rdi
mov    -0x100(%rbp),%rsi
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1813 <R_Dirac+0x613>
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%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 -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0x1924(%rip),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  -0x68(%rbp),%xmm2
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x18ef(%rip),%xmm5
mulsd  -0x90(%rbp),%xmm5
ff
movsd  -0x58(%rbp),%xmm6
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0x18e1(%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 -0x34(%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 -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x186d(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1849(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x183b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1659 <R_Dirac+0x459>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0xf8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    18b5 <R_Dirac+0x6b5>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    18b0 <R_Dirac+0x6b0>
lea    0x17f8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xf8(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
jmp    2334 <R_Dirac+0x1134>
jmp    181c <R_Dirac+0x61c>
movsd  0x176b(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1906 <R_Dirac+0x706>
movsd  0x1718(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18cc <R_Dirac+0x6cc>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    19fc <R_Dirac+0x7fc>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
call   10d0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    190d <R_Dirac+0x70d>
movl   $0x0,-0x40(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1b90 <R_Dirac+0x990>
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1070 <Predictor_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   1070 <Predictor_Out@plt>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    1b48 <R_Dirac+0x948>
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   1060 <Corrector_Out@plt>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1060 <Corrector_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a64 <R_Dirac+0x864>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1b7d <R_Dirac+0x97d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b82 <R_Dirac+0x982>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a0a <R_Dirac+0x80a>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    1bf9 <R_Dirac+0x9f9>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x1425(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22ca <R_Dirac+0x10ca>
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1c38 <R_Dirac+0xa38>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x13e6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22c5 <R_Dirac+0x10c5>
mov    -0x44(%rbp),%eax
mov    %eax,-0x12c(%rbp)
movsd  0x13e7(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
call   1120 <floor@plt>
mov    %eax,%ecx
mov    -0x12c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x5,%eax
cmp    -0x4c(%rbp),%eax
jle    1c78 <R_Dirac+0xa78>
mov    -0x4c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x48(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0xf0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     1dfa <R_Dirac+0xbfa>
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1cd1 <R_Dirac+0xad1>
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1f56 <R_Dirac+0xd56>
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   10c0 <Predictor_In@plt>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   10c0 <Predictor_In@plt>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    1f43 <R_Dirac+0xd43>
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x18(%rbp),%rsi
mov    -0x118(%rbp),%rdx
call   10b0 <Corrector_In@plt>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   10b0 <Corrector_In@plt>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e5f <R_Dirac+0xc5f>
jmp    1f48 <R_Dirac+0xd48>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1e00 <R_Dirac+0xc00>
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1fd7 <R_Dirac+0xdd7>
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f79 <R_Dirac+0xd79>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x48(%rbp),%edi
movsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rsi
call   10a0 <Norm_LogGrid@plt>
movsd  %xmm0,-0xb8(%rbp)
movsd  -0xb8(%rbp),%xmm0
call   10e0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x1008(%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
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     20d9 <R_Dirac+0xed9>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    207b <R_Dirac+0xe7b>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    211c <R_Dirac+0xf1c>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20e2 <R_Dirac+0xee2>
movsd  0xeec(%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 -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xee6(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0xece(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xeaa(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    21b5 <R_Dirac+0xfb5>
movsd  -0x58(%rbp),%xmm0
movaps 0xeac(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    21ca <R_Dirac+0xfca>
movsd  0xe7b(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    21ca <R_Dirac+0xfca>
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  0xe5e(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    2247 <R_Dirac+0x1047>
mov    -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
jmp    2334 <R_Dirac+0x1134>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2268 <R_Dirac+0x1068>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    2272 <R_Dirac+0x1072>
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     22a5 <R_Dirac+0x10a5>
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    22c0 <R_Dirac+0x10c0>
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xd59(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22c5 <R_Dirac+0x10c5>
jmp    22ca <R_Dirac+0x10ca>
jmp    158c <R_Dirac+0x38c>
lea    0xdae(%rip),%rdi
mov    $0x64,%esi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
call   10f0 <dealloc_LogGrid@plt>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Dirac>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2b8,%rsp
mov    %rcx,%r13
mov    %edi,0xbc(%rsp)
lea    0x1(%rsi),%eax
imul   %esi,%eax
mov    %esi,%ebx
not    %ebx
mov    %rsi,0x108(%rsp)
test   %esi,%esi
mov    %r8,0x148(%rsp)
je     1253 <R_Dirac+0x43>
test   %edx,%edx
jle    125d <R_Dirac+0x4d>
cvtsi2sd %ebx,%xmm2
jmp    1266 <R_Dirac+0x56>
movsd  0x1da5(%rip),%xmm2
jmp    1266 <R_Dirac+0x56>
cvtsi2sdl 0x108(%rsp),%xmm2
movapd %xmm2,0x1f0(%rsp)
mov    0x2f8(%rsp),%r14
mov    0x2f0(%rsp),%r15
movsd  (%r9),%xmm3
cvtsi2sd %eax,%xmm1
movapd %xmm1,0x130(%rsp)
movsd  0x1d6f(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %r9,0x150(%rsp)
movapd %xmm3,0x40(%rsp)
jb     12cb <R_Dirac+0xbb>
sqrtsd %xmm0,%xmm0
jmp    12d0 <R_Dirac+0xc0>
call   10f0 <sqrt@plt>
movsd  %xmm0,0x58(%rsp)
xor    %eax,%eax
call   1120 <N_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1050 <log_amesh_LogGrid@plt>
movapd %xmm0,0x60(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x1b0(%rsp)
xor    %eax,%eax
call   1090 <r_LogGrid@plt>
mov    %rax,%r12
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %rax,0x10(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %rax,0x28(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %rax,0x20(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %rax,0x8(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %r12,%r9
mov    %rax,0x30(%rsp)
lea    -0x1(%rbp),%eax
mov    %eax,0x3c(%rsp)
movslq %ebp,%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0xd0(%rsp)
movsd  0x1cb0(%rip),%xmm0
movapd 0x130(%rsp),%xmm8
mulsd  %xmm8,%xmm0
movsd  -0x8(%r12,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm7
divsd  %xmm1,%xmm7
addsd  -0x8(%r13,%rax,8),%xmm7
mov    %eax,%esi
test   %eax,%eax
movapd 0x1f0(%rsp),%xmm4
xorpd  %xmm6,%xmm6
jle    1423 <R_Dirac+0x213>
cmp    $0x1,%ebp
jne    13ad <R_Dirac+0x19d>
xorpd  %xmm6,%xmm6
xor    %eax,%eax
jmp    1404 <R_Dirac+0x1f4>
mov    %esi,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm6,%xmm6
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm1
movsd  0x8(%r9,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm3
divsd  %xmm1,%xmm3
addsd  0x0(%r13,%rax,8),%xmm3
mulsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
divsd  %xmm2,%xmm1
addsd  0x8(%r13,%rax,8),%xmm1
minsd  %xmm3,%xmm6
minsd  %xmm1,%xmm6
add    $0x2,%rax
cmp    %rax,%rcx
jne    13c0 <R_Dirac+0x1b0>
test   $0x1,%sil
je     1423 <R_Dirac+0x213>
movsd  (%r9,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
minsd  %xmm0,%xmm6
movsd  0x1bed(%rip),%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm7,%xmm1
movapd 0x40(%rsp),%xmm2
cmpltsd %xmm2,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movsd  0x1bce(%rip),%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm1,%xmm2
cmpltsd %xmm6,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm1,%xmm3
andpd  %xmm0,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm7,%xmm0
addsd  %xmm6,%xmm0
mulsd  0x1b91(%rip),%xmm0
movq   $0x0,(%r15)
movq   $0x0,(%r14)
mov    0x28(%rsp),%rax
movq   $0x0,(%rax)
lea    0x8(%r15),%rcx
mov    %rcx,0x168(%rsp)
movq   $0x0,0x8(%r15)
lea    0x8(%r14),%rcx
mov    %rcx,0x170(%rsp)
movq   $0x0,0x8(%r14)
movq   $0x0,0x8(%rax)
lea    0x10(%r15),%rcx
mov    %rcx,0x160(%rsp)
movq   $0x0,0x10(%r15)
lea    0x10(%r14),%rcx
mov    %rcx,0x158(%rsp)
movq   $0x0,0x10(%r14)
movq   $0x0,0x10(%rax)
movq   $0x0,0x18(%r15)
movq   $0x0,0x18(%r14)
movq   $0x0,0x18(%rax)
movsd  %xmm7,0xa8(%rsp)
movapd %xmm7,%xmm10
cmpltsd %xmm2,%xmm10
movapd %xmm10,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm10
orpd   %xmm1,%xmm10
movapd 0x1b20(%rip),%xmm1
movapd 0x1b0(%rsp),%xmm9
movapd %xmm9,%xmm2
xorpd  %xmm1,%xmm2
movapd 0x60(%rsp),%xmm0
movapd %xmm0,%xmm3
xorpd  %xmm1,%xmm3
mov    0xbc(%rsp),%eax
add    %eax,%ebx
mov    %ebx,0xb8(%rsp)
movsd  0x58(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xd8(%rsp)
movsd  0x1a9c(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x228(%rsp)
lea    -0x5(%rbp),%ecx
mov    %ecx,0x120(%rsp)
mov    0x20(%rsp),%r12
lea    (%r12,%rsi,8),%rdi
mov    0x8(%rsp),%rbx
mov    %rsi,0x18(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rbx,%rcx,8),%r11
mov    %rbp,0x90(%rsp)
mov    0x18(%rsp),%rcx
lea    (%r9,%rcx,8),%r10
mov    0x18(%rsp),%rcx
lea    0x0(%r13,%rcx,8),%rsi
mov    0x18(%rsp),%rcx
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x40(%rsp)
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rcx
lea    (%r8,%rcx,8),%rbp
sub    0x108(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x128(%rsp)
cmp    %r10,%r8
setb   %dl
cmp    %rbp,%r9
setb   %cl
and    %dl,%cl
cmp    %rsi,%r8
setb   %dl
cmp    %r13,%rbp
seta   %al
and    %dl,%al
or     %cl,%al
mov    %al,0x7(%rsp)
mov    0x18(%rsp),%rax
and    $0xfffffffc,%eax
mov    %rax,0x230(%rsp)
movapd %xmm8,%xmm5
unpcklpd %xmm8,%xmm5
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
mov    0x18(%rsp),%rax
neg    %rax
mov    %rax,0x238(%rsp)
cmp    %r11,%r12
setb   %cl
cmp    %rdi,%rbx
setb   %al
and    %cl,%al
cmp    %r10,%r12
setb   %cl
cmp    %rdi,%r9
setb   %dl
and    %cl,%dl
or     %al,%dl
cmp    %rsi,%r12
mov    %rsi,%rbp
setb   %al
cmp    %r13,%rdi
seta   %cl
and    %al,%cl
or     %dl,%cl
mov    0x40(%rsp),%rsi
cmp    %rsi,%r12
setb   %al
mov    0x30(%rsp),%r12
cmp    %rdi,%r12
setb   %dl
and    %al,%dl
cmp    %r10,%rbx
mov    0x90(%rsp),%r10
setb   %dil
cmp    %r11,%r9
setb   %al
and    %dil,%al
or     %dl,%al
cmp    %rbp,%rbx
setb   %dil
cmp    %r13,%r11
seta   %dl
and    %dil,%dl
or     %al,%dl
or     %cl,%dl
cmp    %rsi,%rbx
mov    %r8,%rbx
mov    %r12,%rsi
setb   %al
cmp    %r11,%r12
mov    0x18(%rsp),%r11
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x6(%rsp)
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x240(%rsp)
movapd %xmm2,0x2a0(%rsp)
pshufd $0x44,%xmm2,%xmm0
movdqa %xmm0,0x290(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x280(%rsp)
movapd %xmm3,0x260(%rsp)
pshufd $0x44,%xmm3,%xmm0
movdqa %xmm0,0x270(%rsp)
mov    0xb8(%rsp),%ecx
mov    %ecx,%eax
and    $0x7,%eax
mov    %eax,0xb4(%rsp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %eax,0x124(%rsp)
lea    0x0(,%r11,8),%rbp
and    $0xffffffffffffffe0,%rbp
mov    0xd0(%rsp),%rax
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0x248(%rsp)
mov    $0xfffffffc,%ecx
sub    %r10d,%ecx
mov    %rcx,0x100(%rsp)
mov    0x3c(%rsp),%ecx
mov    %rcx,0x190(%rsp)
mov    %r9,0x88(%rsp)
lea    (%r9,%rax,8),%rcx
mov    %rcx,0x220(%rsp)
lea    0x4(%r10),%ecx
mov    %ecx,0x12c(%rsp)
lea    (%r15,%rax,8),%rcx
mov    %rcx,0x180(%rsp)
lea    (%r14,%rax,8),%rcx
mov    %rcx,0x188(%rsp)
lea    -0x8(%r8,%rax,8),%rax
mov    %rax,0x198(%rsp)
lea    0x70(%r14),%rax
mov    %rax,0x218(%rsp)
lea    0x70(%r15),%rax
mov    %rax,0x210(%rsp)
lea    0x3(%r10),%eax
mov    %eax,0xb0(%rsp)
xor    %eax,%eax
mov    %rax,0x110(%rsp)
movapd %xmm5,0x1d0(%rsp)
movapd %xmm7,0x1c0(%rsp)
mov    %rbp,0xc0(%rsp)
test   %r10d,%r10d
movapd %xmm10,0xe0(%rsp)
movapd %xmm6,0x1e0(%rsp)
jle    1860 <R_Dirac+0x650>
cmp    $0x4,%r10d
setb   %al
or     0x7(%rsp),%al
je     18b0 <R_Dirac+0x6a0>
xor    %ecx,%ecx
mov    0x88(%rsp),%rdx
jmp    1941 <R_Dirac+0x731>
xchg   %ax,%ax
mov    %r13,%rdi
call   1030 <Derivative_LogGrid@plt>
movsd  0x17cf(%rip),%xmm14
mov    0x8(%rsp),%r11
mov    0x88(%rsp),%rsi
mov    0xd0(%rsp),%r12
mov    0x100(%rsp),%rdx
mov    0x198(%rsp),%r8
movabs $0xffffffff00000000,%r9
ff ff ff
jmp    1c7d <R_Dirac+0xa6d>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm0
xor    %eax,%eax
mov    0x88(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%rax,1),%xmm1
movupd 0x10(%rdx,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd 0x0(%r13,%rax,1),%xmm3
movupd 0x10(%r13,%rax,1),%xmm4
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
addpd  %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm3
addpd  %xmm5,%xmm4
mulpd  %xmm7,%xmm3
mulpd  %xmm7,%xmm4
movupd %xmm3,(%rbx,%rax,1)
movupd %xmm4,0x10(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbp
jne    18d0 <R_Dirac+0x6c0>
mov    0x230(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     19f3 <R_Dirac+0x7e3>
mov    %rcx,%rax
test   $0x1,%r11b
je     197d <R_Dirac+0x76d>
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%r13,%rcx,8),%xmm1
subsd  %xmm10,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x238(%rsp),%rcx
je     19f3 <R_Dirac+0x7e3>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
subsd  %xmm10,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%r13,%rax,8),%xmm1
subsd  %xmm10,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1990 <R_Dirac+0x780>
mov    %r13,%rdi
call   1030 <Derivative_LogGrid@plt>
movapd 0xe0(%rsp),%xmm7
mov    0x18(%rsp),%rdi
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x90(%rsp),%rax
test   %eax,%eax
movapd 0x1f0(%rsp),%xmm8
mov    0x8(%rsp),%r11
mov    0xd0(%rsp),%r12
movapd 0x2a0(%rsp),%xmm9
movapd 0x260(%rsp),%xmm5
mov    0x240(%rsp),%r10
movapd 0x290(%rsp),%xmm10
movapd 0x280(%rsp),%xmm11
movapd 0x270(%rsp),%xmm13
mov    0x100(%rsp),%rdx
movsd  0x15af(%rip),%xmm12
movsd  0x15af(%rip),%xmm6
movsd  0x15ae(%rip),%xmm14
movsd  0x1575(%rip),%xmm15
mov    0x198(%rsp),%r8
movabs $0xffffffff00000000,%r9
ff ff ff
mov    0x20(%rsp),%rbx
jle    1c7d <R_Dirac+0xa6d>
cmp    $0x1,%eax
sete   %al
or     0x6(%rsp),%al
test   $0x1,%al
je     1acd <R_Dirac+0x8bd>
xor    %eax,%eax
jmp    1be0 <R_Dirac+0x9d0>
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
movapd 0x1591(%rip),%xmm5
movapd 0x1598(%rip),%xmm15
movapd 0x159f(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm2,%xmm3
mulpd  %xmm15,%xmm3
addpd  %xmm8,%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 0x1516(%rip),%xmm5
mulpd  %xmm1,%xmm4
movupd %xmm4,(%rbx,%rax,8)
movupd (%rsi,%rax,8),%xmm1
mulpd  %xmm13,%xmm1
mulpd  0x152b(%rip),%xmm1
mulpd  %xmm5,%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
movupd 0x0(%r13,%rax,8),%xmm1
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm15,%xmm3
addpd  %xmm8,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1b00 <R_Dirac+0x8f0>
mov    %r10,%rax
cmp    %rdi,%r10
movapd 0x260(%rsp),%xmm5
movapd 0x1f0(%rsp),%xmm8
movsd  0x143c(%rip),%xmm15
je     1c7d <R_Dirac+0xa6d>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
movapd %xmm7,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm14,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm0
mulsd  %xmm9,%xmm0
subsd  %xmm7,%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm12,%xmm3
movsd  (%rcx,%rax,8),%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm8,%xmm4
divsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rbx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm12,%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movapd %xmm7,%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm14,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1be0 <R_Dirac+0x9d0>
mov    0x110(%rsp),%r10
add    $0x1,%r10d
mov    0x10(%rsp),%rax
movsd  (%rax,%r12,8),%xmm0
mov    0x3c(%rsp),%edi
mov    %edx,%ebx
mov    0x12c(%rsp),%eax
mov    %eax,%edx
mov    0x248(%rsp),%rbp
xor    %ecx,%ecx
xorpd  %xmm2,%xmm2
movapd 0x13a7(%rip),%xmm3
nopl   0x0(%rax)
movapd %xmm0,%xmm1
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
jbe    1d00 <R_Dirac+0xaf0>
add    %r9,%rbp
add    $0xffffffff,%edx
lea    (%r12,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rcx
add    $0x1,%rax
add    $0x1,%ebx
add    $0xffffffff,%edi
cmp    $0x2,%rax
jg     1cc0 <R_Dirac+0xab0>
jmp    2de5 <R_Dirac+0x1bd5>
nopl   0x0(%rax,%rax,1)
mov    %r13,0xc8(%rsp)
mov    0x190(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xf8(%rsp)
movapd %xmm14,%xmm0
cmpl   $0x0,0xb8(%rsp)
jle    1d69 <R_Dirac+0xb59>
mov    0x124(%rsp),%eax
cmpl   $0x7,0x128(%rsp)
07
jb     1d45 <R_Dirac+0xb35>
nopl   0x0(%rax,%rax,1)
add    $0xfffffff8,%eax
jne    1d40 <R_Dirac+0xb30>
movapd %xmm14,%xmm0
cmpl   $0x0,0xb4(%rsp)
je     1d69 <R_Dirac+0xb59>
mov    0xb4(%rsp),%eax
movapd %xmm14,%xmm0
xorpd  %xmm3,%xmm0
add    $0xffffffff,%eax
jne    1d60 <R_Dirac+0xb50>
movapd %xmm0,0x40(%rsp)
mov    %ebx,0x118(%rsp)
mov    %edi,0x11c(%rsp)
mov    %rbp,0x178(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %rcx,0x80(%rsp)
mov    %r10,0x110(%rsp)
movsd  (%rsi),%xmm0
movsd  0x58(%rsp),%xmm1
mov    %rsi,%r13
call   10e0 <pow@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r15)
mulsd  0xd8(%rsp),%xmm0
movsd  %xmm0,(%r14)
mov    0x8(%rsp),%rbp
movsd  0x0(%rbp),%xmm1
addsd  0x60(%rsp),%xmm1
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm2
mov    %rax,%rbx
mov    0x20(%rsp),%rax
addsd  (%rax),%xmm2
mov    %rax,%r12
mulsd  (%r15),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%r13),%xmm0
movsd  0x58(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
mulsd  0xd8(%rsp),%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x8(%rbp),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  0x8(%rbx),%xmm2
addsd  0x8(%r12),%xmm2
mulsd  0x8(%r15),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x28(%rsp),%rbx
movsd  %xmm1,0x8(%rbx)
movsd  0x10(%r13),%xmm0
movsd  0x58(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
mulsd  0xd8(%rsp),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x10(%rbp),%xmm1
addsd  0x60(%rsp),%xmm1
mov    0x10(%rsp),%r12
movsd  0x10(%r12),%xmm2
mov    0x20(%rsp),%rbp
addsd  0x10(%rbp),%xmm2
mulsd  0x10(%r15),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rbx)
movsd  0x18(%r13),%xmm0
movsd  0x58(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x18(%r15)
mulsd  0xd8(%rsp),%xmm0
movsd  %xmm0,0x18(%r14)
mov    0x8(%rsp),%rax
movsd  0x18(%rax),%xmm1
movsd  0x18(%r12),%xmm2
addsd  0x18(%rbp),%xmm2
addsd  0x60(%rsp),%xmm1
mulsd  0x18(%r15),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rbx)
xor    %ebx,%ebx
cmpl   $0x3,0xf8(%rsp)
03
jle    2040 <R_Dirac+0xe30>
mov    0xd0(%rsp),%rax
mov    0x80(%rsp),%rcx
add    %rcx,%rax
mov    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %ebx,%ebx
mov    $0x3,%ebp
jmp    1f73 <R_Dirac+0xd63>
nop
movsd  (%r15,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
sbb    $0xffffffff,%ebx
mov    %r13,%rbp
cmp    0x40(%rsp),%r13
je     2040 <R_Dirac+0xe30>
mov    %ebp,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   1080 <Predictor_Out@plt>
lea    0x1(%rbp),%r13
movsd  %xmm0,0x8(%r15,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    0x28(%rsp),%rdx
call   1080 <Predictor_Out@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,0x8(%r14,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm0
mov    $0x5,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
addsd  0x60(%rsp),%xmm2
mov    0x10(%rsp),%rax
movsd  (%rax,%r13,8),%xmm3
mov    0x20(%rsp),%rax
addsd  (%rax,%r13,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x28(%rsp),%rdx
movsd  %xmm3,(%rdx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
call   1070 <Corrector_Out@plt>
movsd  %xmm0,(%r14,%r13,8)
mov    %ebp,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   1070 <Corrector_Out@plt>
movsd  %xmm0,(%r15,%r13,8)
sub    $0x1,%r12d
jb     1f50 <R_Dirac+0xd40>
movsd  (%r14,%r13,8),%xmm1
jmp    1fc0 <R_Dirac+0xdb0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    0xbc(%rsp),%ebx
add    0x108(%rsp),%ebx
cmp    $0xfffffffe,%ebx
movapd 0x130(%rsp),%xmm8
mov    0x90(%rsp),%r10
movapd 0x1b0(%rsp),%xmm9
mov    0x18(%rsp),%r11
movapd 0xe0(%rsp),%xmm1
movapd 0x1d0(%rsp),%xmm5
movapd 0x1c0(%rsp),%xmm7
jg     20b0 <R_Dirac+0xea0>
movsd  0xa8(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0xf6c(%rip),%xmm0
movapd %xmm1,%xmm6
jmp    20d6 <R_Dirac+0xec6>
nopw   0x0(%rax,%rax,1)
test   %ebx,%ebx
js     2108 <R_Dirac+0xef8>
movapd 0x1e0(%rsp),%xmm6
movapd %xmm6,%xmm0
addsd  %xmm1,%xmm0
mulsd  0xf43(%rip),%xmm0
movsd  %xmm1,0xa8(%rsp)
movapd %xmm0,%xmm10
mov    0xc8(%rsp),%r13
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    0xc0(%rsp),%rbp
cmpl   $0x64,0x110(%rsp)
64
jne    182a <R_Dirac+0x61a>
jmp    2e35 <R_Dirac+0x1c25>
mov    0x180(%rsp),%rax
mov    0x80(%rsp),%rbx
movsd  (%rax,%rbx,8),%xmm0
movaps %xmm0,0x250(%rsp)
mov    0x188(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x208(%rsp)
movsd  0x228(%rsp),%xmm0
call   1130 <floor@plt>
mov    %eax,%ecx
mov    0x190(%rsp),%rax
lea    (%rax,%rcx,1),%edx
add    %ebx,%edx
mov    0x18(%rsp),%rax
mov    %rcx,0x98(%rsp)
add    %ecx,%eax
add    %ebx,%eax
add    $0x4,%eax
cmp    0x90(%rsp),%eax
cmovg  0x120(%rsp),%edx
mov    %rdx,0x78(%rsp)
movslq %edx,%rbx
mov    0x88(%rsp),%r13
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
movapd 0x130(%rsp),%xmm1
divsd  %xmm0,%xmm1
mov    0xc8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
subsd  0xe0(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    0x10(%rsp),%r12
jb     21d6 <R_Dirac+0xfc6>
sqrtsd %xmm0,%xmm0
jmp    21e3 <R_Dirac+0xfd3>
call   10f0 <sqrt@plt>
mov    0x88(%rsp),%r13
movapd %xmm0,0x40(%rsp)
movapd %xmm0,%xmm1
movapd 0xe6b(%rip),%xmm0
xorpd  %xmm0,%xmm1
movapd %xmm1,0x1a0(%rsp)
movsd  0x0(%r13,%rbx,8),%xmm0
subsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,(%r15,%rbx,8)
movsd  0x0(%r13,%rbx,8),%xmm1
xorpd  0xe35(%rip),%xmm1
movapd 0x60(%rsp),%xmm2
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm3
mulsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
mov    0x8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %rax,%rbp
movsd  (%r12,%rbx,8),%xmm2
mov    0x20(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm2
mulsd  (%r15,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    0x28(%rsp),%r12
movsd  %xmm0,(%r12,%rbx,8)
movsd  0x8(%r13,%rbx,8),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x1a0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x8(%r15,%rbx,8)
movsd  0x8(%r13,%rbx,8),%xmm1
xorpd  0xdab(%rip),%xmm1
movapd 0x60(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14,%rbx,8)
movsd  0x8(%rbp,%rbx,8),%xmm0
mov    0x10(%rsp),%rbp
movsd  0x8(%rbp,%rbx,8),%xmm2
mov    0x20(%rsp),%rax
addsd  0x8(%rax,%rbx,8),%xmm2
mulsd  0x8(%r15,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
movsd  0x10(%r13,%rbx,8),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x1a0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x10(%r15,%rbx,8)
movsd  0x10(%r13,%rbx,8),%xmm1
xorpd  0xd28(%rip),%xmm1
movapd 0x60(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14,%rbx,8)
mov    0x8(%rsp),%r12
movsd  0x10(%r12,%rbx,8),%xmm0
movsd  0x10(%rbp,%rbx,8),%xmm2
mov    0x20(%rsp),%rax
addsd  0x10(%rax,%rbx,8),%xmm2
mulsd  0x10(%r15,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    0x28(%rsp),%rbp
movsd  %xmm0,0x10(%rbp,%rbx,8)
movsd  0x18(%r13,%rbx,8),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x1a0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x18(%r15,%rbx,8)
movsd  0x18(%r13,%rbx,8),%xmm1
xorpd  0xca0(%rip),%xmm1
movapd 0x60(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r14,%rbx,8)
movsd  0x18(%r12,%rbx,8),%xmm0
mov    0x10(%rsp),%rax
movsd  0x18(%rax,%rbx,8),%xmm2
mov    0x20(%rsp),%r12
addsd  0x18(%r12,%rbx,8),%xmm2
mulsd  0x18(%r15,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x18(%rbp,%rbx,8)
movsd  0x20(%r13,%rbx,8),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x1a0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x20(%r15,%rbx,8)
movsd  0x20(%r13,%rbx,8),%xmm1
xorpd  0xc1c(%rip),%xmm1
movapd 0x60(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r14,%rbx,8)
mov    0x8(%rsp),%rax
movsd  0x20(%rax,%rbx,8),%xmm0
addsd  %xmm2,%xmm0
mov    0x10(%rsp),%rax
movsd  0x20(%rax,%rbx,8),%xmm2
addsd  0x20(%r12,%rbx,8),%xmm2
mulsd  0x20(%r15,%rbx,8),%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x20(%rbp,%rbx,8)
mov    0xf8(%rsp),%rax
cmp    %eax,0x78(%rsp)
jle    2580 <R_Dirac+0x1370>
mov    0x178(%rsp),%r13
sar    $0x20,%r13
jmp    24c9 <R_Dirac+0x12b9>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r13,%rbx
jle    2580 <R_Dirac+0x1370>
mov    %rbx,%r12
mov    %r12d,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   10d0 <Predictor_In@plt>
add    $0xffffffffffffffff,%rbx
movsd  %xmm0,-0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %r14,%rsi
mov    0x28(%rsp),%rdx
call   10d0 <Predictor_In@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,-0x8(%r14,%r12,8)
movsd  -0x8(%r15,%r12,8),%xmm0
mov    $0x5,%ebp
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
addsd  0x60(%rsp),%xmm2
mov    0x10(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm3
mov    0x20(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x28(%rsp),%rdx
movsd  %xmm3,(%rdx,%rbx,8)
mov    %r12d,%edi
mov    %r14,%rsi
call   10c0 <Corrector_In@plt>
movsd  %xmm0,(%r14,%rbx,8)
mov    %r12d,%edi
mov    %r15,%rsi
mov    %r14,%rdx
call   10c0 <Corrector_In@plt>
movsd  %xmm0,(%r15,%rbx,8)
sub    $0x1,%ebp
jb     24c0 <R_Dirac+0x12b0>
movsd  (%r14,%rbx,8),%xmm1
jmp    2510 <R_Dirac+0x1300>
mov    0x78(%rsp),%rdi
cmp    0xf8(%rsp),%edi
mov    0x10(%rsp),%rbx
mov    0x90(%rsp),%r8
mov    0xc0(%rsp),%rbp
mov    0x80(%rsp),%r10
movapd 0x250(%rsp),%xmm0
mov    0x178(%rsp),%r9
jl     27ac <R_Dirac+0x159c>
mov    0x180(%rsp),%rax
divsd  (%rax,%r10,8),%xmm0
sar    $0x20,%r9
mov    0xa0(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %ecx,%eax
cmp    %eax,%r8d
mov    %eax,%ecx
cmovl  %r8d,%ecx
mov    0x100(%rsp),%rsi
add    %rsi,%rcx
sub    %r10,%rcx
cmp    $0x3,%ecx
jb     270e <R_Dirac+0x14fe>
lea    (%r15,%r9,8),%r11
cmp    %eax,%r8d
mov    %eax,%edx
cmovl  %r8d,%edx
add    %esi,%edx
sub    %r10d,%edx
add    %r9,%rdx
mov    0x170(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%r11
jae    2649 <R_Dirac+0x1439>
mov    0x168(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%r9,8),%rsi
cmp    %rdx,%rsi
jae    2649 <R_Dirac+0x1439>
mov    0x78(%rsp),%rdi
jmp    270e <R_Dirac+0x14fe>
mov    %rbx,%r11
mov    %r9,%r13
mov    %rbp,%r9
mov    %ecx,%ecx
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
add    %rdx,%r13
movapd %xmm0,%xmm1
cmp    %eax,%r8d
mov    %eax,%esi
cmovl  %r8d,%esi
unpcklpd %xmm0,%xmm1
add    0x118(%rsp),%esi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
movslq 0x11c(%rsp),%rbp
mov    0x160(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdi
mov    0x158(%rsp),%rbx
lea    (%rbx,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%rdi,%rbx,8),%xmm2
movupd (%rdi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdi,%rbx,8)
movupd %xmm3,(%rdi,%rbx,8)
movupd -0x10(%rbp,%rbx,8),%xmm2
movupd 0x0(%rbp,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbp,%rbx,8)
movupd %xmm3,0x0(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    26b0 <R_Dirac+0x14a0>
cmp    %rdx,%rcx
mov    %r9,%rbp
mov    %r11,%rbx
mov    %r13,%r9
mov    0x78(%rsp),%rdi
je     27ac <R_Dirac+0x159c>
mov    %edi,%ecx
sub    %r9d,%ecx
add    $0x1,%ecx
test   $0x1,%cl
jne    2728 <R_Dirac+0x1518>
mov    %r9,%rcx
cmp    %r9d,%edi
jne    2754 <R_Dirac+0x1544>
jmp    27ac <R_Dirac+0x159c>
movsd  (%r15,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%r9,8)
movsd  (%r14,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r9,8)
mov    %r9,%rcx
add    $0x1,%rcx
cmp    %r9d,%edi
je     27ac <R_Dirac+0x159c>
cmp    %eax,%r8d
cmovl  %r8d,%eax
add    $0xfffffffc,%eax
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
movsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %ecx,%eax
jne    2760 <R_Dirac+0x1550>
mov    0x188(%rsp),%rax
movsd  (%rax,%r10,8),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x58(%rsp),%xmm0
mov    %r15,%rsi
call   10b0 <Norm_LogGrid@plt>
ucomisd 0x882(%rip),%xmm0
jb     27de <R_Dirac+0x15ce>
sqrtsd %xmm0,%xmm0
jmp    27e3 <R_Dirac+0x15d3>
call   10f0 <sqrt@plt>
movapd 0x130(%rsp),%xmm8
movapd 0x1e0(%rsp),%xmm6
movapd 0x1b0(%rsp),%xmm9
mov    0x18(%rsp),%r11
movapd 0xe0(%rsp),%xmm10
movapd 0x1d0(%rsp),%xmm5
movapd 0x1c0(%rsp),%xmm7
movsd  0x817(%rip),%xmm1
movsd  0x7de(%rip),%xmm11
divsd  %xmm0,%xmm1
mov    0x78(%rsp),%rsi
test   %esi,%esi
mov    0xc8(%rsp),%r13
mov    0x20(%rsp),%r12
mov    0x90(%rsp),%r10
movapd 0x250(%rsp),%xmm4
js     2a85 <R_Dirac+0x1875>
lea    0x1(%rsi),%eax
cmp    $0x3,%esi
jb     2883 <R_Dirac+0x1673>
lea    (%r14,%rax,8),%rcx
cmp    %r15,%rcx
jbe    2932 <R_Dirac+0x1722>
lea    (%r15,%rax,8),%rcx
cmp    %r14,%rcx
jbe    2932 <R_Dirac+0x1722>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     28b3 <R_Dirac+0x16a3>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     2a85 <R_Dirac+0x1875>
mov    0xa0(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %ecx,%eax
cmp    %eax,%r10d
cmovl  %r10d,%eax
add    $0xfffffffc,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0x8(%r15,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    28e0 <R_Dirac+0x16d0>
jmp    2a85 <R_Dirac+0x1875>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2a2c <R_Dirac+0x181c>
mov    0xa0(%rsp),%rsi
mov    0x98(%rsp),%rdi
add    %esi,%edi
cmp    %edi,%r10d
cmovl  %r10d,%edi
add    $0xfffffffc,%edi
and    $0xfffffffc,%edi
add    $0xfffffffffffffffc,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm3,0x10(%r15,%rsi,8)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
movupd 0x20(%r15,%rsi,8),%xmm2
movupd 0x30(%r15,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r15,%rsi,8)
movupd %xmm3,0x30(%r15,%rsi,8)
movupd 0x20(%r14,%rsi,8),%xmm2
movupd 0x30(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r14,%rsi,8)
movupd %xmm3,0x30(%r14,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2990 <R_Dirac+0x1780>
jmp    2a2e <R_Dirac+0x181e>
xor    %esi,%esi
test   $0x1,%dl
je     2a77 <R_Dirac+0x1867>
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm3,0x10(%r15,%rsi,8)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
cmp    %rax,%rcx
mov    0x78(%rsp),%rsi
jne    2885 <R_Dirac+0x1675>
lea    0x1(%rsi),%eax
cmp    %r10d,%eax
jge    2cff <R_Dirac+0x1aef>
cltq
mov    %r10d,%ecx
sub    %esi,%ecx
add    $0xfffffffe,%ecx
cmp    $0x3,%ecx
jb     2c73 <R_Dirac+0x1a63>
lea    (%r15,%rax,8),%rsi
lea    (%rcx,%rax,1),%rdx
mov    0x170(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%rsi
xorpd  %xmm0,%xmm0
jae    2ada <R_Dirac+0x18ca>
mov    0x168(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%rax,8),%rsi
cmp    %rdx,%rsi
jb     2c73 <R_Dirac+0x1a63>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
cmp    $0xc,%rdx
jae    2b01 <R_Dirac+0x18f1>
xor    %edi,%edi
jmp    2bc9 <R_Dirac+0x19b9>
mov    0xa0(%rsp),%rdx
mov    0x98(%rsp),%rsi
lea    (%rsi,%rdx,1),%edi
cmp    %edi,%r10d
cmovl  %r10d,%edi
lea    -0x4(%rdi),%edx
movslq %edx,%rdx
mov    0x218(%rsp),%rsi
lea    (%rsi,%rdx,8),%rbp
mov    0x210(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
mov    0xb0(%rsp),%edx
sub    %edi,%edx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rsi,%rdi,8)
movupd %xmm0,-0x60(%rsi,%rdi,8)
movupd %xmm0,-0x70(%rbp,%rdi,8)
movupd %xmm0,-0x60(%rbp,%rdi,8)
movupd %xmm0,-0x50(%rsi,%rdi,8)
movupd %xmm0,-0x40(%rsi,%rdi,8)
movupd %xmm0,-0x50(%rbp,%rdi,8)
movupd %xmm0,-0x40(%rbp,%rdi,8)
movupd %xmm0,-0x30(%rsi,%rdi,8)
movupd %xmm0,-0x20(%rsi,%rdi,8)
movupd %xmm0,-0x30(%rbp,%rdi,8)
movupd %xmm0,-0x20(%rbp,%rdi,8)
movupd %xmm0,-0x10(%rsi,%rdi,8)
movupd %xmm0,(%rsi,%rdi,8)
movupd %xmm0,-0x10(%rbp,%rdi,8)
movupd %xmm0,0x0(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rdx
jne    2b60 <R_Dirac+0x1950>
test   $0x3,%r9b
je     2c5f <R_Dirac+0x1a4f>
mov    0x98(%rsp),%rbp
add    0xa0(%rsp),%ebp
cmp    %ebp,%r10d
cmovl  %r10d,%ebp
lea    -0x4(%rbp),%edx
movslq %edx,%rdx
add    %rdx,%rdi
mov    0x158(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    0x160(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
mov    0xb0(%rsp),%edi
sub    %ebp,%edi
add    $0x1,%dil
and    $0xc,%dil
add    $0xfc,%dil
shr    $0x2,%dil
add    $0x1,%dil
movzbl %dil,%edi
and    $0x3,%edi
shl    $0x5,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm0,(%rsi,%rbp,1)
movupd %xmm0,-0x10(%rdx,%rbp,1)
movupd %xmm0,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdi
jne    2c40 <R_Dirac+0x1a30>
cmp    %r8,%rcx
mov    0xc0(%rsp),%rbp
je     2cff <R_Dirac+0x1aef>
add    %r8,%rax
mov    %r10d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r10d,%ecx
and    $0x3,%edx
je     2ca9 <R_Dirac+0x1a99>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r15,%rax,8)
movq   $0x0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    2c90 <R_Dirac+0x1a80>
cmp    $0x3,%ecx
jb     2cff <R_Dirac+0x1aef>
xchg   %ax,%ax
movq   $0x0,(%r15,%rax,8)
movq   $0x0,(%r14,%rax,8)
movq   $0x0,0x8(%r15,%rax,8)
movq   $0x0,0x8(%r14,%rax,8)
movq   $0x0,0x10(%r15,%rax,8)
movq   $0x0,0x10(%r14,%rax,8)
movq   $0x0,0x18(%r15,%rax,8)
movq   $0x0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %eax,%r11d
jne    2cb0 <R_Dirac+0x1aa0>
mulsd  %xmm1,%xmm4
movsd  0x208(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x40(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm11,%xmm4
mulsd  %xmm0,%xmm4
mov    0x220(%rsp),%rax
mov    0x80(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x60(%rsp),%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,%xmm0
movapd 0x35e(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm10,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x2e1(%rip),%xmm1
mulsd  0x2e1(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2ea5 <R_Dirac+0x1c95>
ucomisd 0x2d7(%rip),%xmm4
ja     2d8d <R_Dirac+0x1b7d>
movsd  %xmm10,0xa8(%rsp)
xorpd  %xmm0,%xmm0
cmpltsd %xmm4,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm10,%xmm1
andnpd %xmm6,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm0,%xmm6
addsd  %xmm4,%xmm10
ucomisd 0xa8(%rsp),%xmm10
mov    0x30(%rsp),%rsi
ja     2dcc <R_Dirac+0x1bbc>
ucomisd %xmm10,%xmm6
jbe    20f5 <R_Dirac+0xee5>
movapd %xmm6,%xmm10
addsd  0xa8(%rsp),%xmm10
mulsd  %xmm11,%xmm10
jmp    20f5 <R_Dirac+0xee5>
lea    0x2fc(%rip),%rdi
mov    %r11,%rbx
call   1040 <puts@plt>
mov    0x10(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x28(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x20(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x30(%rsp),%rdi
add    $0x2b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1100 <dealloc_LogGrid@plt>
mov    %rbx,%rbp
mov    0x3c(%rsp),%ebx
add    0x80(%rsp),%ebx
lea    0x276(%rip),%rdi
mov    $0x64,%esi
xor    %eax,%eax
movapd %xmm10,0xe0(%rsp)
call   1060 <printf@plt>
mov    0x148(%rsp),%rax
mov    %ebx,(%rax)
mov    0x150(%rsp),%rax
movapd 0xe0(%rsp),%xmm0
movsd  %xmm0,(%rax)
mov    %rbp,%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x28(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x20(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x8(%rsp),%rdi
jmp    2e15 <R_Dirac+0x1c05>
mov    0x3c(%rsp),%ecx
add    0x80(%rsp),%ecx
mov    0x148(%rsp),%rax
mov    %ecx,(%rax)
mov    0x150(%rsp),%rax
movsd  %xmm10,(%rax)
mov    %rbx,%rdi
call   1100 <dealloc_LogGrid@plt>
mov    0x28(%rsp),%rdi
call   1100 <dealloc_LogGrid@plt>
mov    %r12,%rdi
jmp    2e96 <R_Dirac+0x1c86>

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

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