#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 fabs(double);
double paw_Corrector_Out(int, double *, double *);
int paw_N_LogGrid();
double paw_Norm_LogGrid(int, double, double *);
double paw_Predictor_Out(int, double *, double *);
scalar_t__ paw_alloc_LogGrid();
int /*<<< orphan*/ paw_dealloc_LogGrid(double *);
double paw_log_amesh_LogGrid();
scalar_t__ paw_r_LogGrid();
double pow(double, double);
int /*<<< orphan*/ printf(char *, int);
double sqrt(double);
int paw_R_Schrodinger_Fixed_Logderiv(int n, int l, double *v, int match,
                                     double u_logderiv, double *Eig, double *u,
                                     double *uprime) {
  int i;
  int j;
  int iteration;
  int node;
  int Ngrid;
  double sum;
  double E;
  double de;
  double Emax;
  double Emin;
  double log_amesh;
  double log_amesh2;
  double gamma;
  double L2;
  double r2;
  double uout;
  double upout;
  double upin;
  double *r;
  double *f_upp;
  double *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 = (double *)paw_r_LogGrid();
  f_upp = (double *)paw_alloc_LogGrid();
  upp = (double *)paw_alloc_LogGrid();
  Emax = E + 10.0;
  Emin = E - 10.0;
  iteration = 0;
  while (iteration < 1000) {
    ++iteration;
    for (i = 0; i < Ngrid; ++i) {
      r2 = r[i] * r[i];
      f_upp[i] = log_amesh2 * (L2 + 2.0 * (v[i] - E) * r2);
    }
    for (i = 0; i < 4; ++i) {
      u[i] = 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; ++i) {
      u[i + 1] = paw_Predictor_Out(i, u, uprime);
      uprime[i + 1] = paw_Predictor_Out(i, uprime, upp);
      for (j = 0; j < 6; ++j) {
        upp[i + 1] = log_amesh * uprime[i + 1] + f_upp[i + 1] * u[i + 1];
        uprime[i + 1] = 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 {
      upin = u_logderiv * uout;
      sum = paw_Norm_LogGrid(match, gamma, u);
      sum = 1.0 / sqrt(sum);
      uout = sum * uout;
      upout = sum * upout;
      upin = sum * upin;
      for (i = 0; i <= match; ++i) {
        u[i] = sum * u[i];
        uprime[i] = sum * uprime[i];
      }
      for (i = match + 1; i < Ngrid; ++i) {
        u[i] = 0.0;
        uprime[i] = 0.0;
      }
      de = 0.5 * uout * (upout - upin) / (log_amesh * r[match]);
      if (fabs(de) < (((fabs(E) > 0.2) ? fabs(E) : 0.2) * 1.0e-10)) {
        *Eig = E;
        paw_dealloc_LogGrid(upp);
        paw_dealloc_LogGrid(f_upp);
        return 1;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  printf("paw_Error R_Schrodinger_Fixed_Logderiv: 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_Fixed_Logderiv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%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,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1070 <paw_r_LogGrid@plt>
mov    %rax,-0xc0(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0xc8(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0xd0(%rbp)
movsd  0xd96(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xd7f(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3e8,-0x44(%rbp)
jge    18c5 <paw_R_Schrodinger_Fixed_Logderiv+0x715>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1342 <paw_R_Schrodinger_Fixed_Logderiv+0x192>
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x60(%rbp),%xmm3
movsd  0xd1c(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ae <paw_R_Schrodinger_Fixed_Logderiv+0xfe>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    13f9 <paw_R_Schrodinger_Fixed_Logderiv+0x249>
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
call   10a0 <pow@plt>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1349 <paw_R_Schrodinger_Fixed_Logderiv+0x199>
movl   $0x0,-0x48(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1563 <paw_R_Schrodinger_Fixed_Logderiv+0x3b3>
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    0x10(%rbp),%rdx
call   1080 <paw_Predictor_Out@plt>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xd0(%rbp),%rdx
call   1080 <paw_Predictor_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    151b <paw_R_Schrodinger_Fixed_Logderiv+0x36b>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xd0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xd0(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    0x10(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1461 <paw_R_Schrodinger_Fixed_Logderiv+0x2b1>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1550 <paw_R_Schrodinger_Fixed_Logderiv+0x3a0>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1555 <paw_R_Schrodinger_Fixed_Logderiv+0x3a5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1407 <paw_R_Schrodinger_Fixed_Logderiv+0x257>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    15cc <paw_R_Schrodinger_Fixed_Logderiv+0x41c>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xa5a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    18c0 <paw_R_Schrodinger_Fixed_Logderiv+0x710>
mov    -0x48(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    160b <paw_R_Schrodinger_Fixed_Logderiv+0x45b>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xa1b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    18bb <paw_R_Schrodinger_Fixed_Logderiv+0x70b>
movsd  -0x28(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x1c(%rbp),%edi
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rsi
call   10c0 <paw_Norm_LogGrid@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9ba(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     16f5 <paw_R_Schrodinger_Fixed_Logderiv+0x545>
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    169d <paw_R_Schrodinger_Fixed_Logderiv+0x4ed>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1738 <paw_R_Schrodinger_Fixed_Logderiv+0x588>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16fe <paw_R_Schrodinger_Fixed_Logderiv+0x54e>
movsd  0x8d8(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0x8aa(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movaps 0x892(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x866(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    17d1 <paw_R_Schrodinger_Fixed_Logderiv+0x621>
movsd  -0x60(%rbp),%xmm0
movaps 0x870(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    17e6 <paw_R_Schrodinger_Fixed_Logderiv+0x636>
movsd  0x837(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    17e6 <paw_R_Schrodinger_Fixed_Logderiv+0x636>
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0x822(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    183d <paw_R_Schrodinger_Fixed_Logderiv+0x68d>
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xd0(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    -0xc8(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
movl   $0x1,-0x4(%rbp)
jmp    1902 <paw_R_Schrodinger_Fixed_Logderiv+0x752>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    185e <paw_R_Schrodinger_Fixed_Logderiv+0x6ae>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1868 <paw_R_Schrodinger_Fixed_Logderiv+0x6b8>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
ja     189b <paw_R_Schrodinger_Fixed_Logderiv+0x6eb>
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    18b6 <paw_R_Schrodinger_Fixed_Logderiv+0x706>
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x76b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    18bb <paw_R_Schrodinger_Fixed_Logderiv+0x70b>
jmp    18c0 <paw_R_Schrodinger_Fixed_Logderiv+0x710>
jmp    1291 <paw_R_Schrodinger_Fixed_Logderiv+0xe1>
lea    0x774(%rip),%rdi
mov    $0x3e8,%esi
call   1040 <printf@plt>
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xd0(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    -0xc8(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_R_Schrodinger_Fixed_Logderiv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %r9,%r14
movsd  %xmm0,0x188(%rsp)
mov    %ecx,0x1c(%rsp)
mov    %rdx,%r13
mov    %edi,0x7c(%rsp)
mov    0x1f0(%rsp),%rbx
lea    0x1(%rsi),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %r8,0x80(%rsp)
movsd  (%r8),%xmm0
movaps %xmm0,0x50(%rsp)
mov    %rsi,0x1a8(%rsp)
imul   %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0xd0(%rsp)
xor    %r15d,%r15d
xor    %eax,%eax
call   1050 <paw_N_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1060 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0xc0(%rsp)
xor    %eax,%eax
call   1070 <paw_r_LogGrid@plt>
mov    %rax,0x20(%rsp)
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,%r12
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
movapd 0xc0(%rsp),%xmm9
movsd  0x10(%rsp),%xmm0
movapd 0xd0(%rsp),%xmm8
movapd 0x50(%rsp),%xmm5
mov    %rax,0x68(%rsp)
movslq 0x1c(%rsp),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%rax),%r10d
mov    %ebp,%edi
sub    %eax,%ebp
add    $0xfffffffe,%ebp
lea    0x1(%rbp),%rdx
lea    (%r12,%rdi,8),%r9
mov    0x20(%rsp),%rcx
lea    (%rcx,%rdi,8),%rax
lea    0x0(,%rdi,8),%r8
add    %r13,%r8
mov    %r10d,%esi
and    $0xfffffffc,%esi
mov    %rsi,0x170(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x168(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rdx,0x158(%rsp)
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
lea    -0x4(%r11),%rdx
mov    %rdx,0x148(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %rax,%r12
setb   %al
cmp    %r9,%rcx
setb   %cl
and    %al,%cl
cmp    %r8,%r12
setb   %r8b
cmp    %r13,%r9
seta   %al
lea    (%rbx,%r10,8),%r9
and    %r8b,%al
or     %cl,%al
mov    %al,0xf(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x198(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x1a0(%rsp)
cmp    %r14,%r9
seta   %al
lea    (%r14,%r10,8),%rcx
cmp    %rbx,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0xe(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rsi,%rax
mov    %rsi,0x160(%rsp)
and    %rsi,%rcx
mov    %rcx,0x128(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x178(%rsp)
movslq %r10d,%r8
lea    (%r14,%r8,8),%rsi
mov    %rbp,0x180(%rsp)
lea    (%r8,%rbp,1),%rax
mov    0x20(%rsp),%rbp
lea    (%rbx,%rax,8),%rcx
add    $0x8,%rcx
mov    %rsi,0x140(%rsp)
cmp    %rcx,%rsi
lea    0x8(%r14,%rax,8),%rax
setb   %cl
lea    (%rbx,%r8,8),%rsi
cmp    %rax,%rsi
setb   %al
and    %cl,%al
mov    %al,0xd(%rsp)
movsd  0xc2f(%rip),%xmm1
addsd  %xmm5,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0xc25(%rip),%xmm1
addsd  %xmm5,%xmm1
movapd %xmm1,0xb0(%rsp)
movapd %xmm0,%xmm1
mulsd  0x28(%rsp),%xmm1
movsd  %xmm1,0x48(%rsp)
movapd %xmm8,%xmm6
unpcklpd %xmm8,%xmm6
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
mov    %edx,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x110(%rsp)
lea    0x0(,%rdi,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x190(%rsp)
mov    0x60(%rsp),%rax
mov    %eax,%eax
add    $0xfffffffffffffffd,%rax
mov    %rcx,0x138(%rsp)
shl    $0x5,%rcx
mov    %r11,0x150(%rsp)
mov    %r8,0x88(%rsp)
lea    (%r11,%r8,1),%rdx
mov    %rdx,0x130(%rsp)
mov    %rcx,%r8
lea    0x10(%rbx),%rcx
mov    %rcx,0x120(%rsp)
lea    0x10(%r14),%rcx
mov    %rcx,0x118(%rsp)
mov    %r13,0x38(%rsp)
mov    %r10,0xa0(%rsp)
mov    %rdi,0x70(%rsp)
mov    %rsi,0x98(%rsp)
movapd %xmm6,0x100(%rsp)
movapd %xmm7,0xf0(%rsp)
mov    %rax,0x1b0(%rsp)
mov    %r8,0x90(%rsp)
jmp    150f <paw_R_Schrodinger_Fixed_Logderiv+0x35f>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x30(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0xb36(%rip),%xmm0
movapd %xmm1,0xb0(%rsp)
movapd %xmm0,%xmm5
mov    0x38(%rsp),%r13
mov    0x40(%rsp),%r15
mov    0x20(%rsp),%rbp
add    $0x1,%r15d
cmp    $0x3e8,%r15d
je     1f2a <paw_R_Schrodinger_Fixed_Logderiv+0xd7a>
test   %edi,%edi
jle    1674 <paw_R_Schrodinger_Fixed_Logderiv+0x4c4>
cmp    $0x4,%edi
setb   %al
or     0xf(%rsp),%al
je     1530 <paw_R_Schrodinger_Fixed_Logderiv+0x380>
xor    %ecx,%ecx
jmp    15c4 <paw_R_Schrodinger_Fixed_Logderiv+0x414>
nopw   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %eax,%eax
mov    0x190(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd 0x0(%rbp,%rax,1),%xmm1
movupd 0x10(%rbp,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd 0x0(%r13,%rax,1),%xmm3
movupd 0x10(%r13,%rax,1),%xmm4
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
addpd  %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm3
addpd  %xmm6,%xmm4
mulpd  %xmm7,%xmm3
mulpd  %xmm7,%xmm4
movupd %xmm3,(%r12,%rax,1)
movupd %xmm4,0x10(%r12,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    1550 <paw_R_Schrodinger_Fixed_Logderiv+0x3a0>
mov    0x198(%rsp),%rax
mov    %rax,%rcx
cmp    %rdi,%rax
je     1674 <paw_R_Schrodinger_Fixed_Logderiv+0x4c4>
mov    %rcx,%rax
test   $0x1,%dil
je     1601 <paw_R_Schrodinger_Fixed_Logderiv+0x451>
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%r13,%rcx,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x1a0(%rsp),%rcx
je     1674 <paw_R_Schrodinger_Fixed_Logderiv+0x4c4>
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%r13,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1610 <paw_R_Schrodinger_Fixed_Logderiv+0x460>
mov    %r15,0x40(%rsp)
movapd %xmm5,0x50(%rsp)
movsd  0x0(%rbp),%xmm0
movsd  0x28(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,(%r14)
mulsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%r12),%xmm1
mulsd  (%r14),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
mov    0x68(%rsp),%r15
movsd  %xmm0,(%r15)
movsd  0x8(%rbp),%xmm0
movsd  0x28(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x8(%r14)
mulsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%r12),%xmm1
mulsd  0x8(%r14),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x10(%rbp),%xmm0
movsd  0x28(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x10(%r14)
mulsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r12),%xmm1
mulsd  0x10(%r14),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r15)
movsd  0x18(%rbp),%xmm0
movsd  0x28(%rsp),%xmm1
call   10a0 <pow@plt>
xor    %ecx,%ecx
movsd  %xmm0,0x18(%r14)
mulsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x18(%rbx)
movsd  0x18(%r12),%xmm1
mulsd  0x18(%r14),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%r15)
cmpl   $0x4,0x1c(%rsp)
jl     199b <paw_R_Schrodinger_Fixed_Logderiv+0x7eb>
xor    %r13d,%r13d
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    %ecx,0xe0(%rsp)
lea    0x3(%r13),%ebp
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1080 <paw_Predictor_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1080 <paw_Predictor_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
movsd  0x20(%r12,%r13,8),%xmm1
mulsd  0x20(%r14,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x20(%r12,%r13,8),%xmm0
movsd  0x20(%rbx,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x20(%r12,%r13,8),%xmm0
movsd  0x20(%rbx,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x20(%r12,%r13,8),%xmm0
movsd  0x20(%rbx,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x20(%r12,%r13,8),%xmm0
movsd  0x20(%rbx,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x20(%r12,%r13,8),%xmm0
movsd  0x20(%rbx,%r13,8),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r15,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x20(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
mov    0x1b0(%rsp),%rax
mov    0xe0(%rsp),%ecx
movsd  %xmm0,0x20(%r14,%r13,8)
mulsd  0x18(%r14,%r13,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
sbb    $0xffffffff,%ecx
add    $0x1,%r13
cmp    %r13,%rax
jne    1790 <paw_R_Schrodinger_Fixed_Logderiv+0x5e0>
sub    0x7c(%rsp),%ecx
add    0x1a8(%rsp),%ecx
cmp    $0xfffffffe,%ecx
movapd 0x50(%rsp),%xmm1
movapd 0xd0(%rsp),%xmm8
movapd 0xc0(%rsp),%xmm9
mov    0x70(%rsp),%rdi
movapd 0x100(%rsp),%xmm6
movapd 0xf0(%rsp),%xmm7
jle    14d0 <paw_R_Schrodinger_Fixed_Logderiv+0x320>
test   %ecx,%ecx
js     1a04 <paw_R_Schrodinger_Fixed_Logderiv+0x854>
movapd 0xb0(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  0x61f(%rip),%xmm0
movsd  %xmm1,0x30(%rsp)
jmp    14eb <paw_R_Schrodinger_Fixed_Logderiv+0x33b>
mov    0x60(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
movaps %xmm0,0xe0(%rsp)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0x1c(%rsp),%edi
movsd  0x28(%rsp),%xmm0
mov    %r14,%rsi
call   10c0 <paw_Norm_LogGrid@plt>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1a47 <paw_R_Schrodinger_Fixed_Logderiv+0x897>
sqrtsd %xmm0,%xmm0
jmp    1a4c <paw_R_Schrodinger_Fixed_Logderiv+0x89c>
call   10d0 <sqrt@plt>
movapd 0x50(%rsp),%xmm5
mov    0x38(%rsp),%r13
movapd 0xd0(%rsp),%xmm8
mov    0x40(%rsp),%r15
movapd 0xc0(%rsp),%xmm9
mov    0x20(%rsp),%rbp
mov    0xa0(%rsp),%r10
mov    0x70(%rsp),%rdi
mov    0x98(%rsp),%rsi
movapd 0x100(%rsp),%xmm6
movapd 0xf0(%rsp),%xmm7
mov    0x90(%rsp),%r8
movapd 0xe0(%rsp),%xmm4
movsd  0xa8(%rsp),%xmm10
movsd  0x551(%rip),%xmm1
divsd  %xmm0,%xmm1
cmpl   $0x0,0x1c(%rsp)
js     1c89 <paw_R_Schrodinger_Fixed_Logderiv+0xad9>
cmp    $0x4,%r10d
setb   %al
or     0xe(%rsp),%al
je     1ae2 <paw_R_Schrodinger_Fixed_Logderiv+0x932>
xor    %ecx,%ecx
jmp    1c00 <paw_R_Schrodinger_Fixed_Logderiv+0xa50>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0x168(%rsp)
je     1f15 <paw_R_Schrodinger_Fixed_Logderiv+0xd65>
mov    0x128(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm2
movupd 0x30(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r14,%rax,8)
movupd %xmm3,0x30(%r14,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm2
movupd 0x30(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm3,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b10 <paw_R_Schrodinger_Fixed_Logderiv+0x960>
testb  $0x1,0x160(%rsp)
01
je     1bec <paw_R_Schrodinger_Fixed_Logderiv+0xa3c>
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
movupd (%rbx,%rax,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
mov    0x170(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     1c89 <paw_R_Schrodinger_Fixed_Logderiv+0xad9>
mov    %rcx,%rax
test   $0x1,%r10b
je     1c2e <paw_R_Schrodinger_Fixed_Logderiv+0xa7e>
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x178(%rsp),%rcx
je     1c89 <paw_R_Schrodinger_Fixed_Logderiv+0xad9>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1c40 <paw_R_Schrodinger_Fixed_Logderiv+0xa90>
cmp    %edi,%r10d
jge    1e3e <paw_R_Schrodinger_Fixed_Logderiv+0xc8e>
cmpl   $0x3,0x180(%rsp)
03
setb   %al
or     0xd(%rsp),%al
mov    0x88(%rsp),%rax
jne    1dbd <paw_R_Schrodinger_Fixed_Logderiv+0xc0d>
cmpq   $0xc,0x148(%rsp)
mov    0x140(%rsp),%rdx
jae    1cca <paw_R_Schrodinger_Fixed_Logderiv+0xb1a>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    1d48 <paw_R_Schrodinger_Fixed_Logderiv+0xb98>
mov    0x110(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
movupd %xmm0,(%rsi,%rax,8)
movupd %xmm0,0x10(%rsi,%rax,8)
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm0,0x30(%rdx,%rax,8)
movupd %xmm0,0x20(%rsi,%rax,8)
movupd %xmm0,0x30(%rsi,%rax,8)
movupd %xmm0,0x40(%rdx,%rax,8)
movupd %xmm0,0x50(%rdx,%rax,8)
movupd %xmm0,0x40(%rsi,%rax,8)
movupd %xmm0,0x50(%rsi,%rax,8)
movupd %xmm0,0x60(%rdx,%rax,8)
movupd %xmm0,0x70(%rdx,%rax,8)
movupd %xmm0,0x60(%rsi,%rax,8)
movupd %xmm0,0x70(%rsi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1ce0 <paw_R_Schrodinger_Fixed_Logderiv+0xb30>
cmpq   $0x0,0x138(%rsp)
je     1d9f <paw_R_Schrodinger_Fixed_Logderiv+0xbef>
add    0x88(%rsp),%rax
mov    0x120(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x118(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd %xmm0,-0x10(%rax,%rdx,1)
movupd %xmm0,(%rax,%rdx,1)
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1d80 <paw_R_Schrodinger_Fixed_Logderiv+0xbd0>
mov    0x130(%rsp),%rax
mov    0x150(%rsp),%rcx
cmp    %rcx,0x158(%rsp)
je     1e3e <paw_R_Schrodinger_Fixed_Logderiv+0xc8e>
mov    %edi,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
and    $0x3,%edx
je     1de9 <paw_R_Schrodinger_Fixed_Logderiv+0xc39>
nopl   0x0(%rax)
movq   $0x0,(%r14,%rax,8)
movq   $0x0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1dd0 <paw_R_Schrodinger_Fixed_Logderiv+0xc20>
cmp    $0x3,%ecx
jb     1e3e <paw_R_Schrodinger_Fixed_Logderiv+0xc8e>
xchg   %ax,%ax
movq   $0x0,(%r14,%rax,8)
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x8(%r14,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movq   $0x0,0x10(%r14,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movq   $0x0,0x18(%r14,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %eax,%edi
jne    1df0 <paw_R_Schrodinger_Fixed_Logderiv+0xc40>
movapd %xmm4,%xmm0
mulsd  0x188(%rsp),%xmm0
mulsd  %xmm1,%xmm4
mulsd  %xmm1,%xmm10
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm10
mulsd  0x1b3(%rip),%xmm4
mulsd  %xmm10,%xmm4
mov    0x60(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x10(%rsp),%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,%xmm0
movapd 0x1b5(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm5,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x181(%rip),%xmm1
mulsd  0x181(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1f7b <paw_R_Schrodinger_Fixed_Logderiv+0xdcb>
ucomisd 0x177(%rip),%xmm4
ja     1ec1 <paw_R_Schrodinger_Fixed_Logderiv+0xd11>
movsd  %xmm5,0x30(%rsp)
xorpd  %xmm0,%xmm0
cmpltsd %xmm4,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm5,%xmm1
andnpd 0xb0(%rsp),%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm4,%xmm5
ucomisd 0x30(%rsp),%xmm5
movapd %xmm0,0xb0(%rsp)
ja     1efe <paw_R_Schrodinger_Fixed_Logderiv+0xd4e>
ucomisd %xmm5,%xmm0
jbe    14fe <paw_R_Schrodinger_Fixed_Logderiv+0x34e>
movapd %xmm0,%xmm5
addsd  0x30(%rsp),%xmm5
mulsd  0x108(%rip),%xmm5
jmp    14fe <paw_R_Schrodinger_Fixed_Logderiv+0x34e>
xor    %eax,%eax
testb  $0x1,0x160(%rsp)
01
jne    1bac <paw_R_Schrodinger_Fixed_Logderiv+0x9fc>
jmp    1bec <paw_R_Schrodinger_Fixed_Logderiv+0xa3c>
lea    0x11f(%rip),%rdi
mov    $0x3e8,%esi
movapd %xmm5,0x50(%rsp)
call   1040 <printf@plt>
movapd 0x50(%rsp),%xmm5
xor    %ebx,%ebx
mov    0x80(%rsp),%rax
mov    0x68(%rsp),%rdi
movsd  %xmm5,(%rax)
call   10b0 <paw_dealloc_LogGrid@plt>
mov    %r12,%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    %ebx,%eax
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebx
jmp    1f49 <paw_R_Schrodinger_Fixed_Logderiv+0xd99>

LLVM IR (-O0):
@.str = [65 x i8] c"paw_Error R_Schrodinger_Fixed_Logderiv: More than %d iterations\0A\00"
define i32 @paw_R_Schrodinger_Fixed_Logderiv(i32 %0, i32 %1, double* %2, i32 %3, double %4, double* %5, double* %6, double* %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca i32
%14 = alloca double
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%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*
store i32 %0, i32* %10
store i32 %1, i32* %11
store double* %2, double** %12
store i32 %3, i32* %13
store double %4, double* %14
store double* %5, double** %15
store double* %6, double** %16
store double* %7, double** %17
%39 = load double*, double** %15
%40 = load double, double* %39
store double %40, double* %24
%41 = load i32, i32* %11
%42 = add nsw i32 %41, 1
%43 = sitofp i32 %42 to double
store double %43, double* %30
%44 = load i32, i32* %11
%45 = load i32, i32* %11
%46 = add nsw i32 %45, 1
%47 = mul nsw i32 %44, %46
%48 = sitofp i32 %47 to double
store double %48, double* %31
%49 = call i32 (...) @paw_N_LogGrid()
store i32 %49, i32* %22
%50 = call double (...) @paw_log_amesh_LogGrid()
store double %50, double* %28
%51 = load double, double* %28
%52 = load double, double* %28
%53 = fmul double %51, %52
store double %53, double* %29
%54 = call i64 (...) @paw_r_LogGrid()
%55 = inttoptr i64 %54 to double*
store double* %55, double** %36
%56 = call i64 (...) @paw_alloc_LogGrid()
%57 = inttoptr i64 %56 to double*
store double* %57, double** %37
%58 = call i64 (...) @paw_alloc_LogGrid()
%59 = inttoptr i64 %58 to double*
store double* %59, double** %38
%60 = load double, double* %24
%61 = fadd double %60, 1.000000e+01
store double %61, double* %26
%62 = load double, double* %24
%63 = fsub double %62, 1.000000e+01
store double %63, double* %27
store i32 0, i32* %20
br label %64
64: ; preds = %423, %8
%65 = load i32, i32* %20
%66 = icmp slt i32 %65, 1000
br i1 %66, label %67, label %424
67: ; preds = %64
%68 = load i32, i32* %20
%69 = add nsw i32 %68, 1
store i32 %69, i32* %20
store i32 0, i32* %18
br label %70
70: ; preds = %103, %67
%71 = load i32, i32* %18
%72 = load i32, i32* %22
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %106
74: ; preds = %70
%75 = load double*, double** %36
%76 = load i32, i32* %18
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = load double*, double** %36
%81 = load i32, i32* %18
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %80, i64 %82
%84 = load double, double* %83
%85 = fmul double %79, %84
store double %85, double* %32
%86 = load double, double* %29
%87 = load double, double* %31
%88 = load double*, double** %12
%89 = load i32, i32* %18
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
%92 = load double, double* %91
%93 = load double, double* %24
%94 = fsub double %92, %93
%95 = fmul double 2.000000e+00, %94
%96 = load double, double* %32
%97 = call double @llvm.fmuladd.f64(double %95, double %96, double %87)
%98 = fmul double %86, %97
%99 = load double*, double** %37
%100 = load i32, i32* %18
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
store double %98, double* %102
br label %103
103: ; preds = %74
%104 = load i32, i32* %18
%105 = add nsw i32 %104, 1
store i32 %105, i32* %18
br label %70
106: ; preds = %70
store i32 0, i32* %18
br label %107
107: ; preds = %157, %106
%108 = load i32, i32* %18
%109 = icmp slt i32 %108, 4
br i1 %109, label %110, label %160
110: ; preds = %107
%111 = load double*, double** %36
%112 = load i32, i32* %18
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %111, i64 %113
%115 = load double, double* %114
%116 = load double, double* %30
%117 = call double @pow(double %115, double %116)
%118 = load double*, double** %16
%119 = load i32, i32* %18
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
store double %117, double* %121
%122 = load double, double* %28
%123 = load double, double* %30
%124 = fmul double %122, %123
%125 = load double*, double** %16
%126 = load i32, i32* %18
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = fmul double %124, %129
%131 = load double*, double** %17
%132 = load i32, i32* %18
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
store double %130, double* %134
%135 = load double, double* %28
%136 = load double*, double** %17
%137 = load i32, i32* %18
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = load double*, double** %37
%142 = load i32, i32* %18
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %16
%147 = load i32, i32* %18
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
%151 = fmul double %145, %150
%152 = call double @llvm.fmuladd.f64(double %135, double %140, double %151)
%153 = load double*, double** %38
%154 = load i32, i32* %18
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
store double %152, double* %156
br label %157
157: ; preds = %110
%158 = load i32, i32* %18
%159 = add nsw i32 %158, 1
store i32 %159, i32* %18
br label %107
160: ; preds = %107
store i32 0, i32* %21
store i32 3, i32* %18
br label %161
161: ; preds = %253, %160
%162 = load i32, i32* %18
%163 = load i32, i32* %13
%164 = icmp slt i32 %162, %163
br i1 %164, label %165, label %256
165: ; preds = %161
%166 = load i32, i32* %18
%167 = load double*, double** %16
%168 = load double*, double** %17
%169 = call double @paw_Predictor_Out(i32 %166, double* %167, double* %168)
%170 = load double*, double** %16
%171 = load i32, i32* %18
%172 = add nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %170, i64 %173
store double %169, double* %174
%175 = load i32, i32* %18
%176 = load double*, double** %17
%177 = load double*, double** %38
%178 = call double @paw_Predictor_Out(i32 %175, double* %176, double* %177)
%179 = load double*, double** %17
%180 = load i32, i32* %18
%181 = add nsw i32 %180, 1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %179, i64 %182
store double %178, double* %183
store i32 0, i32* %19
br label %184
184: ; preds = %232, %165
%185 = load i32, i32* %19
%186 = icmp slt i32 %185, 6
br i1 %186, label %187, label %235
187: ; preds = %184
%188 = load double, double* %28
%189 = load double*, double** %17
%190 = load i32, i32* %18
%191 = add 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 = add nsw i32 %196, 1
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %195, i64 %198
%200 = load double, double* %199
%201 = load double*, double** %16
%202 = load i32, i32* %18
%203 = add nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %201, i64 %204
%206 = load double, double* %205
%207 = fmul double %200, %206
%208 = call double @llvm.fmuladd.f64(double %188, double %194, double %207)
%209 = load double*, double** %38
%210 = load i32, i32* %18
%211 = add nsw i32 %210, 1
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %209, i64 %212
store double %208, double* %213
%214 = load i32, i32* %18
%215 = load double*, double** %17
%216 = load double*, double** %38
%217 = call double @paw_Corrector_Out(i32 %214, double* %215, double* %216)
%218 = load double*, double** %17
%219 = load i32, i32* %18
%220 = add nsw i32 %219, 1
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %218, i64 %221
store double %217, double* %222
%223 = load i32, i32* %18
%224 = load double*, double** %16
%225 = load double*, double** %17
%226 = call double @paw_Corrector_Out(i32 %223, double* %224, double* %225)
%227 = load double*, double** %16
%228 = load i32, i32* %18
%229 = add nsw i32 %228, 1
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %227, i64 %230
store double %226, double* %231
br label %232
232: ; preds = %187
%233 = load i32, i32* %19
%234 = add nsw i32 %233, 1
store i32 %234, i32* %19
br label %184
235: ; preds = %184
%236 = load double*, double** %16
%237 = load i32, i32* %18
%238 = add nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %236, i64 %239
%241 = load double, double* %240
%242 = load double*, double** %16
%243 = load i32, i32* %18
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %242, i64 %244
%246 = load double, double* %245
%247 = fmul double %241, %246
%248 = fcmp ole double %247, 0.000000e+00
br i1 %248, label %249, label %252
249: ; preds = %235
%250 = load i32, i32* %21
%251 = add nsw i32 %250, 1
store i32 %251, i32* %21
br label %252
252: ; preds = %249, %235
br label %253
253: ; preds = %252
%254 = load i32, i32* %18
%255 = add nsw i32 %254, 1
store i32 %255, i32* %18
br label %161
256: ; preds = %161
%257 = load double*, double** %16
%258 = load i32, i32* %13
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
store double %261, double* %33
%262 = load double*, double** %17
%263 = load i32, i32* %13
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds double, double* %262, i64 %264
%266 = load double, double* %265
store double %266, double* %34
%267 = load i32, i32* %21
%268 = load i32, i32* %10
%269 = sub nsw i32 %267, %268
%270 = load i32, i32* %11
%271 = add nsw i32 %269, %270
%272 = add nsw i32 %271, 1
%273 = icmp slt i32 %272, 0
br i1 %273, label %274, label %280
274: ; preds = %256
%275 = load double, double* %24
store double %275, double* %27
%276 = load double, double* %27
%277 = load double, double* %26
%278 = fadd double %276, %277
%279 = fmul double 5.000000e-01, %278
store double %279, double* %24
br label %423
280: ; preds = %256
%281 = load i32, i32* %21
%282 = load i32, i32* %10
%283 = sub nsw i32 %281, %282
%284 = load i32, i32* %11
%285 = add nsw i32 %283, %284
%286 = add nsw i32 %285, 1
%287 = icmp sgt i32 %286, 0
br i1 %287, label %288, label %294
288: ; preds = %280
%289 = load double, double* %24
store double %289, double* %26
%290 = load double, double* %27
%291 = load double, double* %26
%292 = fadd double %290, %291
%293 = fmul double 5.000000e-01, %292
store double %293, double* %24
br label %422
294: ; preds = %280
%295 = load double, double* %14
%296 = load double, double* %33
%297 = fmul double %295, %296
store double %297, double* %35
%298 = load i32, i32* %13
%299 = load double, double* %30
%300 = load double*, double** %16
%301 = call double @paw_Norm_LogGrid(i32 %298, double %299, double* %300)
store double %301, double* %23
%302 = load double, double* %23
%303 = call double @sqrt(double %302)
%304 = fdiv double 1.000000e+00, %303
store double %304, double* %23
%305 = load double, double* %23
%306 = load double, double* %33
%307 = fmul double %305, %306
store double %307, double* %33
%308 = load double, double* %23
%309 = load double, double* %34
%310 = fmul double %308, %309
store double %310, double* %34
%311 = load double, double* %23
%312 = load double, double* %35
%313 = fmul double %311, %312
store double %313, double* %35
store i32 0, i32* %18
br label %314
314: ; preds = %341, %294
%315 = load i32, i32* %18
%316 = load i32, i32* %13
%317 = icmp sle i32 %315, %316
br i1 %317, label %318, label %344
318: ; preds = %314
%319 = load double, double* %23
%320 = load double*, double** %16
%321 = load i32, i32* %18
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double, double* %320, i64 %322
%324 = load double, double* %323
%325 = fmul double %319, %324
%326 = load double*, double** %16
%327 = load i32, i32* %18
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %326, i64 %328
store double %325, double* %329
%330 = load double, double* %23
%331 = load double*, double** %17
%332 = load i32, i32* %18
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
%335 = load double, double* %334
%336 = fmul double %330, %335
%337 = load double*, double** %17
%338 = load i32, i32* %18
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %337, i64 %339
store double %336, double* %340
br label %341
341: ; preds = %318
%342 = load i32, i32* %18
%343 = add nsw i32 %342, 1
store i32 %343, i32* %18
br label %314
344: ; preds = %314
%345 = load i32, i32* %13
%346 = add nsw i32 %345, 1
store i32 %346, i32* %18
br label %347
347: ; preds = %360, %344
%348 = load i32, i32* %18
%349 = load i32, i32* %22
%350 = icmp slt i32 %348, %349
br i1 %350, label %351, label %363
351: ; preds = %347
%352 = load double*, double** %16
%353 = load i32, i32* %18
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %352, i64 %354
store double 0.000000e+00, double* %355
%356 = load double*, double** %17
%357 = load i32, i32* %18
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
store double 0.000000e+00, double* %359
br label %360
360: ; preds = %351
%361 = load i32, i32* %18
%362 = add nsw i32 %361, 1
store i32 %362, i32* %18
br label %347
363: ; preds = %347
%364 = load double, double* %33
%365 = fmul double 5.000000e-01, %364
%366 = load double, double* %34
%367 = load double, double* %35
%368 = fsub double %366, %367
%369 = fmul double %365, %368
%370 = load double, double* %28
%371 = load double*, double** %36
%372 = load i32, i32* %13
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
%376 = fmul double %370, %375
%377 = fdiv double %369, %376
store double %377, double* %25
%378 = load double, double* %25
%379 = call double @llvm.fabs.f64(double %378)
%380 = load double, double* %24
%381 = call double @llvm.fabs.f64(double %380)
%382 = fcmp ogt double %381, 2.000000e-01
br i1 %382, label %383, label %386
383: ; preds = %363
%384 = load double, double* %24
%385 = call double @llvm.fabs.f64(double %384)
br label %387
386: ; preds = %363
br label %387
387: ; preds = %386, %383
%388 = phi double [ %385, %383 ], [ 2.000000e-01, %386 ]
%389 = fmul double %388, 1.000000e-10
%390 = fcmp olt double %379, %389
br i1 %390, label %391, label %398
391: ; preds = %387
%392 = load double, double* %24
%393 = load double*, double** %15
store double %392, double* %393
%394 = load double*, double** %38
%395 = call i32 @paw_dealloc_LogGrid(double* %394)
%396 = load double*, double** %37
%397 = call i32 @paw_dealloc_LogGrid(double* %396)
store i32 1, i32* %9
br label %432
398: ; preds = %387
%399 = load double, double* %25
%400 = fcmp ogt double %399, 0.000000e+00
br i1 %400, label %401, label %403
401: ; preds = %398
%402 = load double, double* %24
store double %402, double* %27
br label %405
403: ; preds = %398
%404 = load double, double* %24
store double %404, double* %26
br label %405
405: ; preds = %403, %401
%406 = load double, double* %24
%407 = load double, double* %25
%408 = fadd double %406, %407
store double %408, double* %24
%409 = load double, double* %24
%410 = load double, double* %26
%411 = fcmp ogt double %409, %410
br i1 %411, label %416, label %412
412: ; preds = %405
%413 = load double, double* %24
%414 = load double, double* %27
%415 = fcmp olt double %413, %414
br i1 %415, label %416, label %421
416: ; preds = %412, %405
%417 = load double, double* %27
%418 = load double, double* %26
%419 = fadd double %417, %418
%420 = fmul double 5.000000e-01, %419
store double %420, double* %24
br label %421
421: ; preds = %416, %412
br label %422
422: ; preds = %421, %288
br label %423
423: ; preds = %422, %274
br label %64
424: ; preds = %64
%425 = call i32 @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 1000)
%426 = load double, double* %24
%427 = load double*, double** %15
store double %426, double* %427
%428 = load double*, double** %38
%429 = call i32 @paw_dealloc_LogGrid(double* %428)
%430 = load double*, double** %37
%431 = call i32 @paw_dealloc_LogGrid(double* %430)
store i32 0, i32* %9
br label %432
432: ; preds = %424, %391
%433 = load i32, i32* %9
ret i32 %433
}

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