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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
double fabs(double);
int floor(double);
double paw_Corrector_In(int, double *, double *);
double paw_Corrector_Out(int, double *, double *);
int paw_N_LogGrid();
double paw_Norm_LogGrid(int, double, double *);
double paw_Predictor_In(int, double *, double *);
double paw_Predictor_Out(int, double *, double *);
double *paw_alloc_LogGrid();
int /*<<< orphan*/ paw_dealloc_LogGrid(double *);
double paw_log_amesh_LogGrid();
double *paw_r2_LogGrid();
double *paw_r_LogGrid();
double pow(double, double);
int /*<<< orphan*/ printf(char *, ...);
double sqrt(double);
int paw_R_Schrodinger(int n, int l, double *v, double *Eig, double *u,
                      double *uprime) {
  int i, j, iteration, node, match, Ninf, Ngrid;
  double E, de, Emax, Emin, log_amesh, log_amesh2, gamma, L2, sum, a, scale,
      m1scale, uout, upout, upin, *r, *f_upp, *r2, *upp;
  E = *Eig;
  gamma = ((double)(l + 1));
  L2 = ((double)(l * (l + 1)));
  Ngrid = paw_N_LogGrid();
  log_amesh = paw_log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = paw_r_LogGrid();
  r2 = paw_r2_LogGrid();
  f_upp = paw_alloc_LogGrid();
  upp = paw_alloc_LogGrid();
  Emin = 0.0;
  Emax = v[Ngrid - 1] + 0.5 * L2 / (r[Ngrid - 1] * r[Ngrid - 1]);
  for (i = 0; i <= Ngrid - 1; i++)
    Emin =
        ((Emin < (v[i] + 0.5 * L2 / r2[i])) ? Emin : (v[i] + 0.5 * L2 / r2[i]));
  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 < 1000) {
    ++iteration;
    for (i = 0; i < Ngrid; ++i)
      f_upp[i] = log_amesh2 * (L2 + 2.0 * (v[i] - E) * r2[i]);
    match = Ngrid - 1;
    while (f_upp[match - 1] * f_upp[match] > 0.0) {
      match = match - 1;
      if (match < 2) {
        printf("Error in paw_R_Schrodinger: no turning point\n");
        return 0;
      }
    }
    m1scale = 1.0;
    for (i = 0; i < (n - l - 1); ++i)
      m1scale *= -1.0;
    for (i = 0; i <= 3; i++) {
      u[i] = m1scale * pow(r[i], gamma);
      uprime[i] = log_amesh * gamma * u[i];
      upp[i] = log_amesh * uprime[i] + f_upp[i] * u[i];
    }
    node = 0;
    for (i = 3; i <= match - 1; i++) {
      u[i + 1] = paw_Predictor_Out(i, u, uprime);
      uprime[i + 1] = paw_Predictor_Out(i, uprime, upp);
      for (j = 0; j <= 6 - 1; j++) {
        upp[i + 1] = log_amesh * uprime[i + 1] + f_upp[i + 1] * u[i + 1];
        uprime[i + 1] = paw_Corrector_Out(i, uprime, upp);
        u[i + 1] = paw_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] = paw_Predictor_In(i, u, uprime);
        uprime[i - 1] = paw_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] = paw_Corrector_In(i, uprime, upp);
          u[i - 1] = paw_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 = paw_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];
      }
      de = 0.5 * uout * (upout - upin) / (log_amesh * r[match]);
      if (fabs(de) < (((fabs(E) > 0.2) ? fabs(E) : 0.2) * 1.0e-10)) {
        *Eig = E;
        for (i = Ninf + 1; i < Ngrid; ++i) {
          u[i] = u[Ninf] * exp(-a * (r[i] - r[Ninf]));
          uprime[i] = -r[i] * log_amesh * a * u[i];
        }
        paw_dealloc_LogGrid(upp);
        paw_dealloc_LogGrid(f_upp);
        return 1;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if (Emax <= Emin) {
        paw_dealloc_LogGrid(upp);
        paw_dealloc_LogGrid(f_upp);
        *Eig = E;
        return 0;
      }
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  printf("Error paw_R_Schrodinger: More than %d iterations\n", 1000);
  *Eig = E;
  paw_dealloc_LogGrid(upp);
  paw_dealloc_LogGrid(f_upp);
  return 0;
}


x86 assembly (clang, -O0):
<paw_R_Schrodinger>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    $0x0,%al
call   1050 <paw_N_LogGrid@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x0,%al
call   1060 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    $0x0,%al
call   1080 <paw_r_LogGrid@plt>
mov    %rax,-0xd0(%rbp)
mov    $0x0,%al
call   1110 <paw_r2_LogGrid@plt>
mov    %rax,-0xe0(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
mov    %rax,-0xd8(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
mov    %rax,-0xe8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd29(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mov    -0xd0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13d4 <paw_R_Schrodinger+0x1d4>
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xcb8(%rip),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1380 <paw_R_Schrodinger+0x180>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    13b9 <paw_R_Schrodinger+0x1b9>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc6b(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    131d <paw_R_Schrodinger+0x11d>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    13f6 <paw_R_Schrodinger+0x1f6>
movsd  0xc1c(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    141c <paw_R_Schrodinger+0x21c>
movsd  0xbfe(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1447 <paw_R_Schrodinger+0x247>
movsd  -0x68(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xbc2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3e8,-0x3c(%rbp)
jge    1f9a <paw_R_Schrodinger+0xd9a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    14dc <paw_R_Schrodinger+0x2dc>
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0xba2(%rip),%xmm1
mulsd  %xmm3,%xmm1
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146b <paw_R_Schrodinger+0x26b>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1549 <paw_R_Schrodinger+0x349>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    1544 <paw_R_Schrodinger+0x344>
lea    0xb2f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1fd9 <paw_R_Schrodinger+0xdd9>
jmp    14e5 <paw_R_Schrodinger+0x2e5>
movsd  0xac7(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    159a <paw_R_Schrodinger+0x39a>
movsd  0xabc(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1560 <paw_R_Schrodinger+0x360>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jg     1670 <paw_R_Schrodinger+0x470>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15a1 <paw_R_Schrodinger+0x3a1>
movl   $0x0,-0x40(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17df <paw_R_Schrodinger+0x5df>
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1090 <paw_Predictor_Out@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
call   1090 <paw_Predictor_Out@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x5,-0x38(%rbp)
jg     1797 <paw_R_Schrodinger+0x597>
movsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16dd <paw_R_Schrodinger+0x4dd>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     17cc <paw_R_Schrodinger+0x5cc>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17d1 <paw_R_Schrodinger+0x5d1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    167e <paw_R_Schrodinger+0x47e>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x40(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    1848 <paw_R_Schrodinger+0x648>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x7c6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1f95 <paw_R_Schrodinger+0xd95>
mov    -0x40(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1887 <paw_R_Schrodinger+0x687>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x787(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1f90 <paw_R_Schrodinger+0xd90>
mov    -0x44(%rbp),%eax
mov    %eax,-0xfc(%rbp)
movsd  0x788(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
call   1120 <floor@plt>
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x5,%eax
cmp    -0x4c(%rbp),%eax
jle    18c7 <paw_R_Schrodinger+0x6c7>
mov    -0x4c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
mov    -0xd0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   10f0 <sqrt@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     1a29 <paw_R_Schrodinger+0x829>
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1070 <exp@plt>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1920 <paw_R_Schrodinger+0x720>
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1b5b <paw_R_Schrodinger+0x95b>
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   10c0 <paw_Predictor_In@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
call   10c0 <paw_Predictor_In@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    1b48 <paw_R_Schrodinger+0x948>
movsd  -0x78(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xd8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
call   1100 <paw_Corrector_In@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1100 <paw_Corrector_In@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a8e <paw_R_Schrodinger+0x88e>
jmp    1b4d <paw_R_Schrodinger+0x94d>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1a2f <paw_R_Schrodinger+0x82f>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1bdc <paw_R_Schrodinger+0x9dc>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b7e <paw_R_Schrodinger+0x97e>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%edi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rsi
call   10e0 <paw_Norm_LogGrid@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x3f3(%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,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1cde <paw_R_Schrodinger+0xade>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c80 <paw_R_Schrodinger+0xa80>
movsd  0x31a(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
subsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x324(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0x30c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x2d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d77 <paw_R_Schrodinger+0xb77>
movsd  -0x58(%rbp),%xmm0
movaps 0x2ea(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1d8c <paw_R_Schrodinger+0xb8c>
movsd  0x2a9(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1d8c <paw_R_Schrodinger+0xb8c>
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  0x28c(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ecd <paw_R_Schrodinger+0xccd>
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1ea9 <paw_R_Schrodinger+0xca9>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1070 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1dc8 <paw_R_Schrodinger+0xbc8>
mov    -0xe8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0xd8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
movl   $0x1,-0x4(%rbp)
jmp    1fd9 <paw_R_Schrodinger+0xdd9>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1eee <paw_R_Schrodinger+0xcee>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1ef8 <paw_R_Schrodinger+0xcf8>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f4c <paw_R_Schrodinger+0xd4c>
mov    -0xe8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0xd8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1fd9 <paw_R_Schrodinger+0xdd9>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
ja     1f70 <paw_R_Schrodinger+0xd70>
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f8b <paw_R_Schrodinger+0xd8b>
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x7e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1f90 <paw_R_Schrodinger+0xd90>
jmp    1f95 <paw_R_Schrodinger+0xd95>
jmp    144e <paw_R_Schrodinger+0x24e>
lea    0xed(%rip),%rdi
mov    $0x3e8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xe8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0xd8(%rbp),%rdi
call   10d0 <paw_dealloc_LogGrid@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_R_Schrodinger>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x298,%rsp
mov    %r9,0x120(%rsp)
mov    %r8,0x28(%rsp)
mov    %rdx,%rbp
mov    %esi,%ebx
mov    %edi,0x94(%rsp)
lea    0x1(%rbx),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x40(%rsp)
mov    %rcx,0xe8(%rsp)
movsd  (%rcx),%xmm0
movaps %xmm0,0x30(%rsp)
imul   %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x170(%rsp)
xor    %eax,%eax
call   1060 <paw_N_LogGrid@plt>
mov    %eax,%r13d
xor    %eax,%eax
call   1070 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x180(%rsp)
xor    %eax,%eax
call   1090 <paw_r_LogGrid@plt>
mov    %rax,%r12
xor    %eax,%eax
call   1120 <paw_r2_LogGrid@plt>
mov    %rax,%r15
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
mov    %rax,%r14
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
movapd 0x170(%rsp),%xmm9
mov    %rax,0x18(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,0x98(%rsp)
movslq %r13d,%rax
lea    -0x1(%rax),%r9
movsd  0x1d23(%rip),%xmm0
mulsd  %xmm9,%xmm0
mov    %r12,0x78(%rsp)
movsd  -0x8(%r12,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm8
divsd  %xmm1,%xmm8
addsd  -0x8(%rbp,%rax,8),%xmm8
xorpd  %xmm11,%xmm11
mov    %eax,%r10d
xorpd  %xmm7,%xmm7
test   %eax,%eax
jle    1378 <paw_R_Schrodinger+0x168>
cmp    $0x1,%r13d
jne    1321 <paw_R_Schrodinger+0x111>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
jmp    1362 <paw_R_Schrodinger+0x152>
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm7,%xmm7
xor    %eax,%eax
nopl   (%rax)
movapd %xmm0,%xmm1
divsd  (%r15,%rax,8),%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
movapd %xmm0,%xmm2
divsd  0x8(%r15,%rax,8),%xmm2
addsd  0x8(%rbp,%rax,8),%xmm2
minsd  %xmm1,%xmm7
minsd  %xmm2,%xmm7
add    $0x2,%rax
cmp    %rax,%rcx
jne    1330 <paw_R_Schrodinger+0x120>
test   $0x1,%r10b
je     1378 <paw_R_Schrodinger+0x168>
divsd  (%r15,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
minsd  %xmm0,%xmm7
movsd  0x1c88(%rip),%xmm0
mulsd  %xmm8,%xmm0
movapd %xmm8,%xmm1
movapd 0x30(%rsp),%xmm2
cmpltsd %xmm2,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movsd  0x1c67(%rip),%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm1,%xmm2
cmpltsd %xmm7,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm1,%xmm3
andpd  %xmm0,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm8,%xmm0
addsd  %xmm7,%xmm0
mulsd  0x1c29(%rip),%xmm0
movapd %xmm8,%xmm4
cmpltsd %xmm2,%xmm4
movapd %xmm4,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm4
orpd   %xmm1,%xmm4
mov    %ebx,%esi
not    %esi
mov    0x94(%rsp),%edi
add    %edi,%esi
movsd  0x8(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd  0x40(%rsp),%xmm1
movsd  %xmm1,0xe0(%rsp)
movsd  0x1bf9(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x240(%rsp)
lea    -0x5(%r13),%eax
mov    %eax,0x13c(%rsp)
mov    0x28(%rsp),%r12
lea    0x8(%r12),%rax
mov    %rax,0x208(%rsp)
mov    0x120(%rsp),%r11
lea    0x8(%r11),%rax
mov    %rax,0x210(%rsp)
lea    (%r14,%r10,8),%rax
lea    0x0(,%r10,8),%rcx
add    %rbp,%rcx
lea    (%r15,%r10,8),%rdx
mov    %rbx,0x258(%rsp)
sub    %ebx,%edi
add    $0xfffffffe,%edi
mov    %edi,0x144(%rsp)
cmp    %rcx,%r14
setb   %cl
cmp    %rbp,%rax
seta   %bl
and    %cl,%bl
cmp    %rdx,%r14
setb   %cl
cmp    %rax,%r15
setb   %al
and    %cl,%al
mov    %r13,%rcx
or     %bl,%al
mov    %al,0x17(%rsp)
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x248(%rsp)
movapd %xmm9,%xmm6
unpcklpd %xmm9,%xmm6
movapd 0x180(%rsp),%xmm12
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
mov    %r10,%rax
neg    %rax
mov    %rax,0x250(%rsp)
mov    %esi,%eax
and    $0x7,%eax
mov    %eax,0x90(%rsp)
mov    %esi,0x148(%rsp)
and    $0xfffffff8,%esi
mov    %esi,0x140(%rsp)
lea    0x0(,%r10,8),%rdx
and    $0xffffffffffffffe0,%rdx
mov    %r9,%rsi
shl    $0x20,%rsi
mov    $0xfffffffc,%r8d
sub    %ecx,%r8d
mov    %r14,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x230(%rsp)
mov    0x18(%rsp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x228(%rsp)
movsd  0x1adb(%rip),%xmm13
movapd 0x1af2(%rip),%xmm10
lea    0x4(%r13),%eax
mov    %eax,0x14c(%rsp)
mov    0x78(%rsp),%rax
lea    (%rax,%r9,8),%rax
mov    %rax,0x238(%rsp)
mov    0x98(%rsp),%eax
mov    %rax,0x1a8(%rsp)
lea    (%r12,%r9,8),%rax
mov    %rax,0x198(%rsp)
lea    (%r11,%r9,8),%rax
mov    %rax,0x1a0(%rsp)
lea    -0x8(%r14,%r9,8),%rdi
lea    -0x8(%r12),%rax
mov    %rax,0x220(%rsp)
lea    -0x8(%r11),%rax
mov    %rax,0x218(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0x200(%rsp)
lea    0x10(%r11),%rax
mov    %rax,0x1f8(%rsp)
movabs $0xffffffff00000000,%r11
ff ff ff
xor    %r13d,%r13d
mov    %rcx,%rbx
test   %ecx,%ecx
jle    1713 <paw_R_Schrodinger+0x503>
mov    %rbx,%rax
cmp    $0x4,%eax
setb   %al
or     0x17(%rsp),%al
je     1600 <paw_R_Schrodinger+0x3f0>
xor    %ecx,%ecx
jmp    167b <paw_R_Schrodinger+0x46b>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,1),%xmm1
movupd 0x10(%rbp,%rax,1),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm1
addpd  %xmm2,%xmm2
movupd (%r15,%rax,1),%xmm3
mulpd  %xmm1,%xmm3
movupd 0x10(%r15,%rax,1),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm6,%xmm3
addpd  %xmm6,%xmm1
mulpd  %xmm5,%xmm3
mulpd  %xmm5,%xmm1
movupd %xmm3,(%r14,%rax,1)
movupd %xmm1,0x10(%r14,%rax,1)
add    $0x20,%rax
cmp    %rax,%rdx
jne    1610 <paw_R_Schrodinger+0x400>
mov    0x248(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     1713 <paw_R_Schrodinger+0x503>
mov    %rcx,%rax
test   $0x1,%r10b
je     16af <paw_R_Schrodinger+0x49f>
movsd  0x0(%rbp,%rcx,8),%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm0,%xmm0
mulsd  (%r15,%rcx,8),%xmm0
addsd  %xmm9,%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x250(%rsp),%rcx
je     1713 <paw_R_Schrodinger+0x503>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm0,%xmm0
mulsd  (%r15,%rax,8),%xmm0
addsd  %xmm9,%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x8(%r15,%rax,8),%xmm0
addsd  %xmm9,%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    16c0 <paw_R_Schrodinger+0x4b0>
add    $0x1,%r13d
movsd  (%r14,%r9,8),%xmm0
mov    %r8d,%eax
mov    %r8d,0x9c(%rsp)
mov    0x98(%rsp),%eax
mov    %eax,0x88(%rsp)
mov    %rsi,0x130(%rsp)
xor    %ecx,%ecx
mov    0x14c(%rsp),%eax
mov    %rax,0x30(%rsp)
nopl   0x0(%rax)
movapd %xmm0,%xmm1
movsd  (%rdi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm11,%xmm1
jbe    17b0 <paw_R_Schrodinger+0x5a0>
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x30(%rsp)
add    %r11,0x130(%rsp)
lea    (%r9,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rcx
add    $0x1,%rax
addl   $0xffffffff,0x88(%rsp)
ff
addl   $0x1,0x9c(%rsp)
01
cmp    $0x2,%rax
jg     1750 <paw_R_Schrodinger+0x540>
jmp    2a43 <paw_R_Schrodinger+0x1833>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,0xf8(%rsp)
movapd %xmm5,0x1b0(%rsp)
movapd %xmm6,0x1c0(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm7,0x1d0(%rsp)
movsd  %xmm8,0xf0(%rsp)
mov    %rbp,0x110(%rsp)
mov    0x1a8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x118(%rsp)
movapd %xmm13,%xmm0
cmpl   $0x0,0x148(%rsp)
jle    185a <paw_R_Schrodinger+0x64a>
mov    0x140(%rsp),%eax
cmpl   $0x7,0x144(%rsp)
07
jb     1835 <paw_R_Schrodinger+0x625>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffff8,%eax
jne    1830 <paw_R_Schrodinger+0x620>
movapd %xmm13,%xmm0
cmpl   $0x0,0x90(%rsp)
je     185a <paw_R_Schrodinger+0x64a>
mov    0x90(%rsp),%eax
movapd %xmm13,%xmm0
xorpd  %xmm10,%xmm0
add    $0xffffffff,%eax
jne    1850 <paw_R_Schrodinger+0x640>
movapd %xmm0,0x50(%rsp)
mov    %rcx,0xb8(%rsp)
mov    %rdi,0x100(%rsp)
mov    %r8,0xd8(%rsp)
mov    %rsi,0xd0(%rsp)
mov    %r10,0x70(%rsp)
mov    %r9,0x108(%rsp)
mov    %r15,0xc8(%rsp)
mov    %r13,0xc0(%rsp)
mov    %rbx,0x20(%rsp)
mov    0x78(%rsp),%rbx
movsd  (%rbx),%xmm0
movsd  0x40(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,(%r12)
mulsd  0xe0(%rsp),%xmm0
mov    0x120(%rsp),%r15
movsd  %xmm0,(%r15)
movsd  (%r14),%xmm1
mulsd  (%r12),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
movsd  0x8(%rbx),%xmm0
movsd  0x40(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x8(%r12)
mulsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x8(%r14),%xmm1
mulsd  0x8(%r12),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x10(%rbx),%xmm0
movsd  0x40(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x10(%r12)
mulsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
movsd  0x10(%r14),%xmm1
mulsd  0x10(%r12),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x18(%rbx),%xmm0
movsd  0x40(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x18(%r12)
mulsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0x18(%r15)
movsd  0x18(%r14),%xmm1
mulsd  0x18(%r12),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rbp)
xor    %eax,%eax
cmpl   $0x3,0x118(%rsp)
03
mov    %r14,0x80(%rsp)
mov    %r12,%r14
jle    1c16 <paw_R_Schrodinger+0xa06>
mov    0x88(%rsp),%eax
add    $0xfffffffffffffffd,%rax
mov    %rax,0x48(%rsp)
xor    %r12d,%r12d
xor    %eax,%eax
nop
mov    %eax,0x50(%rsp)
lea    0x3(%r12),%r13d
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   10a0 <paw_Predictor_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   10a0 <paw_Predictor_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    0x80(%rsp),%rbx
movsd  0x20(%rbx,%r12,8),%xmm1
mulsd  0x20(%r14,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x20(%rbx,%r12,8),%xmm0
movsd  0x20(%r15,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x20(%rbx,%r12,8),%xmm0
movsd  0x20(%r15,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x20(%rbx,%r12,8),%xmm0
movsd  0x20(%r15,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x20(%rbx,%r12,8),%xmm0
movsd  0x20(%r15,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x20(%rbx,%r12,8),%xmm0
movsd  0x20(%r15,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r12,8)
mov    %r13d,%edi
mov    %r15,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r15,%r12,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
mov    0x50(%rsp),%eax
movsd  %xmm0,0x20(%r14,%r12,8)
mulsd  0x18(%r14,%r12,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
sbb    $0xffffffff,%eax
add    $0x1,%r12
cmp    %r12,0x48(%rsp)
jne    1a00 <paw_R_Schrodinger+0x7f0>
sub    0x94(%rsp),%eax
add    0x258(%rsp),%eax
cmp    $0xfffffffe,%eax
mov    0x108(%rsp),%r9
xorpd  %xmm11,%xmm11
movapd 0x1403(%rip),%xmm10
mov    0xd0(%rsp),%rsi
mov    0xd8(%rsp),%r8
movsd  0x13ca(%rip),%xmm13
mov    0x100(%rsp),%rdi
movabs $0xffffffff00000000,%r11
ff ff ff
jg     1d10 <paw_R_Schrodinger+0xb00>
movsd  0xf0(%rsp),%xmm8
movapd %xmm8,%xmm0
movapd 0xa0(%rsp),%xmm7
addsd  %xmm7,%xmm0
mulsd  0x136e(%rip),%xmm0
movapd %xmm0,%xmm4
mov    %r14,%r12
mov    0x80(%rsp),%r14
mov    0x20(%rsp),%rcx
mov    0x110(%rsp),%rbp
movapd 0x170(%rsp),%xmm9
mov    0xc0(%rsp),%r13
movapd 0x180(%rsp),%xmm12
mov    0xc8(%rsp),%r15
mov    0x70(%rsp),%r10
movapd 0x1c0(%rsp),%xmm6
movapd 0x1b0(%rsp),%xmm5
mov    0xf8(%rsp),%rdx
cmp    $0x3e8,%r13d
jne    15d5 <paw_R_Schrodinger+0x3c5>
jmp    29fd <paw_R_Schrodinger+0x17ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %eax,%eax
mov    %r14,%r12
mov    0x80(%rsp),%r14
mov    0x20(%rsp),%rcx
mov    0x110(%rsp),%rbp
movapd 0x170(%rsp),%xmm9
movapd 0x180(%rsp),%xmm12
mov    0xc8(%rsp),%r15
mov    0x70(%rsp),%r10
movapd 0xa0(%rsp),%xmm8
movapd 0x1c0(%rsp),%xmm6
movapd 0x1b0(%rsp),%xmm5
mov    0xf8(%rsp),%rdx
js     1da9 <paw_R_Schrodinger+0xb99>
movapd 0x1d0(%rsp),%xmm7
movapd %xmm7,%xmm0
addsd  %xmm8,%xmm0
mulsd  0x1275(%rip),%xmm0
movapd %xmm0,%xmm4
mov    0xc0(%rsp),%r13
cmp    $0x3e8,%r13d
jne    15d5 <paw_R_Schrodinger+0x3c5>
jmp    29fd <paw_R_Schrodinger+0x17ed>
mov    0x198(%rsp),%rax
mov    0xb8(%rsp),%rbx
movsd  (%rax,%rbx,8),%xmm0
movaps %xmm0,0x280(%rsp)
mov    0x1a0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x1f0(%rsp)
movsd  0x240(%rsp),%xmm0
mov    %rcx,%r15
call   1130 <floor@plt>
xorpd  %xmm2,%xmm2
mov    %eax,%ecx
mov    0x1a8(%rsp),%rax
lea    (%rax,%rcx,1),%edx
add    %ebx,%edx
mov    0x70(%rsp),%rax
mov    %rcx,0x60(%rsp)
add    %ecx,%eax
add    %ebx,%eax
add    $0x4,%eax
cmp    %r15d,%eax
cmovg  0x13c(%rsp),%edx
mov    %rdx,0x68(%rsp)
movslq %edx,%r15
mov    0x78(%rsp),%rbx
movsd  (%rbx,%r15,8),%xmm0
mulsd  %xmm0,%xmm0
movapd 0x170(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  0x0(%rbp,%r15,8),%xmm0
subsd  0xa0(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jb     1e64 <paw_R_Schrodinger+0xc54>
sqrtsd %xmm0,%xmm0
jmp    1e69 <paw_R_Schrodinger+0xc59>
call   1100 <sqrt@plt>
movapd %xmm0,0x160(%rsp)
movapd %xmm0,%xmm1
movapd 0x11c2(%rip),%xmm0
xorpd  %xmm0,%xmm1
movapd %xmm1,0x150(%rsp)
movsd  (%rbx,%r15,8),%xmm0
subsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
call   1080 <exp@plt>
movsd  %xmm0,(%r12,%r15,8)
movsd  (%rbx,%r15,8),%xmm1
xorpd  0x118e(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x160(%rsp),%xmm1
mulsd  %xmm0,%xmm1
mov    0x120(%rsp),%rbp
movsd  %xmm1,0x0(%rbp,%r15,8)
movsd  (%r14,%r15,8),%xmm0
mulsd  (%r12,%r15,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rsp),%r13
movsd  %xmm1,0x0(%r13,%r15,8)
movsd  0x8(%rbx,%r15,8),%xmm0
subsd  (%rbx,%r15,8),%xmm0
mulsd  0x150(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x8(%r12,%r15,8)
movsd  0x8(%rbx,%r15,8),%xmm1
xorpd  0x1117(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x160(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%r15,8)
movsd  0x8(%r14,%r15,8),%xmm0
mulsd  0x8(%r12,%r15,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%r15,8)
movsd  0x10(%rbx,%r15,8),%xmm0
subsd  (%rbx,%r15,8),%xmm0
mulsd  0x150(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x10(%r12,%r15,8)
movsd  0x10(%rbx,%r15,8),%xmm1
xorpd  0x10ab(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x160(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbp,%r15,8)
movsd  0x10(%r14,%r15,8),%xmm0
mulsd  0x10(%r12,%r15,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%r15,8)
movsd  0x18(%rbx,%r15,8),%xmm0
subsd  (%rbx,%r15,8),%xmm0
mulsd  0x150(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x18(%r12,%r15,8)
movsd  0x18(%rbx,%r15,8),%xmm1
xorpd  0x103f(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x160(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbp,%r15,8)
movsd  0x18(%r14,%r15,8),%xmm0
mulsd  0x18(%r12,%r15,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%r15,8)
movsd  0x20(%rbx,%r15,8),%xmm0
subsd  (%rbx,%r15,8),%xmm0
mulsd  0x150(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x20(%r12,%r15,8)
movsd  0x20(%rbx,%r15,8),%xmm1
xorpd  0xfd3(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x160(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbp,%r15,8)
movsd  0x20(%r14,%r15,8),%xmm0
mov    %rbp,%r14
mulsd  0x20(%r12,%r15,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    %r15,0x1e8(%rsp)
movsd  %xmm1,0x20(%r13,%r15,8)
mov    0x68(%rsp),%rax
cmp    0x118(%rsp),%eax
mov    %r12,%rdx
jle    23c2 <paw_R_Schrodinger+0x11b2>
mov    0x130(%rsp),%rax
sar    $0x20,%rax
mov    %rax,0x278(%rsp)
mov    0x30(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %eax,%ecx
mov    0x20(%rsp),%rax
cmp    %ecx,%eax
cmovl  %eax,%ecx
add    $0xfffffffb,%ecx
mov    %rcx,0x270(%rsp)
movslq %ecx,%rcx
mov    0x220(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x128(%rsp)
mov    0x218(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x260(%rsp)
mov    0x230(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x48(%rsp)
mov    0x228(%rsp),%rax
mov    %rcx,0x268(%rsp)
lea    (%rax,%rcx,8),%rax
mov    %rax,0x50(%rsp)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x270(%rsp),%rax
lea    (%rax,%r12,1),%ebx
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   10d0 <paw_Predictor_In@plt>
mov    0x128(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%r15
mov    %r15,%rdx
call   10d0 <paw_Predictor_In@plt>
mov    0x260(%rsp),%r13
movsd  %xmm0,0x0(%r13,%r12,8)
mov    0x48(%rsp),%rax
movsd  (%rax,%r12,8),%xmm1
mulsd  0x0(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    %r15,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%rbp,%r12,8)
mov    0x48(%rsp),%r15
mulsd  (%r15,%r12,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x50(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%rbp,%r12,8)
mulsd  (%r15,%r12,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x50(%rsp),%r15
movsd  %xmm1,(%r15,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
mov    0x128(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
mov    0x48(%rsp),%rax
mulsd  (%rax,%r12,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
mov    0x128(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%r12,8)
mov    0x48(%rsp),%r15
mulsd  (%r15,%r12,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x50(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%rbp,%r12,8)
mulsd  (%r15,%r12,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x50(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rdx
call   1110 <paw_Corrector_In@plt>
movsd  %xmm0,0x0(%r13,%r12,8)
mov    %ebx,%edi
mov    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1110 <paw_Corrector_In@plt>
mov    0x28(%rsp),%rdx
movsd  %xmm0,0x0(%rbp,%r12,8)
mov    0x268(%rsp),%rax
add    %r12,%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%r12
cmp    0x278(%rsp),%rax
jg     2160 <paw_R_Schrodinger+0xf50>
mov    0x68(%rsp),%r10
cmp    0x118(%rsp),%r10d
mov    %rdx,%r12
mov    0x110(%rsp),%rbp
mov    0xc0(%rsp),%r13
mov    0x30(%rsp),%rbx
mov    0x130(%rsp),%r9
jl     25eb <paw_R_Schrodinger+0x13db>
movapd 0x280(%rsp),%xmm0
mov    0x198(%rsp),%rax
mov    0xb8(%rsp),%rsi
divsd  (%rax,%rsi,8),%xmm0
sar    $0x20,%r9
mov    0x60(%rsp),%rax
add    %ebx,%eax
mov    0x20(%rsp),%rbx
cmp    %eax,%ebx
mov    %eax,%ecx
cmovl  %ebx,%ecx
mov    0xd8(%rsp),%rdi
add    %rdi,%rcx
sub    %rsi,%rcx
cmp    $0x3,%ecx
jb     247d <paw_R_Schrodinger+0x126d>
lea    (%r12,%r9,8),%r8
cmp    %eax,%ebx
mov    %eax,%edx
cmovl  %ebx,%edx
add    %edi,%edx
sub    %esi,%edx
add    %r9,%rdx
mov    0x210(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%r8
jae    2531 <paw_R_Schrodinger+0x1321>
mov    0x208(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%r9,8),%rsi
cmp    %rdx,%rsi
jae    2531 <paw_R_Schrodinger+0x1321>
mov    0x30(%rsp),%rbx
mov    %r10d,%ecx
sub    %r9d,%ecx
add    $0x1,%ecx
test   $0x1,%cl
jne    249d <paw_R_Schrodinger+0x128d>
mov    %r9,%rcx
cmp    %r9d,%r10d
jne    24cd <paw_R_Schrodinger+0x12bd>
jmp    25eb <paw_R_Schrodinger+0x13db>
movsd  (%r12,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r9,8)
movsd  (%r14,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r9,8)
mov    %r9,%rcx
add    $0x1,%rcx
cmp    %r9d,%r10d
je     25eb <paw_R_Schrodinger+0x13db>
mov    0x20(%rsp),%rdx
cmp    %eax,%edx
cmovl  %edx,%eax
add    $0xfffffffc,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
movsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %ecx,%eax
jne    24e0 <paw_R_Schrodinger+0x12d0>
jmp    25eb <paw_R_Schrodinger+0x13db>
mov    %ecx,%r8d
add    $0x1,%r8
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
add    %rdx,%r9
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rcx
cmp    %eax,%ecx
mov    %eax,%esi
cmovl  %ecx,%esi
unpcklpd %xmm0,%xmm1
add    0x9c(%rsp),%esi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
movslq 0x88(%rsp),%rcx
mov    0x200(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
mov    0x1f8(%rsp),%rbx
lea    (%rbx,%rcx,8),%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rcx,8),%xmm2
movupd (%rdi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdi,%rcx,8)
movupd %xmm3,(%rdi,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm2
movupd (%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbx,%rcx,8)
movupd %xmm3,(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    2590 <paw_R_Schrodinger+0x1380>
cmp    %rdx,%r8
mov    0xc0(%rsp),%r13
mov    0x30(%rsp),%rbx
jne    2482 <paw_R_Schrodinger+0x1272>
mov    0x1a0(%rsp),%rax
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r10d,%edi
movsd  0x40(%rsp),%xmm0
mov    %r12,%rsi
call   10f0 <paw_Norm_LogGrid@plt>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm0
jb     2629 <paw_R_Schrodinger+0x1419>
sqrtsd %xmm0,%xmm0
jmp    2633 <paw_R_Schrodinger+0x1423>
call   1100 <sqrt@plt>
xorpd  %xmm11,%xmm11
movapd 0x170(%rsp),%xmm9
movapd 0x180(%rsp),%xmm12
mov    0xc8(%rsp),%r15
mov    0x108(%rsp),%r9
mov    0x70(%rsp),%r10
movsd  0xf0(%rsp),%xmm8
movapd 0x1d0(%rsp),%xmm7
movapd 0xa0(%rsp),%xmm4
movapd 0x9bf(%rip),%xmm10
movapd 0x1c0(%rsp),%xmm6
movapd 0x1b0(%rsp),%xmm5
mov    0xd0(%rsp),%rsi
movsd  0x97c(%rip),%xmm13
mov    0x100(%rsp),%rdi
movabs $0xffffffff00000000,%r11
ff ff ff
movapd %xmm13,%xmm1
divsd  %xmm0,%xmm1
cmpl   $0x0,0x68(%rsp)
mov    0xd8(%rsp),%r8
movapd 0x280(%rsp),%xmm14
js     28f1 <paw_R_Schrodinger+0x16e1>
mov    0x68(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    $0x3,%ecx
jb     2703 <paw_R_Schrodinger+0x14f3>
lea    (%r14,%rax,8),%rcx
cmp    %r12,%rcx
jbe    27a2 <paw_R_Schrodinger+0x1592>
lea    (%r12,%rax,8),%rcx
cmp    %r14,%rcx
jbe    27a2 <paw_R_Schrodinger+0x1592>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     2733 <paw_R_Schrodinger+0x1523>
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     28f1 <paw_R_Schrodinger+0x16e1>
add    0x60(%rsp),%ebx
mov    0x20(%rsp),%rax
cmp    %ebx,%eax
cmovl  %eax,%ebx
add    $0xfffffffc,%ebx
movsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    2750 <paw_R_Schrodinger+0x1540>
jmp    28f1 <paw_R_Schrodinger+0x16e1>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rcx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     288c <paw_R_Schrodinger+0x167c>
mov    0x60(%rsp),%rdx
add    %ebx,%edx
mov    0x20(%rsp),%rsi
cmp    %edx,%esi
cmovl  %esi,%edx
add    $0xfffffffc,%edx
and    $0xfffffffc,%edx
add    $0xfffffffffffffffc,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %esi,%esi
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rsi,8)
movupd %xmm3,0x10(%r12,%rsi,8)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
movupd 0x20(%r12,%rsi,8),%xmm2
movupd 0x30(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r12,%rsi,8)
movupd %xmm3,0x30(%r12,%rsi,8)
movupd 0x20(%r14,%rsi,8),%xmm2
movupd 0x30(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r14,%rsi,8)
movupd %xmm3,0x30(%r14,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    27f0 <paw_R_Schrodinger+0x15e0>
jmp    288e <paw_R_Schrodinger+0x167e>
xor    %esi,%esi
test   $0x1,%r8b
je     28d8 <paw_R_Schrodinger+0x16c8>
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rsi,8)
movupd %xmm3,0x10(%r12,%rsi,8)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
cmp    %rax,%rcx
mov    0xd0(%rsp),%rsi
mov    0xd8(%rsp),%r8
jne    2705 <paw_R_Schrodinger+0x14f5>
mulsd  %xmm1,%xmm14
movsd  0x1f0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x30(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  0x6e6(%rip),%xmm14
mulsd  %xmm0,%xmm14
mov    0x238(%rsp),%rax
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x8(%rsp),%xmm0
divsd  %xmm0,%xmm14
movapd %xmm14,%xmm0
movapd 0x704(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm4,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x6c8(%rip),%xmm1
mulsd  0x6c8(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2a65 <paw_R_Schrodinger+0x1855>
ucomisd %xmm11,%xmm14
ja     297e <paw_R_Schrodinger+0x176e>
movapd %xmm4,%xmm8
xorpd  %xmm0,%xmm0
cmpltsd %xmm14,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm4,%xmm1
andnpd %xmm7,%xmm0
movapd %xmm0,%xmm7
orpd   %xmm1,%xmm7
addsd  %xmm14,%xmm4
ucomisd %xmm8,%xmm7
mov    0x80(%rsp),%r14
mov    0xf8(%rsp),%rdx
jae    2b72 <paw_R_Schrodinger+0x1962>
ucomisd %xmm8,%xmm4
mov    0x20(%rsp),%rcx
ja     29df <paw_R_Schrodinger+0x17cf>
ucomisd %xmm4,%xmm7
ja     29df <paw_R_Schrodinger+0x17cf>
xchg   %ax,%ax
cmp    $0x3e8,%r13d
jne    15d5 <paw_R_Schrodinger+0x3c5>
jmp    29fd <paw_R_Schrodinger+0x17ed>
movapd %xmm7,%xmm4
addsd  %xmm8,%xmm4
mulsd  0x610(%rip),%xmm4
cmp    $0x3e8,%r13d
jne    15d5 <paw_R_Schrodinger+0x3c5>
lea    0x65c(%rip),%rdi
xor    %ebx,%ebx
mov    $0x3e8,%esi
xor    %eax,%eax
movapd %xmm4,0xa0(%rsp)
call   1050 <printf@plt>
mov    0xe8(%rsp),%rax
movaps 0xa0(%rsp),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rsp),%rdi
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %r14,%rdi
call   10e0 <paw_dealloc_LogGrid@plt>
jmp    2a51 <paw_R_Schrodinger+0x1841>
lea    0x648(%rip),%rdi
call   1040 <puts@plt>
xor    %ebx,%ebx
mov    %ebx,%eax
add    $0x298,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xe8(%rsp),%rax
movsd  %xmm4,(%rax)
mov    0x68(%rsp),%rax
add    $0x1,%eax
mov    0x20(%rsp),%r13
cmp    %r13d,%eax
mov    %r13,%rdx
mov    0x1e8(%rsp),%r13
movapd 0x150(%rsp),%xmm1
jge    2b51 <paw_R_Schrodinger+0x1941>
mov    0x60(%rsp),%rax
add    %r10d,%eax
add    %ecx,%eax
add    $0x4,%eax
mov    %rdx,%rsi
cmp    %eax,%esi
cmovl  %esi,%eax
lea    -0x4(%rax),%ecx
movslq %ecx,%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
lea    (%r12,%rcx,8),%rdi
mov    %rdi,0x88(%rsp)
lea    (%r14,%rcx,8),%r15
sub    %eax,%esi
add    $0x4,%esi
mov    %rsi,%r14
xor    %ebp,%ebp
movsd  (%r12,%r13,8),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  (%rbx,%rbp,8),%xmm0
mov    0x78(%rsp),%rax
subsd  (%rax,%r13,8),%xmm0
mulsd  %xmm1,%xmm0
call   1080 <exp@plt>
movapd 0x160(%rsp),%xmm3
movsd  0x8(%rsp),%xmm2
mulsd  0x30(%rsp),%xmm0
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
xorpd  0x513(%rip),%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rbp,8)
movapd 0x150(%rsp),%xmm1
add    $0x1,%rbp
cmp    %ebp,%r14d
jne    2ad9 <paw_R_Schrodinger+0x18c9>
mov    0x18(%rsp),%rdi
call   10e0 <paw_dealloc_LogGrid@plt>
mov    0x80(%rsp),%rdi
call   10e0 <paw_dealloc_LogGrid@plt>
mov    $0x1,%ebx
jmp    2a51 <paw_R_Schrodinger+0x1841>
mov    0x18(%rsp),%rdi
movapd %xmm4,0xa0(%rsp)
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %r14,%rdi
call   10e0 <paw_dealloc_LogGrid@plt>
mov    0xe8(%rsp),%rax
movaps 0xa0(%rsp),%xmm0
movsd  %xmm0,(%rax)
jmp    2a4f <paw_R_Schrodinger+0x183f>

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

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