#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_Logderiv1(int n, int l, double *v, int match,
                                      double u_logderiv, double *Eig, double *u,
                                      double *uprime) {
  int i;
  int j;
  int iteration;
  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];
    }
    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);
      }
    }
    uout = u[match];
    upout = uprime[match];
    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_Logderiv1>:
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,-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,-0x48(%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   1070 <paw_r_LogGrid@plt>
mov    %rax,-0xb8(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0xc0(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0xc8(%rbp)
movsd  0xd99(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0xd82(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3e8,-0x44(%rbp)
jge    17fb <paw_R_Schrodinger_Fixed_Logderiv1+0x64b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    133c <paw_R_Schrodinger_Fixed_Logderiv1+0x18c>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0xd22(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x98(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ab <paw_R_Schrodinger_Fixed_Logderiv1+0xfb>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    13f3 <paw_R_Schrodinger_Fixed_Logderiv1+0x243>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
call   10a0 <pow@plt>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x88(%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  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc0(%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    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1343 <paw_R_Schrodinger_Fixed_Logderiv1+0x193>
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1521 <paw_R_Schrodinger_Fixed_Logderiv1+0x371>
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    -0xc8(%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    150e <paw_R_Schrodinger_Fixed_Logderiv1+0x35e>
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xc0(%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    -0xc8(%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    -0xc8(%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    1454 <paw_R_Schrodinger_Fixed_Logderiv1+0x2a4>
jmp    1513 <paw_R_Schrodinger_Fixed_Logderiv1+0x363>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13fa <paw_R_Schrodinger_Fixed_Logderiv1+0x24a>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x1c(%rbp),%edi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rsi
call   10c0 <paw_Norm_LogGrid@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xa7a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1635 <paw_R_Schrodinger_Fixed_Logderiv1+0x485>
movsd  -0x50(%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  -0x50(%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    15dd <paw_R_Schrodinger_Fixed_Logderiv1+0x42d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1678 <paw_R_Schrodinger_Fixed_Logderiv1+0x4c8>
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    163e <paw_R_Schrodinger_Fixed_Logderiv1+0x48e>
movsd  0x998(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
subsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x96a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0x952(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x926(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1711 <paw_R_Schrodinger_Fixed_Logderiv1+0x561>
movsd  -0x58(%rbp),%xmm0
movaps 0x930(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1726 <paw_R_Schrodinger_Fixed_Logderiv1+0x576>
movsd  0x8f7(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1726 <paw_R_Schrodinger_Fixed_Logderiv1+0x576>
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  0x8e2(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    177d <paw_R_Schrodinger_Fixed_Logderiv1+0x5cd>
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xc8(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    -0xc0(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
movl   $0x1,-0x4(%rbp)
jmp    1838 <paw_R_Schrodinger_Fixed_Logderiv1+0x688>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    179e <paw_R_Schrodinger_Fixed_Logderiv1+0x5ee>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    17a8 <paw_R_Schrodinger_Fixed_Logderiv1+0x5f8>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
ja     17db <paw_R_Schrodinger_Fixed_Logderiv1+0x62b>
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    17f6 <paw_R_Schrodinger_Fixed_Logderiv1+0x646>
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x82b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    128e <paw_R_Schrodinger_Fixed_Logderiv1+0xde>
lea    0x83e(%rip),%rdi
mov    $0x3e8,%esi
call   1040 <printf@plt>
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xc8(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    -0xc0(%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_Logderiv1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,%rbx
movsd  %xmm0,0x150(%rsp)
mov    %ecx,%r14d
mov    %rdx,%r12
mov    0x1e0(%rsp),%rbp
lea    0x1(%rsi),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r8,0xc0(%rsp)
movsd  (%r8),%xmm0
movaps %xmm0,0x40(%rsp)
imul   %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0xb0(%rsp)
xor    %eax,%eax
mov    %rax,0x98(%rsp)
xor    %eax,%eax
call   1050 <paw_N_LogGrid@plt>
mov    %rax,0x28(%rsp)
xor    %eax,%eax
call   1060 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0xa0(%rsp)
xor    %eax,%eax
call   1070 <paw_r_LogGrid@plt>
mov    %rax,%r15
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,%r13
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
mov    %r15,%rsi
movapd 0xa0(%rsp),%xmm9
movapd 0xb0(%rsp),%xmm8
movapd 0x40(%rsp),%xmm5
movslq %r14d,%rcx
mov    %rcx,0x30(%rsp)
lea    0x1(%rcx),%r11d
mov    0x28(%rsp),%rdx
mov    %edx,%r9d
sub    %ecx,%edx
add    $0xfffffffe,%edx
mov    %rdx,0x28(%rsp)
lea    0x1(%rdx),%rcx
lea    0x0(,%r9,8),%r15
add    %r13,%r15
lea    (%rsi,%r9,8),%rdx
mov    %rdx,0x10(%rsp)
lea    (%r12,%r9,8),%rdx
mov    %rdx,0x20(%rsp)
mov    %r11d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x130(%rsp)
lea    -0x4(%rdx),%r8
mov    %r8,0x128(%rsp)
shr    $0x2,%r8
add    $0x1,%r8
mov    %rcx,0x108(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x58(%rsp)
lea    -0x4(%rcx),%r10
mov    %r10,0x100(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
cmp    0x10(%rsp),%r13
setb   %dl
cmp    %r15,%rsi
setb   %cl
and    %dl,%cl
cmp    0x20(%rsp),%r13
setb   %dil
cmp    %r12,%r15
seta   %r15b
lea    0x0(,%r11,8),%rdx
add    %rbp,%rdx
mov    %rdx,0x20(%rsp)
and    %dil,%r15b
or     %cl,%r15b
mov    %r15b,0x7(%rsp)
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x118(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0x140(%rsp)
cmp    %rbx,0x20(%rsp)
seta   %cl
lea    (%rbx,%r11,8),%rdx
cmp    %rbp,%rdx
seta   %dl
mov    %rax,%r15
and    %cl,%dl
mov    %dl,0x6(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %r8,%rax
mov    %r8,0x120(%rsp)
and    %r8,%rcx
mov    %rcx,0xe0(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x138(%rsp)
movslq %r11d,%rdx
lea    (%rbx,%rdx,8),%r8
mov    0x28(%rsp),%rax
add    %rdx,%rax
lea    0x8(,%rax,8),%rcx
add    %rbp,%rcx
mov    %r8,0xf8(%rsp)
cmp    %rcx,%r8
lea    0x8(%rbx,%rax,8),%rax
setb   %cl
lea    0x0(,%rdx,8),%rdi
add    %rbp,%rdi
cmp    %rax,%rdi
setb   %al
and    %cl,%al
mov    %al,0x5(%rsp)
movsd  0xc12(%rip),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  0xc04(%rip),%xmm10
addsd  %xmm5,%xmm10
movsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movapd %xmm8,%xmm6
unpcklpd %xmm8,%xmm6
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
mov    %r10d,%eax
and    $0x3,%eax
and    $0xfffffffffffffffc,%r10
mov    %r10,0xc8(%rsp)
lea    0x0(,%r9,8),%rcx
and    $0xffffffffffffffe0,%rcx
mov    %rcx,0x110(%rsp)
mov    %rax,0xf0(%rsp)
mov    %rax,%r8
shl    $0x5,%r8
mov    0x30(%rsp),%rax
mov    %eax,%r10d
mov    %rdx,0x60(%rsp)
mov    0x58(%rsp),%rax
add    %rdx,%rax
mov    %rax,0xe8(%rsp)
lea    0x10(%rbp),%rax
mov    %rax,0xd8(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0xd0(%rsp)
mov    %r14d,0x3c(%rsp)
mov    %r12,0x148(%rsp)
mov    %rsi,0x88(%rsp)
mov    %r11,0x80(%rsp)
mov    %r9,0x78(%rsp)
mov    %rdi,0x70(%rsp)
movapd %xmm6,0x170(%rsp)
movapd %xmm7,0x160(%rsp)
mov    %r8,0x68(%rsp)
mov    %r10,0x20(%rsp)
jmp    156e <paw_R_Schrodinger_Fixed_Logderiv1+0x3be>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
cmpltsd %xmm4,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm11,%xmm1
andnpd 0x180(%rsp),%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm4,%xmm11
movapd %xmm11,%xmm1
cmpltsd %xmm0,%xmm1
movapd %xmm0,%xmm10
movsd  0x90(%rsp),%xmm2
addsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
cmpltsd %xmm11,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
andpd  %xmm1,%xmm0
andnpd %xmm11,%xmm1
orpd   %xmm0,%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm2,%xmm5
mov    %rax,0x98(%rsp)
cmp    $0x3e8,%eax
je     1ecd <paw_R_Schrodinger_Fixed_Logderiv1+0xd1d>
test   %r9d,%r9d
jle    16d3 <paw_R_Schrodinger_Fixed_Logderiv1+0x523>
cmp    $0x4,%r9d
setb   %al
or     0x7(%rsp),%al
je     1590 <paw_R_Schrodinger_Fixed_Logderiv1+0x3e0>
xor    %ecx,%ecx
jmp    1623 <paw_R_Schrodinger_Fixed_Logderiv1+0x473>
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %eax,%eax
mov    0x110(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsi,%rax,1),%xmm1
movupd 0x10(%rsi,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd (%r12,%rax,1),%xmm3
movupd 0x10(%r12,%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,0x0(%r13,%rax,1)
movupd %xmm4,0x10(%r13,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    15b0 <paw_R_Schrodinger_Fixed_Logderiv1+0x400>
mov    0x118(%rsp),%rax
mov    %rax,%rcx
cmp    %r9,%rax
je     16d3 <paw_R_Schrodinger_Fixed_Logderiv1+0x523>
mov    %rcx,%rax
test   $0x1,%r9b
je     165f <paw_R_Schrodinger_Fixed_Logderiv1+0x4af>
movsd  (%rsi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r12,%rcx,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x140(%rsp),%rcx
je     16d3 <paw_R_Schrodinger_Fixed_Logderiv1+0x523>
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
subsd  %xmm5,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1670 <paw_R_Schrodinger_Fixed_Logderiv1+0x4c0>
movapd %xmm10,0x180(%rsp)
movapd %xmm5,0x40(%rsp)
movsd  (%rsi),%xmm0
movsd  0x18(%rsp),%xmm1
mov    %rsi,%r12
call   10a0 <pow@plt>
movsd  %xmm0,(%rbx)
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x0(%r13),%xmm1
mulsd  (%rbx),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
movsd  0x8(%r12),%xmm0
movsd  0x18(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x8(%rbx)
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x8(%r13),%xmm1
mulsd  0x8(%rbx),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x10(%r12),%xmm0
movsd  0x18(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x10(%rbx)
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x10(%r13),%xmm1
mulsd  0x10(%rbx),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r15)
movsd  0x18(%r12),%xmm0
movsd  0x18(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x18(%rbx)
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x18(%rbp)
movsd  0x18(%r13),%xmm1
mulsd  0x18(%rbx),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%r15)
cmp    $0x4,%r14d
jl     19e3 <paw_R_Schrodinger_Fixed_Logderiv1+0x833>
mov    $0x3,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1080 <paw_Predictor_Out@plt>
lea    0x1(%r12),%r14
movsd  %xmm0,0x8(%rbx,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1080 <paw_Predictor_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
movsd  0x8(%r13,%r12,8),%xmm1
mulsd  0x8(%rbx,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%r12,8)
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbp,%r12,8)
mov    %r12d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
mov    %r14,%r12
cmp    %r14,0x20(%rsp)
jne    17f0 <paw_R_Schrodinger_Fixed_Logderiv1+0x640>
mov    0x30(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
movaps %xmm0,0x190(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x158(%rsp)
mov    0x3c(%rsp),%r14d
mov    %r14d,%edi
movsd  0x18(%rsp),%xmm0
mov    %rbx,%rsi
call   10c0 <paw_Norm_LogGrid@plt>
ucomisd 0x60e(%rip),%xmm0
jb     1a30 <paw_R_Schrodinger_Fixed_Logderiv1+0x880>
sqrtsd %xmm0,%xmm0
jmp    1a35 <paw_R_Schrodinger_Fixed_Logderiv1+0x885>
nopw   0x0(%rax,%rax,1)
call   10d0 <sqrt@plt>
movapd 0x40(%rsp),%xmm11
movapd 0xb0(%rsp),%xmm8
movsd  0x8(%rsp),%xmm10
movapd 0xa0(%rsp),%xmm9
mov    0x88(%rsp),%rsi
mov    0x80(%rsp),%r11
mov    0x78(%rsp),%r9
mov    0x70(%rsp),%rdi
movapd 0x170(%rsp),%xmm6
movapd 0x160(%rsp),%xmm7
mov    0x68(%rsp),%r8
movsd  0x588(%rip),%xmm5
movsd  0x578(%rip),%xmm1
divsd  %xmm0,%xmm1
test   %r14d,%r14d
mov    0x148(%rsp),%r12
movapd 0x190(%rsp),%xmm4
js     1c77 <paw_R_Schrodinger_Fixed_Logderiv1+0xac7>
cmp    $0x4,%r11d
setb   %al
or     0x6(%rsp),%al
je     1ad0 <paw_R_Schrodinger_Fixed_Logderiv1+0x920>
xor    %ecx,%ecx
jmp    1be8 <paw_R_Schrodinger_Fixed_Logderiv1+0xa38>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0x128(%rsp)
je     1eb8 <paw_R_Schrodinger_Fixed_Logderiv1+0xd08>
mov    0xe0(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%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)
movupd 0x20(%rbp,%rax,8),%xmm2
movupd 0x30(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbp,%rax,8)
movupd %xmm3,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b00 <paw_R_Schrodinger_Fixed_Logderiv1+0x950>
testb  $0x1,0x120(%rsp)
01
je     1bd4 <paw_R_Schrodinger_Fixed_Logderiv1+0xa24>
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 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
mov    0x130(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     1c77 <paw_R_Schrodinger_Fixed_Logderiv1+0xac7>
mov    %rcx,%rax
test   $0x1,%r11b
je     1c16 <paw_R_Schrodinger_Fixed_Logderiv1+0xa66>
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x138(%rsp),%rcx
je     1c77 <paw_R_Schrodinger_Fixed_Logderiv1+0xac7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1c30 <paw_R_Schrodinger_Fixed_Logderiv1+0xa80>
cmp    %r9d,%r11d
jge    1e20 <paw_R_Schrodinger_Fixed_Logderiv1+0xc70>
cmpl   $0x3,0x28(%rsp)
setb   %al
or     0x5(%rsp),%al
mov    0x60(%rsp),%rax
jne    1d9a <paw_R_Schrodinger_Fixed_Logderiv1+0xbea>
cmpq   $0xc,0x100(%rsp)
mov    0xf8(%rsp),%rdx
jae    1cb2 <paw_R_Schrodinger_Fixed_Logderiv1+0xb02>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    1d28 <paw_R_Schrodinger_Fixed_Logderiv1+0xb78>
mov    0xc8(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm0,0x10(%rdi,%rax,8)
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm0,0x30(%rdx,%rax,8)
movupd %xmm0,0x20(%rdi,%rax,8)
movupd %xmm0,0x30(%rdi,%rax,8)
movupd %xmm0,0x40(%rdx,%rax,8)
movupd %xmm0,0x50(%rdx,%rax,8)
movupd %xmm0,0x40(%rdi,%rax,8)
movupd %xmm0,0x50(%rdi,%rax,8)
movupd %xmm0,0x60(%rdx,%rax,8)
movupd %xmm0,0x70(%rdx,%rax,8)
movupd %xmm0,0x60(%rdi,%rax,8)
movupd %xmm0,0x70(%rdi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1cc0 <paw_R_Schrodinger_Fixed_Logderiv1+0xb10>
cmpq   $0x0,0xf0(%rsp)
je     1d7f <paw_R_Schrodinger_Fixed_Logderiv1+0xbcf>
add    0x60(%rsp),%rax
mov    0xd8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xd0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    1d60 <paw_R_Schrodinger_Fixed_Logderiv1+0xbb0>
mov    0xe8(%rsp),%rax
mov    0x58(%rsp),%rcx
cmp    %rcx,0x108(%rsp)
je     1e20 <paw_R_Schrodinger_Fixed_Logderiv1+0xc70>
mov    %r9d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r9d,%ecx
and    $0x3,%edx
je     1dca <paw_R_Schrodinger_Fixed_Logderiv1+0xc1a>
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1db0 <paw_R_Schrodinger_Fixed_Logderiv1+0xc00>
cmp    $0x3,%ecx
jb     1e20 <paw_R_Schrodinger_Fixed_Logderiv1+0xc70>
nop
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movq   $0x0,0x8(%rbp,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movq   $0x0,0x10(%rbp,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
movq   $0x0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %eax,%r9d
jne    1dd0 <paw_R_Schrodinger_Fixed_Logderiv1+0xc20>
movapd %xmm4,%xmm0
mulsd  0x150(%rsp),%xmm0
mulsd  %xmm1,%xmm4
movsd  0x158(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm2
mulsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm4
mov    0x30(%rsp),%rax
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm10,%xmm0
divsd  %xmm0,%xmm4
movapd %xmm4,%xmm0
movapd 0x1d3(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm11,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x19e(%rip),%xmm1
mulsd  0x19e(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1eef <paw_R_Schrodinger_Fixed_Logderiv1+0xd3f>
mov    0x98(%rsp),%rax
add    $0x1,%eax
ucomisd 0x18d(%rip),%xmm4
ja     14f0 <paw_R_Schrodinger_Fixed_Logderiv1+0x340>
movsd  %xmm11,0x90(%rsp)
jmp    14f0 <paw_R_Schrodinger_Fixed_Logderiv1+0x340>
xor    %eax,%eax
testb  $0x1,0x120(%rsp)
01
jne    1b96 <paw_R_Schrodinger_Fixed_Logderiv1+0x9e6>
jmp    1bd4 <paw_R_Schrodinger_Fixed_Logderiv1+0xa24>
lea    0x17c(%rip),%rdi
mov    $0x3e8,%esi
movapd %xmm5,0x40(%rsp)
call   1040 <printf@plt>
movapd 0x40(%rsp),%xmm11
xor    %ebx,%ebx
jmp    1ef4 <paw_R_Schrodinger_Fixed_Logderiv1+0xd44>
mov    $0x1,%ebx
mov    0xc0(%rsp),%rax
movsd  %xmm11,(%rax)
mov    %r15,%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    %r13,%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    %ebx,%eax
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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_Logderiv1(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, %527
%131 = phi i32 [ 0, %8 ], [ %135, %527 ]
%132 = phi double [ %9, %8 ], [ %537, %527 ]
%133 = phi double [ %25, %8 ], [ %530, %527 ]
%134 = phi double [ %26, %8 ], [ %529, %527 ]
%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 %293
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 [ %250, %246 ], [ 3, %192 ]
%248 = trunc i64 %247 to i32
%249 = tail call double @paw_Predictor_Out(i32 %248, double* %6, double* %7)
%250 = add nuw nsw i64 %247, 1
%251 = getelementptr inbounds double, double* %6, i64 %250
store double %249, double* %251
%252 = tail call double @paw_Predictor_Out(i32 %248, double* %7, double* %24)
%253 = getelementptr inbounds double, double* %7, i64 %250
store double %252, double* %253
%254 = getelementptr inbounds double, double* %21, i64 %250
%255 = getelementptr inbounds double, double* %24, i64 %250
%256 = load double, double* %254
%257 = load double, double* %251
%258 = fmul double %256, %257
%259 = tail call double @llvm.fmuladd.f64(double %15, double %252, double %258)
store double %259, double* %255
%260 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %260, double* %253
%261 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %261, double* %251
%262 = load double, double* %253
%263 = load double, double* %254
%264 = fmul double %263, %261
%265 = tail call double @llvm.fmuladd.f64(double %15, double %262, double %264)
store double %265, double* %255
%266 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %266, double* %253
%267 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %267, double* %251
%268 = load double, double* %253
%269 = load double, double* %254
%270 = fmul double %269, %267
%271 = tail call double @llvm.fmuladd.f64(double %15, double %268, double %270)
store double %271, double* %255
%272 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %272, double* %253
%273 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %273, double* %251
%274 = load double, double* %253
%275 = load double, double* %254
%276 = fmul double %275, %273
%277 = tail call double @llvm.fmuladd.f64(double %15, double %274, double %276)
store double %277, double* %255
%278 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %278, double* %253
%279 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %279, double* %251
%280 = load double, double* %253
%281 = load double, double* %254
%282 = fmul double %281, %279
%283 = tail call double @llvm.fmuladd.f64(double %15, double %280, double %282)
store double %283, double* %255
%284 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %284, double* %253
%285 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %285, double* %251
%286 = load double, double* %253
%287 = load double, double* %254
%288 = fmul double %287, %285
%289 = tail call double @llvm.fmuladd.f64(double %15, double %286, double %288)
store double %289, double* %255
%290 = tail call double @paw_Corrector_Out(i32 %248, double* %7, double* %24)
store double %290, double* %253
%291 = tail call double @paw_Corrector_Out(i32 %248, double* %6, double* %7)
store double %291, double* %251
%292 = icmp eq i64 %250, %54
br i1 %292, label %293, label %246
293: ; preds = %246, %192
%294 = load double, double* %31
%295 = load double, double* %32
%296 = fmul double %294, %4
%297 = tail call double @paw_Norm_LogGrid(i32 %3, double %11, double* %6)
%298 = tail call double @sqrt(double %297)
%299 = fdiv double 1.000000e+00, %298
%300 = fmul double %294, %299
%301 = fmul double %295, %299
%302 = fmul double %296, %299
br i1 %33, label %395, label %303
303: ; preds = %293
%304 = or i1 %106, %109
br i1 %304, label %381, label %305
305: ; preds = %303
%306 = insertelement <2 x double> poison, double %299, i64 0
%307 = shufflevector <2 x double> %306, <2 x double> poison, <2 x i32> zeroinitializer
%308 = insertelement <2 x double> poison, double %299, i64 0
%309 = shufflevector <2 x double> %308, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %112, label %357, label %310
310: ; preds = %305, %310
%311 = phi i64 [ %354, %310 ], [ 0, %305 ]
%312 = phi i64 [ %355, %310 ], [ 0, %305 ]
%313 = getelementptr inbounds double, double* %6, i64 %311
%314 = bitcast double* %313 to <2 x double>*
%315 = load <2 x double>, <2 x double>* %314
%316 = getelementptr inbounds double, double* %313, i64 2
%317 = bitcast double* %316 to <2 x double>*
%318 = load <2 x double>, <2 x double>* %317
%319 = fmul <2 x double> %307, %315
%320 = fmul <2 x double> %309, %318
%321 = bitcast double* %313 to <2 x double>*
store <2 x double> %319, <2 x double>* %321
%322 = bitcast double* %316 to <2 x double>*
store <2 x double> %320, <2 x double>* %322
%323 = getelementptr inbounds double, double* %7, i64 %311
%324 = bitcast double* %323 to <2 x double>*
%325 = load <2 x double>, <2 x double>* %324
%326 = getelementptr inbounds double, double* %323, i64 2
%327 = bitcast double* %326 to <2 x double>*
%328 = load <2 x double>, <2 x double>* %327
%329 = fmul <2 x double> %307, %325
%330 = fmul <2 x double> %309, %328
%331 = bitcast double* %323 to <2 x double>*
store <2 x double> %329, <2 x double>* %331
%332 = bitcast double* %326 to <2 x double>*
store <2 x double> %330, <2 x double>* %332
%333 = or i64 %311, 4
%334 = getelementptr inbounds double, double* %6, i64 %333
%335 = bitcast double* %334 to <2 x double>*
%336 = load <2 x double>, <2 x double>* %335
%337 = getelementptr inbounds double, double* %334, i64 2
%338 = bitcast double* %337 to <2 x double>*
%339 = load <2 x double>, <2 x double>* %338
%340 = fmul <2 x double> %307, %336
%341 = fmul <2 x double> %309, %339
%342 = bitcast double* %334 to <2 x double>*
store <2 x double> %340, <2 x double>* %342
%343 = bitcast double* %337 to <2 x double>*
store <2 x double> %341, <2 x double>* %343
%344 = getelementptr inbounds double, double* %7, i64 %333
%345 = bitcast double* %344 to <2 x double>*
%346 = load <2 x double>, <2 x double>* %345
%347 = getelementptr inbounds double, double* %344, i64 2
%348 = bitcast double* %347 to <2 x double>*
%349 = load <2 x double>, <2 x double>* %348
%350 = fmul <2 x double> %307, %346
%351 = fmul <2 x double> %309, %349
%352 = bitcast double* %344 to <2 x double>*
store <2 x double> %350, <2 x double>* %352
%353 = bitcast double* %347 to <2 x double>*
store <2 x double> %351, <2 x double>* %353
%354 = add nuw i64 %311, 8
%355 = add i64 %312, 2
%356 = icmp eq i64 %355, %113
br i1 %356, label %357, label %310
357: ; preds = %310, %305
%358 = phi i64 [ 0, %305 ], [ %354, %310 ]
br i1 %114, label %380, label %359
359: ; preds = %357
%360 = getelementptr inbounds double, double* %6, i64 %358
%361 = bitcast double* %360 to <2 x double>*
%362 = load <2 x double>, <2 x double>* %361
%363 = getelementptr inbounds double, double* %360, i64 2
%364 = bitcast double* %363 to <2 x double>*
%365 = load <2 x double>, <2 x double>* %364
%366 = fmul <2 x double> %307, %362
%367 = fmul <2 x double> %309, %365
%368 = bitcast double* %360 to <2 x double>*
store <2 x double> %366, <2 x double>* %368
%369 = bitcast double* %363 to <2 x double>*
store <2 x double> %367, <2 x double>* %369
%370 = getelementptr inbounds double, double* %7, i64 %358
%371 = bitcast double* %370 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = getelementptr inbounds double, double* %370, i64 2
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = fmul <2 x double> %307, %372
%377 = fmul <2 x double> %309, %375
%378 = bitcast double* %370 to <2 x double>*
store <2 x double> %376, <2 x double>* %378
%379 = bitcast double* %373 to <2 x double>*
store <2 x double> %377, <2 x double>* %379
br label %380
380: ; preds = %357, %359
br i1 %115, label %395, label %381
381: ; preds = %303, %380
%382 = phi i64 [ 0, %303 ], [ %110, %380 ]
%383 = xor i64 %382, -1
br i1 %117, label %392, label %384
384: ; preds = %381
%385 = getelementptr inbounds double, double* %6, i64 %382
%386 = load double, double* %385
%387 = fmul double %299, %386
store double %387, double* %385
%388 = getelementptr inbounds double, double* %7, i64 %382
%389 = load double, double* %388
%390 = fmul double %299, %389
store double %390, double* %388
%391 = or i64 %382, 1
br label %392
392: ; preds = %384, %381
%393 = phi i64 [ %382, %381 ], [ %391, %384 ]
%394 = icmp eq i64 %383, %118
br i1 %394, label %395, label %481
395: ; preds = %392, %481, %380, %293
br i1 %35, label %396, label %514
396: ; preds = %395
%397 = select i1 %119, i1 true, i1 %122
br i1 %397, label %462, label %398
398: ; preds = %396
br i1 %126, label %444, label %399
399: ; preds = %398, %399
%400 = phi i64 [ %441, %399 ], [ 0, %398 ]
%401 = phi i64 [ %442, %399 ], [ 0, %398 ]
%402 = add i64 %400, %37
%403 = getelementptr inbounds double, double* %6, i64 %402
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %404
%405 = getelementptr inbounds double, double* %403, i64 2
%406 = bitcast double* %405 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %406
%407 = getelementptr inbounds double, double* %7, i64 %402
%408 = bitcast double* %407 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %408
%409 = getelementptr inbounds double, double* %407, i64 2
%410 = bitcast double* %409 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %410
%411 = or i64 %400, 4
%412 = add i64 %411, %37
%413 = getelementptr inbounds double, double* %6, i64 %412
%414 = bitcast double* %413 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %414
%415 = getelementptr inbounds double, double* %413, i64 2
%416 = bitcast double* %415 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %416
%417 = getelementptr inbounds double, double* %7, i64 %412
%418 = bitcast double* %417 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %418
%419 = getelementptr inbounds double, double* %417, i64 2
%420 = bitcast double* %419 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %420
%421 = or i64 %400, 8
%422 = add i64 %421, %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 %400, 12
%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 = add nuw i64 %400, 16
%442 = add nuw i64 %401, 4
%443 = icmp eq i64 %442, %127
br i1 %443, label %444, label %399
444: ; preds = %399, %398
%445 = phi i64 [ 0, %398 ], [ %441, %399 ]
br i1 %128, label %461, label %446
446: ; preds = %444, %446
%447 = phi i64 [ %458, %446 ], [ %445, %444 ]
%448 = phi i64 [ %459, %446 ], [ 0, %444 ]
%449 = add i64 %447, %37
%450 = getelementptr inbounds double, double* %6, i64 %449
%451 = bitcast double* %450 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %451
%452 = getelementptr inbounds double, double* %450, i64 2
%453 = bitcast double* %452 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %453
%454 = getelementptr inbounds double, double* %7, i64 %449
%455 = bitcast double* %454 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %455
%456 = getelementptr inbounds double, double* %454, i64 2
%457 = bitcast double* %456 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %457
%458 = add nuw i64 %447, 4
%459 = add i64 %448, 1
%460 = icmp eq i64 %459, %125
br i1 %460, label %461, label %446
461: ; preds = %446, %444
br i1 %129, label %514, label %462
462: ; preds = %396, %461
%463 = phi i64 [ %37, %396 ], [ %124, %461 ]
%464 = trunc i64 %463 to i32
%465 = sub i32 %14, %464
%466 = xor i32 %464, -1
%467 = add i32 %14, %466
%468 = and i32 %465, 3
%469 = icmp eq i32 %468, 0
br i1 %469, label %478, label %470
470: ; preds = %462, %470
%471 = phi i64 [ %475, %470 ], [ %463, %462 ]
%472 = phi i32 [ %476, %470 ], [ 0, %462 ]
%473 = getelementptr inbounds double, double* %6, i64 %471
store double 0.000000e+00, double* %473
%474 = getelementptr inbounds double, double* %7, i64 %471
store double 0.000000e+00, double* %474
%475 = add nsw i64 %471, 1
%476 = add i32 %472, 1
%477 = icmp eq i32 %476, %468
br i1 %477, label %478, label %470
478: ; preds = %470, %462
%479 = phi i64 [ %463, %462 ], [ %475, %470 ]
%480 = icmp ult i32 %467, 3
br i1 %480, label %514, label %498
481: ; preds = %392, %481
%482 = phi i64 [ %496, %481 ], [ %393, %392 ]
%483 = getelementptr inbounds double, double* %6, i64 %482
%484 = load double, double* %483
%485 = fmul double %299, %484
store double %485, double* %483
%486 = getelementptr inbounds double, double* %7, i64 %482
%487 = load double, double* %486
%488 = fmul double %299, %487
store double %488, double* %486
%489 = add nuw nsw i64 %482, 1
%490 = getelementptr inbounds double, double* %6, i64 %489
%491 = load double, double* %490
%492 = fmul double %299, %491
store double %492, double* %490
%493 = getelementptr inbounds double, double* %7, i64 %489
%494 = load double, double* %493
%495 = fmul double %299, %494
store double %495, double* %493
%496 = add nuw nsw i64 %482, 2
%497 = icmp eq i64 %496, %55
br i1 %497, label %395, label %481
498: ; preds = %478, %498
%499 = phi i64 [ %511, %498 ], [ %479, %478 ]
%500 = getelementptr inbounds double, double* %6, i64 %499
store double 0.000000e+00, double* %500
%501 = getelementptr inbounds double, double* %7, i64 %499
store double 0.000000e+00, double* %501
%502 = add nsw i64 %499, 1
%503 = getelementptr inbounds double, double* %6, i64 %502
store double 0.000000e+00, double* %503
%504 = getelementptr inbounds double, double* %7, i64 %502
store double 0.000000e+00, double* %504
%505 = add nsw i64 %499, 2
%506 = getelementptr inbounds double, double* %6, i64 %505
store double 0.000000e+00, double* %506
%507 = getelementptr inbounds double, double* %7, i64 %505
store double 0.000000e+00, double* %507
%508 = add nsw i64 %499, 3
%509 = getelementptr inbounds double, double* %6, i64 %508
store double 0.000000e+00, double* %509
%510 = getelementptr inbounds double, double* %7, i64 %508
store double 0.000000e+00, double* %510
%511 = add nsw i64 %499, 4
%512 = trunc i64 %511 to i32
%513 = icmp eq i32 %14, %512
br i1 %513, label %514, label %498
514: ; preds = %478, %498, %461, %395
%515 = fmul double %300, 5.000000e-01
%516 = fsub double %301, %302
%517 = fmul double %515, %516
%518 = load double, double* %36
%519 = fmul double %15, %518
%520 = fdiv double %517, %519
%521 = tail call double @llvm.fabs.f64(double %520)
%522 = tail call double @llvm.fabs.f64(double %132)
%523 = fcmp ogt double %522, 2.000000e-01
%524 = select i1 %523, double %522, double 2.000000e-01
%525 = fmul double %524, 1.000000e-10
%526 = fcmp olt double %521, %525
br i1 %526, label %541, label %527
527: ; preds = %514
%528 = fcmp ogt double %520, 0.000000e+00
%529 = select i1 %528, double %132, double %134
%530 = select i1 %528, double %133, double %132
%531 = fadd double %132, %520
%532 = fcmp ogt double %531, %530
%533 = fcmp olt double %531, %529
%534 = select i1 %532, i1 true, i1 %533
%535 = fadd double %529, %530
%536 = fmul double %535, 5.000000e-01
%537 = select i1 %534, double %536, double %531
%538 = icmp eq i32 %135, 1000
br i1 %538, label %539, label %130
539: ; preds = %527
%540 = tail call i32 @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 1000)
br label %541
541: ; preds = %514, %539
%542 = phi double [ %537, %539 ], [ %132, %514 ]
%543 = phi i32 [ 0, %539 ], [ 1, %514 ]
store double %542, double* %5
%544 = tail call i32 @paw_dealloc_LogGrid(double* %24)
%545 = tail call i32 @paw_dealloc_LogGrid(double* %21)
ret i32 %543
}