void R_ZORA_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]) * (v[i] - E) +
             0.5 * fss * dv[i] * kappa / (r[i] * (1.0 - 0.5 * fss * (v[i]))));
    frp[i] = -log_amesh * r[i] * 0.5 * fss * dv[i] / (1.0 - 0.5 * fss * (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_ZORA_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_ZORA_Fixed_E+0xa7>
cmpl   $0x0,-0xc(%rbp)
jle    1248 <R_ZORA_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_ZORA_Fixed_E+0xa2>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1257 <R_ZORA_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>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    $0x0,%al
call   1070 <r_LogGrid@plt>
cltq
mov    %rax,-0xa0(%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,-0xc8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xc0(%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)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1374 <R_ZORA_Fixed_E+0x1c4>
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    1329 <R_ZORA_Fixed_E+0x179>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1411 <R_ZORA_Fixed_E+0x261>
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  0xc45(%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    137b <R_ZORA_Fixed_E+0x1cb>
mov    -0x20(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15ed <R_ZORA_Fixed_E+0x43d>
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
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x30(%rbp),%xmm3
movsd  0xb6a(%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  0xb38(%rip),%xmm5
mulsd  -0x70(%rbp),%xmm5
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm6
movq   %xmm5,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm5
mulsd  %xmm6,%xmm5
movsd  0xafb(%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  0xaa7(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xa86(%rip),%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
movsd  0xa49(%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    142a <R_ZORA_Fixed_E+0x27a>
movsd  0xa1b(%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    1635 <R_ZORA_Fixed_E+0x485>
movsd  0x9e3(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1601 <R_ZORA_Fixed_E+0x451>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1722 <R_ZORA_Fixed_E+0x572>
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    163c <R_ZORA_Fixed_E+0x48c>
movl   $0x0,-0x44(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18ce <R_ZORA_Fixed_E+0x71e>
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    0x10(%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)
mov    -0x3c(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0xc8(%rbp),%rdx
mov    $0x0,%al
call   1060 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
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    1886 <R_ZORA_Fixed_E+0x6d6>
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
mov    $0x0,%al
call   1050 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
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
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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1796 <R_ZORA_Fixed_E+0x5e6>
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     18bb <R_ZORA_Fixed_E+0x70b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18c0 <R_ZORA_Fixed_E+0x710>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1730 <R_ZORA_Fixed_E+0x580>
mov    -0x24(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%rsi
mov    $0x1,%al
call   1080 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x70b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1976 <R_ZORA_Fixed_E+0x7c6>
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    1918 <R_ZORA_Fixed_E+0x768>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    19b9 <R_ZORA_Fixed_E+0x809>
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    197f <R_ZORA_Fixed_E+0x7cf>
mov    -0xa8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xc8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0xc0(%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>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_ZORA_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_ZORA_Fixed_E+0x33>
test   %edx,%edx
jle    11ed <R_ZORA_Fixed_E+0x3d>
cvtsi2sd %r13d,%xmm2
jmp    11f3 <R_ZORA_Fixed_E+0x43>
movsd  0x1e15(%rip),%xmm2
jmp    11f3 <R_ZORA_Fixed_E+0x43>
cvtsi2sdl 0x70(%rsp),%xmm2
movapd %xmm2,0xb0(%rsp)
movaps %xmm1,0xa0(%rsp)
mov    %rcx,0x10(%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_ZORA_Fixed_E+0x94>
sqrtsd %xmm0,%xmm0
jmp    1249 <R_ZORA_Fixed_E+0x99>
call   10a0 <sqrt@plt>
movsd  %xmm0,0x48(%rsp)
xor    %eax,%eax
call   10d0 <N_LogGrid@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1040 <log_amesh_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x60(%rsp)
xor    %eax,%eax
call   1070 <r_LogGrid@plt>
cltq
mov    %rax,0x30(%rsp)
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>
cltq
mov    %rax,0x28(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movapd 0x60(%rsp),%xmm9
movslq %eax,%rsi
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   %r12d,%r12d
mov    %rsi,0x20(%rsp)
mov    %r12d,0x3c(%rsp)
jle    136b <R_ZORA_Fixed_E+0x1bb>
mov    0x70(%rsp),%rcx
lea    0x1(%rcx),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm8
mulsd  %xmm9,%xmm9
mov    %r12d,%r10d
cmp    $0x4,%r12d
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%rdi
jae    138b <R_ZORA_Fixed_E+0x1db>
xor    %eax,%eax
mov    0x30(%rsp),%rbp
movapd 0xa0(%rsp),%xmm0
jmp    1476 <R_ZORA_Fixed_E+0x2c6>
mov    0x10(%rsp),%rdi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%rsi
jmp    18a1 <R_ZORA_Fixed_E+0x6f1>
lea    (%r15,%r10,8),%rax
mov    0x30(%rsp),%rbp
lea    0x0(,%r10,8),%rcx
add    %rbp,%rcx
lea    (%rdi,%r10,8),%rdx
cmp    %rcx,%r15
setb   %r8b
cmp    %rax,%rbp
setb   %r9b
cmp    %rdx,%r15
setb   %cl
cmp    %rdi,%rax
seta   %dl
xor    %eax,%eax
test   %r9b,%r8b
movapd 0xa0(%rsp),%xmm0
jne    1476 <R_ZORA_Fixed_E+0x2c6>
and    %dl,%cl
jne    1476 <R_ZORA_Fixed_E+0x2c6>
mov    %r10d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
lea    0x0(,%r10,8),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
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,%rcx
jne    1410 <R_ZORA_Fixed_E+0x260>
cmp    %r10,%rax
je     1521 <R_ZORA_Fixed_E+0x371>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r10b
je     14b1 <R_ZORA_Fixed_E+0x301>
movsd  0x0(%rbp,%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    %r10,%rcx
je     1521 <R_ZORA_Fixed_E+0x371>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%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(%rbp,%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,%r10
jne    14c0 <R_ZORA_Fixed_E+0x310>
xor    %eax,%eax
movapd %xmm9,0x90(%rsp)
mov    %r10,0x40(%rsp)
call   1030 <Derivative_LogGrid@plt>
mov    0x40(%rsp),%r10
movapd 0x90(%rsp),%xmm10
movapd 0xa0(%rsp),%xmm15
mov    0x10(%rsp),%rdx
mov    0x20(%rsp),%rdi
cmpl   $0x0,0x3c(%rsp)
mov    0x28(%rsp),%rsi
movapd 0xb0(%rsp),%xmm13
jle    18a1 <R_ZORA_Fixed_E+0x6f1>
movapd 0x1ac3(%rip),%xmm14
xorpd  %xmm14,%xmm10
xorpd  0x60(%rsp),%xmm14
cmpl   $0x1,0x3c(%rsp)
jne    1597 <R_ZORA_Fixed_E+0x3e7>
xor    %eax,%eax
jmp    17df <R_ZORA_Fixed_E+0x62f>
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   0xf(%rsp)
cmp    %rax,0x18(%rsp)
setb   0xe(%rsp)
cmp    %r12,%rsi
setb   %r11b
cmp    %rax,%rbp
setb   0xd(%rsp)
cmp    %r8,%rsi
setb   %r9b
cmp    %rdx,%rax
seta   0xc(%rsp)
lea    (%rdi,%r10,8),%rsi
cmp    %rsi,%rcx
setb   %r10b
cmp    %rax,%rdi
setb   0xb(%rsp)
cmp    %r12,0x18(%rsp)
setb   0xa(%rsp)
cmp    %r15,%rbp
setb   %bpl
cmp    %r8,0x18(%rsp)
mov    0x18(%rsp),%r12
setb   %r8b
cmp    %rdx,%r15
seta   0x9(%rsp)
cmp    %rsi,%r12
setb   %cl
cmp    %r15,%rdi
setb   %dil
xor    %eax,%eax
mov    0xe(%rsp),%dl
test   %dl,0xf(%rsp)
jne    17be <R_ZORA_Fixed_E+0x60e>
and    0xd(%rsp),%r11b
mov    0x90(%rsp),%r15
jne    17c6 <R_ZORA_Fixed_E+0x616>
and    0xc(%rsp),%r9b
mov    0x28(%rsp),%rsi
jne    17cb <R_ZORA_Fixed_E+0x61b>
mov    %edi,%r9d
mov    %ebp,%edi
and    0xb(%rsp),%r10b
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%rdx
jne    17b7 <R_ZORA_Fixed_E+0x607>
and    %dil,0xa(%rsp)
mov    0x40(%rsp),%r10
jne    17b0 <R_ZORA_Fixed_E+0x600>
and    0x9(%rsp),%r8b
jne    17b0 <R_ZORA_Fixed_E+0x600>
and    %r9b,%cl
mov    0x20(%rsp),%rdi
jne    17df <R_ZORA_Fixed_E+0x62f>
mov    %r10d,%eax
and    $0xfffffffe,%eax
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm10
movapd %xmm15,%xmm11
unpcklpd %xmm15,%xmm11
unpcklpd %xmm13,%xmm13
movapd %xmm14,%xmm4
unpcklpd %xmm14,%xmm4
xor    %ecx,%ecx
movapd 0x1976(%rip),%xmm12
movapd 0x197d(%rip),%xmm8
movapd 0x1985(%rip),%xmm7
movapd 0x198d(%rip),%xmm6
movapd 0x1994(%rip),%xmm9
nopl   0x0(%rax)
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd (%rdx,%rcx,8),%xmm2
movapd %xmm2,%xmm5
movapd %xmm2,%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm6,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm10,%xmm1
mulpd  %xmm12,%xmm5
subpd  %xmm11,%xmm3
mulpd  %xmm5,%xmm3
movupd (%rdi,%rcx,8),%xmm5
mulpd  %xmm8,%xmm5
mulpd  %xmm13,%xmm5
divpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm1,%xmm5
movupd %xmm5,(%rsi,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm1
mulpd  %xmm4,%xmm1
mulpd  %xmm9,%xmm1
mulpd  %xmm12,%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm1,%xmm2
movupd (%rdx,%rcx,8),%xmm1
mulpd  %xmm7,%xmm1
addpd  %xmm6,%xmm1
divpd  %xmm1,%xmm2
movupd %xmm2,(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1700 <R_ZORA_Fixed_E+0x550>
cmp    %r10,%rax
movapd 0xb0(%rsp),%xmm13
movapd %xmm0,%xmm10
jne    17df <R_ZORA_Fixed_E+0x62f>
jmp    18a1 <R_ZORA_Fixed_E+0x6f1>
mov    0x20(%rsp),%rdi
jmp    17df <R_ZORA_Fixed_E+0x62f>
mov    0x20(%rsp),%rdi
jmp    17da <R_ZORA_Fixed_E+0x62a>
mov    0x90(%rsp),%r15
mov    0x28(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%rdx
mov    0x40(%rsp),%r10
movsd  0x1829(%rip),%xmm1
movsd  0x1828(%rip),%xmm8
movsd  0x1828(%rip),%xmm3
movsd  0x1828(%rip),%xmm4
movsd  0x1828(%rip),%xmm5
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm6
movsd  (%rdx,%rax,8),%xmm7
movapd %xmm7,%xmm0
movapd %xmm7,%xmm2
mulsd  %xmm3,%xmm7
addsd  %xmm4,%xmm7
mulsd  %xmm6,%xmm7
mulsd  %xmm6,%xmm6
mulsd  %xmm10,%xmm6
mulsd  %xmm1,%xmm0
subsd  %xmm15,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm13,%xmm0
divsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm6,%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm4,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1810 <R_ZORA_Fixed_E+0x660>
mov    0x8c(%rsp),%ecx
add    %ecx,%r13d
movsd  0x1775(%rip),%xmm1
test   %r13d,%r13d
jle    190b <R_ZORA_Fixed_E+0x75b>
sub    0x70(%rsp),%ecx
add    $0xfffffffe,%ecx
mov    %r13d,%eax
and    $0x7,%eax
cmp    $0x7,%ecx
jb     18d6 <R_ZORA_Fixed_E+0x726>
and    $0xfffffff8,%r13d
xchg   %ax,%ax
add    $0xfffffff8,%r13d
jne    18d0 <R_ZORA_Fixed_E+0x720>
mov    %rsi,%r13
test   %eax,%eax
movapd 0x60(%rsp),%xmm3
je     1914 <R_ZORA_Fixed_E+0x764>
movsd  0x173d(%rip),%xmm1
movapd 0x174d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm1
add    $0xffffffff,%eax
jne    1900 <R_ZORA_Fixed_E+0x750>
jmp    1914 <R_ZORA_Fixed_E+0x764>
mov    %rsi,%r13
movapd 0x60(%rsp),%xmm3
movapd %xmm1,0x70(%rsp)
movsd  0x48(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x0(%rbp),%xmm0
call   1090 <pow@plt>
mulsd  0x70(%rsp),%xmm0
movsd  %xmm0,(%r14)
mulsd  0x10(%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  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%r12),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  0x8(%r15),%xmm2
mov    0x28(%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  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r12),%xmm1
addsd  0x60(%rsp),%xmm1
movsd  0x10(%r15),%xmm2
mov    %r15,%r12
mov    0x28(%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  0x10(%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    1b90 <R_ZORA_Fixed_E+0x9e0>
mov    0x50(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    $0x3,%r13d
jmp    1abb <R_ZORA_Fixed_E+0x90b>
nopw   0x0(%rax,%rax,1)
cmp    0x10(%rsp),%r13
je     1b90 <R_ZORA_Fixed_E+0x9e0>
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    0x58(%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
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
addsd  0x60(%rsp),%xmm2
movsd  (%r12,%r13,8),%xmm3
mov    0x28(%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
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     1ab0 <R_ZORA_Fixed_E+0x900>
movsd  (%rbx,%r13,8),%xmm1
jmp    1b10 <R_ZORA_Fixed_E+0x960>
mov    0x50(%rsp),%rdi
movsd  0x48(%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     1bbc <R_ZORA_Fixed_E+0xa0c>
sqrtsd %xmm0,%xmm0
jmp    1bc1 <R_ZORA_Fixed_E+0xa11>
call   10a0 <sqrt@plt>
mov    0x18(%rsp),%rbp
mov    0x50(%rsp),%rcx
lea    0x1(%rcx),%eax
test   %ecx,%ecx
mov    0x28(%rsp),%r15
mov    0x3c(%rsp),%r11d
js     1dc6 <R_ZORA_Fixed_E+0xc16>
movsd  0x1440(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    %eax,%ecx
cmp    $0x4,%eax
jb     1c0d <R_ZORA_Fixed_E+0xa5d>
lea    (%rbx,%rcx,8),%rdx
cmp    %r14,%rdx
jbe    1c9e <R_ZORA_Fixed_E+0xaee>
lea    (%r14,%rcx,8),%rdx
cmp    %rbx,%rdx
jbe    1c9e <R_ZORA_Fixed_E+0xaee>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     1c3c <R_ZORA_Fixed_E+0xa8c>
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     1dc6 <R_ZORA_Fixed_E+0xc16>
cs nopw 0x0(%rax,%rax,1)
nop
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    1c50 <R_ZORA_Fixed_E+0xaa0>
jmp    1dc6 <R_ZORA_Fixed_E+0xc16>
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     2005 <R_ZORA_Fixed_E+0xe55>
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    1ce0 <R_ZORA_Fixed_E+0xb30>
test   $0x1,%r8b
je     1db8 <R_ZORA_Fixed_E+0xc08>
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    1c0f <R_ZORA_Fixed_E+0xa5f>
cmp    %r11d,%eax
jge    1fbe <R_ZORA_Fixed_E+0xe0e>
cltq
mov    %r11d,%r9d
sub    0x50(%rsp),%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     1f20 <R_ZORA_Fixed_E+0xd70>
lea    (%r14,%rax,8),%rdx
lea    (%r9,%rax,1),%rcx
lea    (%rbx,%rcx,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%rdx
jae    1e11 <R_ZORA_Fixed_E+0xc61>
lea    (%r14,%rcx,8),%rcx
add    $0x8,%rcx
lea    (%rbx,%rax,8),%rdx
cmp    %rcx,%rdx
jb     1f20 <R_ZORA_Fixed_E+0xd70>
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    1e3f <R_ZORA_Fixed_E+0xc8f>
xor    %ebp,%ebp
jmp    1ec8 <R_ZORA_Fixed_E+0xd18>
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    1e60 <R_ZORA_Fixed_E+0xcb0>
test   %r10,%r10
je     1f0f <R_ZORA_Fixed_E+0xd5f>
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    1ef0 <R_ZORA_Fixed_E+0xd40>
cmp    %r8,%r9
mov    0x18(%rsp),%rbp
je     1fbe <R_ZORA_Fixed_E+0xe0e>
add    %r8,%rax
mov    %r11d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r11d,%ecx
and    $0x3,%edx
je     1f59 <R_ZORA_Fixed_E+0xda9>
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    1f40 <R_ZORA_Fixed_E+0xd90>
cmp    $0x3,%ecx
jb     1fbe <R_ZORA_Fixed_E+0xe0e>
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    1f70 <R_ZORA_Fixed_E+0xdc0>
mov    %r12,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    0x58(%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    0x20(%rsp),%rdi
xor    %eax,%eax
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    1d78 <R_ZORA_Fixed_E+0xbc8>
jmp    1db8 <R_ZORA_Fixed_E+0xc08>

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

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