#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_ZORA(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] * (v[i] - E) +
               0.5 * fss * dv[i] * kappa / (r[i] * (1.0 - 0.5 * fss * v[i])));
      frp[i] =
          -log_amesh * r[i] * 0.5 * fss * dv[i] / (1.0 - 0.5 * fss * (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_Pauli: 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_ZORA: 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_ZORA>:
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_ZORA+0xc2>
cmpl   $0x0,-0xc(%rbp)
jle    12b3 <R_ZORA+0xb3>
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    12bd <R_ZORA+0xbd>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    12c2 <R_ZORA+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_ZORA+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_ZORA+0x274>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    14a5 <R_ZORA+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_ZORA+0x1ee>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    14e2 <R_ZORA+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_ZORA+0x308>
movsd  0x1b22(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1533 <R_ZORA+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_ZORA+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_ZORA+0x33a>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x64,-0x3c(%rbp)
jge    22ea <R_ZORA+0x10ea>
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_ZORA+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_ZORA+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    182e <R_ZORA+0x62e>
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
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0x192d(%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  0x18f8(%rip),%xmm5
mulsd  -0x90(%rbp),%xmm5
ff
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm6
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
movsd  0x18d8(%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  0x1864(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1840(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1820(%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_ZORA+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    18d0 <R_ZORA+0x6d0>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    18cb <R_ZORA+0x6cb>
lea    0x17dd(%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    234f <R_ZORA+0x114f>
jmp    1837 <R_ZORA+0x637>
movsd  0x1750(%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    1921 <R_ZORA+0x721>
movsd  0x16fd(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18e7 <R_ZORA+0x6e7>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1a17 <R_ZORA+0x817>
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    1928 <R_ZORA+0x728>
movl   $0x0,-0x40(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1bab <R_ZORA+0x9ab>
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    1b63 <R_ZORA+0x963>
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    1a7f <R_ZORA+0x87f>
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     1b98 <R_ZORA+0x998>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b9d <R_ZORA+0x99d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a25 <R_ZORA+0x825>
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    1c14 <R_ZORA+0xa14>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x140a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22e5 <R_ZORA+0x10e5>
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1c53 <R_ZORA+0xa53>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x13cb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22e0 <R_ZORA+0x10e0>
mov    -0x44(%rbp),%eax
mov    %eax,-0x12c(%rbp)
movsd  0x13cc(%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    1c93 <R_ZORA+0xa93>
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     1e15 <R_ZORA+0xc15>
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    1cec <R_ZORA+0xaec>
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1f71 <R_ZORA+0xd71>
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    1f5e <R_ZORA+0xd5e>
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    1e7a <R_ZORA+0xc7a>
jmp    1f63 <R_ZORA+0xd63>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1e1b <R_ZORA+0xc1b>
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     1ff2 <R_ZORA+0xdf2>
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    1f94 <R_ZORA+0xd94>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
mov    -0x48(%rbp),%edi
movsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rsi
call   10a0 <Norm_LogGrid@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xfed(%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     20f4 <R_ZORA+0xef4>
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    2096 <R_ZORA+0xe96>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    2137 <R_ZORA+0xf37>
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    20fd <R_ZORA+0xefd>
movsd  0xed1(%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 0xecb(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0xeb3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xe8f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    21d0 <R_ZORA+0xfd0>
movsd  -0x58(%rbp),%xmm0
movaps 0xe91(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    21e5 <R_ZORA+0xfe5>
movsd  0xe60(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    21e5 <R_ZORA+0xfe5>
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  0xe43(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    2262 <R_ZORA+0x1062>
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    234f <R_ZORA+0x114f>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2283 <R_ZORA+0x1083>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    228d <R_ZORA+0x108d>
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     22c0 <R_ZORA+0x10c0>
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    22db <R_ZORA+0x10db>
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xd3e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    22e0 <R_ZORA+0x10e0>
jmp    22e5 <R_ZORA+0x10e5>
jmp    158c <R_ZORA+0x38c>
lea    0xd93(%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_ZORA>:
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_ZORA+0x43>
test   %edx,%edx
jle    125d <R_ZORA+0x4d>
cvtsi2sd %ebx,%xmm2
jmp    1266 <R_ZORA+0x56>
movsd  0x1da5(%rip),%xmm2
jmp    1266 <R_ZORA+0x56>
cvtsi2sdl 0x108(%rsp),%xmm2
movapd %xmm2,0x260(%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_ZORA+0xbb>
sqrtsd %xmm0,%xmm0
jmp    12d0 <R_ZORA+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 0x260(%rsp),%xmm4
xorpd  %xmm6,%xmm6
jle    1423 <R_ZORA+0x213>
cmp    $0x1,%ebp
jne    13ad <R_ZORA+0x19d>
xorpd  %xmm6,%xmm6
xor    %eax,%eax
jmp    1404 <R_ZORA+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_ZORA+0x1b0>
test   $0x1,%sil
je     1423 <R_ZORA+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 0x1b30(%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,0x218(%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,0x220(%rsp)
movapd %xmm8,%xmm5
unpcklpd %xmm8,%xmm5
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
mov    0x18(%rsp),%rax
neg    %rax
mov    %rax,0x228(%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,0x230(%rsp)
movapd %xmm2,0x2a0(%rsp)
pshufd $0x44,%xmm2,%xmm0
movdqa %xmm0,0x290(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x280(%rsp)
movapd %xmm3,0x250(%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,0x238(%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,0x210(%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,0x208(%rsp)
lea    0x70(%r15),%rax
mov    %rax,0x200(%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_ZORA+0x650>
cmp    $0x4,%r10d
setb   %al
or     0x7(%rsp),%al
je     18b0 <R_ZORA+0x6a0>
xor    %ecx,%ecx
mov    0x88(%rsp),%rdx
jmp    1941 <R_ZORA+0x731>
xchg   %ax,%ax
mov    %r13,%rdi
call   1030 <Derivative_LogGrid@plt>
movsd  0x17d8(%rip),%xmm6
mov    0x8(%rsp),%r11
mov    0x88(%rsp),%rsi
mov    0xd0(%rsp),%r9
mov    0x100(%rsp),%rdx
mov    0x198(%rsp),%r8
movabs $0xffffffff00000000,%r12
ff ff ff
jmp    1c75 <R_ZORA+0xa65>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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_ZORA+0x6c0>
mov    0x220(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     19f3 <R_ZORA+0x7e3>
mov    %rcx,%rax
test   $0x1,%r11b
je     197d <R_ZORA+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    0x228(%rsp),%rcx
je     19f3 <R_ZORA+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_ZORA+0x780>
mov    %r13,%rdi
call   1030 <Derivative_LogGrid@plt>
movapd 0xe0(%rsp),%xmm8
mov    0x18(%rsp),%rdi
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x90(%rsp),%rax
test   %eax,%eax
movapd 0x260(%rsp),%xmm5
mov    0x8(%rsp),%r11
mov    0xd0(%rsp),%r9
movapd 0x2a0(%rsp),%xmm7
movapd 0x250(%rsp),%xmm9
mov    0x230(%rsp),%r10
movapd 0x290(%rsp),%xmm15
movapd 0x280(%rsp),%xmm10
movapd 0x270(%rsp),%xmm11
mov    0x100(%rsp),%rdx
movsd  0x15af(%rip),%xmm12
movsd  0x15ae(%rip),%xmm13
movsd  0x15ad(%rip),%xmm14
movsd  0x15ad(%rip),%xmm6
movsd  0x156d(%rip),%xmm4
mov    0x198(%rsp),%r8
movabs $0xffffffff00000000,%r12
ff ff ff
mov    0x20(%rsp),%rbx
jle    1c75 <R_ZORA+0xa65>
cmp    $0x1,%eax
sete   %al
or     0x6(%rsp),%al
test   $0x1,%al
je     1ad5 <R_ZORA+0x8c5>
xor    %eax,%eax
jmp    1be0 <R_ZORA+0x9d0>
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
xor    %eax,%eax
movapd 0x1596(%rip),%xmm13
movapd 0x15ad(%rip),%xmm8
movapd 0x15b4(%rip),%xmm9
nopl   0x0(%rax)
movupd (%rsi,%rax,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
movapd %xmm2,%xmm3
movapd %xmm2,%xmm4
mulpd  %xmm8,%xmm2
addpd  %xmm9,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm15,%xmm1
mulpd  %xmm13,%xmm3
subpd  %xmm0,%xmm4
mulpd  %xmm3,%xmm4
movupd (%rcx,%rax,8),%xmm3
mulpd  0x154b(%rip),%xmm3
mulpd  %xmm10,%xmm3
divpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,(%rbx,%rax,8)
movupd (%rsi,%rax,8),%xmm1
mulpd  %xmm11,%xmm1
mulpd  0x1553(%rip),%xmm1
mulpd  %xmm13,%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
movupd 0x0(%r13,%rax,8),%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm9,%xmm1
divpd  %xmm1,%xmm2
movupd %xmm2,(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1b00 <R_ZORA+0x8f0>
mov    %r10,%rax
cmp    %rdi,%r10
movsd  0x145f(%rip),%xmm4
movapd 0xe0(%rsp),%xmm8
movapd 0x250(%rsp),%xmm9
movsd  0x146a(%rip),%xmm13
je     1c75 <R_ZORA+0xa65>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
movapd %xmm1,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm14,%xmm1
addsd  %xmm6,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm0
mulsd  %xmm7,%xmm0
mulsd  %xmm12,%xmm2
subsd  %xmm8,%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rcx,%rax,8),%xmm2
mulsd  %xmm13,%xmm2
mulsd  %xmm5,%xmm2
divsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm12,%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm6,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1be0 <R_ZORA+0x9d0>
mov    0x110(%rsp),%r10
add    $0x1,%r10d
mov    0x10(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
mov    0x3c(%rsp),%ebp
mov    %edx,%ebx
mov    0x12c(%rsp),%eax
mov    %eax,%edx
mov    0x238(%rsp),%rdi
xor    %ecx,%ecx
xorpd  %xmm2,%xmm2
movapd 0x13bf(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
movsd  (%r8,%rcx,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
jbe    1d00 <R_ZORA+0xaf0>
add    %r12,%rdi
add    $0xffffffff,%edx
lea    (%r9,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rcx
add    $0x1,%rax
add    $0x1,%ebx
add    $0xffffffff,%ebp
cmp    $0x2,%rax
jg     1cc0 <R_ZORA+0xab0>
jmp    2ded <R_ZORA+0x1bdd>
nopl   0x0(%rax,%rax,1)
mov    %r13,0xc8(%rsp)
mov    0x190(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xf8(%rsp)
movapd %xmm6,%xmm0
cmpl   $0x0,0xb8(%rsp)
jle    1d69 <R_ZORA+0xb59>
mov    0x124(%rsp),%eax
cmpl   $0x7,0x128(%rsp)
07
jb     1d45 <R_ZORA+0xb35>
nopw   0x0(%rax,%rax,1)
add    $0xfffffff8,%eax
jne    1d40 <R_ZORA+0xb30>
movapd %xmm6,%xmm0
cmpl   $0x0,0xb4(%rsp)
je     1d69 <R_ZORA+0xb59>
mov    0xb4(%rsp),%eax
movapd %xmm6,%xmm0
xchg   %ax,%ax
xorpd  %xmm3,%xmm0
add    $0xffffffff,%eax
jne    1d60 <R_ZORA+0xb50>
movapd %xmm0,0x40(%rsp)
mov    %ebx,0x118(%rsp)
mov    %ebp,0x11c(%rsp)
mov    %rdi,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_ZORA+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_ZORA+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_ZORA+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_ZORA+0xd40>
movsd  (%r14,%r13,8),%xmm1
jmp    1fc0 <R_ZORA+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
movsd  0xf7b(%rip),%xmm2
jg     20b0 <R_ZORA+0xea0>
movsd  0xa8(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm1,%xmm6
jmp    20d2 <R_ZORA+0xec2>
xchg   %ax,%ax
test   %ebx,%ebx
js     2104 <R_ZORA+0xef4>
movapd 0x1e0(%rsp),%xmm6
movapd %xmm6,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%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_ZORA+0x61a>
jmp    2e3d <R_ZORA+0x1c2d>
mov    0x180(%rsp),%rax
mov    0x80(%rsp),%rbx
movsd  (%rax,%rbx,8),%xmm0
movaps %xmm0,0x240(%rsp)
mov    0x188(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x1f8(%rsp)
movsd  0x218(%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     21d2 <R_ZORA+0xfc2>
sqrtsd %xmm0,%xmm0
jmp    21df <R_ZORA+0xfcf>
call   10f0 <sqrt@plt>
mov    0x88(%rsp),%r13
movapd %xmm0,0x40(%rsp)
movapd %xmm0,%xmm1
movapd 0xe7f(%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  0xe49(%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  0xdbf(%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  0xd3c(%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  0xcb4(%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  0xc30(%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_ZORA+0x1370>
mov    0x178(%rsp),%r13
sar    $0x20,%r13
jmp    24c9 <R_ZORA+0x12b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r13,%rbx
jle    2580 <R_ZORA+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_ZORA+0x12b0>
movsd  (%r14,%rbx,8),%xmm1
jmp    2510 <R_ZORA+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 0x240(%rsp),%xmm0
mov    0x178(%rsp),%r9
jl     27ac <R_ZORA+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_ZORA+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_ZORA+0x1439>
mov    0x168(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%r9,8),%rsi
cmp    %rdx,%rsi
jae    2649 <R_ZORA+0x1439>
mov    0x78(%rsp),%rdi
jmp    270e <R_ZORA+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_ZORA+0x14a0>
cmp    %rdx,%rcx
mov    %r9,%rbp
mov    %r11,%rbx
mov    %r13,%r9
mov    0x78(%rsp),%rdi
je     27ac <R_ZORA+0x159c>
mov    %edi,%ecx
sub    %r9d,%ecx
add    $0x1,%ecx
test   $0x1,%cl
jne    2728 <R_ZORA+0x1518>
mov    %r9,%rcx
cmp    %r9d,%edi
jne    2754 <R_ZORA+0x1544>
jmp    27ac <R_ZORA+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_ZORA+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_ZORA+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 0x88a(%rip),%xmm0
jb     27de <R_ZORA+0x15ce>
sqrtsd %xmm0,%xmm0
jmp    27e3 <R_ZORA+0x15d3>
call   10f0 <sqrt@plt>
movapd 0x130(%rsp),%xmm8
movapd 0x1e0(%rsp),%xmm11
movapd 0x1b0(%rsp),%xmm9
mov    0x18(%rsp),%r11
movapd 0xe0(%rsp),%xmm10
movapd 0x1d0(%rsp),%xmm5
movapd 0x1c0(%rsp),%xmm7
movsd  0x81e(%rip),%xmm1
xorpd  %xmm6,%xmm6
divsd  %xmm0,%xmm1
mov    0x78(%rsp),%rsi
test   %esi,%esi
mov    0xc8(%rsp),%r13
mov    0x20(%rsp),%r12
mov    0x90(%rsp),%r10
movapd 0x240(%rsp),%xmm4
js     2a85 <R_ZORA+0x1875>
lea    0x1(%rsi),%eax
cmp    $0x3,%esi
jb     287f <R_ZORA+0x166f>
lea    (%r14,%rax,8),%rcx
cmp    %r15,%rcx
jbe    2932 <R_ZORA+0x1722>
lea    (%r15,%rax,8),%rcx
cmp    %r14,%rcx
jbe    2932 <R_ZORA+0x1722>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     28af <R_ZORA+0x169f>
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_ZORA+0x1875>
mov    0xa0(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %ecx,%eax
cmp    %eax,%r10d
cmovl  %r10d,%eax
add    $0xfffffffc,%eax
nopw   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_ZORA+0x16d0>
jmp    2a85 <R_ZORA+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_ZORA+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_ZORA+0x1780>
jmp    2a2e <R_ZORA+0x181e>
xor    %esi,%esi
test   $0x1,%dl
je     2a77 <R_ZORA+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    2881 <R_ZORA+0x1671>
lea    0x1(%rsi),%eax
cmp    %r10d,%eax
jge    2cff <R_ZORA+0x1aef>
cltq
mov    %r10d,%ecx
sub    %esi,%ecx
add    $0xfffffffe,%ecx
cmp    $0x3,%ecx
jb     2c73 <R_ZORA+0x1a63>
lea    (%r15,%rax,8),%rsi
lea    (%rcx,%rax,1),%rdx
mov    0x170(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%rsi
jae    2ad6 <R_ZORA+0x18c6>
mov    0x168(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%rax,8),%rsi
cmp    %rdx,%rsi
jb     2c73 <R_ZORA+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    2afd <R_ZORA+0x18ed>
xor    %edi,%edi
jmp    2bc9 <R_ZORA+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    0x208(%rsp),%rsi
lea    (%rsi,%rdx,8),%rbp
mov    0x200(%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,%rax,1)
movupd %xmm6,-0x70(%rsi,%rdi,8)
movupd %xmm6,-0x60(%rsi,%rdi,8)
movupd %xmm6,-0x70(%rbp,%rdi,8)
movupd %xmm6,-0x60(%rbp,%rdi,8)
movupd %xmm6,-0x50(%rsi,%rdi,8)
movupd %xmm6,-0x40(%rsi,%rdi,8)
movupd %xmm6,-0x50(%rbp,%rdi,8)
movupd %xmm6,-0x40(%rbp,%rdi,8)
movupd %xmm6,-0x30(%rsi,%rdi,8)
movupd %xmm6,-0x20(%rsi,%rdi,8)
movupd %xmm6,-0x30(%rbp,%rdi,8)
movupd %xmm6,-0x20(%rbp,%rdi,8)
movupd %xmm6,-0x10(%rsi,%rdi,8)
movupd %xmm6,(%rsi,%rdi,8)
movupd %xmm6,-0x10(%rbp,%rdi,8)
movupd %xmm6,0x0(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rdx
jne    2b60 <R_ZORA+0x1950>
test   $0x3,%r9b
je     2c5f <R_ZORA+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 %xmm6,-0x10(%rsi,%rbp,1)
movupd %xmm6,(%rsi,%rbp,1)
movupd %xmm6,-0x10(%rdx,%rbp,1)
movupd %xmm6,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdi
jne    2c40 <R_ZORA+0x1a30>
cmp    %r8,%rcx
mov    0xc0(%rsp),%rbp
je     2cff <R_ZORA+0x1aef>
add    %r8,%rax
mov    %r10d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r10d,%ecx
and    $0x3,%edx
je     2ca9 <R_ZORA+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_ZORA+0x1a80>
cmp    $0x3,%ecx
jb     2cff <R_ZORA+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_ZORA+0x1aa0>
mulsd  %xmm1,%xmm4
movsd  0x1f8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x40(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  0x2ea(%rip),%xmm4
mulsd  %xmm0,%xmm4
mov    0x210(%rsp),%rax
mov    0x80(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x60(%rsp),%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,%xmm0
movapd 0x37b(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm10,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x2e6(%rip),%xmm1
mulsd  0x2e6(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2ead <R_ZORA+0x1c9d>
ucomisd 0x2dc(%rip),%xmm4
ja     2d90 <R_ZORA+0x1b80>
movsd  %xmm10,0xa8(%rsp)
xorpd  %xmm0,%xmm0
cmpltsd %xmm4,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm10,%xmm1
andnpd %xmm11,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm0,%xmm6
addsd  %xmm4,%xmm10
ucomisd 0xa8(%rsp),%xmm10
mov    0x30(%rsp),%rsi
ja     2dd0 <R_ZORA+0x1bc0>
ucomisd %xmm10,%xmm6
jbe    20f1 <R_ZORA+0xee1>
movapd %xmm6,%xmm10
addsd  0xa8(%rsp),%xmm10
mulsd  0x228(%rip),%xmm10
jmp    20f1 <R_ZORA+0xee1>
lea    0x313(%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    0x28e(%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    2e1d <R_ZORA+0x1c0d>
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    2e9e <R_ZORA+0x1c8e>

LLVM IR (-O0):
@.str = [36 x i8] c"Error in R_Pauli: no turning point\0A\00"
@.str.1 = [39 x i8] c"Error R_ZORA: More than %d iterations\0A\00"
define void @R_ZORA(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 = %1007, %206
%208 = load i32, i32* %21
%209 = icmp slt i32 %208, 100
br i1 %209, label %210, label %1008
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 = %347, %246
%251 = load i32, i32* %19
%252 = load i32, i32* %25
%253 = icmp slt i32 %251, %252
br i1 %253, label %254, label %350
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 = fmul double %270, %275
%277 = load double*, double** %14
%278 = load i32, i32* %19
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %277, i64 %279
%281 = load double, double* %280
%282 = load double, double* %26
%283 = fsub double %281, %282
%284 = load double, double* %33
%285 = fmul double 5.000000e-01, %284
%286 = load double*, double** %47
%287 = load i32, i32* %19
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %286, i64 %288
%290 = load double, double* %289
%291 = fmul double %285, %290
%292 = load double, double* %28
%293 = fmul double %291, %292
%294 = load double*, double** %45
%295 = load i32, i32* %19
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %294, i64 %296
%298 = load double, double* %297
%299 = load double, double* %33
%300 = fmul double 5.000000e-01, %299
%301 = load double*, double** %14
%302 = load i32, i32* %19
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %301, i64 %303
%305 = load double, double* %304
%306 = fneg double %300
%307 = call double @llvm.fmuladd.f64(double %306, double %305, double 1.000000e+00)
%308 = fmul double %298, %307
%309 = fdiv double %293, %308
%310 = call double @llvm.fmuladd.f64(double %276, double %283, double %309)
%311 = fmul double %269, %310
%312 = load double*, double** %49
%313 = load i32, i32* %19
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %312, i64 %314
store double %311, double* %315
%316 = load double, double* %31
%317 = fneg double %316
%318 = load double*, double** %45
%319 = load i32, i32* %19
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %318, i64 %320
%322 = load double, double* %321
%323 = fmul double %317, %322
%324 = fmul double %323, 5.000000e-01
%325 = load double, double* %33
%326 = fmul double %324, %325
%327 = load double*, double** %47
%328 = load i32, i32* %19
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %327, i64 %329
%331 = load double, double* %330
%332 = fmul double %326, %331
%333 = load double, double* %33
%334 = fmul double 5.000000e-01, %333
%335 = load double*, double** %14
%336 = load i32, i32* %19
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %335, i64 %337
%339 = load double, double* %338
%340 = fneg double %334
%341 = call double @llvm.fmuladd.f64(double %340, double %339, double 1.000000e+00)
%342 = fdiv double %332, %341
%343 = load double*, double** %48
%344 = load i32, i32* %19
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
store double %342, double* %346
br label %347
347: ; preds = %254
%348 = load i32, i32* %19
%349 = add nsw i32 %348, 1
store i32 %349, i32* %19
br label %250
350: ; preds = %250
%351 = load i32, i32* %25
%352 = sub nsw i32 %351, 1
store i32 %352, i32* %23
br label %353
353: ; preds = %384, %350
%354 = load double*, double** %46
%355 = load i32, i32* %23
%356 = sub nsw i32 %355, 1
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %354, i64 %357
%359 = load double, double* %358
%360 = load double*, double** %46
%361 = load i32, i32* %23
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
%364 = load double, double* %363
%365 = fmul double %359, %364
%366 = fcmp ogt double %365, 0.000000e+00
br i1 %366, label %367, label %385
367: ; preds = %353
%368 = load i32, i32* %23
%369 = sub nsw i32 %368, 1
store i32 %369, i32* %23
%370 = load i32, i32* %23
%371 = icmp slt i32 %370, 2
br i1 %371, label %372, label %384
372: ; preds = %367
%373 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%374 = load double*, double** %46
%375 = call i32 @dealloc_LogGrid(double* %374)
%376 = load double*, double** %50
%377 = call i32 @dealloc_LogGrid(double* %376)
%378 = load double*, double** %49
%379 = call i32 @dealloc_LogGrid(double* %378)
%380 = load double*, double** %48
%381 = call i32 @dealloc_LogGrid(double* %380)
%382 = load double*, double** %47
%383 = call i32 @dealloc_LogGrid(double* %382)
br label %1024
384: ; preds = %367
br label %353
385: ; preds = %353
store double 1.000000e+00, double* %41
store i32 0, i32* %19
br label %386
386: ; preds = %396, %385
%387 = load i32, i32* %19
%388 = load i32, i32* %10
%389 = load i32, i32* %11
%390 = sub nsw i32 %388, %389
%391 = sub nsw i32 %390, 1
%392 = icmp slt i32 %387, %391
br i1 %392, label %393, label %399
393: ; preds = %386
%394 = load double, double* %41
%395 = fmul double %394, -1.000000e+00
store double %395, double* %41
br label %396
396: ; preds = %393
%397 = load i32, i32* %19
%398 = add nsw i32 %397, 1
store i32 %398, i32* %19
br label %386
399: ; preds = %386
store i32 0, i32* %19
br label %400
400: ; preds = %464, %399
%401 = load i32, i32* %19
%402 = icmp slt i32 %401, 4
br i1 %402, label %403, label %467
403: ; preds = %400
%404 = load double, double* %41
%405 = load double*, double** %45
%406 = load i32, i32* %19
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %405, i64 %407
%409 = load double, double* %408
%410 = load double, double* %34
%411 = call double @pow(double %409, double %410)
%412 = fmul double %404, %411
%413 = load double*, double** %17
%414 = load i32, i32* %19
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %413, i64 %415
store double %412, double* %416
%417 = load double, double* %31
%418 = load double, double* %34
%419 = fmul double %417, %418
%420 = load double*, double** %17
%421 = load i32, i32* %19
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %420, i64 %422
%424 = load double, double* %423
%425 = fmul double %419, %424
%426 = load double*, double** %18
%427 = load i32, i32* %19
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
store double %425, double* %429
%430 = load double, double* %31
%431 = load double*, double** %48
%432 = load i32, i32* %19
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fadd double %430, %435
%437 = load double*, double** %18
%438 = load i32, i32* %19
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %437, i64 %439
%441 = load double, double* %440
%442 = load double*, double** %46
%443 = load i32, i32* %19
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
%446 = load double, double* %445
%447 = load double*, double** %49
%448 = load i32, i32* %19
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %447, i64 %449
%451 = load double, double* %450
%452 = fadd double %446, %451
%453 = load double*, double** %17
%454 = load i32, i32* %19
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %453, i64 %455
%457 = load double, double* %456
%458 = fmul double %452, %457
%459 = call double @llvm.fmuladd.f64(double %436, double %441, double %458)
%460 = load double*, double** %50
%461 = load i32, i32* %19
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %460, i64 %462
store double %459, double* %463
br label %464
464: ; preds = %403
%465 = load i32, i32* %19
%466 = add nsw i32 %465, 1
store i32 %466, i32* %19
br label %400
467: ; preds = %400
store i32 0, i32* %22
store i32 3, i32* %19
br label %468
468: ; preds = %574, %467
%469 = load i32, i32* %19
%470 = load i32, i32* %23
%471 = icmp slt i32 %469, %470
br i1 %471, label %472, label %577
472: ; preds = %468
%473 = load i32, i32* %19
%474 = load double*, double** %17
%475 = load double*, double** %18
%476 = call double @Predictor_Out(i32 %473, double* %474, double* %475)
%477 = load double*, double** %17
%478 = load i32, i32* %19
%479 = add nsw i32 %478, 1
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %477, i64 %480
store double %476, double* %481
%482 = load i32, i32* %19
%483 = load double*, double** %18
%484 = load double*, double** %50
%485 = call double @Predictor_Out(i32 %482, double* %483, double* %484)
%486 = load double*, double** %18
%487 = load i32, i32* %19
%488 = add nsw i32 %487, 1
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %486, i64 %489
store double %485, double* %490
store i32 0, i32* %20
br label %491
491: ; preds = %553, %472
%492 = load i32, i32* %20
%493 = icmp slt i32 %492, 6
br i1 %493, label %494, label %556
494: ; preds = %491
%495 = load double, double* %31
%496 = load double*, double** %48
%497 = load i32, i32* %19
%498 = add nsw i32 %497, 1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds double, double* %496, i64 %499
%501 = load double, double* %500
%502 = fadd double %495, %501
%503 = load double*, double** %18
%504 = load i32, i32* %19
%505 = add nsw i32 %504, 1
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %503, i64 %506
%508 = load double, double* %507
%509 = load double*, double** %46
%510 = load i32, i32* %19
%511 = add nsw i32 %510, 1
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %509, i64 %512
%514 = load double, double* %513
%515 = load double*, double** %49
%516 = load i32, i32* %19
%517 = add nsw i32 %516, 1
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %515, i64 %518
%520 = load double, double* %519
%521 = fadd double %514, %520
%522 = load double*, double** %17
%523 = load i32, i32* %19
%524 = add nsw i32 %523, 1
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds double, double* %522, i64 %525
%527 = load double, double* %526
%528 = fmul double %521, %527
%529 = call double @llvm.fmuladd.f64(double %502, double %508, double %528)
%530 = load double*, double** %50
%531 = load i32, i32* %19
%532 = add nsw i32 %531, 1
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %530, i64 %533
store double %529, double* %534
%535 = load i32, i32* %19
%536 = load double*, double** %18
%537 = load double*, double** %50
%538 = call double @Corrector_Out(i32 %535, double* %536, double* %537)
%539 = load double*, double** %18
%540 = load i32, i32* %19
%541 = add nsw i32 %540, 1
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds double, double* %539, i64 %542
store double %538, double* %543
%544 = load i32, i32* %19
%545 = load double*, double** %17
%546 = load double*, double** %18
%547 = call double @Corrector_Out(i32 %544, double* %545, double* %546)
%548 = load double*, double** %17
%549 = load i32, i32* %19
%550 = add nsw i32 %549, 1
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds double, double* %548, i64 %551
store double %547, double* %552
br label %553
553: ; preds = %494
%554 = load i32, i32* %20
%555 = add nsw i32 %554, 1
store i32 %555, i32* %20
br label %491
556: ; preds = %491
%557 = load double*, double** %17
%558 = load i32, i32* %19
%559 = add nsw i32 %558, 1
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %557, i64 %560
%562 = load double, double* %561
%563 = load double*, double** %17
%564 = load i32, i32* %19
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %563, i64 %565
%567 = load double, double* %566
%568 = fmul double %562, %567
%569 = fcmp ole double %568, 0.000000e+00
br i1 %569, label %570, label %573
570: ; preds = %556
%571 = load i32, i32* %22
%572 = add nsw i32 %571, 1
store i32 %572, i32* %22
br label %573
573: ; preds = %570, %556
br label %574
574: ; preds = %573
%575 = load i32, i32* %19
%576 = add nsw i32 %575, 1
store i32 %576, i32* %19
br label %468
577: ; preds = %468
%578 = load double*, double** %17
%579 = load i32, i32* %23
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds double, double* %578, i64 %580
%582 = load double, double* %581
store double %582, double* %42
%583 = load double*, double** %18
%584 = load i32, i32* %23
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %583, i64 %585
%587 = load double, double* %586
store double %587, double* %43
%588 = load i32, i32* %22
%589 = load i32, i32* %10
%590 = sub nsw i32 %588, %589
%591 = load i32, i32* %11
%592 = add nsw i32 %590, %591
%593 = add nsw i32 %592, 1
%594 = icmp slt i32 %593, 0
br i1 %594, label %595, label %601
595: ; preds = %577
%596 = load double, double* %26
store double %596, double* %30
%597 = load double, double* %30
%598 = load double, double* %29
%599 = fadd double %597, %598
%600 = fmul double 5.000000e-01, %599
store double %600, double* %26
br label %1007
601: ; preds = %577
%602 = load i32, i32* %22
%603 = load i32, i32* %10
%604 = sub nsw i32 %602, %603
%605 = load i32, i32* %11
%606 = add nsw i32 %604, %605
%607 = add nsw i32 %606, 1
%608 = icmp sgt i32 %607, 0
br i1 %608, label %609, label %615
609: ; preds = %601
%610 = load double, double* %26
store double %610, double* %29
%611 = load double, double* %30
%612 = load double, double* %29
%613 = fadd double %611, %612
%614 = fmul double 5.000000e-01, %613
store double %614, double* %26
br label %1006
615: ; preds = %601
%616 = load i32, i32* %23
%617 = load double, double* %31
%618 = fdiv double 2.300000e+00, %617
%619 = call i32 @floor(double %618)
%620 = add nsw i32 %616, %619
store i32 %620, i32* %24
%621 = load i32, i32* %24
%622 = add nsw i32 %621, 5
%623 = load i32, i32* %25
%624 = icmp sgt i32 %622, %623
br i1 %624, label %625, label %628
625: ; preds = %615
%626 = load i32, i32* %25
%627 = sub nsw i32 %626, 5
store i32 %627, i32* %24
br label %628
628: ; preds = %625, %615
%629 = load double, double* %35
%630 = load double*, double** %45
%631 = load i32, i32* %24
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %630, i64 %632
%634 = load double, double* %633
%635 = load double*, double** %45
%636 = load i32, i32* %24
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
%639 = load double, double* %638
%640 = fmul double %634, %639
%641 = fdiv double %629, %640
%642 = load double*, double** %14
%643 = load i32, i32* %24
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double, double* %642, i64 %644
%646 = load double, double* %645
%647 = load double, double* %26
%648 = fsub double %646, %647
%649 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %648, double %641)
%650 = call double @sqrt(double %649)
store double %650, double* %39
%651 = load i32, i32* %24
store i32 %651, i32* %19
br label %652
652: ; preds = %731, %628
%653 = load i32, i32* %19
%654 = load i32, i32* %24
%655 = add nsw i32 %654, 4
%656 = icmp sle i32 %653, %655
br i1 %656, label %657, label %734
657: ; preds = %652
%658 = load double, double* %39
%659 = fneg double %658
%660 = load double*, double** %45
%661 = load i32, i32* %19
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds double, double* %660, i64 %662
%664 = load double, double* %663
%665 = load double*, double** %45
%666 = load i32, i32* %24
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double, double* %665, i64 %667
%669 = load double, double* %668
%670 = fsub double %664, %669
%671 = fmul double %659, %670
%672 = call double @exp(double %671)
%673 = load double*, double** %17
%674 = load i32, i32* %19
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double, double* %673, i64 %675
store double %672, double* %676
%677 = load double*, double** %45
%678 = load i32, i32* %19
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %677, i64 %679
%681 = load double, double* %680
%682 = fneg double %681
%683 = load double, double* %31
%684 = fmul double %682, %683
%685 = load double, double* %39
%686 = fmul double %684, %685
%687 = load double*, double** %17
%688 = load i32, i32* %19
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %687, i64 %689
%691 = load double, double* %690
%692 = fmul double %686, %691
%693 = load double*, double** %18
%694 = load i32, i32* %19
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds double, double* %693, i64 %695
store double %692, double* %696
%697 = load double, double* %31
%698 = load double*, double** %48
%699 = load i32, i32* %19
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %698, i64 %700
%702 = load double, double* %701
%703 = fadd double %697, %702
%704 = load double*, double** %18
%705 = load i32, i32* %19
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %704, i64 %706
%708 = load double, double* %707
%709 = load double*, double** %46
%710 = load i32, i32* %19
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds double, double* %709, i64 %711
%713 = load double, double* %712
%714 = load double*, double** %49
%715 = load i32, i32* %19
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %714, i64 %716
%718 = load double, double* %717
%719 = fadd double %713, %718
%720 = load double*, double** %17
%721 = load i32, i32* %19
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %720, i64 %722
%724 = load double, double* %723
%725 = fmul double %719, %724
%726 = call double @llvm.fmuladd.f64(double %703, double %708, double %725)
%727 = load double*, double** %50
%728 = load i32, i32* %19
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds double, double* %727, i64 %729
store double %726, double* %730
br label %731
731: ; preds = %657
%732 = load i32, i32* %19
%733 = add nsw i32 %732, 1
store i32 %733, i32* %19
br label %652
734: ; preds = %652
%735 = load i32, i32* %24
store i32 %735, i32* %19
br label %736
736: ; preds = %826, %734
%737 = load i32, i32* %19
%738 = load i32, i32* %23
%739 = add nsw i32 %738, 1
%740 = icmp sge i32 %737, %739
br i1 %740, label %741, label %829
741: ; preds = %736
%742 = load i32, i32* %19
%743 = load double*, double** %17
%744 = load double*, double** %18
%745 = call double @Predictor_In(i32 %742, double* %743, double* %744)
%746 = load double*, double** %17
%747 = load i32, i32* %19
%748 = sub nsw i32 %747, 1
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds double, double* %746, i64 %749
store double %745, double* %750
%751 = load i32, i32* %19
%752 = load double*, double** %18
%753 = load double*, double** %50
%754 = call double @Predictor_In(i32 %751, double* %752, double* %753)
%755 = load double*, double** %18
%756 = load i32, i32* %19
%757 = sub nsw i32 %756, 1
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %755, i64 %758
store double %754, double* %759
store i32 0, i32* %20
br label %760
760: ; preds = %822, %741
%761 = load i32, i32* %20
%762 = icmp slt i32 %761, 6
br i1 %762, label %763, label %825
763: ; preds = %760
%764 = load double, double* %31
%765 = load double*, double** %48
%766 = load i32, i32* %19
%767 = sub nsw i32 %766, 1
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds double, double* %765, i64 %768
%770 = load double, double* %769
%771 = fadd double %764, %770
%772 = load double*, double** %18
%773 = load i32, i32* %19
%774 = sub nsw i32 %773, 1
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds double, double* %772, i64 %775
%777 = load double, double* %776
%778 = load double*, double** %46
%779 = load i32, i32* %19
%780 = sub nsw i32 %779, 1
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %778, i64 %781
%783 = load double, double* %782
%784 = load double*, double** %49
%785 = load i32, i32* %19
%786 = sub nsw i32 %785, 1
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %784, i64 %787
%789 = load double, double* %788
%790 = fadd double %783, %789
%791 = load double*, double** %17
%792 = load i32, i32* %19
%793 = sub nsw i32 %792, 1
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %791, i64 %794
%796 = load double, double* %795
%797 = fmul double %790, %796
%798 = call double @llvm.fmuladd.f64(double %771, double %777, double %797)
%799 = load double*, double** %50
%800 = load i32, i32* %19
%801 = sub nsw i32 %800, 1
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds double, double* %799, i64 %802
store double %798, double* %803
%804 = load i32, i32* %19
%805 = load double*, double** %18
%806 = load double*, double** %50
%807 = call double @Corrector_In(i32 %804, double* %805, double* %806)
%808 = load double*, double** %18
%809 = load i32, i32* %19
%810 = sub nsw i32 %809, 1
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds double, double* %808, i64 %811
store double %807, double* %812
%813 = load i32, i32* %19
%814 = load double*, double** %17
%815 = load double*, double** %18
%816 = call double @Corrector_In(i32 %813, double* %814, double* %815)
%817 = load double*, double** %17
%818 = load i32, i32* %19
%819 = sub nsw i32 %818, 1
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds double, double* %817, i64 %820
store double %816, double* %821
br label %822
822: ; preds = %763
%823 = load i32, i32* %20
%824 = add nsw i32 %823, 1
store i32 %824, i32* %20
br label %760
825: ; preds = %760
br label %826
826: ; preds = %825
%827 = load i32, i32* %19
%828 = add nsw i32 %827, -1
store i32 %828, i32* %19
br label %736
829: ; preds = %736
%830 = load double, double* %42
%831 = load double*, double** %17
%832 = load i32, i32* %23
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %831, i64 %833
%835 = load double, double* %834
%836 = fdiv double %830, %835
store double %836, double* %40
%837 = load i32, i32* %23
store i32 %837, i32* %19
br label %838
838: ; preds = %865, %829
%839 = load i32, i32* %19
%840 = load i32, i32* %24
%841 = icmp sle i32 %839, %840
br i1 %841, label %842, label %868
842: ; preds = %838
%843 = load double, double* %40
%844 = load double*, double** %17
%845 = load i32, i32* %19
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %844, i64 %846
%848 = load double, double* %847
%849 = fmul double %843, %848
%850 = load double*, double** %17
%851 = load i32, i32* %19
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds double, double* %850, i64 %852
store double %849, double* %853
%854 = load double, double* %40
%855 = load double*, double** %18
%856 = load i32, i32* %19
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %855, i64 %857
%859 = load double, double* %858
%860 = fmul double %854, %859
%861 = load double*, double** %18
%862 = load i32, i32* %19
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds double, double* %861, i64 %863
store double %860, double* %864
br label %865
865: ; preds = %842
%866 = load i32, i32* %19
%867 = add nsw i32 %866, 1
store i32 %867, i32* %19
br label %838
868: ; preds = %838
%869 = load double*, double** %18
%870 = load i32, i32* %23
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %869, i64 %871
%873 = load double, double* %872
store double %873, double* %44
%874 = load i32, i32* %24
%875 = load double, double* %34
%876 = load double*, double** %17
%877 = call double @Norm_LogGrid(i32 %874, double %875, double* %876)
store double %877, double* %38
%878 = load double, double* %38
%879 = call double @sqrt(double %878)
%880 = fdiv double 1.000000e+00, %879
store double %880, double* %38
%881 = load double, double* %38
%882 = load double, double* %42
%883 = fmul double %881, %882
store double %883, double* %42
%884 = load double, double* %38
%885 = load double, double* %43
%886 = fmul double %884, %885
store double %886, double* %43
%887 = load double, double* %38
%888 = load double, double* %44
%889 = fmul double %887, %888
store double %889, double* %44
store i32 0, i32* %19
br label %890
890: ; preds = %917, %868
%891 = load i32, i32* %19
%892 = load i32, i32* %24
%893 = icmp sle i32 %891, %892
br i1 %893, label %894, label %920
894: ; preds = %890
%895 = load double, double* %38
%896 = load double*, double** %17
%897 = load i32, i32* %19
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds double, double* %896, i64 %898
%900 = load double, double* %899
%901 = fmul double %895, %900
%902 = load double*, double** %17
%903 = load i32, i32* %19
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %902, i64 %904
store double %901, double* %905
%906 = load double, double* %38
%907 = load double*, double** %18
%908 = load i32, i32* %19
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds double, double* %907, i64 %909
%911 = load double, double* %910
%912 = fmul double %906, %911
%913 = load double*, double** %18
%914 = load i32, i32* %19
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds double, double* %913, i64 %915
store double %912, double* %916
br label %917
917: ; preds = %894
%918 = load i32, i32* %19
%919 = add nsw i32 %918, 1
store i32 %919, i32* %19
br label %890
920: ; preds = %890
%921 = load i32, i32* %24
%922 = add nsw i32 %921, 1
store i32 %922, i32* %19
br label %923
923: ; preds = %936, %920
%924 = load i32, i32* %19
%925 = load i32, i32* %25
%926 = icmp slt i32 %924, %925
br i1 %926, label %927, label %939
927: ; preds = %923
%928 = load double*, double** %17
%929 = load i32, i32* %19
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds double, double* %928, i64 %930
store double 0.000000e+00, double* %931
%932 = load double*, double** %18
%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
br label %936
936: ; preds = %927
%937 = load i32, i32* %19
%938 = add nsw i32 %937, 1
store i32 %938, i32* %19
br label %923
939: ; preds = %923
%940 = load double, double* %42
%941 = fmul double 5.000000e-01, %940
%942 = load double, double* %43
%943 = load double, double* %44
%944 = fsub double %942, %943
%945 = fmul double %941, %944
%946 = load double, double* %31
%947 = load double*, double** %45
%948 = load i32, i32* %23
%949 = sext i32 %948 to i64
%950 = getelementptr inbounds double, double* %947, i64 %949
%951 = load double, double* %950
%952 = fmul double %946, %951
%953 = fdiv double %945, %952
store double %953, double* %27
%954 = load double, double* %27
%955 = call double @llvm.fabs.f64(double %954)
%956 = load double, double* %26
%957 = call double @llvm.fabs.f64(double %956)
%958 = fcmp ogt double %957, 2.000000e-01
br i1 %958, label %959, label %962
959: ; preds = %939
%960 = load double, double* %26
%961 = call double @llvm.fabs.f64(double %960)
br label %963
962: ; preds = %939
br label %963
963: ; preds = %962, %959
%964 = phi double [ %961, %959 ], [ 2.000000e-01, %962 ]
%965 = fmul double %964, 1.000000e-10
%966 = fcmp olt double %955, %965
br i1 %966, label %967, label %982
967: ; preds = %963
%968 = load i32, i32* %23
%969 = load i32*, i32** %15
store i32 %968, i32* %969
%970 = load double, double* %26
%971 = load double*, double** %16
store double %970, double* %971
%972 = load double*, double** %46
%973 = call i32 @dealloc_LogGrid(double* %972)
%974 = load double*, double** %50
%975 = call i32 @dealloc_LogGrid(double* %974)
%976 = load double*, double** %49
%977 = call i32 @dealloc_LogGrid(double* %976)
%978 = load double*, double** %48
%979 = call i32 @dealloc_LogGrid(double* %978)
%980 = load double*, double** %47
%981 = call i32 @dealloc_LogGrid(double* %980)
br label %1024
982: ; preds = %963
%983 = load double, double* %27
%984 = fcmp ogt double %983, 0.000000e+00
br i1 %984, label %985, label %987
985: ; preds = %982
%986 = load double, double* %26
store double %986, double* %30
br label %989
987: ; preds = %982
%988 = load double, double* %26
store double %988, double* %29
br label %989
989: ; preds = %987, %985
%990 = load double, double* %26
%991 = load double, double* %27
%992 = fadd double %990, %991
store double %992, double* %26
%993 = load double, double* %26
%994 = load double, double* %29
%995 = fcmp ogt double %993, %994
br i1 %995, label %1000, label %996
996: ; preds = %989
%997 = load double, double* %26
%998 = load double, double* %30
%999 = fcmp olt double %997, %998
br i1 %999, label %1000, label %1005
1000: ; preds = %996, %989
%1001 = load double, double* %30
%1002 = load double, double* %29
%1003 = fadd double %1001, %1002
%1004 = fmul double 5.000000e-01, %1003
store double %1004, double* %26
br label %1005
1005: ; preds = %1000, %996
br label %1006
1006: ; preds = %1005, %609
br label %1007
1007: ; preds = %1006, %595
br label %207
1008: ; preds = %207
%1009 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0), i32 100)
%1010 = load i32, i32* %23
%1011 = load i32*, i32** %15
store i32 %1010, i32* %1011
%1012 = load double, double* %26
%1013 = load double*, double** %16
store double %1012, double* %1013
%1014 = load double*, double** %46
%1015 = call i32 @dealloc_LogGrid(double* %1014)
%1016 = load double*, double** %50
%1017 = call i32 @dealloc_LogGrid(double* %1016)
%1018 = load double*, double** %49
%1019 = call i32 @dealloc_LogGrid(double* %1018)
%1020 = load double*, double** %48
%1021 = call i32 @dealloc_LogGrid(double* %1020)
%1022 = load double*, double** %47
%1023 = call i32 @dealloc_LogGrid(double* %1022)
br label %1024
1024: ; preds = %1008, %967, %372
ret void
}

LLVM IR (-O2):
@.str.1 = [39 x i8] c"Error R_ZORA: More than %d iterations\0A\00"
@str = [35 x i8] c"Error in R_Pauli: no turning point\00"
define void @R_ZORA(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, %1101
%215 = phi i32 [ 0, %95 ], [ %219, %1101 ]
%216 = phi double [ %115, %95 ], [ %1104, %1101 ]
%217 = phi double [ %46, %95 ], [ %1103, %1101 ]
%218 = phi double [ %96, %95 ], [ %1102, %1101 ]
%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 %353
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 %353
305: ; preds = %303
%306 = select i1 %174, i1 true, i1 %201
br i1 %306, label %351, 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 ], [ %348, %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 = fmul <2 x double> %319, <double 0x3F0BEB460CEF1CFC, double 0x3F0BEB460CEF1CFC>
%321 = fsub <2 x double> %319, %309
%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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> <double 0xBEFBEB460CEF1CFC, double 0xBEFBEB460CEF1CFC>, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%328 = fmul <2 x double> %314, %327
%329 = fdiv <2 x double> %326, %328
%330 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %320, <2 x double> %321, <2 x double> %329)
%331 = fmul <2 x double> %316, %330
%332 = getelementptr inbounds double, double* %34, i64 %311
%333 = bitcast double* %332 to <2 x double>*
store <2 x double> %331, <2 x double>* %333
%334 = bitcast double* %312 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = fmul <2 x double> %335, %208
%337 = fmul <2 x double> %336, <double 5.000000e-01, double 5.000000e-01>
%338 = fmul <2 x double> %337, <double 0x3F0BEB460CEF1CFC, double 0x3F0BEB460CEF1CFC>
%339 = bitcast double* %322 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = fmul <2 x double> %340, %338
%342 = bitcast double* %317 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %343, <2 x double> <double 0xBEFBEB460CEF1CFC, double 0xBEFBEB460CEF1CFC>, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%345 = fdiv <2 x double> %341, %344
%346 = getelementptr inbounds double, double* %35, i64 %311
%347 = bitcast double* %346 to <2 x double>*
store <2 x double> %345, <2 x double>* %347
%348 = add nuw i64 %311, 2
%349 = icmp eq i64 %348, %202
br i1 %349, label %350, label %310
350: ; preds = %310
br i1 %209, label %353, label %351
351: ; preds = %305, %350
%352 = phi i64 [ 0, %305 ], [ %202, %350 ]
br label %355
353: ; preds = %355, %350, %276, %303
%354 = load double, double* %126
br label %387
355: ; preds = %351, %355
%356 = phi i64 [ %385, %355 ], [ %352, %351 ]
%357 = getelementptr inbounds double, double* %31, i64 %356
%358 = load double, double* %357
%359 = fmul double %358, %358
%360 = fmul double %359, %116
%361 = getelementptr inbounds double, double* %4, i64 %356
%362 = load double, double* %361
%363 = fmul double %362, 0x3F0BEB460CEF1CFC
%364 = fsub double %362, %216
%365 = getelementptr inbounds double, double* %36, i64 %356
%366 = load double, double* %365
%367 = fmul double %366, 0x3EFBEB460CEF1CFC
%368 = fmul double %23, %367
%369 = tail call double @llvm.fmuladd.f64(double %362, double 0xBEFBEB460CEF1CFC, double 1.000000e+00)
%370 = fmul double %358, %369
%371 = fdiv double %368, %370
%372 = tail call double @llvm.fmuladd.f64(double %363, double %364, double %371)
%373 = fmul double %360, %372
%374 = getelementptr inbounds double, double* %34, i64 %356
store double %373, double* %374
%375 = load double, double* %357
%376 = fmul double %375, %117
%377 = fmul double %376, 5.000000e-01
%378 = fmul double %377, 0x3F0BEB460CEF1CFC
%379 = load double, double* %365
%380 = fmul double %379, %378
%381 = load double, double* %361
%382 = tail call double @llvm.fmuladd.f64(double %381, double 0xBEFBEB460CEF1CFC, double 1.000000e+00)
%383 = fdiv double %380, %382
%384 = getelementptr inbounds double, double* %35, i64 %356
store double %383, double* %384
%385 = add nuw nsw i64 %356, 1
%386 = icmp eq i64 %385, %125
br i1 %386, label %353, label %355
387: ; preds = %353, %398
%388 = phi double [ %354, %353 ], [ %392, %398 ]
%389 = phi i64 [ %38, %353 ], [ %390, %398 ]
%390 = add nsw i64 %389, -1
%391 = getelementptr inbounds double, double* %32, i64 %390
%392 = load double, double* %391
%393 = fmul double %392, %388
%394 = fcmp ogt double %393, 0.000000e+00
br i1 %394, label %398, label %395
395: ; preds = %387
%396 = trunc i64 %389 to i32
br i1 %120, label %397, label %413
397: ; preds = %395
br i1 %211, label %406, label %464
398: ; preds = %387
%399 = icmp slt i64 %389, 3
br i1 %399, label %400, label %387
400: ; preds = %398
%401 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str, i64 0, i64 0))
%402 = tail call i32 @dealloc_LogGrid(double* %32)
%403 = tail call i32 @dealloc_LogGrid(double* %33)
%404 = tail call i32 @dealloc_LogGrid(double* %34)
%405 = tail call i32 @dealloc_LogGrid(double* %35)
br label %1113
406: ; preds = %464, %397
br i1 %213, label %413, label %407
407: ; preds = %406, %407
%408 = phi double [ %410, %407 ], [ 1.000000e+00, %406 ]
%409 = phi i32 [ %411, %407 ], [ 0, %406 ]
%410 = fneg double %408
%411 = add i32 %409, 1
%412 = icmp eq i32 %411, %210
br i1 %412, label %413, label %407
413: ; preds = %406, %407, %395
%414 = phi double [ 1.000000e+00, %395 ], [ 1.000000e+00, %406 ], [ %410, %407 ]
%415 = load double, double* %31
%416 = tail call double @pow(double %415, double %27)
%417 = fmul double %414, %416
store double %417, double* %7
%418 = fmul double %121, %417
store double %418, double* %8
%419 = load double, double* %35
%420 = fadd double %29, %419
%421 = load double, double* %32
%422 = load double, double* %34
%423 = fadd double %421, %422
%424 = load double, double* %7
%425 = fmul double %423, %424
%426 = tail call double @llvm.fmuladd.f64(double %420, double %418, double %425)
store double %426, double* %33
%427 = load double, double* %127
%428 = tail call double @pow(double %427, double %27)
%429 = fmul double %414, %428
store double %429, double* %105
%430 = fmul double %121, %429
store double %430, double* %106
%431 = load double, double* %128
%432 = fadd double %29, %431
%433 = load double, double* %129
%434 = load double, double* %130
%435 = fadd double %433, %434
%436 = load double, double* %105
%437 = fmul double %435, %436
%438 = tail call double @llvm.fmuladd.f64(double %432, double %430, double %437)
store double %438, double* %107
%439 = load double, double* %131
%440 = tail call double @pow(double %439, double %27)
%441 = fmul double %414, %440
store double %441, double* %108
%442 = fmul double %121, %441
store double %442, double* %109
%443 = load double, double* %132
%444 = fadd double %29, %443
%445 = load double, double* %133
%446 = load double, double* %134
%447 = fadd double %445, %446
%448 = load double, double* %108
%449 = fmul double %447, %448
%450 = tail call double @llvm.fmuladd.f64(double %444, double %442, double %449)
store double %450, double* %110
%451 = load double, double* %135
%452 = tail call double @pow(double %451, double %27)
%453 = fmul double %414, %452
store double %453, double* %111
%454 = fmul double %121, %453
store double %454, double* %112
%455 = load double, double* %136
%456 = fadd double %29, %455
%457 = load double, double* %137
%458 = load double, double* %138
%459 = fadd double %457, %458
%460 = load double, double* %111
%461 = fmul double %459, %460
%462 = tail call double @llvm.fmuladd.f64(double %456, double %454, double %461)
store double %462, double* %113
%463 = icmp sgt i32 %396, 3
br i1 %463, label %468, label %509
464: ; preds = %397, %464
%465 = phi i32 [ %466, %464 ], [ 0, %397 ]
%466 = add i32 %465, 8
%467 = icmp eq i32 %466, %212
br i1 %467, label %406, label %464
468: ; preds = %413
%469 = and i64 %389, 4294967295
br label %470
470: ; preds = %468, %501
%471 = phi i64 [ 3, %468 ], [ %475, %501 ]
%472 = phi i32 [ 0, %468 ], [ %507, %501 ]
%473 = trunc i64 %471 to i32
%474 = tail call double @Predictor_Out(i32 %473, double* %7, double* %8)
%475 = add nuw nsw i64 %471, 1
%476 = getelementptr inbounds double, double* %7, i64 %475
store double %474, double* %476
%477 = tail call double @Predictor_Out(i32 %473, double* %8, double* %33)
%478 = getelementptr inbounds double, double* %8, i64 %475
store double %477, double* %478
%479 = getelementptr inbounds double, double* %35, i64 %475
%480 = getelementptr inbounds double, double* %32, i64 %475
%481 = getelementptr inbounds double, double* %34, i64 %475
%482 = getelementptr inbounds double, double* %33, i64 %475
%483 = load double, double* %476
br label %484
484: ; preds = %499, %470
%485 = phi double [ %483, %470 ], [ %496, %499 ]
%486 = phi double [ %477, %470 ], [ %500, %499 ]
%487 = phi i32 [ 0, %470 ], [ %497, %499 ]
%488 = load double, double* %479
%489 = fadd double %29, %488
%490 = load double, double* %480
%491 = load double, double* %481
%492 = fadd double %490, %491
%493 = fmul double %492, %485
%494 = tail call double @llvm.fmuladd.f64(double %489, double %486, double %493)
store double %494, double* %482
%495 = tail call double @Corrector_Out(i32 %473, double* %8, double* %33)
store double %495, double* %478
%496 = tail call double @Corrector_Out(i32 %473, double* %7, double* %8)
store double %496, double* %476
%497 = add nuw nsw i32 %487, 1
%498 = icmp eq i32 %497, 6
br i1 %498, label %501, label %499
499: ; preds = %484
%500 = load double, double* %478
br label %484
501: ; preds = %484
%502 = getelementptr inbounds double, double* %7, i64 %471
%503 = load double, double* %502
%504 = fmul double %496, %503
%505 = fcmp ole double %504, 0.000000e+00
%506 = zext i1 %505 to i32
%507 = add nuw nsw i32 %472, %506
%508 = icmp eq i64 %475, %469
br i1 %508, label %509, label %470
509: ; preds = %501, %413
%510 = phi i32 [ 0, %413 ], [ %507, %501 ]
%511 = getelementptr inbounds double, double* %7, i64 %389
%512 = load double, double* %511
%513 = getelementptr inbounds double, double* %8, i64 %389
%514 = load double, double* %513
%515 = sub nsw i32 %510, %0
%516 = add nsw i32 %515, %1
%517 = icmp slt i32 %516, -1
br i1 %517, label %518, label %521
518: ; preds = %509
%519 = fadd double %217, %216
%520 = fmul double %519, 5.000000e-01
br label %1101
521: ; preds = %509
%522 = icmp sgt i32 %516, -1
br i1 %522, label %523, label %526
523: ; preds = %521
%524 = fadd double %218, %216
%525 = fmul double %524, 5.000000e-01
br label %1101
526: ; preds = %521
%527 = tail call i32 @floor(double %122)
%528 = add nsw i32 %527, %396
%529 = add nsw i32 %528, 5
%530 = icmp sgt i32 %529, %28
%531 = select i1 %530, i32 %123, i32 %528
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %31, i64 %532
%534 = load double, double* %533
%535 = fmul double %534, %534
%536 = fdiv double %13, %535
%537 = getelementptr inbounds double, double* %4, i64 %532
%538 = load double, double* %537
%539 = fsub double %538, %216
%540 = tail call double @llvm.fmuladd.f64(double %539, double 2.000000e+00, double %536)
%541 = tail call double @sqrt(double %540)
%542 = fneg double %541
%543 = load double, double* %533
%544 = fsub double %543, %543
%545 = fmul double %544, %542
%546 = tail call double @exp(double %545)
%547 = getelementptr inbounds double, double* %7, i64 %532
store double %546, double* %547
%548 = load double, double* %533
%549 = fneg double %548
%550 = fmul double %29, %549
%551 = fmul double %541, %550
%552 = fmul double %546, %551
%553 = getelementptr inbounds double, double* %8, i64 %532
store double %552, double* %553
%554 = getelementptr inbounds double, double* %35, i64 %532
%555 = load double, double* %554
%556 = fadd double %29, %555
%557 = getelementptr inbounds double, double* %32, i64 %532
%558 = load double, double* %557
%559 = getelementptr inbounds double, double* %34, i64 %532
%560 = load double, double* %559
%561 = fadd double %558, %560
%562 = load double, double* %547
%563 = fmul double %561, %562
%564 = tail call double @llvm.fmuladd.f64(double %556, double %552, double %563)
%565 = getelementptr inbounds double, double* %33, i64 %532
store double %564, double* %565
%566 = add nsw i64 %532, 1
%567 = getelementptr inbounds double, double* %31, i64 %566
%568 = load double, double* %567
%569 = load double, double* %533
%570 = fsub double %568, %569
%571 = fmul double %570, %542
%572 = tail call double @exp(double %571)
%573 = getelementptr inbounds double, double* %7, i64 %566
store double %572, double* %573
%574 = load double, double* %567
%575 = fneg double %574
%576 = fmul double %29, %575
%577 = fmul double %541, %576
%578 = fmul double %572, %577
%579 = getelementptr inbounds double, double* %8, i64 %566
store double %578, double* %579
%580 = getelementptr inbounds double, double* %35, i64 %566
%581 = load double, double* %580
%582 = fadd double %29, %581
%583 = getelementptr inbounds double, double* %32, i64 %566
%584 = load double, double* %583
%585 = getelementptr inbounds double, double* %34, i64 %566
%586 = load double, double* %585
%587 = fadd double %584, %586
%588 = load double, double* %573
%589 = fmul double %587, %588
%590 = tail call double @llvm.fmuladd.f64(double %582, double %578, double %589)
%591 = getelementptr inbounds double, double* %33, i64 %566
store double %590, double* %591
%592 = add nsw i64 %532, 2
%593 = getelementptr inbounds double, double* %31, i64 %592
%594 = load double, double* %593
%595 = load double, double* %533
%596 = fsub double %594, %595
%597 = fmul double %596, %542
%598 = tail call double @exp(double %597)
%599 = getelementptr inbounds double, double* %7, i64 %592
store double %598, double* %599
%600 = load double, double* %593
%601 = fneg double %600
%602 = fmul double %29, %601
%603 = fmul double %541, %602
%604 = fmul double %598, %603
%605 = getelementptr inbounds double, double* %8, i64 %592
store double %604, double* %605
%606 = getelementptr inbounds double, double* %35, i64 %592
%607 = load double, double* %606
%608 = fadd double %29, %607
%609 = getelementptr inbounds double, double* %32, i64 %592
%610 = load double, double* %609
%611 = getelementptr inbounds double, double* %34, i64 %592
%612 = load double, double* %611
%613 = fadd double %610, %612
%614 = load double, double* %599
%615 = fmul double %613, %614
%616 = tail call double @llvm.fmuladd.f64(double %608, double %604, double %615)
%617 = getelementptr inbounds double, double* %33, i64 %592
store double %616, double* %617
%618 = add nsw i64 %532, 3
%619 = getelementptr inbounds double, double* %31, i64 %618
%620 = load double, double* %619
%621 = load double, double* %533
%622 = fsub double %620, %621
%623 = fmul double %622, %542
%624 = tail call double @exp(double %623)
%625 = getelementptr inbounds double, double* %7, i64 %618
store double %624, double* %625
%626 = load double, double* %619
%627 = fneg double %626
%628 = fmul double %29, %627
%629 = fmul double %541, %628
%630 = fmul double %624, %629
%631 = getelementptr inbounds double, double* %8, i64 %618
store double %630, double* %631
%632 = getelementptr inbounds double, double* %35, i64 %618
%633 = load double, double* %632
%634 = fadd double %29, %633
%635 = getelementptr inbounds double, double* %32, i64 %618
%636 = load double, double* %635
%637 = getelementptr inbounds double, double* %34, i64 %618
%638 = load double, double* %637
%639 = fadd double %636, %638
%640 = load double, double* %625
%641 = fmul double %639, %640
%642 = tail call double @llvm.fmuladd.f64(double %634, double %630, double %641)
%643 = getelementptr inbounds double, double* %33, i64 %618
store double %642, double* %643
%644 = add nsw i64 %532, 4
%645 = getelementptr inbounds double, double* %31, i64 %644
%646 = load double, double* %645
%647 = load double, double* %533
%648 = fsub double %646, %647
%649 = fmul double %648, %542
%650 = tail call double @exp(double %649)
%651 = getelementptr inbounds double, double* %7, i64 %644
store double %650, double* %651
%652 = load double, double* %645
%653 = fneg double %652
%654 = fmul double %29, %653
%655 = fmul double %541, %654
%656 = fmul double %650, %655
%657 = getelementptr inbounds double, double* %8, i64 %644
store double %656, double* %657
%658 = getelementptr inbounds double, double* %35, i64 %644
%659 = load double, double* %658
%660 = fadd double %29, %659
%661 = getelementptr inbounds double, double* %32, i64 %644
%662 = load double, double* %661
%663 = getelementptr inbounds double, double* %34, i64 %644
%664 = load double, double* %663
%665 = fadd double %662, %664
%666 = load double, double* %651
%667 = fmul double %665, %666
%668 = tail call double @llvm.fmuladd.f64(double %660, double %656, double %667)
%669 = getelementptr inbounds double, double* %33, i64 %644
store double %668, double* %669
%670 = icmp sgt i32 %531, %396
br i1 %670, label %671, label %706
671: ; preds = %526
%672 = shl i64 %389, 32
%673 = ashr exact i64 %672, 32
br label %676
674: ; preds = %689
%675 = icmp sgt i64 %680, %673
br i1 %675, label %676, label %706
676: ; preds = %671, %674
%677 = phi i64 [ %532, %671 ], [ %680, %674 ]
%678 = trunc i64 %677 to i32
%679 = tail call double @Predictor_In(i32 %678, double* %7, double* %8)
%680 = add nsw i64 %677, -1
%681 = getelementptr inbounds double, double* %7, i64 %680
store double %679, double* %681
%682 = tail call double @Predictor_In(i32 %678, double* %8, double* %33)
%683 = getelementptr inbounds double, double* %8, i64 %680
store double %682, double* %683
%684 = getelementptr inbounds double, double* %35, i64 %680
%685 = getelementptr inbounds double, double* %32, i64 %680
%686 = getelementptr inbounds double, double* %34, i64 %680
%687 = getelementptr inbounds double, double* %33, i64 %680
%688 = load double, double* %681
br label %689
689: ; preds = %704, %676
%690 = phi double [ %688, %676 ], [ %701, %704 ]
%691 = phi double [ %682, %676 ], [ %705, %704 ]
%692 = phi i32 [ 0, %676 ], [ %702, %704 ]
%693 = load double, double* %684
%694 = fadd double %29, %693
%695 = load double, double* %685
%696 = load double, double* %686
%697 = fadd double %695, %696
%698 = fmul double %697, %690
%699 = tail call double @llvm.fmuladd.f64(double %694, double %691, double %698)
store double %699, double* %687
%700 = tail call double @Corrector_In(i32 %678, double* %8, double* %33)
store double %700, double* %683
%701 = tail call double @Corrector_In(i32 %678, double* %7, double* %8)
store double %701, double* %681
%702 = add nuw nsw i32 %692, 1
%703 = icmp eq i32 %702, 6
br i1 %703, label %674, label %704
704: ; preds = %689
%705 = load double, double* %683
br label %689
706: ; preds = %674, %526
%707 = load double, double* %511
%708 = fdiv double %512, %707
%709 = icmp slt i32 %531, %396
br i1 %709, label %799, label %710
710: ; preds = %706
%711 = shl i64 %389, 32
%712 = ashr exact i64 %711, 32
%713 = add i32 %531, 1
%714 = sub i32 %531, %396
%715 = zext i32 %714 to i64
%716 = add nuw nsw i64 %715, 1
%717 = icmp ult i32 %714, 3
br i1 %717, label %763, label %718
718: ; preds = %710
%719 = getelementptr double, double* %7, i64 %712
%720 = sub i32 %531, %396
%721 = zext i32 %720 to i64
%722 = add nsw i64 %712, %721
%723 = getelementptr double, double* %141, i64 %722
%724 = getelementptr double, double* %8, i64 %712
%725 = getelementptr double, double* %142, i64 %722
%726 = icmp ult double* %719, %725
%727 = icmp ult double* %724, %723
%728 = and i1 %726, %727
br i1 %728, label %763, label %729
729: ; preds = %718
%730 = and i64 %716, 8589934588
%731 = add nsw i64 %712, %730
%732 = insertelement <2 x double> poison, double %708, i64 0
%733 = shufflevector <2 x double> %732, <2 x double> poison, <2 x i32> zeroinitializer
%734 = insertelement <2 x double> poison, double %708, i64 0
%735 = shufflevector <2 x double> %734, <2 x double> poison, <2 x i32> zeroinitializer
br label %736
736: ; preds = %736, %729
%737 = phi i64 [ 0, %729 ], [ %759, %736 ]
%738 = add i64 %712, %737
%739 = getelementptr inbounds double, double* %7, i64 %738
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = getelementptr inbounds double, double* %739, i64 2
%743 = bitcast double* %742 to <2 x double>*
%744 = load <2 x double>, <2 x double>* %743
%745 = fmul <2 x double> %733, %741
%746 = fmul <2 x double> %735, %744
%747 = bitcast double* %739 to <2 x double>*
store <2 x double> %745, <2 x double>* %747
%748 = bitcast double* %742 to <2 x double>*
store <2 x double> %746, <2 x double>* %748
%749 = getelementptr inbounds double, double* %8, i64 %738
%750 = bitcast double* %749 to <2 x double>*
%751 = load <2 x double>, <2 x double>* %750
%752 = getelementptr inbounds double, double* %749, i64 2
%753 = bitcast double* %752 to <2 x double>*
%754 = load <2 x double>, <2 x double>* %753
%755 = fmul <2 x double> %733, %751
%756 = fmul <2 x double> %735, %754
%757 = bitcast double* %749 to <2 x double>*
store <2 x double> %755, <2 x double>* %757
%758 = bitcast double* %752 to <2 x double>*
store <2 x double> %756, <2 x double>* %758
%759 = add nuw i64 %737, 4
%760 = icmp eq i64 %759, %730
br i1 %760, label %761, label %736
761: ; preds = %736
%762 = icmp eq i64 %716, %730
br i1 %762, label %799, label %763
763: ; preds = %718, %710, %761
%764 = phi i64 [ %712, %718 ], [ %712, %710 ], [ %731, %761 ]
%765 = add i32 %531, 1
%766 = trunc i64 %764 to i32
%767 = sub i32 %765, %766
%768 = and i32 %767, 1
%769 = icmp eq i32 %768, 0
br i1 %769, label %778, label %770
770: ; preds = %763
%771 = getelementptr inbounds double, double* %7, i64 %764
%772 = load double, double* %771
%773 = fmul double %708, %772
store double %773, double* %771
%774 = getelementptr inbounds double, double* %8, i64 %764
%775 = load double, double* %774
%776 = fmul double %708, %775
store double %776, double* %774
%777 = add nsw i64 %764, 1
br label %778
778: ; preds = %770, %763
%779 = phi i64 [ %764, %763 ], [ %777, %770 ]
%780 = icmp eq i32 %531, %766
br i1 %780, label %799, label %781
781: ; preds = %778, %781
%782 = phi i64 [ %796, %781 ], [ %779, %778 ]
%783 = getelementptr inbounds double, double* %7, i64 %782
%784 = load double, double* %783
%785 = fmul double %708, %784
store double %785, double* %783
%786 = getelementptr inbounds double, double* %8, i64 %782
%787 = load double, double* %786
%788 = fmul double %708, %787
store double %788, double* %786
%789 = add nsw i64 %782, 1
%790 = getelementptr inbounds double, double* %7, i64 %789
%791 = load double, double* %790
%792 = fmul double %708, %791
store double %792, double* %790
%793 = getelementptr inbounds double, double* %8, i64 %789
%794 = load double, double* %793
%795 = fmul double %708, %794
store double %795, double* %793
%796 = add nsw i64 %782, 2
%797 = trunc i64 %796 to i32
%798 = icmp eq i32 %713, %797
br i1 %798, label %799, label %781
799: ; preds = %778, %781, %761, %706
%800 = load double, double* %513
%801 = tail call double @Norm_LogGrid(i32 %531, double %27, double* %7)
%802 = tail call double @sqrt(double %801)
%803 = fdiv double 1.000000e+00, %802
%804 = fmul double %512, %803
%805 = fmul double %514, %803
%806 = fmul double %800, %803
%807 = icmp slt i32 %531, 0
br i1 %807, label %921, label %808
808: ; preds = %799
%809 = add nuw i32 %531, 1
%810 = zext i32 %809 to i64
%811 = icmp ult i32 %531, 3
br i1 %811, label %904, label %812
812: ; preds = %808
%813 = getelementptr double, double* %7, i64 %810
%814 = getelementptr double, double* %8, i64 %810
%815 = icmp ugt double* %814, %7
%816 = icmp ugt double* %813, %8
%817 = and i1 %815, %816
br i1 %817, label %904, label %818
818: ; preds = %812
%819 = and i64 %810, 4294967292
%820 = insertelement <2 x double> poison, double %803, i64 0
%821 = shufflevector <2 x double> %820, <2 x double> poison, <2 x i32> zeroinitializer
%822 = insertelement <2 x double> poison, double %803, i64 0
%823 = shufflevector <2 x double> %822, <2 x double> poison, <2 x i32> zeroinitializer
%824 = add nsw i64 %819, -4
%825 = lshr exact i64 %824, 2
%826 = add nuw nsw i64 %825, 1
%827 = and i64 %826, 1
%828 = icmp eq i64 %824, 0
br i1 %828, label %878, label %829
829: ; preds = %818
%830 = and i64 %826, 9223372036854775806
br label %831
831: ; preds = %831, %829
%832 = phi i64 [ 0, %829 ], [ %875, %831 ]
%833 = phi i64 [ 0, %829 ], [ %876, %831 ]
%834 = getelementptr inbounds double, double* %7, i64 %832
%835 = bitcast double* %834 to <2 x double>*
%836 = load <2 x double>, <2 x double>* %835
%837 = getelementptr inbounds double, double* %834, i64 2
%838 = bitcast double* %837 to <2 x double>*
%839 = load <2 x double>, <2 x double>* %838
%840 = fmul <2 x double> %821, %836
%841 = fmul <2 x double> %823, %839
%842 = bitcast double* %834 to <2 x double>*
store <2 x double> %840, <2 x double>* %842
%843 = bitcast double* %837 to <2 x double>*
store <2 x double> %841, <2 x double>* %843
%844 = getelementptr inbounds double, double* %8, i64 %832
%845 = bitcast double* %844 to <2 x double>*
%846 = load <2 x double>, <2 x double>* %845
%847 = getelementptr inbounds double, double* %844, i64 2
%848 = bitcast double* %847 to <2 x double>*
%849 = load <2 x double>, <2 x double>* %848
%850 = fmul <2 x double> %821, %846
%851 = fmul <2 x double> %823, %849
%852 = bitcast double* %844 to <2 x double>*
store <2 x double> %850, <2 x double>* %852
%853 = bitcast double* %847 to <2 x double>*
store <2 x double> %851, <2 x double>* %853
%854 = or i64 %832, 4
%855 = getelementptr inbounds double, double* %7, i64 %854
%856 = bitcast double* %855 to <2 x double>*
%857 = load <2 x double>, <2 x double>* %856
%858 = getelementptr inbounds double, double* %855, i64 2
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = fmul <2 x double> %821, %857
%862 = fmul <2 x double> %823, %860
%863 = bitcast double* %855 to <2 x double>*
store <2 x double> %861, <2 x double>* %863
%864 = bitcast double* %858 to <2 x double>*
store <2 x double> %862, <2 x double>* %864
%865 = getelementptr inbounds double, double* %8, i64 %854
%866 = bitcast double* %865 to <2 x double>*
%867 = load <2 x double>, <2 x double>* %866
%868 = getelementptr inbounds double, double* %865, i64 2
%869 = bitcast double* %868 to <2 x double>*
%870 = load <2 x double>, <2 x double>* %869
%871 = fmul <2 x double> %821, %867
%872 = fmul <2 x double> %823, %870
%873 = bitcast double* %865 to <2 x double>*
store <2 x double> %871, <2 x double>* %873
%874 = bitcast double* %868 to <2 x double>*
store <2 x double> %872, <2 x double>* %874
%875 = add nuw i64 %832, 8
%876 = add i64 %833, 2
%877 = icmp eq i64 %876, %830
br i1 %877, label %878, label %831
878: ; preds = %831, %818
%879 = phi i64 [ 0, %818 ], [ %875, %831 ]
%880 = icmp eq i64 %827, 0
br i1 %880, label %902, label %881
881: ; preds = %878
%882 = getelementptr inbounds double, double* %7, i64 %879
%883 = bitcast double* %882 to <2 x double>*
%884 = load <2 x double>, <2 x double>* %883
%885 = getelementptr inbounds double, double* %882, i64 2
%886 = bitcast double* %885 to <2 x double>*
%887 = load <2 x double>, <2 x double>* %886
%888 = fmul <2 x double> %821, %884
%889 = fmul <2 x double> %823, %887
%890 = bitcast double* %882 to <2 x double>*
store <2 x double> %888, <2 x double>* %890
%891 = bitcast double* %885 to <2 x double>*
store <2 x double> %889, <2 x double>* %891
%892 = getelementptr inbounds double, double* %8, i64 %879
%893 = bitcast double* %892 to <2 x double>*
%894 = load <2 x double>, <2 x double>* %893
%895 = getelementptr inbounds double, double* %892, i64 2
%896 = bitcast double* %895 to <2 x double>*
%897 = load <2 x double>, <2 x double>* %896
%898 = fmul <2 x double> %821, %894
%899 = fmul <2 x double> %823, %897
%900 = bitcast double* %892 to <2 x double>*
store <2 x double> %898, <2 x double>* %900
%901 = bitcast double* %895 to <2 x double>*
store <2 x double> %899, <2 x double>* %901
br label %902
902: ; preds = %878, %881
%903 = icmp eq i64 %819, %810
br i1 %903, label %921, label %904
904: ; preds = %812, %808, %902
%905 = phi i64 [ 0, %812 ], [ 0, %808 ], [ %819, %902 ]
%906 = xor i64 %905, -1
%907 = and i64 %810, 1
%908 = icmp eq i64 %907, 0
br i1 %908, label %917, label %909
909: ; preds = %904
%910 = getelementptr inbounds double, double* %7, i64 %905
%911 = load double, double* %910
%912 = fmul double %803, %911
store double %912, double* %910
%913 = getelementptr inbounds double, double* %8, i64 %905
%914 = load double, double* %913
%915 = fmul double %803, %914
store double %915, double* %913
%916 = or i64 %905, 1
br label %917
917: ; preds = %909, %904
%918 = phi i64 [ %905, %904 ], [ %916, %909 ]
%919 = sub nsw i64 0, %810
%920 = icmp eq i64 %906, %919
br i1 %920, label %921, label %1037
921: ; preds = %917, %1037, %902, %799
%922 = add i32 %531, 1
%923 = icmp slt i32 %922, %28
br i1 %923, label %924, label %1070
924: ; preds = %921
%925 = sext i32 %922 to i64
%926 = sub i32 %28, %531
%927 = add i32 %926, -2
%928 = zext i32 %927 to i64
%929 = add nuw nsw i64 %928, 1
%930 = icmp ult i32 %927, 3
br i1 %930, label %1018, label %931
931: ; preds = %924
%932 = getelementptr double, double* %7, i64 %925
%933 = sub i32 %28, %531
%934 = add i32 %933, -2
%935 = zext i32 %934 to i64
%936 = add nsw i64 %925, %935
%937 = getelementptr double, double* %139, i64 %936
%938 = getelementptr double, double* %8, i64 %925
%939 = getelementptr double, double* %140, i64 %936
%940 = icmp ult double* %932, %939
%941 = icmp ult double* %938, %937
%942 = and i1 %940, %941
br i1 %942, label %1018, label %943
943: ; preds = %931
%944 = and i64 %929, 8589934588
%945 = add nsw i64 %944, %925
%946 = add nsw i64 %944, -4
%947 = lshr exact i64 %946, 2
%948 = add nuw nsw i64 %947, 1
%949 = and i64 %948, 3
%950 = icmp ult i64 %946, 12
br i1 %950, label %998, label %951
951: ; preds = %943
%952 = and i64 %948, 9223372036854775804
br label %953
953: ; preds = %953, %951
%954 = phi i64 [ 0, %951 ], [ %995, %953 ]
%955 = phi i64 [ 0, %951 ], [ %996, %953 ]
%956 = add i64 %954, %925
%957 = getelementptr inbounds double, double* %7, i64 %956
%958 = bitcast double* %957 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %958
%959 = getelementptr inbounds double, double* %957, i64 2
%960 = bitcast double* %959 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %960
%961 = getelementptr inbounds double, double* %8, i64 %956
%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 = or i64 %954, 4
%966 = add i64 %965, %925
%967 = getelementptr inbounds double, double* %7, i64 %966
%968 = bitcast double* %967 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %968
%969 = getelementptr inbounds double, double* %967, i64 2
%970 = bitcast double* %969 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %970
%971 = getelementptr inbounds double, double* %8, i64 %966
%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 = or i64 %954, 8
%976 = add i64 %975, %925
%977 = getelementptr inbounds double, double* %7, i64 %976
%978 = bitcast double* %977 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %978
%979 = getelementptr inbounds double, double* %977, i64 2
%980 = bitcast double* %979 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %980
%981 = getelementptr inbounds double, double* %8, i64 %976
%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 = or i64 %954, 12
%986 = add i64 %985, %925
%987 = getelementptr inbounds double, double* %7, i64 %986
%988 = bitcast double* %987 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %988
%989 = getelementptr inbounds double, double* %987, i64 2
%990 = bitcast double* %989 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %990
%991 = getelementptr inbounds double, double* %8, i64 %986
%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 = add nuw i64 %954, 16
%996 = add nuw i64 %955, 4
%997 = icmp eq i64 %996, %952
br i1 %997, label %998, label %953
998: ; preds = %953, %943
%999 = phi i64 [ 0, %943 ], [ %995, %953 ]
%1000 = icmp eq i64 %949, 0
br i1 %1000, label %1016, label %1001
1001: ; preds = %998, %1001
%1002 = phi i64 [ %1013, %1001 ], [ %999, %998 ]
%1003 = phi i64 [ %1014, %1001 ], [ 0, %998 ]
%1004 = add i64 %1002, %925
%1005 = getelementptr inbounds double, double* %7, i64 %1004
%1006 = bitcast double* %1005 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1006
%1007 = getelementptr inbounds double, double* %1005, i64 2
%1008 = bitcast double* %1007 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1008
%1009 = getelementptr inbounds double, double* %8, i64 %1004
%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 = add nuw i64 %1002, 4
%1014 = add i64 %1003, 1
%1015 = icmp eq i64 %1014, %949
br i1 %1015, label %1016, label %1001
1016: ; preds = %1001, %998
%1017 = icmp eq i64 %929, %944
br i1 %1017, label %1070, label %1018
1018: ; preds = %931, %924, %1016
%1019 = phi i64 [ %925, %931 ], [ %925, %924 ], [ %945, %1016 ]
%1020 = trunc i64 %1019 to i32
%1021 = sub i32 %28, %1020
%1022 = xor i32 %1020, -1
%1023 = add i32 %28, %1022
%1024 = and i32 %1021, 3
%1025 = icmp eq i32 %1024, 0
br i1 %1025, label %1034, label %1026
1026: ; preds = %1018, %1026
%1027 = phi i64 [ %1031, %1026 ], [ %1019, %1018 ]
%1028 = phi i32 [ %1032, %1026 ], [ 0, %1018 ]
%1029 = getelementptr inbounds double, double* %7, i64 %1027
store double 0.000000e+00, double* %1029
%1030 = getelementptr inbounds double, double* %8, i64 %1027
store double 0.000000e+00, double* %1030
%1031 = add nsw i64 %1027, 1
%1032 = add i32 %1028, 1
%1033 = icmp eq i32 %1032, %1024
br i1 %1033, label %1034, label %1026
1034: ; preds = %1026, %1018
%1035 = phi i64 [ %1019, %1018 ], [ %1031, %1026 ]
%1036 = icmp ult i32 %1023, 3
br i1 %1036, label %1070, label %1054
1037: ; preds = %917, %1037
%1038 = phi i64 [ %1052, %1037 ], [ %918, %917 ]
%1039 = getelementptr inbounds double, double* %7, i64 %1038
%1040 = load double, double* %1039
%1041 = fmul double %803, %1040
store double %1041, double* %1039
%1042 = getelementptr inbounds double, double* %8, i64 %1038
%1043 = load double, double* %1042
%1044 = fmul double %803, %1043
store double %1044, double* %1042
%1045 = add nuw nsw i64 %1038, 1
%1046 = getelementptr inbounds double, double* %7, i64 %1045
%1047 = load double, double* %1046
%1048 = fmul double %803, %1047
store double %1048, double* %1046
%1049 = getelementptr inbounds double, double* %8, i64 %1045
%1050 = load double, double* %1049
%1051 = fmul double %803, %1050
store double %1051, double* %1049
%1052 = add nuw nsw i64 %1038, 2
%1053 = icmp eq i64 %1052, %810
br i1 %1053, label %921, label %1037
1054: ; preds = %1034, %1054
%1055 = phi i64 [ %1067, %1054 ], [ %1035, %1034 ]
%1056 = getelementptr inbounds double, double* %7, i64 %1055
store double 0.000000e+00, double* %1056
%1057 = getelementptr inbounds double, double* %8, i64 %1055
store double 0.000000e+00, double* %1057
%1058 = add nsw i64 %1055, 1
%1059 = getelementptr inbounds double, double* %7, i64 %1058
store double 0.000000e+00, double* %1059
%1060 = getelementptr inbounds double, double* %8, i64 %1058
store double 0.000000e+00, double* %1060
%1061 = add nsw i64 %1055, 2
%1062 = getelementptr inbounds double, double* %7, i64 %1061
store double 0.000000e+00, double* %1062
%1063 = getelementptr inbounds double, double* %8, i64 %1061
store double 0.000000e+00, double* %1063
%1064 = add nsw i64 %1055, 3
%1065 = getelementptr inbounds double, double* %7, i64 %1064
store double 0.000000e+00, double* %1065
%1066 = getelementptr inbounds double, double* %8, i64 %1064
store double 0.000000e+00, double* %1066
%1067 = add nsw i64 %1055, 4
%1068 = trunc i64 %1067 to i32
%1069 = icmp eq i32 %28, %1068
br i1 %1069, label %1070, label %1054
1070: ; preds = %1034, %1054, %1016, %921
%1071 = fmul double %804, 5.000000e-01
%1072 = fsub double %805, %806
%1073 = fmul double %1071, %1072
%1074 = getelementptr inbounds double, double* %31, i64 %389
%1075 = load double, double* %1074
%1076 = fmul double %29, %1075
%1077 = fdiv double %1073, %1076
%1078 = tail call double @llvm.fabs.f64(double %1077)
%1079 = tail call double @llvm.fabs.f64(double %216)
%1080 = fcmp ogt double %1079, 2.000000e-01
%1081 = select i1 %1080, double %1079, double 2.000000e-01
%1082 = fmul double %1081, 1.000000e-10
%1083 = fcmp olt double %1078, %1082
br i1 %1083, label %1084, label %1090
1084: ; preds = %1070
%1085 = trunc i64 %389 to i32
store i32 %1085, i32* %5
store double %216, double* %6
%1086 = tail call i32 @dealloc_LogGrid(double* %32)
%1087 = tail call i32 @dealloc_LogGrid(double* %33)
%1088 = tail call i32 @dealloc_LogGrid(double* %34)
%1089 = tail call i32 @dealloc_LogGrid(double* %35)
br label %1113
1090: ; preds = %1070
%1091 = fcmp ogt double %1077, 0.000000e+00
%1092 = select i1 %1091, double %216, double %218
%1093 = select i1 %1091, double %217, double %216
%1094 = fadd double %216, %1077
%1095 = fcmp ogt double %1094, %1093
%1096 = fcmp olt double %1094, %1092
%1097 = select i1 %1095, i1 true, i1 %1096
br i1 %1097, label %1098, label %1101
1098: ; preds = %1090
%1099 = fadd double %1092, %1093
%1100 = fmul double %1099, 5.000000e-01
br label %1101
1101: ; preds = %1090, %523, %1098, %518
%1102 = phi double [ %216, %518 ], [ %218, %523 ], [ %1092, %1098 ], [ %1092, %1090 ]
%1103 = phi double [ %217, %518 ], [ %216, %523 ], [ %1093, %1098 ], [ %1093, %1090 ]
%1104 = phi double [ %520, %518 ], [ %525, %523 ], [ %1100, %1098 ], [ %1094, %1090 ]
%1105 = icmp eq i32 %219, 100
br i1 %1105, label %1106, label %214
1106: ; preds = %1101
%1107 = trunc i64 %389 to i32
%1108 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0), i32 100)
store i32 %1107, i32* %5
store double %1104, double* %6
%1109 = tail call i32 @dealloc_LogGrid(double* %32)
%1110 = tail call i32 @dealloc_LogGrid(double* %33)
%1111 = tail call i32 @dealloc_LogGrid(double* %34)
%1112 = tail call i32 @dealloc_LogGrid(double* %35)
br label %1113
1113: ; preds = %1106, %1084, %400
%1114 = tail call i32 @dealloc_LogGrid(double* %36)
ret void
}