#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 */
int /*<<< orphan*/ exit(int);
double fabs(double);
double paw_Corrector_Out(int, double *, double *);
int paw_N_LogGrid();
double paw_Predictor_Out(int, double *, double *);
double *paw_alloc_LogGrid();
int /*<<< orphan*/ paw_dealloc_LogGrid(double *);
double paw_log_amesh_LogGrid();
double *paw_r_LogGrid();
double pow(double, double);
int /*<<< orphan*/ printf(char *);
int paw_R_Schrodinger_Fixed_E(int l, double *v, int match, double E, double *u,
                              double *uprime) {
  int i, j, Ngrid;
  double log_amesh, log_amesh2, gamma, L2, r2, *r, *f_upp, *upp;
  double max_u;
  max_u = 100000000;
  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;
  if (match > Ngrid - 1) {
    printf("match point is outside the allowed region\n");
    printf("abborting the program\n");
    exit(1);
  }
  r = paw_r_LogGrid();
  f_upp = paw_alloc_LogGrid();
  upp = paw_alloc_LogGrid();
  for (i = 0; i <= match; i++) {
    u[i] = 0.0;
    uprime[i] = 0.0;
  }
  for (i = 0; i < match + 1; ++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];
  }
  i = 3;
  while (i < match && fabs(u[i]) < max_u) {
    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);
    }
    i = i + 1;
  }
  paw_dealloc_LogGrid(upp);
  paw_dealloc_LogGrid(f_upp);
  return 1;
}


x86 assembly (clang, -O0):
<paw_R_Schrodinger_Fixed_E>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movsd  0xe36(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    $0x0,%al
call   1050 <paw_N_LogGrid@plt>
mov    %eax,-0x3c(%rbp)
mov    $0x0,%al
call   1060 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    124e <paw_R_Schrodinger_Fixed_E+0xae>
lea    0xded(%rip),%rdi
call   1040 <printf@plt>
lea    0xe0c(%rip),%rdi
call   1040 <printf@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>
mov    $0x0,%al
call   1070 <paw_r_LogGrid@plt>
mov    %rax,-0x70(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0x78(%rbp)
mov    $0x0,%al
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12b0 <paw_R_Schrodinger_Fixed_E+0x110>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1276 <paw_R_Schrodinger_Fixed_E+0xd6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    133b <paw_R_Schrodinger_Fixed_E+0x19b>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x20(%rbp),%xmm3
movsd  0xcfd(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b7 <paw_R_Schrodinger_Fixed_E+0x117>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    13e3 <paw_R_Schrodinger_Fixed_E+0x243>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm1
call   10a0 <pow@plt>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1342 <paw_R_Schrodinger_Fixed_E+0x1a2>
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x89(%rbp)
jge    142b <paw_R_Schrodinger_Fixed_E+0x28b>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xbfe(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
test   $0x1,%al
jne    143e <paw_R_Schrodinger_Fixed_E+0x29e>
jmp    1548 <paw_R_Schrodinger_Fixed_E+0x3a8>
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1080 <paw_Predictor_Out@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x80(%rbp),%rdx
call   1080 <paw_Predictor_Out@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    153a <paw_R_Schrodinger_Fixed_E+0x39a>
movsd  -0x48(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x80(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <paw_Corrector_Out@plt>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1489 <paw_R_Schrodinger_Fixed_E+0x2e9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ea <paw_R_Schrodinger_Fixed_E+0x24a>
mov    -0x80(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    -0x78(%rbp),%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    $0x1,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_R_Schrodinger_Fixed_E>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%rbx
mov    %rcx,%r14
movaps %xmm0,0x20(%rsp)
mov    %edx,%r13d
mov    %rsi,0x40(%rsp)
mov    %edi,%ebp
xor    %eax,%eax
call   1050 <paw_N_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1060 <paw_log_amesh_LogGrid@plt>
movsd  %xmm0,0x8(%rsp)
cmp    %r13d,%r15d
jle    18e6 <paw_R_Schrodinger_Fixed_E+0x746>
mov    %rbp,0x38(%rsp)
lea    0x1(%rbp),%eax
mov    %eax,0x1c(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1070 <paw_r_LogGrid@plt>
mov    %rax,%rbp
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,%r15
xor    %eax,%eax
call   1090 <paw_alloc_LogGrid@plt>
mov    %rax,%r12
test   %r13d,%r13d
movapd 0x20(%rsp),%xmm9
mov    0x40(%rsp),%rax
js     15a1 <paw_R_Schrodinger_Fixed_E+0x401>
lea    0x1(%r13),%r9d
cmp    $0x3,%r13d
jb     1253 <paw_R_Schrodinger_Fixed_E+0xb3>
lea    (%rbx,%r9,8),%rcx
cmp    %r14,%rcx
jbe    12f4 <paw_R_Schrodinger_Fixed_E+0x154>
lea    (%r14,%r9,8),%rcx
cmp    %rbx,%rcx
jbe    12f4 <paw_R_Schrodinger_Fixed_E+0x154>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     128a <paw_R_Schrodinger_Fixed_E+0xea>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%r14,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1270 <paw_R_Schrodinger_Fixed_E+0xd0>
cmp    $0x3,%rdx
jb     13e8 <paw_R_Schrodinger_Fixed_E+0x248>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r14,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
movq   $0x0,0x8(%r14,%rcx,8)
movq   $0x0,0x8(%rbx,%rcx,8)
movq   $0x0,0x10(%r14,%rcx,8)
movq   $0x0,0x10(%rbx,%rcx,8)
movq   $0x0,0x18(%r14,%rcx,8)
movq   $0x0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    12a0 <paw_R_Schrodinger_Fixed_E+0x100>
jmp    13e8 <paw_R_Schrodinger_Fixed_E+0x248>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdx
jae    131d <paw_R_Schrodinger_Fixed_E+0x17d>
xor    %edi,%edi
jmp    13a0 <paw_R_Schrodinger_Fixed_E+0x200>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,(%r14,%rdi,8)
movupd %xmm0,0x10(%r14,%rdi,8)
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm0,0x10(%rbx,%rdi,8)
movupd %xmm0,0x20(%r14,%rdi,8)
movupd %xmm0,0x30(%r14,%rdi,8)
movupd %xmm0,0x20(%rbx,%rdi,8)
movupd %xmm0,0x30(%rbx,%rdi,8)
movupd %xmm0,0x40(%r14,%rdi,8)
movupd %xmm0,0x50(%r14,%rdi,8)
movupd %xmm0,0x40(%rbx,%rdi,8)
movupd %xmm0,0x50(%rbx,%rdi,8)
movupd %xmm0,0x60(%r14,%rdi,8)
movupd %xmm0,0x70(%r14,%rdi,8)
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm0,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1330 <paw_R_Schrodinger_Fixed_E+0x190>
test   %r8,%r8
je     13df <paw_R_Schrodinger_Fixed_E+0x23f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
xorpd  %xmm0,%xmm0
nop
movupd %xmm0,-0x10(%rdi,%rdx,1)
movupd %xmm0,(%rdi,%rdx,1)
movupd %xmm0,-0x10(%rsi,%rdx,1)
movupd %xmm0,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    13c0 <paw_R_Schrodinger_Fixed_E+0x220>
cmp    %r9,%rcx
jne    1255 <paw_R_Schrodinger_Fixed_E+0xb5>
test   %r13d,%r13d
js     15a1 <paw_R_Schrodinger_Fixed_E+0x401>
mov    0x1c(%rsp),%ecx
imul   0x38(%rsp),%ecx
cvtsi2sd %ecx,%xmm8
movsd  0x8(%rsp),%xmm1
mulsd  %xmm1,%xmm1
cmp    $0x3,%r13d
jae    1416 <paw_R_Schrodinger_Fixed_E+0x276>
xor    %ecx,%ecx
jmp    14f6 <paw_R_Schrodinger_Fixed_E+0x356>
lea    (%r15,%r9,8),%rcx
lea    0x0(,%r9,8),%rdx
add    %rbp,%rdx
lea    (%rax,%r9,8),%rsi
cmp    %rdx,%r15
setb   %dil
cmp    %rcx,%rbp
setb   %r8b
cmp    %rsi,%r15
setb   %dl
cmp    %rax,%rcx
seta   %sil
xor    %ecx,%ecx
test   %r8b,%dil
jne    14f6 <paw_R_Schrodinger_Fixed_E+0x356>
and    %sil,%dl
jne    14f6 <paw_R_Schrodinger_Fixed_E+0x356>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
lea    0x0(,%r9,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rsi,1),%xmm5
movupd 0x10(%rbp,%rsi,1),%xmm6
mulpd  %xmm5,%xmm5
mulpd  %xmm6,%xmm6
movupd (%rax,%rsi,1),%xmm7
movupd 0x10(%rax,%rsi,1),%xmm0
subpd  %xmm2,%xmm7
subpd  %xmm2,%xmm0
addpd  %xmm7,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm0,%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm3,%xmm7
addpd  %xmm3,%xmm0
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm0
movupd %xmm7,(%r15,%rsi,1)
movupd %xmm0,0x10(%r15,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1490 <paw_R_Schrodinger_Fixed_E+0x2f0>
cmp    %r9,%rcx
je     15a1 <paw_R_Schrodinger_Fixed_E+0x401>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r9b
je     1531 <paw_R_Schrodinger_Fixed_E+0x391>
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%rax,%rcx,8),%xmm2
subsd  %xmm9,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
or     $0x1,%rcx
add    %r9,%rdx
je     15a1 <paw_R_Schrodinger_Fixed_E+0x401>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%rax,%rcx,8),%xmm2
subsd  %xmm9,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%rax,%rcx,8),%xmm2
subsd  %xmm9,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r15,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1540 <paw_R_Schrodinger_Fixed_E+0x3a0>
movsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x0(%rbp),%xmm0
call   10a0 <pow@plt>
movsd  %xmm0,(%r14)
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%r15),%xmm1
mulsd  (%r14),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12)
movsd  0x8(%rbp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x8(%r14)
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%r15),%xmm1
mulsd  0x8(%r14),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12)
movsd  0x10(%rbp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x10(%r14)
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r15),%xmm1
mulsd  0x10(%r14),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r12)
movsd  0x18(%rbp),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x18(%r14)
movsd  0x20(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx)
movsd  0x18(%r15),%xmm0
mulsd  0x18(%r14),%xmm0
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r12)
cmp    $0x3,%r13d
jle    18c2 <paw_R_Schrodinger_Fixed_E+0x722>
mov    %r13d,%eax
mov    %rax,0x10(%rsp)
movsd  0x18(%r14),%xmm0
mov    $0x3,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
andpd  0x928(%rip),%xmm0
movsd  0x930(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    18c2 <paw_R_Schrodinger_Fixed_E+0x722>
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1080 <paw_Predictor_Out@plt>
lea    0x1(%rbp),%r13
movsd  %xmm0,0x8(%r14,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1080 <paw_Predictor_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm1
mulsd  0x8(%r14,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
mulsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1030 <paw_Corrector_Out@plt>
movsd  %xmm0,0x8(%r14,%rbp,8)
mov    %r13,%rbp
cmp    %r13,0x10(%rsp)
jne    16d0 <paw_R_Schrodinger_Fixed_E+0x530>
mov    %r12,%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    %r15,%rdi
call   10b0 <paw_dealloc_LogGrid@plt>
mov    $0x1,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x72b(%rip),%rdi
call   1040 <puts@plt>
lea    0x749(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>

LLVM IR (-O0):
@.str = [43 x i8] c"match point is outside the allowed region\0A\00"
@.str.1 = [23 x i8] c"abborting the program\0A\00"
define i32 @paw_R_Schrodinger_Fixed_E(i32 %0, double* %1, i32 %2, double %3, double* %4, double* %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32
%10 = alloca double
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double
store i32 %0, i32* %7
store double* %1, double** %8
store i32 %2, i32* %9
store double %3, double* %10
store double* %4, double** %11
store double* %5, double** %12
store double 1.000000e+08, double* %24
%25 = load i32, i32* %7
%26 = add nsw i32 %25, 1
%27 = sitofp i32 %26 to double
store double %27, double* %18
%28 = load i32, i32* %7
%29 = load i32, i32* %7
%30 = add nsw i32 %29, 1
%31 = mul nsw i32 %28, %30
%32 = sitofp i32 %31 to double
store double %32, double* %19
%33 = call i32 (...) @paw_N_LogGrid()
store i32 %33, i32* %15
%34 = call double (...) @paw_log_amesh_LogGrid()
store double %34, double* %16
%35 = load double, double* %16
%36 = load double, double* %16
%37 = fmul double %35, %36
store double %37, double* %17
%38 = load i32, i32* %9
%39 = load i32, i32* %15
%40 = sub nsw i32 %39, 1
%41 = icmp sgt i32 %38, %40
br i1 %41, label %42, label %46
42: ; preds = %6
%43 = call i32 @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str, i64 0, i64 0))
%44 = call i32 @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
%45 = call i32 @exit(i32 1)
unreachable
46: ; preds = %6
%47 = call double* (...) @paw_r_LogGrid()
store double* %47, double** %21
%48 = call double* (...) @paw_alloc_LogGrid()
store double* %48, double** %22
%49 = call double* (...) @paw_alloc_LogGrid()
store double* %49, double** %23
store i32 0, i32* %13
br label %50
50: ; preds = %63, %46
%51 = load i32, i32* %13
%52 = load i32, i32* %9
%53 = icmp sle i32 %51, %52
br i1 %53, label %54, label %66
54: ; preds = %50
%55 = load double*, double** %11
%56 = load i32, i32* %13
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
store double 0.000000e+00, double* %58
%59 = load double*, double** %12
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
store double 0.000000e+00, double* %62
br label %63
63: ; preds = %54
%64 = load i32, i32* %13
%65 = add nsw i32 %64, 1
store i32 %65, i32* %13
br label %50
66: ; preds = %50
store i32 0, i32* %13
br label %67
67: ; preds = %101, %66
%68 = load i32, i32* %13
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
%71 = icmp slt i32 %68, %70
br i1 %71, label %72, label %104
72: ; preds = %67
%73 = load double*, double** %21
%74 = load i32, i32* %13
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %73, i64 %75
%77 = load double, double* %76
%78 = load double*, double** %21
%79 = load i32, i32* %13
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
%82 = load double, double* %81
%83 = fmul double %77, %82
store double %83, double* %20
%84 = load double, double* %17
%85 = load double, double* %19
%86 = load double*, double** %8
%87 = load i32, i32* %13
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
%90 = load double, double* %89
%91 = load double, double* %10
%92 = fsub double %90, %91
%93 = fmul double 2.000000e+00, %92
%94 = load double, double* %20
%95 = call double @llvm.fmuladd.f64(double %93, double %94, double %85)
%96 = fmul double %84, %95
%97 = load double*, double** %22
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %97, i64 %99
store double %96, double* %100
br label %101
101: ; preds = %72
%102 = load i32, i32* %13
%103 = add nsw i32 %102, 1
store i32 %103, i32* %13
br label %67
104: ; preds = %67
store i32 0, i32* %13
br label %105
105: ; preds = %155, %104
%106 = load i32, i32* %13
%107 = icmp slt i32 %106, 4
br i1 %107, label %108, label %158
108: ; preds = %105
%109 = load double*, double** %21
%110 = load i32, i32* %13
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %109, i64 %111
%113 = load double, double* %112
%114 = load double, double* %18
%115 = call double @pow(double %113, double %114)
%116 = load double*, double** %11
%117 = load i32, i32* %13
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
store double %115, double* %119
%120 = load double, double* %16
%121 = load double, double* %18
%122 = fmul double %120, %121
%123 = load double*, double** %11
%124 = load i32, i32* %13
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
%127 = load double, double* %126
%128 = fmul double %122, %127
%129 = load double*, double** %12
%130 = load i32, i32* %13
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
store double %128, double* %132
%133 = load double, double* %16
%134 = load double*, double** %12
%135 = load i32, i32* %13
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
%138 = load double, double* %137
%139 = load double*, double** %22
%140 = load i32, i32* %13
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
%143 = load double, double* %142
%144 = load double*, double** %11
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %144, i64 %146
%148 = load double, double* %147
%149 = fmul double %143, %148
%150 = call double @llvm.fmuladd.f64(double %133, double %138, double %149)
%151 = load double*, double** %23
%152 = load i32, i32* %13
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
store double %150, double* %154
br label %155
155: ; preds = %108
%156 = load i32, i32* %13
%157 = add nsw i32 %156, 1
store i32 %157, i32* %13
br label %105
158: ; preds = %105
store i32 3, i32* %13
br label %159
159: ; preds = %244, %158
%160 = load i32, i32* %13
%161 = load i32, i32* %9
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %172
163: ; preds = %159
%164 = load double*, double** %11
%165 = load i32, i32* %13
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds double, double* %164, i64 %166
%168 = load double, double* %167
%169 = call double @llvm.fabs.f64(double %168)
%170 = load double, double* %24
%171 = fcmp olt double %169, %170
br label %172
172: ; preds = %163, %159
%173 = phi i1 [ false, %159 ], [ %171, %163 ]
br i1 %173, label %174, label %247
174: ; preds = %172
%175 = load i32, i32* %13
%176 = load double*, double** %11
%177 = load double*, double** %12
%178 = call double @paw_Predictor_Out(i32 %175, double* %176, double* %177)
%179 = load double*, double** %11
%180 = load i32, i32* %13
%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
%184 = load i32, i32* %13
%185 = load double*, double** %12
%186 = load double*, double** %23
%187 = call double @paw_Predictor_Out(i32 %184, double* %185, double* %186)
%188 = load double*, double** %12
%189 = load i32, i32* %13
%190 = add nsw i32 %189, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %188, i64 %191
store double %187, double* %192
store i32 0, i32* %14
br label %193
193: ; preds = %241, %174
%194 = load i32, i32* %14
%195 = icmp slt i32 %194, 6
br i1 %195, label %196, label %244
196: ; preds = %193
%197 = load double, double* %16
%198 = load double*, double** %12
%199 = load i32, i32* %13
%200 = add nsw i32 %199, 1
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %198, i64 %201
%203 = load double, double* %202
%204 = load double*, double** %22
%205 = load i32, i32* %13
%206 = add nsw i32 %205, 1
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %204, i64 %207
%209 = load double, double* %208
%210 = load double*, double** %11
%211 = load i32, i32* %13
%212 = add nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %210, i64 %213
%215 = load double, double* %214
%216 = fmul double %209, %215
%217 = call double @llvm.fmuladd.f64(double %197, double %203, double %216)
%218 = load double*, double** %23
%219 = load i32, i32* %13
%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* %13
%224 = load double*, double** %12
%225 = load double*, double** %23
%226 = call double @paw_Corrector_Out(i32 %223, double* %224, double* %225)
%227 = load double*, double** %12
%228 = load i32, i32* %13
%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
%232 = load i32, i32* %13
%233 = load double*, double** %11
%234 = load double*, double** %12
%235 = call double @paw_Corrector_Out(i32 %232, double* %233, double* %234)
%236 = load double*, double** %11
%237 = load i32, i32* %13
%238 = add nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %236, i64 %239
store double %235, double* %240
br label %241
241: ; preds = %196
%242 = load i32, i32* %14
%243 = add nsw i32 %242, 1
store i32 %243, i32* %14
br label %193
244: ; preds = %193
%245 = load i32, i32* %13
%246 = add nsw i32 %245, 1
store i32 %246, i32* %13
br label %159
247: ; preds = %172
%248 = load double*, double** %23
%249 = call i32 @paw_dealloc_LogGrid(double* %248)
%250 = load double*, double** %22
%251 = call i32 @paw_dealloc_LogGrid(double* %250)
ret i32 1
}

LLVM IR (-O2):
@str = [42 x i8] c"match point is outside the allowed region\00"
@str.2 = [22 x i8] c"abborting the program\00"
define i32 @paw_R_Schrodinger_Fixed_E(i32 %0, double* nocapture %1, i32 %2, double %3, double* %4, double* %5) {
%7 = add nsw i32 %0, 1
%8 = sitofp i32 %7 to double
%9 = mul nsw i32 %7, %0
%10 = sitofp i32 %9 to double
%11 = tail call i32 (...) @paw_N_LogGrid()
%12 = tail call double (...) @paw_log_amesh_LogGrid()
%13 = fmul double %12, %12
%14 = icmp sgt i32 %11, %2
br i1 %14, label %19, label %15
15: ; preds = %6
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.2, i64 0, i64 0))
%18 = tail call i32 @exit(i32 1)
unreachable
19: ; preds = %6
%20 = tail call double* (...) @paw_r_LogGrid()
%21 = tail call double* (...) @paw_alloc_LogGrid()
%22 = tail call double* (...) @paw_alloc_LogGrid()
%23 = icmp slt i32 %2, 0
br i1 %23, label %218, label %24
24: ; preds = %19
%25 = add nuw nsw i32 %2, 1
%26 = zext i32 %25 to i64
%27 = icmp ult i32 %2, 3
br i1 %27, label %103, label %28
28: ; preds = %24
%29 = getelementptr double, double* %4, i64 %26
%30 = getelementptr double, double* %5, i64 %26
%31 = icmp ugt double* %30, %4
%32 = icmp ugt double* %29, %5
%33 = and i1 %31, %32
br i1 %33, label %103, label %34
34: ; preds = %28
%35 = and i64 %26, 4294967292
%36 = add nsw i64 %35, -4
%37 = lshr exact i64 %36, 2
%38 = add nuw nsw i64 %37, 1
%39 = and i64 %38, 3
%40 = icmp ult i64 %36, 12
br i1 %40, label %84, label %41
41: ; preds = %34
%42 = and i64 %38, 9223372036854775804
br label %43
43: ; preds = %43, %41
%44 = phi i64 [ 0, %41 ], [ %81, %43 ]
%45 = phi i64 [ 0, %41 ], [ %82, %43 ]
%46 = getelementptr inbounds double, double* %4, i64 %44
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %47
%48 = getelementptr inbounds double, double* %46, i64 2
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %49
%50 = getelementptr inbounds double, double* %5, i64 %44
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %51
%52 = getelementptr inbounds double, double* %50, i64 2
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %53
%54 = or i64 %44, 4
%55 = getelementptr inbounds double, double* %4, i64 %54
%56 = bitcast double* %55 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %56
%57 = getelementptr inbounds double, double* %55, i64 2
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %58
%59 = getelementptr inbounds double, double* %5, i64 %54
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %60
%61 = getelementptr inbounds double, double* %59, i64 2
%62 = bitcast double* %61 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %62
%63 = or i64 %44, 8
%64 = getelementptr inbounds double, double* %4, i64 %63
%65 = bitcast double* %64 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %65
%66 = getelementptr inbounds double, double* %64, i64 2
%67 = bitcast double* %66 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %67
%68 = getelementptr inbounds double, double* %5, i64 %63
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %69
%70 = getelementptr inbounds double, double* %68, i64 2
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %71
%72 = or i64 %44, 12
%73 = getelementptr inbounds double, double* %4, i64 %72
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %74
%75 = getelementptr inbounds double, double* %73, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %76
%77 = getelementptr inbounds double, double* %5, i64 %72
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %78
%79 = getelementptr inbounds double, double* %77, i64 2
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %80
%81 = add nuw i64 %44, 16
%82 = add nuw i64 %45, 4
%83 = icmp eq i64 %82, %42
br i1 %83, label %84, label %43
84: ; preds = %43, %34
%85 = phi i64 [ 0, %34 ], [ %81, %43 ]
%86 = icmp eq i64 %39, 0
br i1 %86, label %101, label %87
87: ; preds = %84, %87
%88 = phi i64 [ %98, %87 ], [ %85, %84 ]
%89 = phi i64 [ %99, %87 ], [ 0, %84 ]
%90 = getelementptr inbounds double, double* %4, i64 %88
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %91
%92 = getelementptr inbounds double, double* %90, i64 2
%93 = bitcast double* %92 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %93
%94 = getelementptr inbounds double, double* %5, i64 %88
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %95
%96 = getelementptr inbounds double, double* %94, i64 2
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %97
%98 = add nuw i64 %88, 4
%99 = add i64 %89, 1
%100 = icmp eq i64 %99, %39
br i1 %100, label %101, label %87
101: ; preds = %87, %84
%102 = icmp eq i64 %35, %26
br i1 %102, label %120, label %103
103: ; preds = %28, %24, %101
%104 = phi i64 [ 0, %28 ], [ 0, %24 ], [ %35, %101 ]
%105 = xor i64 %104, -1
%106 = add nsw i64 %105, %26
%107 = and i64 %26, 3
%108 = icmp eq i64 %107, 0
br i1 %108, label %117, label %109
109: ; preds = %103, %109
%110 = phi i64 [ %114, %109 ], [ %104, %103 ]
%111 = phi i64 [ %115, %109 ], [ 0, %103 ]
%112 = getelementptr inbounds double, double* %4, i64 %110
store double 0.000000e+00, double* %112
%113 = getelementptr inbounds double, double* %5, i64 %110
store double 0.000000e+00, double* %113
%114 = add nuw nsw i64 %110, 1
%115 = add i64 %111, 1
%116 = icmp eq i64 %115, %107
br i1 %116, label %117, label %109
117: ; preds = %109, %103
%118 = phi i64 [ %104, %103 ], [ %114, %109 ]
%119 = icmp ult i64 %106, 3
br i1 %119, label %120, label %203
120: ; preds = %117, %203, %101
br i1 %23, label %218, label %121
121: ; preds = %120
%122 = add nuw i32 %2, 1
%123 = zext i32 %122 to i64
%124 = icmp ult i32 %2, 3
br i1 %124, label %182, label %125
125: ; preds = %121
%126 = getelementptr double, double* %21, i64 %26
%127 = getelementptr double, double* %20, i64 %26
%128 = getelementptr double, double* %1, i64 %26
%129 = icmp ult double* %21, %127
%130 = icmp ult double* %20, %126
%131 = and i1 %129, %130
%132 = icmp ult double* %21, %128
%133 = icmp ugt double* %126, %1
%134 = and i1 %132, %133
%135 = or i1 %131, %134
br i1 %135, label %182, label %136
136: ; preds = %125
%137 = and i64 %26, 4294967292
%138 = insertelement <2 x double> poison, double %3, i64 0
%139 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> zeroinitializer
%140 = insertelement <2 x double> poison, double %3, i64 0
%141 = shufflevector <2 x double> %140, <2 x double> poison, <2 x i32> zeroinitializer
%142 = insertelement <2 x double> poison, double %10, i64 0
%143 = shufflevector <2 x double> %142, <2 x double> poison, <2 x i32> zeroinitializer
%144 = insertelement <2 x double> poison, double %10, i64 0
%145 = shufflevector <2 x double> %144, <2 x double> poison, <2 x i32> zeroinitializer
%146 = insertelement <2 x double> poison, double %13, i64 0
%147 = shufflevector <2 x double> %146, <2 x double> poison, <2 x i32> zeroinitializer
%148 = insertelement <2 x double> poison, double %13, i64 0
%149 = shufflevector <2 x double> %148, <2 x double> poison, <2 x i32> zeroinitializer
br label %150
150: ; preds = %150, %136
%151 = phi i64 [ 0, %136 ], [ %178, %150 ]
%152 = getelementptr inbounds double, double* %20, i64 %151
%153 = bitcast double* %152 to <2 x double>*
%154 = load <2 x double>, <2 x double>* %153
%155 = getelementptr inbounds double, double* %152, i64 2
%156 = bitcast double* %155 to <2 x double>*
%157 = load <2 x double>, <2 x double>* %156
%158 = fmul <2 x double> %154, %154
%159 = fmul <2 x double> %157, %157
%160 = getelementptr inbounds double, double* %1, i64 %151
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = getelementptr inbounds double, double* %160, i64 2
%164 = bitcast double* %163 to <2 x double>*
%165 = load <2 x double>, <2 x double>* %164
%166 = fsub <2 x double> %162, %139
%167 = fsub <2 x double> %165, %141
%168 = fmul <2 x double> %166, <double 2.000000e+00, double 2.000000e+00>
%169 = fmul <2 x double> %167, <double 2.000000e+00, double 2.000000e+00>
%170 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %168, <2 x double> %158, <2 x double> %143)
%171 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %169, <2 x double> %159, <2 x double> %145)
%172 = fmul <2 x double> %147, %170
%173 = fmul <2 x double> %149, %171
%174 = getelementptr inbounds double, double* %21, i64 %151
%175 = bitcast double* %174 to <2 x double>*
store <2 x double> %172, <2 x double>* %175
%176 = getelementptr inbounds double, double* %174, i64 2
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> %173, <2 x double>* %177
%178 = add nuw i64 %151, 4
%179 = icmp eq i64 %178, %137
br i1 %179, label %180, label %150
180: ; preds = %150
%181 = icmp eq i64 %137, %26
br i1 %181, label %218, label %182
182: ; preds = %125, %121, %180
%183 = phi i64 [ 0, %125 ], [ 0, %121 ], [ %137, %180 ]
%184 = xor i64 %183, -1
%185 = and i64 %26, 1
%186 = icmp eq i64 %185, 0
br i1 %186, label %199, label %187
187: ; preds = %182
%188 = getelementptr inbounds double, double* %20, i64 %183
%189 = load double, double* %188
%190 = fmul double %189, %189
%191 = getelementptr inbounds double, double* %1, i64 %183
%192 = load double, double* %191
%193 = fsub double %192, %3
%194 = fmul double %193, 2.000000e+00
%195 = tail call double @llvm.fmuladd.f64(double %194, double %190, double %10)
%196 = fmul double %13, %195
%197 = getelementptr inbounds double, double* %21, i64 %183
store double %196, double* %197
%198 = or i64 %183, 1
br label %199
199: ; preds = %187, %182
%200 = phi i64 [ %183, %182 ], [ %198, %187 ]
%201 = sub nsw i64 0, %26
%202 = icmp eq i64 %184, %201
br i1 %202, label %218, label %264
203: ; preds = %117, %203
%204 = phi i64 [ %216, %203 ], [ %118, %117 ]
%205 = getelementptr inbounds double, double* %4, i64 %204
store double 0.000000e+00, double* %205
%206 = getelementptr inbounds double, double* %5, i64 %204
store double 0.000000e+00, double* %206
%207 = add nuw nsw i64 %204, 1
%208 = getelementptr inbounds double, double* %4, i64 %207
store double 0.000000e+00, double* %208
%209 = getelementptr inbounds double, double* %5, i64 %207
store double 0.000000e+00, double* %209
%210 = add nuw nsw i64 %204, 2
%211 = getelementptr inbounds double, double* %4, i64 %210
store double 0.000000e+00, double* %211
%212 = getelementptr inbounds double, double* %5, i64 %210
store double 0.000000e+00, double* %212
%213 = add nuw nsw i64 %204, 3
%214 = getelementptr inbounds double, double* %4, i64 %213
store double 0.000000e+00, double* %214
%215 = getelementptr inbounds double, double* %5, i64 %213
store double 0.000000e+00, double* %215
%216 = add nuw nsw i64 %204, 4
%217 = icmp eq i64 %216, %26
br i1 %217, label %120, label %203
218: ; preds = %199, %264, %180, %19, %120
%219 = fmul double %12, %8
%220 = load double, double* %20
%221 = tail call double @pow(double %220, double %8)
store double %221, double* %4
%222 = fmul double %219, %221
store double %222, double* %5
%223 = load double, double* %21
%224 = load double, double* %4
%225 = fmul double %223, %224
%226 = tail call double @llvm.fmuladd.f64(double %12, double %222, double %225)
store double %226, double* %22
%227 = getelementptr inbounds double, double* %20, i64 1
%228 = load double, double* %227
%229 = tail call double @pow(double %228, double %8)
%230 = getelementptr inbounds double, double* %4, i64 1
store double %229, double* %230
%231 = fmul double %219, %229
%232 = getelementptr inbounds double, double* %5, i64 1
store double %231, double* %232
%233 = getelementptr inbounds double, double* %21, i64 1
%234 = load double, double* %233
%235 = load double, double* %230
%236 = fmul double %234, %235
%237 = tail call double @llvm.fmuladd.f64(double %12, double %231, double %236)
%238 = getelementptr inbounds double, double* %22, i64 1
store double %237, double* %238
%239 = getelementptr inbounds double, double* %20, i64 2
%240 = load double, double* %239
%241 = tail call double @pow(double %240, double %8)
%242 = getelementptr inbounds double, double* %4, i64 2
store double %241, double* %242
%243 = fmul double %219, %241
%244 = getelementptr inbounds double, double* %5, i64 2
store double %243, double* %244
%245 = getelementptr inbounds double, double* %21, i64 2
%246 = load double, double* %245
%247 = load double, double* %242
%248 = fmul double %246, %247
%249 = tail call double @llvm.fmuladd.f64(double %12, double %243, double %248)
%250 = getelementptr inbounds double, double* %22, i64 2
store double %249, double* %250
%251 = getelementptr inbounds double, double* %20, i64 3
%252 = load double, double* %251
%253 = tail call double @pow(double %252, double %8)
%254 = getelementptr inbounds double, double* %4, i64 3
store double %253, double* %254
%255 = fmul double %219, %253
%256 = getelementptr inbounds double, double* %5, i64 3
store double %255, double* %256
%257 = getelementptr inbounds double, double* %21, i64 3
%258 = load double, double* %257
%259 = load double, double* %254
%260 = fmul double %258, %259
%261 = tail call double @llvm.fmuladd.f64(double %12, double %255, double %260)
%262 = getelementptr inbounds double, double* %22, i64 3
store double %261, double* %262
%263 = icmp sgt i32 %2, 3
br i1 %263, label %289, label %343
264: ; preds = %199, %264
%265 = phi i64 [ %287, %264 ], [ %200, %199 ]
%266 = getelementptr inbounds double, double* %20, i64 %265
%267 = load double, double* %266
%268 = fmul double %267, %267
%269 = getelementptr inbounds double, double* %1, i64 %265
%270 = load double, double* %269
%271 = fsub double %270, %3
%272 = fmul double %271, 2.000000e+00
%273 = tail call double @llvm.fmuladd.f64(double %272, double %268, double %10)
%274 = fmul double %13, %273
%275 = getelementptr inbounds double, double* %21, i64 %265
store double %274, double* %275
%276 = add nuw nsw i64 %265, 1
%277 = getelementptr inbounds double, double* %20, i64 %276
%278 = load double, double* %277
%279 = fmul double %278, %278
%280 = getelementptr inbounds double, double* %1, i64 %276
%281 = load double, double* %280
%282 = fsub double %281, %3
%283 = fmul double %282, 2.000000e+00
%284 = tail call double @llvm.fmuladd.f64(double %283, double %279, double %10)
%285 = fmul double %13, %284
%286 = getelementptr inbounds double, double* %21, i64 %276
store double %285, double* %286
%287 = add nuw nsw i64 %265, 2
%288 = icmp eq i64 %287, %123
br i1 %288, label %218, label %264
289: ; preds = %218
%290 = zext i32 %2 to i64
%291 = load double, double* %254
br label %292
292: ; preds = %289, %297
%293 = phi double [ %291, %289 ], [ %341, %297 ]
%294 = phi i64 [ 3, %289 ], [ %300, %297 ]
%295 = tail call double @llvm.fabs.f64(double %293)
%296 = fcmp olt double %295, 1.000000e+08
br i1 %296, label %297, label %343
297: ; preds = %292
%298 = trunc i64 %294 to i32
%299 = tail call double @paw_Predictor_Out(i32 %298, double* %4, double* %5)
%300 = add nuw nsw i64 %294, 1
%301 = getelementptr inbounds double, double* %4, i64 %300
store double %299, double* %301
%302 = tail call double @paw_Predictor_Out(i32 %298, double* %5, double* %22)
%303 = getelementptr inbounds double, double* %5, i64 %300
store double %302, double* %303
%304 = getelementptr inbounds double, double* %21, i64 %300
%305 = getelementptr inbounds double, double* %22, i64 %300
%306 = load double, double* %304
%307 = load double, double* %301
%308 = fmul double %306, %307
%309 = tail call double @llvm.fmuladd.f64(double %12, double %302, double %308)
store double %309, double* %305
%310 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %310, double* %303
%311 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %311, double* %301
%312 = load double, double* %303
%313 = load double, double* %304
%314 = fmul double %313, %311
%315 = tail call double @llvm.fmuladd.f64(double %12, double %312, double %314)
store double %315, double* %305
%316 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %316, double* %303
%317 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %317, double* %301
%318 = load double, double* %303
%319 = load double, double* %304
%320 = fmul double %319, %317
%321 = tail call double @llvm.fmuladd.f64(double %12, double %318, double %320)
store double %321, double* %305
%322 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %322, double* %303
%323 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %323, double* %301
%324 = load double, double* %303
%325 = load double, double* %304
%326 = fmul double %325, %323
%327 = tail call double @llvm.fmuladd.f64(double %12, double %324, double %326)
store double %327, double* %305
%328 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %328, double* %303
%329 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %329, double* %301
%330 = load double, double* %303
%331 = load double, double* %304
%332 = fmul double %331, %329
%333 = tail call double @llvm.fmuladd.f64(double %12, double %330, double %332)
store double %333, double* %305
%334 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %334, double* %303
%335 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %335, double* %301
%336 = load double, double* %303
%337 = load double, double* %304
%338 = fmul double %337, %335
%339 = tail call double @llvm.fmuladd.f64(double %12, double %336, double %338)
store double %339, double* %305
%340 = tail call double @paw_Corrector_Out(i32 %298, double* %5, double* %22)
store double %340, double* %303
%341 = tail call double @paw_Corrector_Out(i32 %298, double* %4, double* %5)
store double %341, double* %301
%342 = icmp eq i64 %300, %290
br i1 %342, label %343, label %292
343: ; preds = %292, %297, %218
%344 = tail call i32 @paw_dealloc_LogGrid(double* %22)
%345 = tail call i32 @paw_dealloc_LogGrid(double* %21)
ret i32 1
}