void R_Pauli_Fixed_E(n, l, Z, v, match, E, u, uprime) int n, l;
double Z;
double v[];
int match;
double E;
double u[], uprime[];
{
  int i, j, node, Ngrid;
  double log_amesh, 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;
  if (l == 0)
    gamma = sqrt(1.0 - fss * Z * Z);
  else {
    L0 = (double)l;
    gamma = (sqrt(L0 * L0 - fss * Z * Z) * L0 +
             sqrt((L0 + 1.0) * (L0 + 1) - fss * Z * Z) * (L0 + 1.0)) /
            (2.0 * L0 + 1.0);
  }
  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] / (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]));
  }
  for (i = 0; i < 4; ++i) {
    u[i] = 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);
    }
  }
  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_Pauli_Fixed_E>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %r8,-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,-0x70(%rbp)
movsd  0xe09(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    125a <R_Pauli_Fixed_E+0xaa>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xdc1(%rip),%xmm1
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
jmp    134d <R_Pauli_Fixed_E+0x19d>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%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,-0xc0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xd4a(%rip),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  0xd3d(%rip),%xmm2
addsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%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  -0xc8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0xcea(%rip),%xmm3
addsd  -0x78(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  %xmm1,%xmm1
movsd  0xcc8(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    $0x0,%al
call   10d0 <N_LogGrid@plt>
mov    %eax,-0x48(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    $0x0,%al
call   1070 <r_LogGrid@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x98(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xb8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xb0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1428 <R_Pauli_Fixed_E+0x278>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%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    13dd <R_Pauli_Fixed_E+0x22d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    14b6 <R_Pauli_Fixed_E+0x306>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x28(%rbp),%xmm3
movsd  0xb95(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x80(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    142f <R_Pauli_Fixed_E+0x27f>
mov    -0x18(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    166c <R_Pauli_Fixed_E+0x4bc>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x28(%rbp),%xmm3
movsd  0xaba(%rip),%xmm2
mulsd  -0x60(%rbp),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xa8d(%rip),%xmm5
mulsd  -0x60(%rbp),%xmm5
movsd  -0x28(%rbp),%xmm6
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0xa62(%rip),%xmm6
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xb0(%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    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xa0e(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x9ed(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x9c2(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %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    14cf <R_Pauli_Fixed_E+0x31f>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    173d <R_Pauli_Fixed_E+0x58d>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
call   1090 <pow@plt>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %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    1673 <R_Pauli_Fixed_E+0x4c3>
movl   $0x0,-0x44(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18b4 <R_Pauli_Fixed_E+0x704>
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1060 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%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    -0xb8(%rbp),%rdx
mov    $0x0,%al
call   1060 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%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    18a1 <R_Pauli_Fixed_E+0x6f1>
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x98(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%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    -0xb8(%rbp),%rdx
mov    $0x0,%al
call   1050 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1050 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%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    17b1 <R_Pauli_Fixed_E+0x601>
jmp    18a6 <R_Pauli_Fixed_E+0x6f6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    174b <R_Pauli_Fixed_E+0x59b>
mov    -0x1c(%rbp),%edi
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rsi
mov    $0x1,%al
call   1080 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x71d(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     195c <R_Pauli_Fixed_E+0x7ac>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%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)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18fe <R_Pauli_Fixed_E+0x74e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    199f <R_Pauli_Fixed_E+0x7ef>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%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    1965 <R_Pauli_Fixed_E+0x7b5>
mov    -0x98(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xb8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xb0(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xa8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xa0(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Pauli_Fixed_E>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,%rbx
mov    %r8,%r14
movaps %xmm1,0x70(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,(%rsp)
test   %esi,%esi
mov    %rsi,0x30(%rsp)
je     1217 <R_Pauli_Fixed_E+0x67>
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
movsd  0xe13(%rip),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
movsd  %xmm1,0x28(%rsp)
jb     1249 <R_Pauli_Fixed_E+0x99>
sqrtsd %xmm0,%xmm0
jmp    1264 <R_Pauli_Fixed_E+0xb4>
movsd  0xde1(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  0xdd9(%rip),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jb     12c9 <R_Pauli_Fixed_E+0x119>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    12d2 <R_Pauli_Fixed_E+0x122>
movsd  %xmm2,0x40(%rsp)
call   10a0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x40(%rsp),%xmm2
movsd  0x28(%rsp),%xmm1
movsd  %xmm0,0x20(%rsp)
movsd  0xd96(%rip),%xmm3
addsd  %xmm1,%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm4,%xmm0
jb     128e <R_Pauli_Fixed_E+0xde>
sqrtsd %xmm0,%xmm0
jmp    12a5 <R_Pauli_Fixed_E+0xf5>
movsd  %xmm3,0x40(%rsp)
call   10a0 <sqrt@plt>
movsd  0x40(%rsp),%xmm3
movsd  0x28(%rsp),%xmm1
mulsd  %xmm0,%xmm3
movsd  0x20(%rsp),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
addsd  %xmm1,%xmm1
addsd  0xd45(%rip),%xmm1
divsd  %xmm1,%xmm0
jmp    12d2 <R_Pauli_Fixed_E+0x122>
movapd %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   10d0 <N_LogGrid@plt>
mov    %eax,0x1c(%rsp)
xor    %eax,%eax
call   1040 <log_amesh_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x40(%rsp)
xor    %eax,%eax
call   1070 <r_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r15
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%rbp
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r12
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x10(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movapd 0x40(%rsp),%xmm9
mov    0x1c(%rsp),%esi
mov    %r12,%rdx
movslq %eax,%r12
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,0x28(%rsp)
movq   $0x0,0x18(%rbp)
test   %esi,%esi
mov    %rdx,0x38(%rsp)
mov    %r12,0x58(%rsp)
jle    13e3 <R_Pauli_Fixed_E+0x233>
mov    0x30(%rsp),%rcx
lea    0x1(%rcx),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm8
mulsd  %xmm9,%xmm9
mov    %esi,%ebp
cmp    $0x4,%esi
mov    (%rsp),%rdi
jae    1401 <R_Pauli_Fixed_E+0x251>
xor    %eax,%eax
movapd 0x70(%rsp),%xmm0
jmp    14e8 <R_Pauli_Fixed_E+0x338>
mov    (%rsp),%rdi
mov    %r12,%rsi
xor    %eax,%eax
mov    %rdx,%rbp
call   1030 <Derivative_LogGrid@plt>
mov    %rbp,%rsi
mov    0x10(%rsp),%rbp
jmp    18c9 <R_Pauli_Fixed_E+0x719>
lea    (%r15,%rbp,8),%rax
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
lea    (%rdi,%rbp,8),%rsi
cmp    %rcx,%r15
setb   %r10b
cmp    %rax,%r13
setb   %r8b
cmp    %rsi,%r15
setb   %cl
cmp    %rdi,%rax
seta   %r9b
xor    %eax,%eax
test   %r8b,%r10b
movapd 0x70(%rsp),%xmm0
jne    14e8 <R_Pauli_Fixed_E+0x338>
and    %r9b,%cl
jne    14e8 <R_Pauli_Fixed_E+0x338>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
lea    0x0(,%rbp,8),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdx,1),%xmm4
movupd 0x10(%r13,%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,%rcx
jne    1480 <R_Pauli_Fixed_E+0x2d0>
cmp    %rbp,%rax
je     1593 <R_Pauli_Fixed_E+0x3e3>
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     1524 <R_Pauli_Fixed_E+0x374>
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  (%rdi,%rax,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,(%r15,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
je     1593 <R_Pauli_Fixed_E+0x3e3>
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  (%rdi,%rax,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,(%r15,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x8(%rdi,%rax,8),%xmm2
subsd  %xmm0,%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
mulsd  %xmm9,%xmm2
movsd  %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1530 <R_Pauli_Fixed_E+0x380>
mov    %r12,%rsi
xor    %eax,%eax
movapd %xmm9,0x80(%rsp)
mov    %rbp,0x30(%rsp)
call   1030 <Derivative_LogGrid@plt>
mov    0x30(%rsp),%rdx
movapd 0x80(%rsp),%xmm15
movapd 0x70(%rsp),%xmm5
mov    (%rsp),%rdi
cmpl   $0x0,0x1c(%rsp)
mov    0x38(%rsp),%rsi
mov    0x10(%rsp),%rbp
jle    18c9 <R_Pauli_Fixed_E+0x719>
movapd 0xa4d(%rip),%xmm14
xorpd  0x40(%rsp),%xmm14
cmpl   $0x1,0x1c(%rsp)
jne    15f8 <R_Pauli_Fixed_E+0x448>
xor    %eax,%eax
jmp    1801 <R_Pauli_Fixed_E+0x651>
mov    %rsi,%rcx
mov    %r15,0x68(%rsp)
lea    (%rsi,%rdx,8),%rax
lea    0x0(,%rdx,8),%r15
add    %rbp,%r15
lea    0x0(,%rdx,8),%r8
add    %r13,%r8
lea    (%rdi,%rdx,8),%r10
cmp    %r15,%rsi
setb   0xf(%rsp)
cmp    %rax,0x10(%rsp)
setb   0xe(%rsp)
cmp    %r8,%rsi
setb   %r9b
cmp    %rax,%r13
setb   0xd(%rsp)
cmp    %r10,%rsi
setb   %r11b
cmp    %rdi,%rax
seta   0xc(%rsp)
lea    (%r12,%rdx,8),%rsi
cmp    %rsi,%rcx
setb   %dl
cmp    %rax,%r12
setb   0xb(%rsp)
cmp    %r8,0x10(%rsp)
setb   %r8b
cmp    %r15,%r13
setb   0xa(%rsp)
cmp    %r10,0x10(%rsp)
mov    0x10(%rsp),%rbp
setb   %r10b
cmp    %rdi,%r15
seta   0x9(%rsp)
cmp    %rsi,%rbp
setb   %dil
cmp    %r15,%r12
setb   %r12b
xor    %eax,%eax
mov    0xe(%rsp),%cl
test   %cl,0xf(%rsp)
jne    1fb1 <R_Pauli_Fixed_E+0xe01>
and    0xd(%rsp),%r9b
mov    0x68(%rsp),%r15
jne    1fb6 <R_Pauli_Fixed_E+0xe06>
and    0xc(%rsp),%r11b
mov    0x38(%rsp),%rsi
jne    1fbb <R_Pauli_Fixed_E+0xe0b>
mov    %r12d,%ecx
and    0xb(%rsp),%dl
mov    0x58(%rsp),%r12
mov    0x30(%rsp),%rdx
jne    17fd <R_Pauli_Fixed_E+0x64d>
and    0xa(%rsp),%r8b
jne    17fd <R_Pauli_Fixed_E+0x64d>
and    0x9(%rsp),%r10b
jne    17fd <R_Pauli_Fixed_E+0x64d>
and    %cl,%dil
mov    (%rsp),%rdi
jne    1801 <R_Pauli_Fixed_E+0x651>
mov    %edx,%eax
and    $0xfffffffe,%eax
movapd %xmm15,%xmm11
unpcklpd %xmm15,%xmm11
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
movapd %xmm14,%xmm13
unpcklpd %xmm14,%xmm13
xor    %ecx,%ecx
movapd 0x915(%rip),%xmm8
movapd 0x91d(%rip),%xmm0
movapd 0x924(%rip),%xmm12
movapd 0x92b(%rip),%xmm9
movapd 0x932(%rip),%xmm10
xchg   %ax,%ax
movupd 0x0(%r13,%rcx,8),%xmm7
movupd (%rdi,%rcx,8),%xmm4
movapd %xmm1,%xmm2
subpd  %xmm4,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm12,%xmm2
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm7
mulpd  %xmm11,%xmm7
subpd  %xmm1,%xmm4
movapd %xmm4,%xmm6
mulpd  %xmm8,%xmm6
movupd (%r12,%rcx,8),%xmm3
mulpd  %xmm0,%xmm3
divpd  %xmm2,%xmm3
mulpd  %xmm4,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm7,%xmm6
movupd %xmm6,(%rsi,%rcx,8)
movupd 0x0(%r13,%rcx,8),%xmm2
mulpd  %xmm13,%xmm2
mulpd  %xmm9,%xmm2
mulpd  %xmm10,%xmm2
movupd (%r12,%rcx,8),%xmm3
mulpd  %xmm2,%xmm3
movupd (%rdi,%rcx,8),%xmm2
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm12,%xmm4
divpd  %xmm4,%xmm3
movupd %xmm3,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1750 <R_Pauli_Fixed_E+0x5a0>
cmp    %rdx,%rax
jne    1801 <R_Pauli_Fixed_E+0x651>
jmp    18c9 <R_Pauli_Fixed_E+0x719>
mov    (%rsp),%rdi
movsd  0x7f6(%rip),%xmm8
movsd  0x7fe(%rip),%xmm2
movsd  0x7ee(%rip),%xmm3
movsd  0x7f5(%rip),%xmm9
movsd  0x7f4(%rip),%xmm10
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm6
movsd  (%rdi,%rax,8),%xmm7
movapd %xmm5,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm0
mulsd  %xmm6,%xmm6
mulsd  %xmm15,%xmm6
subsd  %xmm5,%xmm7
movapd %xmm7,%xmm1
mulsd  %xmm8,%xmm1
movsd  (%r12,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
divsd  %xmm0,%xmm4
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm6,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm10,%xmm0
mulsd  (%r12,%rax,8),%xmm0
movapd %xmm5,%xmm1
subsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1830 <R_Pauli_Fixed_E+0x680>
movsd  0x20(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x0(%r13),%xmm0
mov    %rsi,%r12
call   1090 <pow@plt>
movsd  %xmm0,(%r14)
mulsd  (%rsp),%xmm0
movsd  %xmm0,(%rbx)
movsd  0x0(%rbp),%xmm1
addsd  0x40(%rsp),%xmm1
movsd  (%r15),%xmm2
addsd  (%r12),%xmm2
mulsd  (%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%r13),%xmm0
movsd  0x20(%rsp),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x8(%r14)
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%rbp),%xmm1
addsd  0x40(%rsp),%xmm1
movsd  0x8(%r15),%xmm2
addsd  0x8(%r12),%xmm2
mulsd  0x8(%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x28(%rsp),%r12
movsd  %xmm1,0x8(%r12)
movsd  0x10(%r13),%xmm0
movsd  0x20(%rsp),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x10(%r14)
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%rbp),%xmm1
addsd  0x40(%rsp),%xmm1
movsd  0x10(%r15),%xmm2
mov    %r15,%rbp
mov    0x38(%rsp),%r15
addsd  0x10(%r15),%xmm2
mulsd  0x10(%r14),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%r12)
movsd  0x18(%r13),%xmm0
movsd  0x20(%rsp),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x18(%r14)
movsd  (%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx)
movapd %xmm1,%xmm2
mov    0x10(%rsp),%rax
movsd  0x18(%rax),%xmm0
addsd  0x40(%rsp),%xmm0
mov    %rbp,%r12
movsd  0x18(%rbp),%xmm1
addsd  0x18(%r15),%xmm1
mulsd  0x18(%r14),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rsp),%rax
movsd  %xmm0,0x18(%rax)
cmpl   $0x3,0x60(%rsp)
jle    1b30 <R_Pauli_Fixed_E+0x980>
mov    0x60(%rsp),%eax
mov    %rax,(%rsp)
mov    $0x3,%r13d
jmp    1a5a <R_Pauli_Fixed_E+0x8aa>
nopl   0x0(%rax,%rax,1)
cmp    (%rsp),%r13
je     1b30 <R_Pauli_Fixed_E+0x980>
mov    %r13,%rbp
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1060 <Predictor_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
add    $0x1,%r13
movsd  %xmm0,0x8(%r14,%rbp,8)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    0x28(%rsp),%rdx
xor    %eax,%eax
call   1060 <Predictor_Out@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0x8(%rbx,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
mov    $0x5,%r15d
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
addsd  0x40(%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    0x28(%rsp),%rdx
movsd  %xmm3,(%rdx,%r13,8)
mov    %ebp,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rbx,%r13,8)
mov    %ebp,%edi
mov    %r14,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14,%r13,8)
sub    $0x1,%r15d
jb     1a50 <R_Pauli_Fixed_E+0x8a0>
movsd  (%rbx,%r13,8),%xmm1
jmp    1ab0 <R_Pauli_Fixed_E+0x900>
mov    0x60(%rsp),%rdi
movsd  0x20(%rsp),%xmm0
mov    %r14,%rsi
mov    $0x1,%al
call   1080 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1b5c <R_Pauli_Fixed_E+0x9ac>
sqrtsd %xmm0,%xmm0
jmp    1b61 <R_Pauli_Fixed_E+0x9b1>
call   10a0 <sqrt@plt>
mov    0x10(%rsp),%rbp
mov    0x1c(%rsp),%r11d
mov    0x60(%rsp),%rcx
lea    0x1(%rcx),%eax
test   %ecx,%ecx
mov    %r12,%rdi
mov    0x38(%rsp),%r15
mov    0x58(%rsp),%r12
js     1d66 <R_Pauli_Fixed_E+0xbb6>
movsd  0x478(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    %eax,%ecx
cmp    $0x4,%eax
jb     1bb5 <R_Pauli_Fixed_E+0xa05>
lea    (%rbx,%rcx,8),%rdx
cmp    %r14,%rdx
jbe    1c3e <R_Pauli_Fixed_E+0xa8e>
lea    (%r14,%rcx,8),%rdx
cmp    %rbx,%rdx
jbe    1c3e <R_Pauli_Fixed_E+0xa8e>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     1be4 <R_Pauli_Fixed_E+0xa34>
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     1d66 <R_Pauli_Fixed_E+0xbb6>
nopl   (%rax)
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    1bf0 <R_Pauli_Fixed_E+0xa40>
jmp    1d66 <R_Pauli_Fixed_E+0xbb6>
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     1fa0 <R_Pauli_Fixed_E+0xdf0>
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    1c80 <R_Pauli_Fixed_E+0xad0>
test   $0x1,%r8b
je     1d58 <R_Pauli_Fixed_E+0xba8>
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    0x10(%rsp),%rbp
jne    1bb7 <R_Pauli_Fixed_E+0xa07>
cmp    %r11d,%eax
jge    1f5e <R_Pauli_Fixed_E+0xdae>
cltq
mov    %r11d,%r9d
sub    0x60(%rsp),%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     1ec0 <R_Pauli_Fixed_E+0xd10>
lea    (%r14,%rax,8),%rdx
lea    (%r9,%rax,1),%rcx
lea    (%rbx,%rcx,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%rdx
jae    1db1 <R_Pauli_Fixed_E+0xc01>
lea    (%r14,%rcx,8),%rcx
add    $0x8,%rcx
lea    (%rbx,%rax,8),%rdx
cmp    %rcx,%rdx
jb     1ec0 <R_Pauli_Fixed_E+0xd10>
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    1ddf <R_Pauli_Fixed_E+0xc2f>
xor    %ebp,%ebp
jmp    1e68 <R_Pauli_Fixed_E+0xcb8>
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    1e00 <R_Pauli_Fixed_E+0xc50>
test   %r10,%r10
je     1eaf <R_Pauli_Fixed_E+0xcff>
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    1e90 <R_Pauli_Fixed_E+0xce0>
cmp    %r8,%r9
mov    0x10(%rsp),%rbp
je     1f5e <R_Pauli_Fixed_E+0xdae>
add    %r8,%rax
mov    %r11d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r11d,%ecx
and    $0x3,%edx
je     1ef9 <R_Pauli_Fixed_E+0xd49>
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    1ee0 <R_Pauli_Fixed_E+0xd30>
cmp    $0x3,%ecx
jb     1f5e <R_Pauli_Fixed_E+0xdae>
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    1f10 <R_Pauli_Fixed_E+0xd60>
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    0x28(%rsp),%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %r12,%rdi
xor    %eax,%eax
add    $0x98,%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    1d18 <R_Pauli_Fixed_E+0xb68>
jmp    1d58 <R_Pauli_Fixed_E+0xba8>
mov    0x68(%rsp),%r15
mov    0x38(%rsp),%rsi
mov    0x58(%rsp),%r12
mov    (%rsp),%rdi
mov    0x30(%rsp),%rdx
jmp    1801 <R_Pauli_Fixed_E+0x651>

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

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