#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 Corrector_Out(int, double *, double *);
int /*<<< orphan*/ Derivative_LogGrid(double const *, double *);
int N_LogGrid();
double Norm_LogGrid(int, double, double *);
double Predictor_Out(int, double *, double *);
double *alloc_LogGrid();
int /*<<< orphan*/ dealloc_LogGrid(double *);
double log_amesh_LogGrid();
double pow(double, double);
double *r_LogGrid();
double sqrt(double);
void R_Dirac_Fixed_E(int n, int l, int s2, double Z, const double *v, int match,
                     double E, double *u, double *uprime) {
  int i, j, node, Ngrid;
  double log_amesh, kappa, m1scale, log_amesh2, fss, gamma, L2, L0, r2, sum, *r,
      *f_upp, *dv, *frp, *fr, *upp;
  L2 = ((double)(l * (l + 1)));
  fss = 1.0 / 137.03602;
  fss = fss * fss;
  kappa = -1;
  if (l) {
    if (s2 > 0) {
      kappa = -(l + 1);
    } else {
      kappa = l;
    }
  }
  gamma = sqrt(kappa * kappa - fss * Z * Z);
  Ngrid = N_LogGrid();
  log_amesh = log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = r_LogGrid();
  f_upp = alloc_LogGrid();
  upp = alloc_LogGrid();
  fr = alloc_LogGrid();
  frp = alloc_LogGrid();
  dv = alloc_LogGrid();
  for (i = 0; i < 4; ++i) {
    u[i] = 0.0;
    uprime[i] = 0.0;
    upp[i] = 0.0;
  }
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i];
    r2 = r2 * r2;
    f_upp[i] = log_amesh2 * (L2 + 2.0 * (v[i] - E) * r2);
  }
  Derivative_LogGrid(v, dv);
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i] * r[i];
    fr[i] =
        -log_amesh2 * r2 *
        (fss * (v[i] - E) * (v[i] - E) +
         0.5 * fss * dv[i] * kappa / (r[i] * (1.0 + 0.5 * fss * (E - v[i]))));
    frp[i] =
        -log_amesh * r[i] * 0.5 * fss * dv[i] / (1.0 + 0.5 * fss * (E - v[i]));
  }
  m1scale = 1.0;
  for (i = 0; i < (n - l - 1); ++i)
    m1scale *= -1.0;
  for (i = 0; i < 4; ++i) {
    u[i] = m1scale * pow(r[i], gamma);
    uprime[i] = log_amesh * gamma * u[i];
    upp[i] = (log_amesh + frp[i]) * uprime[i] + (f_upp[i] + fr[i]) * u[i];
  }
  node = 0;
  for (i = 3; i < match; ++i) {
    u[i + 1] = Predictor_Out(i, u, uprime);
    uprime[i + 1] = Predictor_Out(i, uprime, upp);
    for (j = 0; j < 6; ++j) {
      upp[i + 1] = (log_amesh + frp[i + 1]) * uprime[i + 1] +
                   (f_upp[i + 1] + fr[i + 1]) * u[i + 1];
      uprime[i + 1] = Corrector_Out(i, uprime, upp);
      u[i + 1] = Corrector_Out(i, u, uprime);
    }
    if (u[i + 1] * u[i] <= 0)
      node = node + 1;
  }
  sum = Norm_LogGrid(match, gamma, u);
  sum = 1.0 / sqrt(sum);
  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;
  }
  dealloc_LogGrid(f_upp);
  dealloc_LogGrid(upp);
  dealloc_LogGrid(fr);
  dealloc_LogGrid(frp);
  dealloc_LogGrid(dv);
  return;
}


x86 assembly (clang, -O0):
<R_Dirac_Fixed_E>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe0d(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xde9(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x8(%rbp)
je     1257 <R_Dirac_Fixed_E+0xa7>
cmpl   $0x0,-0xc(%rbp)
jle    1248 <R_Dirac_Fixed_E+0x98>
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1252 <R_Dirac_Fixed_E+0xa2>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1257 <R_Dirac_Fixed_E+0xa7>
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
mov    $0x0,%al
call   10d0 <N_LogGrid@plt>
mov    %eax,-0x48(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    $0x0,%al
call   1070 <r_LogGrid@plt>
mov    %rax,-0xa0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
mov    %rax,-0xa8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
mov    %rax,-0xc8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
mov    %rax,-0xc0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
mov    %rax,-0xb8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1364 <R_Dirac_Fixed_E+0x1b4>
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    -0xc8(%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    1319 <R_Dirac_Fixed_E+0x169>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1401 <R_Dirac_Fixed_E+0x251>
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x30(%rbp),%xmm3
movsd  0xc55(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x90(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    136b <R_Dirac_Fixed_E+0x1bb>
mov    -0x20(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15c0 <R_Dirac_Fixed_E+0x410>
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x30(%rbp),%xmm3
movsd  0xb73(%rip),%xmm2
mulsd  -0x70(%rbp),%xmm2
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  -0x58(%rbp),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xb41(%rip),%xmm5
mulsd  -0x70(%rbp),%xmm5
movsd  -0x30(%rbp),%xmm6
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0xb16(%rip),%xmm6
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xac2(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xaa1(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xa76(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1418 <R_Dirac_Fixed_E+0x268>
movsd  0xa48(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1608 <R_Dirac_Fixed_E+0x458>
movsd  0xa10(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15d4 <R_Dirac_Fixed_E+0x424>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    16f5 <R_Dirac_Fixed_E+0x545>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
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  -0x50(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%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    160f <R_Dirac_Fixed_E+0x45f>
movl   $0x0,-0x44(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1889 <R_Dirac_Fixed_E+0x6d9>
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    0x10(%rbp),%rdx
call   1060 <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   1060 <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    1841 <R_Dirac_Fixed_E+0x691>
movsd  -0x50(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xc0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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   1050 <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   1050 <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    175d <R_Dirac_Fixed_E+0x5ad>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1876 <R_Dirac_Fixed_E+0x6c6>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    187b <R_Dirac_Fixed_E+0x6cb>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1703 <R_Dirac_Fixed_E+0x553>
mov    -0x24(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%rsi
call   1080 <Norm_LogGrid@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x756(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     192b <R_Dirac_Fixed_E+0x77b>
movsd  -0x98(%rbp),%xmm0
ff
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  -0x98(%rbp),%xmm0
ff
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    18cd <R_Dirac_Fixed_E+0x71d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    196e <R_Dirac_Fixed_E+0x7be>
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    1934 <R_Dirac_Fixed_E+0x784>
mov    -0xa8(%rbp),%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    -0xc8(%rbp),%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    -0xc0(%rbp),%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    -0xb8(%rbp),%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    -0xb0(%rbp),%rdi
call   10b0 <dealloc_LogGrid@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Dirac_Fixed_E>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,%r14
mov    %r8,0x50(%rsp)
mov    %esi,%r13d
not    %r13d
mov    %rsi,0x70(%rsp)
test   %esi,%esi
je     11e3 <R_Dirac_Fixed_E+0x33>
test   %edx,%edx
jle    11ed <R_Dirac_Fixed_E+0x3d>
cvtsi2sd %r13d,%xmm2
jmp    11f3 <R_Dirac_Fixed_E+0x43>
movsd  0x1e15(%rip),%xmm2
jmp    11f3 <R_Dirac_Fixed_E+0x43>
cvtsi2sdl 0x70(%rsp),%xmm2
movapd %xmm2,0xb0(%rsp)
movaps %xmm1,0xa0(%rsp)
mov    %rcx,0x8(%rsp)
mov    0x100(%rsp),%rbx
movsd  0x1def(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %edi,0x8c(%rsp)
jb     1244 <R_Dirac_Fixed_E+0x94>
sqrtsd %xmm0,%xmm0
jmp    1249 <R_Dirac_Fixed_E+0x99>
call   10a0 <sqrt@plt>
movsd  %xmm0,0x48(%rsp)
xor    %eax,%eax
call   10d0 <N_LogGrid@plt>
mov    %eax,0x2c(%rsp)
xor    %eax,%eax
call   1040 <log_amesh_LogGrid@plt>
movapd %xmm0,0x60(%rsp)
xor    %eax,%eax
call   1070 <r_LogGrid@plt>
mov    %rax,0x40(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
mov    %rax,%r15
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
mov    %rax,%rbp
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
mov    %rax,%r12
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movapd 0x60(%rsp),%xmm9
mov    0x2c(%rsp),%edi
movq   $0x0,(%r14)
movq   $0x0,(%rbx)
movq   $0x0,0x0(%rbp)
movq   $0x0,0x8(%r14)
movq   $0x0,0x8(%rbx)
movq   $0x0,0x8(%rbp)
movq   $0x0,0x10(%r14)
movq   $0x0,0x10(%rbx)
movq   $0x0,0x10(%rbp)
movq   $0x0,0x18(%r14)
movq   $0x0,0x18(%rbx)
mov    %rbp,0x58(%rsp)
movq   $0x0,0x18(%rbp)
test   %edi,%edi
mov    %r12,0x38(%rsp)
mov    %rax,0x20(%rsp)
jle    1361 <R_Dirac_Fixed_E+0x1b1>
mov    0x70(%rsp),%rsi
lea    0x1(%rsi),%ecx
imul   %esi,%ecx
cvtsi2sd %ecx,%xmm8
mulsd  %xmm9,%xmm9
mov    %edi,%r8d
cmp    $0x4,%edi
mov    0x18(%rsp),%r12
mov    0x8(%rsp),%rdi
mov    %r8,0x30(%rsp)
jae    1383 <R_Dirac_Fixed_E+0x1d3>
xor    %ecx,%ecx
mov    0x40(%rsp),%rbp
movapd 0xa0(%rsp),%xmm0
jmp    1481 <R_Dirac_Fixed_E+0x2d1>
mov    0x8(%rsp),%rdi
mov    %rax,%rsi
mov    %r12,%rbp
call   1030 <Derivative_LogGrid@plt>
mov    %r12,%rsi
mov    0x18(%rsp),%r12
mov    0x40(%rsp),%rbp
jmp    18bb <R_Dirac_Fixed_E+0x70b>
lea    (%r15,%r8,8),%rsi
mov    0x40(%rsp),%rbp
lea    0x0(,%r8,8),%rcx
add    %rbp,%rcx
lea    (%rdi,%r8,8),%r8
cmp    %rcx,%r15
setb   %r9b
cmp    %rsi,%rbp
setb   %r11b
cmp    %r8,%r15
setb   %r10b
cmp    %rdi,%rsi
seta   %r8b
xor    %ecx,%ecx
test   %r11b,%r9b
movapd 0xa0(%rsp),%xmm0
jne    1477 <R_Dirac_Fixed_E+0x2c7>
and    %r8b,%r10b
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%r8
jne    1481 <R_Dirac_Fixed_E+0x2d1>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
lea    0x0(,%r8,8),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edx,%edx
xchg   %ax,%ax
movupd 0x0(%rbp,%rdx,1),%xmm4
movupd 0x10(%rbp,%rdx,1),%xmm5
mulpd  %xmm4,%xmm4
mulpd  %xmm5,%xmm5
movupd (%rdi,%rdx,1),%xmm6
movupd 0x10(%rdi,%rdx,1),%xmm7
subpd  %xmm1,%xmm6
subpd  %xmm1,%xmm7
addpd  %xmm6,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm2,%xmm6
addpd  %xmm2,%xmm7
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
movupd %xmm6,(%r15,%rdx,1)
movupd %xmm7,0x10(%r15,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1410 <R_Dirac_Fixed_E+0x260>
cmp    %r8,%rcx
jne    1481 <R_Dirac_Fixed_E+0x2d1>
jmp    1531 <R_Dirac_Fixed_E+0x381>
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%r8
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r8b
je     14bc <R_Dirac_Fixed_E+0x30c>
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  (%rdi,%rcx,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
or     $0x1,%rcx
add    %r8,%rdx
je     1531 <R_Dirac_Fixed_E+0x381>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  (%rdi,%rcx,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x8(%rdi,%rcx,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,0x8(%r15,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r8
jne    14d0 <R_Dirac_Fixed_E+0x320>
mov    %rax,%rsi
movapd %xmm9,0x90(%rsp)
call   1030 <Derivative_LogGrid@plt>
mov    0x30(%rsp),%r10
movapd 0x90(%rsp),%xmm9
movapd 0xa0(%rsp),%xmm15
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%rdi
cmpl   $0x0,0x2c(%rsp)
mov    0x38(%rsp),%rsi
movapd 0xb0(%rsp),%xmm11
jle    18bb <R_Dirac_Fixed_E+0x70b>
movapd 0x1aa7(%rip),%xmm14
xorpd  %xmm14,%xmm9
xorpd  0x60(%rsp),%xmm14
cmpl   $0x1,0x2c(%rsp)
jne    15a3 <R_Dirac_Fixed_E+0x3f3>
xor    %eax,%eax
jmp    17f1 <R_Dirac_Fixed_E+0x641>
mov    %rsi,%rcx
mov    %r15,0x90(%rsp)
lea    (%rsi,%r10,8),%rax
lea    (%r12,%r10,8),%r15
lea    0x0(,%r10,8),%r12
add    %rbp,%r12
lea    (%rdx,%r10,8),%r8
cmp    %r15,%rsi
setb   0x17(%rsp)
cmp    %rax,0x18(%rsp)
setb   0x16(%rsp)
cmp    %r12,%rsi
setb   %r11b
cmp    %rax,%rbp
setb   0x15(%rsp)
cmp    %r8,%rsi
setb   %r9b
cmp    %rdx,%rax
seta   0x14(%rsp)
lea    (%rdi,%r10,8),%rsi
cmp    %rsi,%rcx
setb   %r10b
cmp    %rax,%rdi
setb   0x13(%rsp)
cmp    %r12,0x18(%rsp)
setb   %cl
cmp    %r15,%rbp
setb   0x12(%rsp)
cmp    %r8,0x18(%rsp)
mov    0x18(%rsp),%r12
setb   %r8b
cmp    %rdx,%r15
seta   0x11(%rsp)
cmp    %rsi,%r12
setb   %bpl
cmp    %r15,%rdi
setb   %dil
xor    %eax,%eax
mov    0x16(%rsp),%dl
test   %dl,0x17(%rsp)
jne    17d0 <R_Dirac_Fixed_E+0x620>
and    0x15(%rsp),%r11b
mov    0x90(%rsp),%r15
jne    17d8 <R_Dirac_Fixed_E+0x628>
and    0x14(%rsp),%r9b
mov    0x38(%rsp),%rsi
jne    17dd <R_Dirac_Fixed_E+0x62d>
mov    %ebp,%edx
and    0x13(%rsp),%r10b
mov    0x40(%rsp),%rbp
jne    17c9 <R_Dirac_Fixed_E+0x619>
and    0x12(%rsp),%cl
mov    0x30(%rsp),%r10
jne    17bd <R_Dirac_Fixed_E+0x60d>
and    0x11(%rsp),%r8b
jne    17bd <R_Dirac_Fixed_E+0x60d>
and    %dil,%dl
mov    0x20(%rsp),%rdi
mov    0x8(%rsp),%rdx
jne    17f1 <R_Dirac_Fixed_E+0x641>
mov    %r10d,%eax
and    $0xfffffffe,%eax
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm9
movapd %xmm15,%xmm3
unpcklpd %xmm15,%xmm3
unpcklpd %xmm11,%xmm11
movapd %xmm14,%xmm13
unpcklpd %xmm14,%xmm13
xor    %ecx,%ecx
movapd 0x195e(%rip),%xmm10
movapd 0x1966(%rip),%xmm6
movapd 0x196d(%rip),%xmm12
movapd 0x1974(%rip),%xmm8
nopl   0x0(%rax)
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd (%rdx,%rcx,8),%xmm5
movapd %xmm3,%xmm2
subpd  %xmm5,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm12,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm9,%xmm1
subpd  %xmm3,%xmm5
movapd %xmm5,%xmm7
mulpd  %xmm10,%xmm7
movupd (%rdi,%rcx,8),%xmm4
mulpd  %xmm6,%xmm4
mulpd  %xmm11,%xmm4
divpd  %xmm2,%xmm4
mulpd  %xmm5,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm1,%xmm7
movupd %xmm7,(%rsi,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm1
mulpd  %xmm13,%xmm1
mulpd  %xmm8,%xmm1
mulpd  %xmm10,%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm1,%xmm2
movupd (%rdx,%rcx,8),%xmm1
movapd %xmm3,%xmm4
subpd  %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm12,%xmm4
divpd  %xmm4,%xmm2
movupd %xmm2,(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1700 <R_Dirac_Fixed_E+0x550>
cmp    %r10,%rax
movapd 0xb0(%rsp),%xmm11
movapd %xmm0,%xmm9
jne    17f1 <R_Dirac_Fixed_E+0x641>
jmp    18bb <R_Dirac_Fixed_E+0x70b>
mov    0x20(%rsp),%rdi
mov    0x8(%rsp),%rdx
jmp    17f1 <R_Dirac_Fixed_E+0x641>
mov    0x20(%rsp),%rdi
jmp    17e7 <R_Dirac_Fixed_E+0x637>
mov    0x90(%rsp),%r15
mov    0x38(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x40(%rsp),%rbp
mov    0x8(%rsp),%rdx
mov    0x30(%rsp),%r10
movsd  0x1817(%rip),%xmm1
movsd  0x1817(%rip),%xmm2
movsd  0x1817(%rip),%xmm3
movsd  0x1816(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm5
movsd  (%rdx,%rax,8),%xmm6
movapd %xmm15,%xmm7
subsd  %xmm6,%xmm7
mulsd  %xmm2,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm5,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm15,%xmm6
movapd %xmm6,%xmm0
mulsd  %xmm1,%xmm0
movsd  (%rdi,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm11,%xmm4
divsd  %xmm7,%xmm4
mulsd  %xmm6,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movapd %xmm15,%xmm4
subsd  (%rdx,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
divsd  %xmm4,%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1820 <R_Dirac_Fixed_E+0x670>
mov    0x8c(%rsp),%ecx
add    %ecx,%r13d
movsd  0x1753(%rip),%xmm2
test   %r13d,%r13d
jle    192b <R_Dirac_Fixed_E+0x77b>
sub    0x70(%rsp),%ecx
add    $0xfffffffe,%ecx
mov    %r13d,%eax
and    $0x7,%eax
cmp    $0x7,%ecx
jb     18f6 <R_Dirac_Fixed_E+0x746>
and    $0xfffffff8,%r13d
nopl   0x0(%rax,%rax,1)
add    $0xfffffff8,%r13d
jne    18f0 <R_Dirac_Fixed_E+0x740>
mov    %rsi,%r13
test   %eax,%eax
movapd 0x60(%rsp),%xmm1
je     1934 <R_Dirac_Fixed_E+0x784>
movsd  0x1715(%rip),%xmm2
movapd 0x171d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm2
add    $0xffffffff,%eax
jne    1920 <R_Dirac_Fixed_E+0x770>
jmp    1934 <R_Dirac_Fixed_E+0x784>
mov    %rsi,%r13
movapd 0x60(%rsp),%xmm1
movapd %xmm2,0x70(%rsp)
movsd  0x48(%rsp),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x0(%rbp),%xmm0
movapd %xmm2,%xmm1
call   1090 <pow@plt>
mulsd  0x70(%rsp),%xmm0
movsd  %xmm0,(%r14)
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%rbx)
movsd  (%r12),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  (%r15),%xmm2
addsd  0x0(%r13),%xmm2
mulsd  (%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x58(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%rbp),%xmm0
movsd  0x48(%rsp),%xmm1
call   1090 <pow@plt>
mulsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x8(%r14)
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%r12),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  0x8(%r15),%xmm2
mov    0x38(%rsp),%rax
addsd  0x8(%rax),%xmm2
mulsd  0x8(%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x58(%rsp),%r13
movsd  %xmm1,0x8(%r13)
movsd  0x10(%rbp),%xmm0
movsd  0x48(%rsp),%xmm1
call   1090 <pow@plt>
mulsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x10(%r14)
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r12),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  0x10(%r15),%xmm2
mov    %r15,%r12
mov    0x38(%rsp),%r15
addsd  0x10(%r15),%xmm2
mulsd  0x10(%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%r13)
movsd  0x18(%rbp),%xmm0
movsd  0x48(%rsp),%xmm1
call   1090 <pow@plt>
mulsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x18(%r14)
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x18(%rbx)
mov    0x18(%rsp),%rax
movsd  0x18(%rax),%xmm1
addsd  0x60(%rsp),%xmm1
mov    %r12,%rcx
movsd  0x18(%r12),%xmm2
addsd  0x18(%r15),%xmm2
mulsd  0x18(%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%r13)
cmpl   $0x3,0x50(%rsp)
jle    1b8e <R_Dirac_Fixed_E+0x9de>
mov    0x50(%rsp),%eax
mov    %rax,0x8(%rsp)
mov    $0x3,%r13d
jmp    1adb <R_Dirac_Fixed_E+0x92b>
nopw   0x0(%rax,%rax,1)
cmp    0x8(%rsp),%r13
je     1b8e <R_Dirac_Fixed_E+0x9de>
mov    %r13,%rbp
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1060 <Predictor_Out@plt>
add    $0x1,%r13
movsd  %xmm0,0x8(%r14,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    0x58(%rsp),%rdx
call   1060 <Predictor_Out@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,0x8(%rbx,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
mov    $0x5,%r15d
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
addsd  0x60(%rsp),%xmm2
movsd  (%r12,%r13,8),%xmm3
mov    0x38(%rsp),%rax
addsd  (%rax,%r13,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x58(%rsp),%rdx
movsd  %xmm3,(%rdx,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
call   1050 <Corrector_Out@plt>
movsd  %xmm0,(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1050 <Corrector_Out@plt>
movsd  %xmm0,(%r14,%r13,8)
sub    $0x1,%r15d
jb     1ad0 <R_Dirac_Fixed_E+0x920>
movsd  (%rbx,%r13,8),%xmm1
jmp    1b20 <R_Dirac_Fixed_E+0x970>
mov    0x50(%rsp),%rdi
movsd  0x48(%rsp),%xmm0
mov    %r14,%rsi
call   1080 <Norm_LogGrid@plt>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1bb1 <R_Dirac_Fixed_E+0xa01>
sqrtsd %xmm0,%xmm0
jmp    1bb6 <R_Dirac_Fixed_E+0xa06>
call   10a0 <sqrt@plt>
mov    0x18(%rsp),%rbp
mov    0x50(%rsp),%rcx
lea    0x1(%rcx),%eax
test   %ecx,%ecx
mov    0x38(%rsp),%r15
mov    0x2c(%rsp),%r11d
js     1db6 <R_Dirac_Fixed_E+0xc06>
movsd  0x1443(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    %eax,%ecx
cmp    $0x4,%eax
jb     1c02 <R_Dirac_Fixed_E+0xa52>
lea    (%rbx,%rcx,8),%rdx
cmp    %r14,%rdx
jbe    1c8e <R_Dirac_Fixed_E+0xade>
lea    (%r14,%rcx,8),%rdx
cmp    %rbx,%rdx
jbe    1c8e <R_Dirac_Fixed_E+0xade>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     1c31 <R_Dirac_Fixed_E+0xa81>
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
or     $0x1,%rdx
add    %rcx,%rsi
je     1db6 <R_Dirac_Fixed_E+0xc06>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1c40 <R_Dirac_Fixed_E+0xa90>
jmp    1db6 <R_Dirac_Fixed_E+0xc06>
mov    %ecx,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1feb <R_Dirac_Fixed_E+0xe3b>
movabs $0x7ffffffffffffffc,%rbp
ff ff 7f
or     $0x2,%rbp
and    %r8,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rsi,8)
movupd %xmm3,0x10(%rbx,%rsi,8)
movupd 0x20(%r14,%rsi,8),%xmm2
movupd 0x30(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r14,%rsi,8)
movupd %xmm3,0x30(%r14,%rsi,8)
movupd 0x20(%rbx,%rsi,8),%xmm2
movupd 0x30(%rbx,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbx,%rsi,8)
movupd %xmm3,0x30(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbp
jne    1cd0 <R_Dirac_Fixed_E+0xb20>
test   $0x1,%r8b
je     1da8 <R_Dirac_Fixed_E+0xbf8>
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rsi,8)
movupd %xmm3,0x10(%r14,%rsi,8)
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rsi,8)
movupd %xmm3,0x10(%rbx,%rsi,8)
cmp    %rcx,%rdx
mov    0x18(%rsp),%rbp
jne    1c04 <R_Dirac_Fixed_E+0xa54>
cmp    %r11d,%eax
jge    1fae <R_Dirac_Fixed_E+0xdfe>
cltq
mov    %r11d,%r9d
sub    0x50(%rsp),%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     1f10 <R_Dirac_Fixed_E+0xd60>
lea    (%r14,%rax,8),%rdx
lea    (%r9,%rax,1),%rcx
lea    (%rbx,%rcx,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%rdx
jae    1e01 <R_Dirac_Fixed_E+0xc51>
lea    (%r14,%rcx,8),%rcx
add    $0x8,%rcx
lea    (%rbx,%rax,8),%rdx
cmp    %rcx,%rdx
jb     1f10 <R_Dirac_Fixed_E+0xd60>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0xc,%rcx
jae    1e2f <R_Dirac_Fixed_E+0xc7f>
xor    %ebp,%ebp
jmp    1eb8 <R_Dirac_Fixed_E+0xd08>
and    $0xfffffffffffffffc,%rsi
lea    (%rbx,%rax,8),%rdx
add    $0x70,%rdx
lea    (%r14,%rax,8),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rcx,%rbp,8)
movupd %xmm0,-0x60(%rcx,%rbp,8)
movupd %xmm0,-0x70(%rdx,%rbp,8)
movupd %xmm0,-0x60(%rdx,%rbp,8)
movupd %xmm0,-0x50(%rcx,%rbp,8)
movupd %xmm0,-0x40(%rcx,%rbp,8)
movupd %xmm0,-0x50(%rdx,%rbp,8)
movupd %xmm0,-0x40(%rdx,%rbp,8)
movupd %xmm0,-0x30(%rcx,%rbp,8)
movupd %xmm0,-0x20(%rcx,%rbp,8)
movupd %xmm0,-0x30(%rdx,%rbp,8)
movupd %xmm0,-0x20(%rdx,%rbp,8)
movupd %xmm0,-0x10(%rcx,%rbp,8)
movupd %xmm0,(%rcx,%rbp,8)
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm0,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1e50 <R_Dirac_Fixed_E+0xca0>
test   %r10,%r10
je     1eff <R_Dirac_Fixed_E+0xd4f>
add    %rax,%rbp
lea    (%rbx,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%r14,%rbp,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r10
xor    %esi,%esi
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm0,-0x10(%rcx,%rsi,1)
movupd %xmm0,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    1ee0 <R_Dirac_Fixed_E+0xd30>
cmp    %r8,%r9
mov    0x18(%rsp),%rbp
je     1fae <R_Dirac_Fixed_E+0xdfe>
add    %r8,%rax
mov    %r11d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r11d,%ecx
and    $0x3,%edx
je     1f49 <R_Dirac_Fixed_E+0xd99>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%r14,%rax,8)
movq   $0x0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1f30 <R_Dirac_Fixed_E+0xd80>
cmp    $0x3,%ecx
jb     1fae <R_Dirac_Fixed_E+0xdfe>
mov    %r11d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%r14,%rax,8)
movq   $0x0,(%rbx,%rax,8)
movq   $0x0,0x8(%r14,%rax,8)
movq   $0x0,0x8(%rbx,%rax,8)
movq   $0x0,0x10(%r14,%rax,8)
movq   $0x0,0x10(%rbx,%rax,8)
movq   $0x0,0x18(%r14,%rax,8)
movq   $0x0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %eax,%ecx
jne    1f60 <R_Dirac_Fixed_E+0xdb0>
mov    %r12,%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    0x58(%rsp),%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    %r15,%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    %rbp,%rdi
call   10b0 <dealloc_LogGrid@plt>
mov    0x20(%rsp),%rdi
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10b0 <dealloc_LogGrid@plt>
xor    %esi,%esi
test   $0x1,%r8b
jne    1d68 <R_Dirac_Fixed_E+0xbb8>
jmp    1da8 <R_Dirac_Fixed_E+0xbf8>

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

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