void R_Schrodinger(n, l, v, mch, Eig, u, uprime) int n, l;
double v[];
int *mch;
double *Eig;
double u[], uprime[];
{
  int i, j, iteration, node, match, Ninf, Ngrid;
  double E, de, Emax, Emin, log_amesh, log_amesh2, gamma, L2, r2, sum, a, scale,
      m1scale, uout, upout, upin, *r, *f_upp, *upp;
  E = *Eig;
  gamma = ((double)(l + 1));
  L2 = ((double)(l * (l + 1)));
  Ngrid = N_LogGrid();
  log_amesh = log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = (double *)r_LogGrid();
  f_upp = (double *)alloc_LogGrid();
  upp = (double *)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);
  iteration = 0;
  while (iteration < 500) {
    ++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);
    }
    match = Ngrid - 1;
    while (f_upp[match - 1] * f_upp[match] > 0.0) {
      match = match - 1;
      if (match < 2) {
        printf("Error in R_Schrodinger: no turning point\n");
        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];
    }
    for (i = 0; i < 4; ++i)
      upp[i] = log_amesh * uprime[i] + f_upp[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 * uprime[i + 1] + f_upp[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 * uprime[i] + f_upp[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 * uprime[i - 1] + f_upp[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(upp);
        dealloc_LogGrid(f_upp);
        return;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  printf("R_Schrodinger: More than %d iterations, Eig=%le, de=%le\n", 500, E,
         de);
  match = Ngrid - 1;
  R_Schrodinger_Fixed_Logderiv(n, l, v, Ngrid - 1, 0.0, Eig, u, uprime);
  R_Schrodinger_Fixed_E(n, l, v, Ngrid - 1, *Eig, u, uprime);
  printf(
      "R_Schrodinger: Running R_Schrodginger_Fixed_E with eig=%le match=%d\n",
      *Eig, match);
  *mch = match;
  *Eig = E;
  dealloc_LogGrid(upp);
  dealloc_LogGrid(f_upp);
  return;
}


x86 assembly (clang, -O0):
<R_Schrodinger>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1120 <N_LogGrid@plt>
mov    %eax,-0x44(%rbp)
mov    $0x0,%al
call   1030 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    $0x0,%al
call   1080 <r_LogGrid@plt>
cltq
mov    %rax,-0xd0(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xd8(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d24(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mov    -0xd0(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd0(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    13fc <R_Schrodinger+0x1ec>
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1c80(%rip),%xmm2
mulsd  -0x88(%rbp),%xmm2
ff
divsd  -0x90(%rbp),%xmm2
ff
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    13b0 <R_Schrodinger+0x1a0>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    13e1 <R_Schrodinger+0x1d1>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1c3b(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
divsd  -0x90(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    132a <R_Schrodinger+0x11a>
movsd  -0x50(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    141e <R_Schrodinger+0x20e>
movsd  0x1bf4(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1444 <R_Schrodinger+0x234>
movsd  0x1bd6(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    146f <R_Schrodinger+0x25f>
movsd  -0x60(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x1b9a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x1f4,-0x34(%rbp)
jge    1f51 <R_Schrodinger+0xd41>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    152c <R_Schrodinger+0x31c>
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x50(%rbp),%xmm3
movsd  0x1b4a(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x90(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1493 <R_Schrodinger+0x283>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1592 <R_Schrodinger+0x382>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    158d <R_Schrodinger+0x37d>
lea    0x1adf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2013 <R_Schrodinger+0xe03>
jmp    1535 <R_Schrodinger+0x325>
movsd  0x1a7e(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15e3 <R_Schrodinger+0x3d3>
movsd  0x1a73(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15a9 <R_Schrodinger+0x399>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    166c <R_Schrodinger+0x45c>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm1
call   10d0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ea <R_Schrodinger+0x3da>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    16d2 <R_Schrodinger+0x4c2>
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1673 <R_Schrodinger+0x463>
movl   $0x0,-0x38(%rbp)
movl   $0x3,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1854 <R_Schrodinger+0x644>
mov    -0x2c(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   1070 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    $0x0,%al
call   1070 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    180c <R_Schrodinger+0x5fc>
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    $0x0,%al
call   1060 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   1060 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1746 <R_Schrodinger+0x536>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1841 <R_Schrodinger+0x631>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1846 <R_Schrodinger+0x636>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16e0 <R_Schrodinger+0x4d0>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    18bd <R_Schrodinger+0x6ad>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  0x1751(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1f4c <R_Schrodinger+0xd3c>
mov    -0x38(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    18fc <R_Schrodinger+0x6ec>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  0x1712(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1f47 <R_Schrodinger+0xd37>
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0x170f(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
call   1130 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x5,%eax
cmp    -0x44(%rbp),%eax
jle    1949 <R_Schrodinger+0x739>
mov    -0x44(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x40(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
mov    -0xd0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     1aab <R_Schrodinger+0x89b>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19a2 <R_Schrodinger+0x792>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1bf5 <R_Schrodinger+0x9e5>
mov    -0x2c(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   10c0 <Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    $0x0,%al
call   10c0 <Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1be2 <R_Schrodinger+0x9d2>
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    $0x0,%al
call   10b0 <Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   10b0 <Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b1c <R_Schrodinger+0x90c>
jmp    1be7 <R_Schrodinger+0x9d7>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ab1 <R_Schrodinger+0x8a1>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1c76 <R_Schrodinger+0xa66>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c18 <R_Schrodinger+0xa08>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x40(%rbp),%edi
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    $0x1,%al
call   10a0 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x1356(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1d7b <R_Schrodinger+0xb6b>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d1d <R_Schrodinger+0xb0d>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1dbe <R_Schrodinger+0xbae>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d84 <R_Schrodinger+0xb74>
movsd  0x123a(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
subsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movaps 0x1244(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movaps 0x122c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x11f8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1e57 <R_Schrodinger+0xc47>
movsd  -0x50(%rbp),%xmm0
movaps 0x120a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1e6c <R_Schrodinger+0xc5c>
movsd  0x11c9(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1e6c <R_Schrodinger+0xc5c>
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  0x11ac(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ec9 <R_Schrodinger+0xcb9>
mov    -0x3c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xe0(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
jmp    2013 <R_Schrodinger+0xe03>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1eea <R_Schrodinger+0xcda>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1ef4 <R_Schrodinger+0xce4>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
ja     1f27 <R_Schrodinger+0xd17>
movsd  -0x50(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f42 <R_Schrodinger+0xd32>
movsd  -0x68(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  0x10c7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1f47 <R_Schrodinger+0xd37>
jmp    1f4c <R_Schrodinger+0xd3c>
jmp    1476 <R_Schrodinger+0x266>
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
lea    0x1128(%rip),%rdi
mov    $0x1f4,%esi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
mov    %rax,(%rsp)
mov    $0x1,%al
call   1050 <R_Schrodinger_Fixed_Logderiv@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%r8
mov    0x10(%rbp),%r9
mov    $0x1,%al
call   1110 <R_Schrodinger_Fixed_E@plt>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x3c(%rbp),%esi
lea    0x10e9(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xe0(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0xd8(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Schrodinger>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
mov    %r9,0x50(%rsp)
mov    %rcx,0x150(%rsp)
mov    %rdx,%r14
mov    %edi,0x74(%rsp)
mov    0x2b0(%rsp),%rax
mov    %rax,0x20(%rsp)
lea    0x1(%rsi),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x88(%rsp)
mov    %r8,0x158(%rsp)
movsd  (%r8),%xmm0
movaps %xmm0,0x30(%rsp)
mov    %rsi,0x108(%rsp)
imul   %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0xf0(%rsp)
xor    %eax,%eax
call   1130 <N_LogGrid@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1040 <log_amesh_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x18(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x140(%rsp)
xor    %eax,%eax
call   1090 <r_LogGrid@plt>
movslq %eax,%rbp
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
movslq %eax,%r15
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %r12,%rdx
mov    %rbp,%rsi
cltq
mov    %rax,0x60(%rsp)
lea    -0x1(%r12),%eax
mov    %eax,0x5c(%rsp)
movslq %edx,%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x110(%rsp)
movsd  0x1cfe(%rip),%xmm0
mulsd  0xf0(%rsp),%xmm0
movsd  -0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm4
divsd  %xmm1,%xmm4
addsd  -0x8(%r14,%rax,8),%xmm4
mov    %eax,%r8d
xorpd  %xmm5,%xmm5
test   %eax,%eax
jle    13ae <R_Schrodinger+0x18e>
cmp    $0x1,%edx
jne    133c <R_Schrodinger+0x11c>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
jmp    1391 <R_Schrodinger+0x171>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm5,%xmm5
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
movsd  0x8(%rsi,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm3
divsd  %xmm1,%xmm3
addsd  (%r14,%rax,8),%xmm3
mulsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
divsd  %xmm2,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
minsd  %xmm3,%xmm5
minsd  %xmm1,%xmm5
add    $0x2,%rax
cmp    %rax,%rcx
jne    1350 <R_Schrodinger+0x130>
test   $0x1,%r8b
je     13ae <R_Schrodinger+0x18e>
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
addsd  (%r14,%rax,8),%xmm0
minsd  %xmm0,%xmm5
movsd  0x1c52(%rip),%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm4,%xmm1
movapd 0x30(%rsp),%xmm2
cmpltsd %xmm2,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movsd  0x1c33(%rip),%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm1,%xmm2
cmpltsd %xmm5,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm1,%xmm3
andpd  %xmm0,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm4,%xmm0
movapd %xmm5,0x130(%rsp)
addsd  %xmm5,%xmm0
mulsd  0x1bed(%rip),%xmm0
movsd  %xmm4,0xd8(%rsp)
cmpltsd %xmm2,%xmm4
movapd %xmm4,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm4
orpd   %xmm1,%xmm4
movapd %xmm4,0x90(%rsp)
mov    0x108(%rsp),%r13
mov    %r13d,%r12d
not    %r12d
mov    %rsi,0x48(%rsp)
mov    0x74(%rsp),%ebp
add    %ebp,%r12d
movsd  0x88(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xe8(%rsp)
movsd  0x1ba0(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %rdx,0x80(%rsp)
mov    %r8,0xa8(%rsp)
call   1140 <floor@plt>
mov    0xa8(%rsp),%r11
xorpd  %xmm10,%xmm10
mov    0x80(%rsp),%rsi
movsd  %xmm0,0x238(%rsp)
lea    -0x5(%rsi),%eax
mov    %eax,0x120(%rsp)
mov    0x50(%rsp),%r9
lea    0x8(%r9),%rax
mov    %rax,0x170(%rsp)
mov    0x20(%rsp),%rbx
lea    0x8(%rbx),%rax
mov    %rax,0x178(%rsp)
mov    %r15,%rdi
lea    (%r15,%r11,8),%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%r11,8),%rcx
lea    (%r14,%r11,8),%r8
mov    %ebp,%edx
mov    0x48(%rsp),%r15
sub    %r13d,%edx
add    $0xfffffffe,%edx
mov    %edx,0x128(%rsp)
cmp    %rcx,%rdi
setb   %cl
cmp    %rax,%r15
setb   %dl
and    %cl,%dl
cmp    %r8,%rdi
setb   %cl
mov    %r14,0xb0(%rsp)
cmp    %r14,%rax
seta   %r13b
and    %cl,%r13b
or     %dl,%r13b
mov    %rsi,%rdx
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x240(%rsp)
movapd 0xf0(%rsp),%xmm11
movapd %xmm11,%xmm5
unpcklpd %xmm11,%xmm5
movapd 0x140(%rsp),%xmm12
movapd %xmm12,%xmm6
unpcklpd %xmm12,%xmm6
mov    %r11,%rax
neg    %rax
mov    %rax,0x248(%rsp)
mov    %r12d,%eax
and    $0x7,%eax
mov    %eax,0xbc(%rsp)
mov    %r12d,0x12c(%rsp)
and    $0xfffffff8,%r12d
mov    %r12d,0x124(%rsp)
lea    0x0(,%r11,8),%r12
and    $0xffffffffffffffe0,%r12
mov    0x5c(%rsp),%eax
mov    %rax,0x250(%rsp)
mov    0x110(%rsp),%r10
lea    (%r15,%r10,8),%rax
mov    %rax,0x230(%rsp)
mov    %r10,%r8
shl    $0x20,%r8
mov    $0xfffffffc,%ecx
sub    %edx,%ecx
movsd  0x1a49(%rip),%xmm13
movapd 0x1a60(%rip),%xmm8
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
mov    %rax,0x208(%rsp)
lea    (%r9,%r10,8),%rax
mov    %rax,0x188(%rsp)
lea    (%rbx,%r10,8),%rax
mov    %rax,0x198(%rsp)
lea    -0x8(%rdi,%r10,8),%rax
mov    %rax,0x258(%rsp)
lea    -0x8(%r9),%rax
mov    %rax,0x228(%rsp)
lea    -0x8(%rbx),%rax
mov    %rax,0x220(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,0x218(%rsp)
mov    0x60(%rsp),%rax
lea    -0x8(%rax),%rax
mov    %rax,0x210(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x168(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x160(%rsp)
lea    0x70(%rbx),%rax
mov    %rax,0x1f8(%rsp)
lea    0x70(%r9),%rax
mov    %rcx,%r9
mov    %rax,0x1f0(%rsp)
xor    %esi,%esi
mov    %rdi,0x68(%rsp)
test   %edx,%edx
movapd 0x90(%rsp),%xmm7
jle    1800 <R_Schrodinger+0x5e0>
cmp    $0x4,%edx
setb   %al
or     %r13b,%al
je     16b0 <R_Schrodinger+0x490>
xor    %ecx,%ecx
jmp    1740 <R_Schrodinger+0x520>
nopl   (%rax)
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
mov    0xb0(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r15,%rax,1),%xmm1
movupd 0x10(%r15,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd (%rcx,%rax,1),%xmm3
movupd 0x10(%rcx,%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  %xmm6,%xmm3
mulpd  %xmm6,%xmm4
movupd %xmm3,(%rdi,%rax,1)
movupd %xmm4,0x10(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%r12
jne    16d0 <R_Schrodinger+0x4b0>
mov    0x240(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     1800 <R_Schrodinger+0x5e0>
mov    %rcx,%rax
test   $0x1,%r11b
je     1782 <R_Schrodinger+0x562>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
mov    0xb0(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm11,%xmm1
mulsd  %xmm12,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x248(%rsp),%rcx
mov    0xb0(%rsp),%rcx
je     1800 <R_Schrodinger+0x5e0>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%rcx,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm11,%xmm1
mulsd  %xmm12,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%rcx,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm11,%xmm1
mulsd  %xmm12,%xmm1
movsd  %xmm1,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    17a0 <R_Schrodinger+0x580>
mov    %rbx,%r14
add    $0x1,%esi
mov    %esi,0x2c(%rsp)
movsd  (%rdi,%r10,8),%xmm0
mov    %r9d,%edx
mov    0x5c(%rsp),%ebp
mov    %r8,%rdi
xor    %ebx,%ebx
mov    0x258(%rsp),%rcx
movabs $0xffffffff00000000,%rsi
ff ff ff
xchg   %ax,%ax
movapd %xmm0,%xmm1
movsd  (%rcx,%rbx,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm10,%xmm1
jbe    1870 <R_Schrodinger+0x650>
add    %rsi,%rdi
lea    (%r10,%rbx,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rbx
add    $0x1,%rax
add    $0xffffffff,%ebp
add    $0x1,%edx
cmp    $0x2,%rax
jg     1830 <R_Schrodinger+0x610>
jmp    2dc7 <R_Schrodinger+0x1ba7>
nopl   0x0(%rax,%rax,1)
mov    %ebp,0xb8(%rsp)
mov    %r12,0x100(%rsp)
movapd %xmm6,0x1c0(%rsp)
movapd %xmm5,0x1d0(%rsp)
mov    0x250(%rsp),%rax
add    %rbx,%rax
mov    %rax,0xe0(%rsp)
movapd %xmm13,%xmm0
cmpl   $0x0,0x12c(%rsp)
jle    18fa <R_Schrodinger+0x6da>
mov    0x124(%rsp),%eax
cmpl   $0x7,0x128(%rsp)
07
jb     18d5 <R_Schrodinger+0x6b5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xfffffff8,%eax
jne    18d0 <R_Schrodinger+0x6b0>
movapd %xmm13,%xmm0
cmpl   $0x0,0xbc(%rsp)
je     18fa <R_Schrodinger+0x6da>
mov    0xbc(%rsp),%eax
movapd %xmm13,%xmm0
xorpd  %xmm8,%xmm0
add    $0xffffffff,%eax
jne    18f0 <R_Schrodinger+0x6d0>
movapd %xmm0,0x30(%rsp)
mov    %rdx,0x200(%rsp)
mov    %rdi,0x180(%rsp)
mov    %rbx,0x190(%rsp)
mov    %r9,0x78(%rsp)
mov    %r8,0x1a0(%rsp)
mov    %r13b,0x17(%rsp)
movsd  (%r15),%xmm0
movsd  0x88(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
mov    0x50(%rsp),%r13
movsd  %xmm0,0x0(%r13)
mulsd  0xe8(%rsp),%xmm0
mov    %r14,%rbx
movsd  %xmm0,(%r14)
movsd  0x8(%r15),%xmm0
movsd  0x88(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
mulsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x10(%r15),%xmm0
movsd  0x88(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
mulsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x18(%r15),%xmm0
movsd  0x88(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x18(%r13)
mulsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0x18(%r14)
mov    0x68(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  0x0(%r13),%xmm0
movsd  (%r14),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x60(%rsp),%r12
movsd  %xmm1,(%r12)
movsd  0x8(%rax),%xmm0
mulsd  0x8(%r13),%xmm0
movsd  0x8(%r14),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12)
movsd  0x10(%rax),%xmm0
mulsd  0x10(%r13),%xmm0
movsd  0x10(%r14),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r12)
movsd  0x18(%rax),%xmm0
mulsd  0x18(%r13),%xmm0
movsd  0x18(%r14),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r12)
xor    %eax,%eax
cmpl   $0x3,0xe0(%rsp)
03
jle    1d43 <R_Schrodinger+0xb23>
mov    0xb8(%rsp),%eax
add    $0xfffffffffffffffd,%rax
mov    %rax,0xc0(%rsp)
xor    %r15d,%r15d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,0x30(%rsp)
lea    0x3(%r15),%r14d
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1080 <Predictor_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1080 <Predictor_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    0x68(%rsp),%rbp
movsd  0x20(%rbp,%r15,8),%xmm1
mulsd  0x20(%r13,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x20(%rbp,%r15,8),%xmm0
movsd  0x20(%rbx,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x20(%rbp,%r15,8),%xmm0
movsd  0x20(%rbx,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x20(%rbp,%r15,8),%xmm0
movsd  0x20(%rbx,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x20(%rbp,%r15,8),%xmm0
movsd  0x20(%rbx,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x20(%rbp,%r15,8),%xmm0
movsd  0x20(%rbx,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%r15,8)
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rbx,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x30(%rsp),%eax
movsd  %xmm0,0x20(%r13,%r15,8)
mulsd  0x18(%r13,%r15,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
sbb    $0xffffffff,%eax
add    $0x1,%r15
cmp    %r15,0xc0(%rsp)
jne    1ab0 <R_Schrodinger+0x890>
sub    0x74(%rsp),%eax
add    0x108(%rsp),%eax
cmp    $0xfffffffe,%eax
mov    0x110(%rsp),%r10
xorpd  %xmm10,%xmm10
mov    0x1a0(%rsp),%r8
mov    0x78(%rsp),%r9
movsd  0x12ac(%rip),%xmm13
movapd 0x12c3(%rip),%xmm8
jg     1db0 <R_Schrodinger+0xb90>
movsd  0xd8(%rsp),%xmm0
movapd 0x90(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  0x1263(%rip),%xmm2
mulsd  %xmm2,%xmm0
movapd %xmm1,0x130(%rsp)
jmp    1de3 <R_Schrodinger+0xbc3>
nopl   0x0(%rax)
test   %eax,%eax
js     1e4e <R_Schrodinger+0xc2e>
movapd 0x130(%rsp),%xmm0
movapd 0x90(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  0x122a(%rip),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm1,0xd8(%rsp)
movapd %xmm0,0x90(%rsp)
mov    0x68(%rsp),%rdi
movapd 0xf0(%rsp),%xmm11
mov    0x80(%rsp),%rdx
movapd 0x140(%rsp),%xmm12
mov    0x48(%rsp),%r15
mov    0xa8(%rsp),%r11
mov    0x17(%rsp),%r13b
movapd 0x1d0(%rsp),%xmm5
movapd 0x1c0(%rsp),%xmm6
mov    0x100(%rsp),%r12
mov    0x2c(%rsp),%esi
cmp    $0x1f4,%esi
jne    168a <R_Schrodinger+0x46a>
jmp    2ce9 <R_Schrodinger+0x1ac9>
mov    0x188(%rsp),%rax
mov    0x190(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps %xmm0,0x1b0(%rsp)
mov    0x198(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x1e8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xe0(%rsp),%xmm0
addsd  0x238(%rsp),%xmm0
cvttsd2si %xmm0,%ecx
lea    0x5(%rcx),%eax
cmp    0x80(%rsp),%eax
cmovg  0x120(%rsp),%ecx
mov    %rcx,0xa0(%rsp)
movslq %ecx,%rbp
mov    0x48(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
movapd 0xf0(%rsp),%xmm1
divsd  %xmm0,%xmm1
mov    0xb0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
subsd  0x90(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm10,%xmm0
mov    0x68(%rsp),%r14
jb     1f02 <R_Schrodinger+0xce2>
sqrtsd %xmm0,%xmm0
jmp    1f07 <R_Schrodinger+0xce7>
call   10f0 <sqrt@plt>
movapd %xmm0,0x30(%rsp)
movapd %xmm0,%xmm1
movapd 0x1127(%rip),%xmm0
xorpd  %xmm0,%xmm1
movapd %xmm1,0xc0(%rsp)
mov    0x48(%rsp),%r15
movsd  (%r15,%rbp,8),%xmm0
subsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x0(%r13,%rbp,8)
movsd  (%r15,%rbp,8),%xmm1
xorpd  0x10ed(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x0(%r13,%rbp,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x60(%rsp),%r12
movsd  %xmm1,(%r12,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0xc0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x8(%r13,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm1
xorpd  0x1083(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
mulsd  0x8(%r13,%rbp,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
movsd  0x10(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0xc0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x10(%r13,%rbp,8)
movsd  0x10(%r15,%rbp,8),%xmm1
xorpd  0x101b(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx,%rbp,8)
movsd  0x10(%r14,%rbp,8),%xmm0
mulsd  0x10(%r13,%rbp,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r12,%rbp,8)
movsd  0x18(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0xc0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x18(%r13,%rbp,8)
movsd  0x18(%r15,%rbp,8),%xmm1
xorpd  0xfb3(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx,%rbp,8)
movsd  0x18(%r14,%rbp,8),%xmm0
mulsd  0x18(%r13,%rbp,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r12,%rbp,8)
movsd  0x20(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0xc0(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x20(%r13,%rbp,8)
movsd  0x20(%r15,%rbp,8),%xmm1
xorpd  0xf4b(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbx,%rbp,8)
movsd  0x20(%r14,%rbp,8),%xmm0
mulsd  0x20(%r13,%rbp,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r12,%rbp,8)
mov    0xe0(%rsp),%rax
cmp    %eax,0xa0(%rsp)
mov    %rbp,0x1a8(%rsp)
jle    24e7 <R_Schrodinger+0x12c7>
mov    0x180(%rsp),%rax
sar    $0x20,%rax
mov    %rax,0x270(%rsp)
mov    0xa0(%rsp),%eax
mov    %rax,0x268(%rsp)
mov    0x228(%rsp),%rax
mov    0x1a8(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    %rax,0xc0(%rsp)
mov    0x220(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x260(%rsp)
mov    0x218(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x30(%rsp)
mov    0x210(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x118(%rsp)
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x268(%rsp),%rax
lea    (%rax,%r15,1),%r14d
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10d0 <Predictor_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    %rax,%rbp
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%r13
mov    %r13,%rdx
xor    %eax,%eax
call   10d0 <Predictor_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x260(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    %rax,%r12
mov    0x30(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
mulsd  0x0(%rbp,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm0
addsd  %xmm1,%xmm0
mov    0x118(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r15,8)
mov    %r14d,%edi
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp,%r15,8)
mov    %rbp,%r13
mov    0x30(%rsp),%rbx
mulsd  (%rbx,%r15,8),%xmm0
movsd  (%r12,%r15,8),%xmm1
mov    %r12,%rbp
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x118(%rsp),%r12
movsd  %xmm1,(%r12,%r15,8)
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp,%r15,8)
mov    %r14d,%edi
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
mulsd  (%rbx,%r15,8),%xmm0
movsd  0x0(%rbp,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r15,8)
mov    %r12,%rbx
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%r13
mov    %r13,%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    %rbp,%r12
movsd  %xmm0,0x0(%rbp,%r15,8)
mov    %r14d,%edi
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    0x30(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm0
movsd  0x0(%rbp,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r15,8)
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    %r13,%rdx
mov    %r13,%rbp
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r15,8)
mov    %r14d,%edi
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xc0(%rsp),%r13
movsd  %xmm0,0x0(%r13,%r15,8)
mov    0x30(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm0
movsd  (%r12,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r15,8)
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r15,8)
mov    %r14d,%edi
mov    0x50(%rsp),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
mov    %r13,%rbx
mov    0x30(%rsp),%rax
mulsd  (%rax,%r15,8),%xmm0
movsd  (%r12,%r15,8),%xmm1
mulsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x118(%rsp),%rax
movsd  %xmm1,(%rax,%r15,8)
mov    %r14d,%edi
mov    0x20(%rsp),%rsi
mov    %rbp,%rdx
mov    0x50(%rsp),%r13
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r15,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rbx,%r15,8)
mov    0x20(%rsp),%rbx
mov    0x1a8(%rsp),%rax
add    %r15,%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%r15
cmp    0x270(%rsp),%rax
jg     21d0 <R_Schrodinger+0xfb0>
mov    0xa0(%rsp),%rbp
cmp    0xe0(%rsp),%ebp
mov    0x48(%rsp),%r15
mov    0x190(%rsp),%r14
mov    0x180(%rsp),%r8
jl     26da <R_Schrodinger+0x14ba>
movapd 0x1b0(%rsp),%xmm0
mov    0x188(%rsp),%rax
divsd  (%rax,%r14,8),%xmm0
sar    $0x20,%r8
lea    0x5(%rbp),%eax
mov    0x78(%rsp),%rcx
add    %rcx,%rax
sub    %r14,%rax
cmp    $0x3,%eax
jb     263b <R_Schrodinger+0x141b>
lea    0x0(,%r8,8),%rdx
add    %r13,%rdx
add    %ebp,%ecx
sub    %r14d,%ecx
add    $0x5,%ecx
add    %r8,%rcx
mov    0x178(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    2583 <R_Schrodinger+0x1363>
mov    0x170(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rbx,%r8,8),%rdx
cmp    %rcx,%rdx
jb     263b <R_Schrodinger+0x141b>
mov    %eax,%eax
add    $0x1,%rax
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rcx,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    0x200(%rsp),%rdx
add    %ebp,%edx
add    $0x5,%edx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
movslq 0xb8(%rsp),%rdi
mov    0x168(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
mov    0x160(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd -0x10(%rsi,%rbp,8),%xmm2
movupd (%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rsi,%rbp,8)
movupd %xmm3,(%rsi,%rbp,8)
movupd -0x10(%rdi,%rbp,8),%xmm2
movupd (%rdi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdi,%rbp,8)
movupd %xmm3,(%rdi,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    25e0 <R_Schrodinger+0x13c0>
cmp    %rcx,%rax
mov    0x48(%rsp),%r15
mov    0xa0(%rsp),%rbp
je     26da <R_Schrodinger+0x14ba>
lea    0x1(%rbp),%ecx
mov    %ecx,%eax
sub    %r8d,%eax
test   $0x1,%al
jne    2654 <R_Schrodinger+0x1434>
mov    %r8,%rax
cmp    %r8d,%ebp
jne    2682 <R_Schrodinger+0x1462>
jmp    26da <R_Schrodinger+0x14ba>
movsd  0x0(%r13,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r8,8)
movsd  (%rbx,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r8,8)
mov    %r8,%rax
add    $0x1,%rax
cmp    %r8d,%ebp
je     26da <R_Schrodinger+0x14ba>
mov    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %eax,%ecx
jne    2690 <R_Schrodinger+0x1470>
mov    0x198(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %ebp,%edi
movsd  0x88(%rsp),%xmm0
mov    %r13,%rsi
mov    $0x1,%al
call   10b0 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm10,%xmm10
ucomisd %xmm10,%xmm0
jb     271c <R_Schrodinger+0x14fc>
sqrtsd %xmm0,%xmm0
jmp    2726 <R_Schrodinger+0x1506>
call   10f0 <sqrt@plt>
xorpd  %xmm10,%xmm10
movapd 0xf0(%rsp),%xmm11
mov    0x80(%rsp),%r10
movsd  0x18(%rsp),%xmm9
movapd 0x140(%rsp),%xmm12
mov    0xa8(%rsp),%r11
movapd 0x130(%rsp),%xmm8
movapd 0x90(%rsp),%xmm4
movsd  0x8b3(%rip),%xmm13
movsd  0x88b(%rip),%xmm5
xorpd  %xmm6,%xmm6
mov    0x2c(%rsp),%esi
movapd %xmm13,%xmm1
divsd  %xmm0,%xmm1
test   %ebp,%ebp
mov    0x68(%rsp),%rdi
mov    0x78(%rsp),%r9
movapd 0x1b0(%rsp),%xmm7
js     2998 <R_Schrodinger+0x1778>
lea    0x1(%rbp),%eax
cmp    $0x3,%ebp
jb     27ca <R_Schrodinger+0x15aa>
lea    (%rbx,%rax,8),%rcx
cmp    %r13,%rcx
jbe    2860 <R_Schrodinger+0x1640>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
jbe    2860 <R_Schrodinger+0x1640>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     27fa <R_Schrodinger+0x15da>
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     2998 <R_Schrodinger+0x1778>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%r13,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    2810 <R_Schrodinger+0x15f0>
jmp    2998 <R_Schrodinger+0x1778>
mov    %rdi,%rbp
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2936 <R_Schrodinger+0x1716>
mov    %rsi,%rdi
and    0x208(%rsp),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rdx,8)
movupd %xmm3,0x10(%r13,%rdx,8)
movupd (%rbx,%rdx,8),%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
movupd 0x20(%r13,%rdx,8),%xmm2
movupd 0x30(%r13,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r13,%rdx,8)
movupd %xmm3,0x30(%r13,%rdx,8)
movupd 0x20(%rbx,%rdx,8),%xmm2
movupd 0x30(%rbx,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbx,%rdx,8)
movupd %xmm3,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    28a0 <R_Schrodinger+0x1680>
jmp    2938 <R_Schrodinger+0x1718>
xor    %edx,%edx
test   $0x1,%sil
je     2980 <R_Schrodinger+0x1760>
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rdx,8)
movupd %xmm3,0x10(%r13,%rdx,8)
movupd (%rbx,%rdx,8),%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
cmp    %rax,%rcx
mov    0x2c(%rsp),%esi
mov    %rbp,%rdi
mov    0xa0(%rsp),%rbp
jne    27cc <R_Schrodinger+0x15ac>
lea    0x1(%rbp),%eax
mov    %r10,%rdx
cmp    %edx,%eax
jge    2bc0 <R_Schrodinger+0x19a0>
cltq
mov    %edx,%r9d
sub    %ebp,%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     2b21 <R_Schrodinger+0x1901>
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
lea    (%r9,%rax,1),%rcx
mov    0x178(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    29fd <R_Schrodinger+0x17dd>
mov    0x170(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rbx,%rax,8),%rdx
cmp    %rcx,%rdx
jae    29fd <R_Schrodinger+0x17dd>
mov    0x2c(%rsp),%esi
mov    %r10,%rdx
jmp    2b21 <R_Schrodinger+0x1901>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rcx
jae    2a29 <R_Schrodinger+0x1809>
xor    %ebp,%ebp
jmp    2ab8 <R_Schrodinger+0x1898>
and    $0xfffffffffffffffc,%rdi
mov    0x1f8(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd %xmm6,-0x70(%rcx,%rbp,8)
movupd %xmm6,-0x60(%rcx,%rbp,8)
movupd %xmm6,-0x70(%rdx,%rbp,8)
movupd %xmm6,-0x60(%rdx,%rbp,8)
movupd %xmm6,-0x50(%rcx,%rbp,8)
movupd %xmm6,-0x40(%rcx,%rbp,8)
movupd %xmm6,-0x50(%rdx,%rbp,8)
movupd %xmm6,-0x40(%rdx,%rbp,8)
movupd %xmm6,-0x30(%rcx,%rbp,8)
movupd %xmm6,-0x20(%rcx,%rbp,8)
movupd %xmm6,-0x30(%rdx,%rbp,8)
movupd %xmm6,-0x20(%rdx,%rbp,8)
movupd %xmm6,-0x10(%rcx,%rbp,8)
movupd %xmm6,(%rcx,%rbp,8)
movupd %xmm6,-0x10(%rdx,%rbp,8)
movupd %xmm6,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    2a50 <R_Schrodinger+0x1830>
test   %rsi,%rsi
je     2aff <R_Schrodinger+0x18df>
add    %rax,%rbp
mov    0x160(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    0x168(%rsp),%rdx
lea    (%rdx,%rbp,8),%rdx
shl    $0x5,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movupd %xmm6,-0x10(%rdx,%rdi,1)
movupd %xmm6,(%rdx,%rdi,1)
movupd %xmm6,-0x10(%rcx,%rdi,1)
movupd %xmm6,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    2ae0 <R_Schrodinger+0x18c0>
cmp    %r8,%r9
mov    0x48(%rsp),%r15
mov    0x78(%rsp),%r9
mov    0x2c(%rsp),%esi
mov    0x68(%rsp),%rdi
mov    %r10,%rdx
je     2bc0 <R_Schrodinger+0x19a0>
add    %r8,%rax
mov    %rdx,%rbp
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %ebp,%ecx
and    $0x3,%edx
je     2b5c <R_Schrodinger+0x193c>
mov    0x78(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    2b40 <R_Schrodinger+0x1920>
jmp    2b61 <R_Schrodinger+0x1941>
mov    0x78(%rsp),%r9
cmp    $0x3,%ecx
mov    %r10,%rdx
jb     2bc0 <R_Schrodinger+0x19a0>
nopl   0x0(%rax)
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movq   $0x0,0x10(%r13,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movq   $0x0,0x18(%r13,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %eax,%r11d
jne    2b70 <R_Schrodinger+0x1950>
mulsd  %xmm1,%xmm7
movsd  0x1e8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x30(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm7
mulsd  %xmm0,%xmm7
mov    0x230(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mulsd  %xmm9,%xmm0
divsd  %xmm0,%xmm7
movapd %xmm7,%xmm0
movapd 0x446(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm4,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x40a(%rip),%xmm1
mulsd  0x40a(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2de4 <R_Schrodinger+0x1bc4>
ucomisd %xmm10,%xmm7
movsd  0xd8(%rsp),%xmm2
ja     2c44 <R_Schrodinger+0x1a24>
movapd %xmm4,%xmm2
xorpd  %xmm0,%xmm0
cmpltsd %xmm7,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm4,%xmm1
andnpd %xmm8,%xmm0
orpd   %xmm1,%xmm0
movapd %xmm7,0x1b0(%rsp)
addsd  %xmm7,%xmm4
ucomisd %xmm2,%xmm4
mov    0x110(%rsp),%r10
mov    0x17(%rsp),%r13b
mov    0x100(%rsp),%r12
mov    0x1a0(%rsp),%r8
movsd  %xmm2,0xd8(%rsp)
movapd %xmm0,0x130(%rsp)
ja     2cb1 <R_Schrodinger+0x1a91>
ucomisd %xmm4,%xmm0
ja     2cb1 <R_Schrodinger+0x1a91>
movapd %xmm4,0x90(%rsp)
jmp    2cc2 <R_Schrodinger+0x1aa2>
addsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm0,0x90(%rsp)
movapd 0x1d0(%rsp),%xmm5
movapd 0x1c0(%rsp),%xmm6
movapd 0x363(%rip),%xmm8
cmp    $0x1f4,%esi
jne    168a <R_Schrodinger+0x46a>
lea    0x370(%rip),%rdi
mov    $0x1f4,%esi
movaps 0x90(%rsp),%xmm0
movapd 0x1b0(%rsp),%xmm1
mov    $0x2,%al
call   1050 <printf@plt>
mov    %rbx,(%rsp)
xorps  %xmm0,%xmm0
mov    0x74(%rsp),%r15d
mov    %r15d,%edi
mov    0x5c(%rsp),%ebx
mov    0x108(%rsp),%r13
mov    %r13d,%esi
mov    0xb0(%rsp),%r12
mov    %r12,%rdx
mov    %ebx,%ecx
mov    0x158(%rsp),%rbp
mov    %rbp,%r8
mov    0x50(%rsp),%r14
mov    %r14,%r9
mov    $0x1,%al
call   1060 <R_Schrodinger_Fixed_Logderiv@plt>
movsd  0x0(%rbp),%xmm0
mov    %r15d,%edi
mov    %r13d,%esi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    %r14,%r8
mov    0x20(%rsp),%r9
mov    $0x1,%al
call   1120 <R_Schrodinger_Fixed_E@plt>
movsd  0x0(%rbp),%xmm0
lea    0x31c(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x150(%rsp),%rax
mov    %ebx,(%rax)
movapd 0x90(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
mov    0x60(%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    0x68(%rsp),%rdi
xor    %eax,%eax
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1100 <dealloc_LogGrid@plt>
lea    0x310(%rip),%rdi
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>
mov    0x5c(%rsp),%ecx
add    %r14d,%ecx
mov    0x150(%rsp),%rax
mov    %ecx,(%rax)
mov    0x158(%rsp),%rax
movsd  %xmm4,(%rax)
mov    %rdi,%rbx
mov    0x60(%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
jmp    2daf <R_Schrodinger+0x1b8f>

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

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