void R_Pauli(n, l, Z, v, mch, Eig, u, uprime) int n, l;
double Z;
double v[];
int *mch;
double *Eig;
double u[], uprime[];
{
  int i, j, iteration, node, match, Ninf, Ngrid;
  double E, de, Emax, Emin, log_amesh, log_amesh2, fss, gamma, L2, L0, r2, sum,
      a, scale, m1scale, uout, upout, upin, *r, *f_upp, *dv, *frp, *fr, *upp;
  E = *Eig;
  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();
  Emax = v[Ngrid - 1] + 0.5 * L2 / (r[Ngrid - 1] * r[Ngrid - 1]);
  Emin = 0.0;
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i];
    r2 = r2 * r2;
    Emin = ((Emin < (v[i] + 0.5 * L2 / r2)) ? Emin : (v[i] + 0.5 * L2 / r2));
  }
  if (E > Emax)
    E = 1.25 * Emax;
  if (E < Emin)
    E = 0.75 * Emin;
  if (E > Emax)
    E = 0.5 * (Emax + Emin);
  for (i = 0; i < 4; ++i) {
    u[i] = 0.0;
    uprime[i] = 0.0;
    upp[i] = 0.0;
  }
  iteration = 0;
  while (iteration < 100) {
    ++iteration;
    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]));
    }
    match = Ngrid - 1;
    while (f_upp[match - 1] * f_upp[match] > 0.0) {
      match = match - 1;
      if (match < 2) {
        printf("Error in R_Pauli: no turning point\n");
        dealloc_LogGrid(f_upp);
        dealloc_LogGrid(upp);
        dealloc_LogGrid(fr);
        dealloc_LogGrid(frp);
        dealloc_LogGrid(dv);
        return;
      }
    }
    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;
    }
    uout = u[match];
    upout = uprime[match];
    if ((node - n + l + 1) < 0) {
      Emin = E;
      E = 0.5 * (Emin + Emax);
    } else if ((node - n + l + 1) > 0) {
      Emax = E;
      E = 0.5 * (Emin + Emax);
    } else {
      Ninf = match + floor(2.3 / log_amesh);
      if ((Ninf + 5) > Ngrid)
        Ninf = Ngrid - 5;
      a = sqrt(L2 / (r[Ninf] * r[Ninf]) + 2.0 * (v[Ninf] - E));
      for (i = Ninf; i <= (Ninf + 4); ++i) {
        u[i] = exp(-a * (r[i] - r[Ninf]));
        uprime[i] = -r[i] * log_amesh * a * u[i];
        upp[i] = (log_amesh + frp[i]) * uprime[i] + (f_upp[i] + fr[i]) * u[i];
      }
      for (i = Ninf; i >= (match + 1); --i) {
        u[i - 1] = Predictor_In(i, u, uprime);
        uprime[i - 1] = Predictor_In(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_In(i, uprime, upp);
          u[i - 1] = Corrector_In(i, u, uprime);
        }
      }
      scale = uout / u[match];
      for (i = match; i <= Ninf; ++i) {
        u[i] = scale * u[i];
        uprime[i] = scale * uprime[i];
      }
      upin = uprime[match];
      sum = Norm_LogGrid(Ninf, gamma, u);
      sum = 1.0 / sqrt(sum);
      uout = sum * uout;
      upout = sum * upout;
      upin = sum * upin;
      for (i = 0; i <= Ninf; ++i) {
        u[i] = sum * u[i];
        uprime[i] = sum * uprime[i];
      }
      for (i = Ninf + 1; i < Ngrid; ++i) {
        u[i] = 0.0;
        uprime[i] = 0.0;
      }
      de = 0.5 * uout * (upout - upin) / (log_amesh * r[match]);
      if (fabs(de) < (((fabs(E) > 0.2) ? fabs(E) : 0.2) * 1.0e-10)) {
        *mch = match;
        *Eig = E;
        dealloc_LogGrid(f_upp);
        dealloc_LogGrid(upp);
        dealloc_LogGrid(fr);
        dealloc_LogGrid(frp);
        dealloc_LogGrid(dv);
        return;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  printf("Error R_Pauli: More than %d iterations\n", 100);
  *mch = match;
  *Eig = E;
  dealloc_LogGrid(f_upp);
  dealloc_LogGrid(upp);
  dealloc_LogGrid(fr);
  dealloc_LogGrid(frp);
  dealloc_LogGrid(dv);
  return;
}


x86 assembly (clang, -O0):
<R_Pauli>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1da9(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x8(%rbp)
jne    12cc <R_Pauli+0xcc>
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d52(%rip),%xmm1
addsd  %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13e0 <R_Pauli+0x1e0>
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
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   10e0 <sqrt@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  0x1cc9(%rip),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  0x1cb9(%rip),%xmm2
addsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
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   10e0 <sqrt@plt>
movsd  -0x120(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
ff
movsd  0x1c60(%rip),%xmm3
addsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
movsd  0x1c38(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    $0x0,%al
call   1110 <N_LogGrid@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    $0x0,%al
call   1080 <r_LogGrid@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xf0(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    $0x0,%al
call   1100 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1b8d(%rip),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mov    -0xe8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xe8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    15a3 <R_Pauli+0x3a3>
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1ae9(%rip),%xmm2
mulsd  -0x98(%rbp),%xmm2
ff
divsd  -0xa8(%rbp),%xmm2
ff
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1557 <R_Pauli+0x357>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1588 <R_Pauli+0x388>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1aa4(%rip),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
divsd  -0xa8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14d1 <R_Pauli+0x2d1>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    15c5 <R_Pauli+0x3c5>
movsd  0x1a5d(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15eb <R_Pauli+0x3eb>
movsd  0x1a3f(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1616 <R_Pauli+0x416>
movsd  -0x68(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x1a03(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1668 <R_Pauli+0x468>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    161d <R_Pauli+0x41d>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x64,-0x3c(%rbp)
jge    2400 <R_Pauli+0x1200>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1722 <R_Pauli+0x522>
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0x195c(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1689 <R_Pauli+0x489>
mov    -0x18(%rbp),%rdi
mov    -0xf8(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    18ed <R_Pauli+0x6ed>
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x58(%rbp),%xmm3
movsd  0x1845(%rip),%xmm2
mulsd  -0x88(%rbp),%xmm2
ff
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x1815(%rip),%xmm5
mulsd  -0x88(%rbp),%xmm5
ff
movsd  -0x58(%rbp),%xmm6
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0x17e7(%rip),%xmm6
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1793(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x176f(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1741(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    173b <R_Pauli+0x53b>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0xf0(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1999 <R_Pauli+0x799>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    1994 <R_Pauli+0x794>
lea    0x171e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xf0(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
jmp    246f <R_Pauli+0x126f>
jmp    18f6 <R_Pauli+0x6f6>
movsd  0x1667(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    19ea <R_Pauli+0x7ea>
movsd  0x1674(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19b0 <R_Pauli+0x7b0>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1ae0 <R_Pauli+0x8e0>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
call   10d0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19f1 <R_Pauli+0x7f1>
movl   $0x0,-0x40(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1c8c <R_Pauli+0xa8c>
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   1070 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0x110(%rbp),%rdx
mov    $0x0,%al
call   1070 <Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    1c44 <R_Pauli+0xa44>
movsd  -0x78(%rbp),%xmm0
mov    -0x100(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0x110(%rbp),%rdx
mov    $0x0,%al
call   1060 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   1060 <Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b54 <R_Pauli+0x954>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1c79 <R_Pauli+0xa79>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c7e <R_Pauli+0xa7e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1aee <R_Pauli+0x8ee>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    1cf5 <R_Pauli+0xaf5>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x1329(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    23fb <R_Pauli+0x11fb>
mov    -0x40(%rbp),%eax
sub    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1d34 <R_Pauli+0xb34>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x12ea(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    23f6 <R_Pauli+0x11f6>
cvtsi2sdl -0x44(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0x12df(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
call   1120 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x138(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x5,%eax
cmp    -0x4c(%rbp),%eax
jle    1d81 <R_Pauli+0xb81>
mov    -0x4c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
mov    -0xe8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     1f03 <R_Pauli+0xd03>
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1dda <R_Pauli+0xbda>
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     2077 <R_Pauli+0xe77>
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   10c0 <Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0x110(%rbp),%rdx
mov    $0x0,%al
call   10c0 <Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    2064 <R_Pauli+0xe64>
movsd  -0x78(%rbp),%xmm0
mov    -0x100(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    0x10(%rbp),%rsi
mov    -0x110(%rbp),%rdx
mov    $0x0,%al
call   10b0 <Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x0,%al
call   10b0 <Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1f74 <R_Pauli+0xd74>
jmp    2069 <R_Pauli+0xe69>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1f09 <R_Pauli+0xd09>
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     20f8 <R_Pauli+0xef8>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    209a <R_Pauli+0xe9a>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%edi
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rsi
mov    $0x1,%al
call   10a0 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xec1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     2200 <R_Pauli+0x1000>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    21a2 <R_Pauli+0xfa2>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    2243 <R_Pauli+0x1043>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2209 <R_Pauli+0x1009>
movsd  0xdc5(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xdbf(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movaps 0xda7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xd7b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    22dc <R_Pauli+0x10dc>
movsd  -0x58(%rbp),%xmm0
movaps 0xd85(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    22f1 <R_Pauli+0x10f1>
movsd  0xd4c(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    22f1 <R_Pauli+0x10f1>
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
movsd  0xd2f(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    2378 <R_Pauli+0x1178>
mov    -0x44(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf0(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
jmp    246f <R_Pauli+0x126f>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2399 <R_Pauli+0x1199>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    23a3 <R_Pauli+0x11a3>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
ja     23d6 <R_Pauli+0x11d6>
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    23f1 <R_Pauli+0x11f1>
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0xc28(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    23f6 <R_Pauli+0x11f6>
jmp    23fb <R_Pauli+0x11fb>
jmp    166f <R_Pauli+0x46f>
lea    0xc7d(%rip),%rdi
mov    $0x64,%esi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x44(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf0(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10f0 <dealloc_LogGrid@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Pauli>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x258,%rsp
mov    %r9,%r12
mov    %rcx,0x140(%rsp)
mov    %rdx,%r15
mov    %esi,%ebx
mov    %edi,%r13d
mov    0x290(%rsp),%r14
mov    %r8,0x148(%rsp)
movsd  (%r8),%xmm2
lea    0x1(%rbx),%eax
imul   %esi,%eax
cvtsi2sd %eax,%xmm1
movapd %xmm1,0x130(%rsp)
test   %esi,%esi
mov    %rbx,0x188(%rsp)
movapd %xmm2,0xe0(%rsp)
je     12aa <R_Pauli+0x9a>
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd  0x1d80(%rip),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
movsd  %xmm1,0x18(%rsp)
jb     12dc <R_Pauli+0xcc>
sqrtsd %xmm0,%xmm0
jmp    12f5 <R_Pauli+0xe5>
movsd  0x1d4e(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  0x1d46(%rip),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jb     1358 <R_Pauli+0x148>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1361 <R_Pauli+0x151>
movsd  %xmm3,(%rsp)
call   10f0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  (%rsp),%xmm3
movsd  0x18(%rsp),%xmm1
movsd  %xmm0,0x38(%rsp)
movsd  0x1d05(%rip),%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm4,%xmm0
jb     131f <R_Pauli+0x10f>
sqrtsd %xmm0,%xmm0
jmp    1334 <R_Pauli+0x124>
movsd  %xmm2,(%rsp)
call   10f0 <sqrt@plt>
movsd  (%rsp),%xmm2
movsd  0x18(%rsp),%xmm1
mulsd  %xmm0,%xmm2
movsd  0x38(%rsp),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm1
addsd  0x1cb6(%rip),%xmm1
divsd  %xmm1,%xmm0
jmp    1361 <R_Pauli+0x151>
movapd %xmm1,%xmm0
call   10f0 <sqrt@plt>
movsd  %xmm0,0x38(%rsp)
xor    %eax,%eax
call   1120 <N_LogGrid@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1050 <log_amesh_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x50(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0xd0(%rsp)
xor    %eax,%eax
call   1090 <r_LogGrid@plt>
movslq %eax,%rbp
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
cltq
mov    %rax,(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
cltq
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
cltq
mov    %rax,0x20(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
cltq
mov    %rax,0x10(%rsp)
xor    %eax,%eax
call   1110 <alloc_LogGrid@plt>
mov    %rbp,%rdx
movslq %eax,%rbp
movslq %ebx,%rax
add    $0xffffffff,%ebx
mov    %ebx,0x48(%rsp)
lea    -0x1(%rax),%rcx
mov    %rcx,0xa0(%rsp)
movsd  0x1c13(%rip),%xmm0
mulsd  0x130(%rsp),%xmm0
movsd  -0x8(%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm4
divsd  %xmm1,%xmm4
addsd  -0x8(%r15,%rax,8),%xmm4
mov    %eax,%esi
xorpd  %xmm5,%xmm5
test   %eax,%eax
jle    14ae <R_Pauli+0x29e>
cmp    $0x1,%esi
jne    143a <R_Pauli+0x22a>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
jmp    1491 <R_Pauli+0x281>
mov    %esi,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm5,%xmm5
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rax,8),%xmm1
movsd  0x8(%rdx,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm3
divsd  %xmm1,%xmm3
addsd  (%r15,%rax,8),%xmm3
mulsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
divsd  %xmm2,%xmm1
addsd  0x8(%r15,%rax,8),%xmm1
minsd  %xmm3,%xmm5
minsd  %xmm1,%xmm5
add    $0x2,%rax
cmp    %rax,%rcx
jne    1450 <R_Pauli+0x240>
test   $0x1,%sil
je     14ae <R_Pauli+0x29e>
movsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
addsd  (%r15,%rax,8),%xmm0
minsd  %xmm0,%xmm5
movsd  0x1b62(%rip),%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm4,%xmm1
movapd 0xe0(%rsp),%xmm2
cmpltsd %xmm2,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movsd  0x1b40(%rip),%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm1,%xmm2
cmpltsd %xmm5,%xmm2
movapd %xmm2,%xmm3
andnpd %xmm1,%xmm3
andpd  %xmm0,%xmm2
movapd %xmm4,%xmm0
movapd %xmm5,0x120(%rsp)
addsd  %xmm5,%xmm0
mulsd  0x1afe(%rip),%xmm0
orpd   %xmm3,%xmm2
movq   $0x0,(%r12)
movq   $0x0,(%r14)
mov    0x18(%rsp),%rax
movq   $0x0,(%rax)
lea    0x8(%r12),%rcx
mov    %rcx,0x160(%rsp)
movq   $0x0,0x8(%r12)
lea    0x8(%r14),%rcx
mov    %rcx,0x168(%rsp)
movq   $0x0,0x8(%r14)
movq   $0x0,0x8(%rax)
lea    0x10(%r12),%rcx
mov    %rcx,0x158(%rsp)
movq   $0x0,0x10(%r12)
lea    0x10(%r14),%rcx
mov    %rcx,0x150(%rsp)
movq   $0x0,0x10(%r14)
movq   $0x0,0x10(%rax)
movq   $0x0,0x18(%r12)
movq   $0x0,0x18(%r14)
movq   $0x0,0x18(%rax)
movsd  %xmm4,0x98(%rsp)
cmpltsd %xmm2,%xmm4
movapd %xmm4,%xmm1
andnpd %xmm2,%xmm1
andpd  %xmm0,%xmm4
orpd   %xmm1,%xmm4
movapd %xmm4,0x70(%rsp)
movapd 0x1a86(%rip),%xmm0
movapd 0x50(%rsp),%xmm1
xorpd  %xmm1,%xmm0
movapd %xmm0,0x1d0(%rsp)
mov    0x188(%rsp),%rbx
mov    %ebx,%eax
not    %eax
add    %r13d,%eax
mov    %eax,0xac(%rsp)
movsd  0x38(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xc8(%rsp)
movsd  0x1a0a(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %rdx,0x30(%rsp)
mov    %rsi,0x8(%rsp)
call   1130 <floor@plt>
movsd  %xmm0,0x208(%rsp)
mov    0x8(%rsp),%rax
add    $0xfffffffb,%eax
mov    %eax,0x110(%rsp)
mov    %r13d,%edx
mov    0x20(%rsp),%r13
mov    0x8(%rsp),%rax
lea    0x0(%r13,%rax,8),%rdi
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%rax
lea    (%rsi,%rax,8),%r10
mov    0x30(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,8),%r11
mov    0x8(%rsp),%rax
lea    (%r15,%rax,8),%r9
mov    0x8(%rsp),%rax
lea    0x0(%rbp,%rax,8),%r8
mov    (%rsp),%rcx
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %edx,0x11c(%rsp)
sub    %ebx,%edx
add    $0xfffffffe,%edx
mov    %edx,0x118(%rsp)
cmp    %r11,%rcx
mov    %rbp,0x40(%rsp)
mov    %rcx,%rbp
setb   %bl
cmp    %rax,0x30(%rsp)
setb   %cl
and    %bl,%cl
cmp    %r9,%rbp
setb   %bl
cmp    %r15,%rax
seta   %al
and    %bl,%al
or     %cl,%al
mov    %al,0x2f(%rsp)
mov    0x8(%rsp),%rax
and    $0xfffffffc,%eax
mov    %rax,0x220(%rsp)
movapd 0x130(%rsp),%xmm9
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
movapd 0xd0(%rsp),%xmm10
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
mov    0x8(%rsp),%rax
neg    %rax
mov    %rax,0x228(%rsp)
cmp    %r10,%r13
setb   %cl
cmp    %rdi,%rsi
setb   %bl
and    %cl,%bl
cmp    %r11,%r13
setb   %cl
cmp    %rdi,0x30(%rsp)
setb   %dl
and    %cl,%dl
or     %bl,%dl
cmp    %r9,%r13
setb   %cl
cmp    %r15,%rdi
seta   %bl
and    %cl,%bl
or     %dl,%bl
cmp    %r8,%r13
setb   %cl
cmp    %rdi,0x40(%rsp)
setb   %dl
and    %cl,%dl
cmp    %r11,%rsi
setb   %cl
cmp    %r10,0x30(%rsp)
setb   %al
and    %cl,%al
or     %dl,%al
cmp    %r9,%rsi
setb   %cl
cmp    %r15,%r10
seta   %dl
and    %cl,%dl
or     %al,%dl
or     %bl,%dl
mov    0x40(%rsp),%r13
cmp    %r8,%rsi
mov    0x30(%rsp),%rsi
setb   %al
cmp    %r10,%r13
mov    0x8(%rsp),%r10
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x2e(%rsp)
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x218(%rsp)
pshufd $0x44,0x1d0(%rsp),%xmm0
movdqa %xmm0,0x240(%rsp)
mov    0xac(%rsp),%ecx
mov    %ecx,%eax
and    $0x7,%eax
mov    %eax,0xa8(%rsp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %eax,0x114(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,%rbx
and    $0xffffffffffffffe0,%rbx
and    $0xfffffffffffffff0,%rax
mov    %rax,0x210(%rsp)
mov    0x48(%rsp),%eax
mov    %rax,0x230(%rsp)
mov    0xa0(%rsp),%rax
lea    (%rsi,%rax,8),%rcx
mov    %rcx,0x200(%rsp)
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0x238(%rsp)
mov    $0xfffffffc,%ecx
sub    %r10d,%ecx
mov    %rcx,0xc0(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rcx,0x1f8(%rsp)
lea    (%r12,%rax,8),%rcx
mov    %rcx,0x178(%rsp)
lea    (%r14,%rax,8),%rcx
mov    %rcx,0x180(%rsp)
lea    -0x8(%rbp,%rax,8),%rax
mov    %rax,0x100(%rsp)
lea    0x70(%r14),%rax
mov    %rax,0x1f0(%rsp)
lea    0x70(%r12),%rax
mov    %rax,0x1e8(%rsp)
xor    %ecx,%ecx
movapd %xmm6,0x1a0(%rsp)
movapd %xmm5,0x1c0(%rsp)
mov    %rbx,0xf8(%rsp)
test   %r10d,%r10d
mov    %ecx,0x4c(%rsp)
jle    18e0 <R_Pauli+0x6d0>
cmp    $0x4,%r10d
setb   %al
or     0x2f(%rsp),%al
je     1940 <R_Pauli+0x730>
xor    %ecx,%ecx
movapd 0x70(%rsp),%xmm7
jmp    19c1 <R_Pauli+0x7b1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
movsd  0x1712(%rip),%xmm11
mov    0xa0(%rsp),%r10
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rdx
xorpd  %xmm8,%xmm8
mov    0xc0(%rsp),%rbp
mov    0x100(%rsp),%r9
movabs $0xffffffff00000000,%r11
ff ff ff
jmp    1d59 <R_Pauli+0xb49>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd 0x70(%rsp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
movupd (%rsi,%rax,1),%xmm1
movupd 0x10(%rsi,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd (%r15,%rax,1),%xmm3
movupd 0x10(%r15,%rax,1),%xmm4
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
addpd  %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm3
addpd  %xmm5,%xmm4
mulpd  %xmm6,%xmm3
mulpd  %xmm6,%xmm4
movupd %xmm3,0x0(%rbp,%rax,1)
movupd %xmm4,0x10(%rbp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1950 <R_Pauli+0x740>
mov    0x220(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     1a71 <R_Pauli+0x861>
mov    %rcx,%rax
test   $0x1,%r10b
je     19fc <R_Pauli+0x7ec>
movsd  (%rsi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r15,%rcx,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x228(%rsp),%rcx
je     1a71 <R_Pauli+0x861>
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  (%r15,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%r15,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1a10 <R_Pauli+0x800>
cmp    $0x2,%r10d
setb   %bl
mov    %r15,%rdi
mov    0x40(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
or     0x2e(%rsp),%bl
test   $0x1,%bl
je     1b20 <R_Pauli+0x910>
xor    %eax,%eax
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rdx
movapd 0xd0(%rsp),%xmm10
mov    0x30(%rsp),%rsi
mov    0xa0(%rsp),%r10
mov    0x8(%rsp),%rbx
xorpd  %xmm8,%xmm8
movapd 0x70(%rsp),%xmm7
movapd 0x1d0(%rsp),%xmm9
mov    0xc0(%rsp),%rbp
movsd  0x151a(%rip),%xmm6
movsd  0x1542(%rip),%xmm5
movsd  0x1511(%rip),%xmm11
movsd  0x1510(%rip),%xmm12
movsd  0x152f(%rip),%xmm13
mov    0x100(%rsp),%r9
movabs $0xffffffff00000000,%r11
ff ff ff
jmp    1cc0 <R_Pauli+0xab0>
movapd 0x70(%rsp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rdx
mov    0x30(%rsp),%rsi
mov    0xa0(%rsp),%r10
xorpd  %xmm8,%xmm8
movapd 0x1d0(%rsp),%xmm9
movapd 0x1a0(%rsp),%xmm10
movapd 0x240(%rsp),%xmm15
mov    0x210(%rsp),%rbx
mov    0xc0(%rsp),%rbp
movsd  0x1480(%rip),%xmm11
movsd  0x147f(%rip),%xmm12
movsd  0x149e(%rip),%xmm13
movapd 0x14de(%rip),%xmm6
movapd 0x14e6(%rip),%xmm5
movapd 0x14fd(%rip),%xmm14
mov    0x100(%rsp),%r9
movabs $0xffffffff00000000,%r11
ff ff ff
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rsi,%rax,1),%xmm1
movupd (%r15,%rax,1),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm2,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm1
mulpd  %xmm10,%xmm1
subpd  %xmm0,%xmm2
movapd %xmm2,%xmm4
mulpd  0x1468(%rip),%xmm4
movupd 0x0(%r13,%rax,1),%xmm5
mulpd  %xmm6,%xmm5
divpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movapd 0x1469(%rip),%xmm5
mulpd  %xmm1,%xmm4
movupd %xmm4,(%rdx,%rax,1)
movupd (%rsi,%rax,1),%xmm1
mulpd  %xmm15,%xmm1
mulpd  0x145e(%rip),%xmm1
mulpd  %xmm14,%xmm1
movupd 0x0(%r13,%rax,1),%xmm2
mulpd  %xmm1,%xmm2
movupd (%r15,%rax,1),%xmm1
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm5,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,(%rcx,%rax,1)
add    $0x10,%rax
cmp    %rax,%rbx
jne    1bd0 <R_Pauli+0x9c0>
mov    0x218(%rsp),%r8
mov    %r8,%rax
mov    0x8(%rsp),%rbx
cmp    %rbx,%r8
movapd 0xd0(%rsp),%xmm10
movsd  0x135d(%rip),%xmm6
movsd  0x1385(%rip),%xmm5
je     1d59 <R_Pauli+0xb49>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  (%r15,%rax,8),%xmm1
movapd %xmm7,%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm11,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm0
mulsd  %xmm10,%xmm0
subsd  %xmm7,%xmm1
movapd %xmm1,%xmm3
mulsd  %xmm6,%xmm3
movsd  0x0(%r13,%rax,8),%xmm4
mulsd  %xmm5,%xmm4
divsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rdx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm13,%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
movapd %xmm7,%xmm1
subsd  (%r15,%rax,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm11,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1cc0 <R_Pauli+0xab0>
addl   $0x1,0x4c(%rsp)
mov    (%rsp),%rax
movsd  (%rax,%r10,8),%xmm0
mov    0x48(%rsp),%eax
mov    %rbp,0xe0(%rsp)
mov    %eax,%ebp
mov    0x238(%rsp),%rdi
xor    %ebx,%ebx
movapd 0x12d8(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
movsd  (%r9,%rbx,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm8,%xmm1
jbe    1de0 <R_Pauli+0xbd0>
add    %r11,%rdi
lea    (%r10,%rbx,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rbx
add    $0x1,%rax
mov    0xe0(%rsp),%r8
add    $0x1,%r8d
mov    %r8,0xe0(%rsp)
add    $0xffffffff,%ebp
cmp    $0x2,%rax
jg     1d90 <R_Pauli+0xb80>
jmp    2e68 <R_Pauli+0x1c58>
nopw   0x0(%rax,%rax,1)
mov    0x230(%rsp),%rax
add    %rbx,%rax
mov    %rax,0xb8(%rsp)
movapd %xmm11,%xmm0
cmpl   $0x0,0xac(%rsp)
mov    (%rsp),%r13
jle    1e49 <R_Pauli+0xc39>
mov    0x114(%rsp),%eax
cmpl   $0x7,0x118(%rsp)
07
jb     1e25 <R_Pauli+0xc15>
nopw   0x0(%rax,%rax,1)
add    $0xfffffff8,%eax
jne    1e20 <R_Pauli+0xc10>
movapd %xmm11,%xmm0
cmpl   $0x0,0xa8(%rsp)
je     1e49 <R_Pauli+0xc39>
mov    0xa8(%rsp),%eax
movapd %xmm11,%xmm0
xorpd  %xmm2,%xmm0
add    $0xffffffff,%eax
jne    1e40 <R_Pauli+0xc30>
movapd %xmm0,0x80(%rsp)
mov    %ebp,0x10c(%rsp)
mov    %rdi,0x170(%rsp)
mov    %rbx,0x68(%rsp)
mov    %r15,0xb0(%rsp)
movsd  (%rsi),%xmm0
movsd  0x38(%rsp),%xmm1
mov    %rsi,%rbx
call   10e0 <pow@plt>
mulsd  0x80(%rsp),%xmm0
movsd  %xmm0,(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,(%r14)
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm1
addsd  0x50(%rsp),%xmm1
movsd  0x0(%r13),%xmm2
mov    %r13,%rbp
mov    0x20(%rsp),%r15
addsd  (%r15),%xmm2
mulsd  (%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x18(%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%rbx),%xmm0
movsd  0x38(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x8(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x8(%r14)
mov    0x10(%rsp),%r13
movsd  0x8(%r13),%xmm1
addsd  0x50(%rsp),%xmm1
movsd  0x8(%rbp),%xmm2
addsd  0x8(%r15),%xmm2
mulsd  0x8(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    0x18(%rsp),%rbp
movsd  %xmm1,0x8(%rbp)
movsd  0x10(%rbx),%xmm0
movsd  0x38(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x10(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x10(%r13),%xmm1
addsd  0x50(%rsp),%xmm1
mov    (%rsp),%rbx
movsd  0x10(%rbx),%xmm2
addsd  0x10(%r15),%xmm2
mulsd  0x10(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rbp)
mov    0x30(%rsp),%rax
movsd  0x18(%rax),%xmm0
movsd  0x38(%rsp),%xmm1
call   10e0 <pow@plt>
mulsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x18(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x18(%r14)
movsd  0x18(%r13),%xmm1
movsd  0x18(%rbx),%xmm2
addsd  0x18(%r15),%xmm2
addsd  0x50(%rsp),%xmm1
mulsd  0x18(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rbp)
xor    %ebx,%ebx
cmpl   $0x3,0xb8(%rsp)
jle    2140 <R_Pauli+0xf30>
mov    0xa0(%rsp),%rax
mov    0x68(%rsp),%rcx
add    %rcx,%rax
mov    %eax,%eax
mov    %rax,0x80(%rsp)
xor    %ebx,%ebx
mov    $0x3,%r13d
jmp    2052 <R_Pauli+0xe42>
nopl   0x0(%rax,%rax,1)
mulsd  (%r12,%r13,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
sbb    $0xffffffff,%ebx
mov    %rbp,%r13
cmp    0x80(%rsp),%rbp
je     2140 <R_Pauli+0xf30>
mov    %r13d,%edi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1080 <Predictor_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    0x1(%r13),%rbp
movsd  %xmm0,0x8(%r12,%r13,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rdx
xor    %eax,%eax
call   1080 <Predictor_Out@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0x8(%r14,%r13,8)
movsd  0x8(%r12,%r13,8),%xmm0
mov    $0x5,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  (%rax,%rbp,8),%xmm2
addsd  0x50(%rsp),%xmm2
mov    (%rsp),%rax
movsd  (%rax,%rbp,8),%xmm3
addsd  (%rcx,%rbp,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rsp),%rdx
movsd  %xmm3,(%rdx,%rbp,8)
mov    %r13d,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
mov    %r13d,%edi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1070 <Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbp,8)
sub    $0x1,%r15d
jb     2030 <R_Pauli+0xe20>
movsd  (%r14,%rbp,8),%xmm1
jmp    20b0 <R_Pauli+0xea0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x11c(%rsp),%eax
sub    %eax,%ebx
mov    0x188(%rsp),%rcx
add    %ecx,%ebx
cmp    $0xfffffffe,%ebx
movapd 0x130(%rsp),%xmm9
movapd 0x70(%rsp),%xmm2
movapd 0x1c0(%rsp),%xmm5
movapd 0x1a0(%rsp),%xmm6
jg     21a0 <R_Pauli+0xf90>
movapd %xmm2,0x120(%rsp)
movapd %xmm2,%xmm0
addsd  0x98(%rsp),%xmm0
jmp    21ba <R_Pauli+0xfaa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %ebx,%ebx
js     220c <R_Pauli+0xffc>
movsd  %xmm2,0x98(%rsp)
movapd %xmm2,%xmm0
addsd  0x120(%rsp),%xmm0
mulsd  0xe4e(%rip),%xmm0
movapd %xmm0,0x70(%rsp)
mov    0xb0(%rsp),%r15
mov    0x40(%rsp),%r13
mov    (%rsp),%rbp
movapd 0xd0(%rsp),%xmm10
mov    0x30(%rsp),%rsi
mov    0x8(%rsp),%r10
mov    0xf8(%rsp),%rbx
mov    0x4c(%rsp),%ecx
mov    0x68(%rsp),%rdx
cmp    $0x64,%ecx
jne    18af <R_Pauli+0x69f>
jmp    2e0a <R_Pauli+0x1bfa>
mov    0x178(%rsp),%rax
mov    0x68(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps %xmm0,0x1b0(%rsp)
mov    0x180(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x1e0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xb8(%rsp),%xmm0
addsd  0x208(%rsp),%xmm0
cvttsd2si %xmm0,%ecx
lea    0x5(%rcx),%eax
cmp    0x8(%rsp),%eax
cmovg  0x110(%rsp),%ecx
mov    %rcx,0xf0(%rsp)
movslq %ecx,%rbp
mov    0x30(%rsp),%r15
movsd  (%r15,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm9,%xmm1
divsd  %xmm0,%xmm1
mov    0xb0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
subsd  %xmm2,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    (%rsp),%r13
jb     22b4 <R_Pauli+0x10a4>
sqrtsd %xmm0,%xmm0
jmp    22be <R_Pauli+0x10ae>
call   10f0 <sqrt@plt>
mov    0x30(%rsp),%r15
movapd %xmm0,0x80(%rsp)
movapd %xmm0,%xmm1
movapd 0xd8d(%rip),%xmm0
xorpd  %xmm0,%xmm1
movapd %xmm1,0x190(%rsp)
movsd  (%r15,%rbp,8),%xmm0
subsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm1
xorpd  0xd59(%rip),%xmm1
movapd 0x50(%rsp),%xmm2
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm3
mulsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbp,8)
mov    0x10(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  0x0(%r13,%rbp,8),%xmm2
mov    0x20(%rsp),%rax
addsd  (%rax,%rbp,8),%xmm2
mulsd  (%r12,%rbp,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0x190(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x8(%r12,%rbp,8)
movsd  0x8(%r15,%rbp,8),%xmm1
xorpd  0xcd0(%rip),%xmm1
movapd 0x50(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14,%rbp,8)
mov    0x10(%rsp),%rbx
movsd  0x8(%rbx,%rbp,8),%xmm0
movsd  0x8(%r13,%rbp,8),%xmm2
mov    0x20(%rsp),%rax
addsd  0x8(%rax,%rbp,8),%xmm2
mulsd  0x8(%r12,%rbp,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    0x18(%rsp),%r13
movsd  %xmm0,0x8(%r13,%rbp,8)
movsd  0x10(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0x190(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x10(%r12,%rbp,8)
movsd  0x10(%r15,%rbp,8),%xmm1
xorpd  0xc45(%rip),%xmm1
movapd 0x50(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14,%rbp,8)
movsd  0x10(%rbx,%rbp,8),%xmm0
mov    (%rsp),%rax
movsd  0x10(%rax,%rbp,8),%xmm2
mov    0x20(%rsp),%rbx
addsd  0x10(%rbx,%rbp,8),%xmm2
mulsd  0x10(%r12,%rbp,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%r13,%rbp,8)
movsd  0x18(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0x190(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x18(%r12,%rbp,8)
movsd  0x18(%r15,%rbp,8),%xmm1
xorpd  0xbc1(%rip),%xmm1
movapd 0x50(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r14,%rbp,8)
mov    0x10(%rsp),%rax
movsd  0x18(%rax,%rbp,8),%xmm0
mov    (%rsp),%r13
movsd  0x18(%r13,%rbp,8),%xmm2
addsd  0x18(%rbx,%rbp,8),%xmm2
mulsd  0x18(%r12,%rbp,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    0x18(%rsp),%rbx
movsd  %xmm0,0x18(%rbx,%rbp,8)
movsd  0x20(%r15,%rbp,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
mulsd  0x190(%rsp),%xmm0
call   10a0 <exp@plt>
movsd  %xmm0,0x20(%r12,%rbp,8)
movsd  0x20(%r15,%rbp,8),%xmm1
xorpd  0xb38(%rip),%xmm1
movapd 0x50(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x80(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r14,%rbp,8)
mov    0x10(%rsp),%rax
movsd  0x20(%rax,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
movsd  0x20(%r13,%rbp,8),%xmm2
mov    0x20(%rsp),%rax
addsd  0x20(%rax,%rbp,8),%xmm2
mulsd  0x20(%r12,%rbp,8),%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x20(%rbx,%rbp,8)
mov    0xb8(%rsp),%rax
cmp    %eax,0xf0(%rsp)
jle    2684 <R_Pauli+0x1474>
mov    0x170(%rsp),%r15
sar    $0x20,%r15
jmp    25a9 <R_Pauli+0x1399>
nop
cmp    %r15,%rbp
jle    2684 <R_Pauli+0x1474>
mov    %rbp,%r13
mov    %r13d,%edi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   10d0 <Predictor_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
add    $0xffffffffffffffff,%rbp
movsd  %xmm0,-0x8(%r12,%r13,8)
mov    %r13d,%edi
mov    %r14,%rsi
mov    0x18(%rsp),%rdx
xor    %eax,%eax
call   10d0 <Predictor_In@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,-0x8(%r14,%r13,8)
movsd  -0x8(%r12,%r13,8),%xmm0
mov    $0x5,%ebx
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  (%rax,%rbp,8),%xmm2
addsd  0x50(%rsp),%xmm2
mov    (%rsp),%rax
movsd  (%rax,%rbp,8),%xmm3
addsd  (%rcx,%rbp,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rsp),%rdx
movsd  %xmm3,(%rdx,%rbp,8)
mov    %r13d,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
mov    %r13d,%edi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   10c0 <Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbp,8)
sub    $0x1,%ebx
jb     25a0 <R_Pauli+0x1390>
movsd  (%r14,%rbp,8),%xmm1
jmp    2600 <R_Pauli+0x13f0>
mov    0xf0(%rsp),%rdi
cmp    0xb8(%rsp),%edi
mov    0x40(%rsp),%r13
mov    0xf8(%rsp),%rbx
mov    0x68(%rsp),%r8
mov    0x170(%rsp),%r9
jl     286c <R_Pauli+0x165c>
movapd 0x1b0(%rsp),%xmm0
mov    0x178(%rsp),%rax
divsd  (%rax,%r8,8),%xmm0
sar    $0x20,%r9
lea    0x5(%rdi),%eax
mov    0xc0(%rsp),%rcx
add    %rcx,%rax
sub    %r8,%rax
cmp    $0x3,%eax
jb     27ce <R_Pauli+0x15be>
lea    (%r12,%r9,8),%rdx
add    %edi,%ecx
sub    %r8d,%ecx
add    $0x5,%ecx
add    %r9,%rcx
mov    0x168(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    2721 <R_Pauli+0x1511>
mov    0x160(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%r14,%r9,8),%rdx
cmp    %rcx,%rdx
jb     27ce <R_Pauli+0x15be>
mov    %eax,%r10d
add    $0x1,%r10
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rcx,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    0xe0(%rsp),%rax
lea    (%rdi,%rax,1),%edx
add    $0x5,%edx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
movslq 0x10c(%rsp),%rax
mov    0x158(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    0x150(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd -0x10(%rsi,%rbp,8),%xmm2
movupd (%rsi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rsi,%rbp,8)
movupd %xmm3,(%rsi,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm2
movupd (%rax,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rax,%rbp,8)
movupd %xmm3,(%rax,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    2780 <R_Pauli+0x1570>
cmp    %rcx,%r10
je     286c <R_Pauli+0x165c>
lea    0x1(%rdi),%ecx
mov    %ecx,%eax
sub    %r9d,%eax
test   $0x1,%al
jne    27e7 <R_Pauli+0x15d7>
mov    %r9,%rax
cmp    %r9d,%edi
jne    2813 <R_Pauli+0x1603>
jmp    286c <R_Pauli+0x165c>
movsd  (%r12,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r9,8)
movsd  (%r14,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r9,8)
mov    %r9,%rax
add    $0x1,%rax
cmp    %r9d,%edi
je     286c <R_Pauli+0x165c>
mov    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  (%r14,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %eax,%ecx
jne    2820 <R_Pauli+0x1610>
mov    0x180(%rsp),%rax
movsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  0x38(%rsp),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   10b0 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
jb     28aa <R_Pauli+0x169a>
sqrtsd %xmm0,%xmm0
jmp    28b3 <R_Pauli+0x16a3>
call   10f0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movapd 0x130(%rsp),%xmm9
movapd 0xd0(%rsp),%xmm10
mov    0x8(%rsp),%r10
movapd 0x120(%rsp),%xmm8
movapd 0x70(%rsp),%xmm7
movapd 0x1a0(%rsp),%xmm6
movsd  0x71b(%rip),%xmm1
movsd  0x71a(%rip),%xmm11
xorpd  %xmm5,%xmm5
divsd  %xmm0,%xmm1
mov    0xf0(%rsp),%rbp
lea    0x1(%rbp),%eax
test   %ebp,%ebp
mov    0xb0(%rsp),%r15
movapd 0x1b0(%rsp),%xmm3
js     2b11 <R_Pauli+0x1901>
mov    %eax,%ecx
cmp    $0x4,%eax
jb     2943 <R_Pauli+0x1733>
lea    (%r14,%rcx,8),%rdx
cmp    %r12,%rdx
jbe    29d2 <R_Pauli+0x17c2>
lea    (%r12,%rcx,8),%rdx
cmp    %r14,%rdx
jbe    29d2 <R_Pauli+0x17c2>
xor    %edx,%edx
mov    %rdx,%rsi
test   $0x1,%cl
je     2974 <R_Pauli+0x1764>
movsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
mov    %rdx,%rsi
or     $0x1,%rsi
not    %rdx
add    %rcx,%rdx
je     2b11 <R_Pauli+0x1901>
movsd  (%r12,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
movsd  (%r14,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rsi,8)
movsd  0x8(%r12,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rsi,8)
movsd  0x8(%r14,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    2980 <R_Pauli+0x1770>
jmp    2b11 <R_Pauli+0x1901>
mov    %rbx,%r8
mov    %ecx,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     2aac <R_Pauli+0x189c>
mov    %rbx,%rdi
and    0x1f8(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rsi,8)
movupd %xmm3,0x10(%r12,%rsi,8)
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 0x20(%r12,%rsi,8),%xmm2
movupd 0x30(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r12,%rsi,8)
movupd %xmm3,0x30(%r12,%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)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2a10 <R_Pauli+0x1800>
jmp    2aae <R_Pauli+0x189e>
xor    %esi,%esi
test   $0x1,%bl
je     2af7 <R_Pauli+0x18e7>
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rsi,8)
movupd %xmm3,0x10(%r12,%rsi,8)
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)
cmp    %rcx,%rdx
mov    0x40(%rsp),%r13
mov    %r8,%rbx
movapd 0x1b0(%rsp),%xmm3
jne    2945 <R_Pauli+0x1735>
cmp    %r10d,%eax
jge    2d0f <R_Pauli+0x1aff>
cltq
mov    %r10d,%r9d
sub    %ebp,%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     2c83 <R_Pauli+0x1a73>
lea    (%r12,%rax,8),%rsi
mov    %r10d,%edx
sub    %ebp,%edx
add    $0xfffffffe,%edx
add    %rax,%rdx
mov    0x168(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdi
cmp    %rdi,%rsi
jae    2b69 <R_Pauli+0x1959>
mov    0x160(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
lea    (%r14,%rax,8),%rsi
cmp    %rdx,%rsi
jb     2c83 <R_Pauli+0x1a73>
mov    %rbx,%rbp
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rdx
jae    2b98 <R_Pauli+0x1988>
xor    %ecx,%ecx
jmp    2c28 <R_Pauli+0x1a18>
and    $0xfffffffffffffffc,%rdi
mov    0x1f0(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
mov    0x1e8(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd %xmm5,-0x70(%rdx,%rcx,8)
movupd %xmm5,-0x60(%rdx,%rcx,8)
movupd %xmm5,-0x70(%rbx,%rcx,8)
movupd %xmm5,-0x60(%rbx,%rcx,8)
movupd %xmm5,-0x50(%rdx,%rcx,8)
movupd %xmm5,-0x40(%rdx,%rcx,8)
movupd %xmm5,-0x50(%rbx,%rcx,8)
movupd %xmm5,-0x40(%rbx,%rcx,8)
movupd %xmm5,-0x30(%rdx,%rcx,8)
movupd %xmm5,-0x20(%rdx,%rcx,8)
movupd %xmm5,-0x30(%rbx,%rcx,8)
movupd %xmm5,-0x20(%rbx,%rcx,8)
movupd %xmm5,-0x10(%rdx,%rcx,8)
movupd %xmm5,(%rdx,%rcx,8)
movupd %xmm5,-0x10(%rbx,%rcx,8)
movupd %xmm5,(%rbx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdi
jne    2bc0 <R_Pauli+0x19b0>
test   %rsi,%rsi
je     2c6f <R_Pauli+0x1a5f>
add    %rax,%rcx
mov    0x150(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    0x158(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
shl    $0x5,%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
movupd %xmm5,-0x10(%rdi,%rcx,1)
movupd %xmm5,(%rdi,%rcx,1)
movupd %xmm5,-0x10(%rdx,%rcx,1)
movupd %xmm5,(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    2c50 <R_Pauli+0x1a40>
cmp    %r8,%r9
mov    0x40(%rsp),%r13
mov    %rbp,%rbx
je     2d0f <R_Pauli+0x1aff>
add    %r8,%rax
mov    %r10d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r10d,%ecx
and    $0x3,%edx
je     2cb9 <R_Pauli+0x1aa9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r12,%rax,8)
movq   $0x0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    2ca0 <R_Pauli+0x1a90>
cmp    $0x3,%ecx
jb     2d0f <R_Pauli+0x1aff>
xchg   %ax,%ax
movq   $0x0,(%r12,%rax,8)
movq   $0x0,(%r14,%rax,8)
movq   $0x0,0x8(%r12,%rax,8)
movq   $0x0,0x8(%r14,%rax,8)
movq   $0x0,0x10(%r12,%rax,8)
movq   $0x0,0x10(%r14,%rax,8)
movq   $0x0,0x18(%r12,%rax,8)
movq   $0x0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %eax,%r10d
jne    2cc0 <R_Pauli+0x1ab0>
mulsd  %xmm1,%xmm3
movsd  0x1e0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe0(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
mov    0x200(%rsp),%rax
mov    0x68(%rsp),%rdx
movsd  (%rax,%rdx,8),%xmm0
mulsd  0x50(%rsp),%xmm0
divsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
movapd 0x35e(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm7,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x2ca(%rip),%xmm1
mulsd  0x2ca(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2ec0 <R_Pauli+0x1cb0>
ucomisd %xmm4,%xmm3
ja     2d97 <R_Pauli+0x1b87>
movsd  %xmm7,0x98(%rsp)
xorpd  %xmm0,%xmm0
cmpltsd %xmm3,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm7,%xmm1
andnpd %xmm8,%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm3,%xmm7
ucomisd 0x98(%rsp),%xmm7
mov    0x30(%rsp),%rsi
mov    0x4c(%rsp),%ecx
movapd %xmm0,0x120(%rsp)
ja     2de0 <R_Pauli+0x1bd0>
ucomisd %xmm7,%xmm0
ja     2de0 <R_Pauli+0x1bd0>
movapd %xmm7,0x70(%rsp)
jmp    2df4 <R_Pauli+0x1be4>
addsd  0x98(%rsp),%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm0,0x70(%rsp)
movapd 0x1c0(%rsp),%xmm5
mov    (%rsp),%rbp
cmp    $0x64,%ecx
jne    18af <R_Pauli+0x69f>
mov    0x48(%rsp),%ebx
add    %edx,%ebx
lea    0x2b9(%rip),%rdi
mov    $0x64,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x140(%rsp),%rax
mov    %ebx,(%rax)
mov    0x148(%rsp),%rax
movapd 0x70(%rsp),%xmm0
movsd  %xmm0,(%rax)
mov    %rbp,%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    0x20(%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    0x10(%rsp),%rdi
jmp    2e9e <R_Pauli+0x1c8e>
mov    %rdx,%rbp
lea    0x286(%rip),%rdi
mov    %rcx,%r14
call   1040 <puts@plt>
mov    (%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1100 <dealloc_LogGrid@plt>
mov    %r13,%rdi
xor    %eax,%eax
add    $0x258,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1100 <dealloc_LogGrid@plt>
mov    0x48(%rsp),%ecx
add    %edx,%ecx
mov    0x140(%rsp),%rax
mov    %ecx,(%rax)
mov    0x148(%rsp),%rax
movsd  %xmm7,(%rax)
mov    (%rsp),%rdi
jmp    2e42 <R_Pauli+0x1c32>

LLVM IR (-O0):
@.str = [36 x i8] c"Error in R_Pauli: no turning point\0A\00"
@.str.1 = [40 x i8] c"Error R_Pauli: More than %d iterations\0A\00"
define void @R_Pauli(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 i32
%22 = alloca i32
%23 = alloca i32
%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
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = 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
%48 = load double*, double** %14
%49 = load double, double* %48
store double %49, double* %24
%50 = load i32, i32* %10
%51 = load i32, i32* %10
%52 = add nsw i32 %51, 1
%53 = mul nsw i32 %50, %52
%54 = sitofp i32 %53 to double
store double %54, double* %32
store double 0x3F7DE3D3DD944526, double* %30
%55 = load double, double* %30
%56 = load double, double* %30
%57 = fmul double %55, %56
store double %57, double* %30
%58 = load i32, i32* %10
%59 = icmp eq i32 %58, 0
br i1 %59, label %60, label %68
60: ; preds = %8
%61 = load double, double* %30
%62 = load double, double* %11
%63 = fmul double %61, %62
%64 = load double, double* %11
%65 = fneg double %63
%66 = call double @llvm.fmuladd.f64(double %65, double %64, double 1.000000e+00)
%67 = call double @sqrt(double %66)
store double %67, double* %31
br label %101
68: ; preds = %8
%69 = load i32, i32* %10
%70 = sitofp i32 %69 to double
store double %70, double* %33
%71 = load double, double* %33
%72 = load double, double* %33
%73 = load double, double* %30
%74 = load double, double* %11
%75 = fmul double %73, %74
%76 = load double, double* %11
%77 = fmul double %75, %76
%78 = fneg double %77
%79 = call double @llvm.fmuladd.f64(double %71, double %72, double %78)
%80 = call double @sqrt(double %79)
%81 = load double, double* %33
%82 = load double, double* %33
%83 = fadd double %82, 1.000000e+00
%84 = load double, double* %33
%85 = fadd double %84, 1.000000e+00
%86 = load double, double* %30
%87 = load double, double* %11
%88 = fmul double %86, %87
%89 = load double, double* %11
%90 = fmul double %88, %89
%91 = fneg double %90
%92 = call double @llvm.fmuladd.f64(double %83, double %85, double %91)
%93 = call double @sqrt(double %92)
%94 = load double, double* %33
%95 = fadd double %94, 1.000000e+00
%96 = fmul double %93, %95
%97 = call double @llvm.fmuladd.f64(double %80, double %81, double %96)
%98 = load double, double* %33
%99 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %98, double 1.000000e+00)
%100 = fdiv double %97, %99
store double %100, double* %31
br label %101
101: ; preds = %68, %60
%102 = call i32 (...) @N_LogGrid()
store i32 %102, i32* %23
%103 = call i32 (...) @log_amesh_LogGrid()
%104 = sitofp i32 %103 to double
store double %104, double* %28
%105 = load double, double* %28
%106 = load double, double* %28
%107 = fmul double %105, %106
store double %107, double* %29
%108 = call i32 (...) @r_LogGrid()
%109 = sext i32 %108 to i64
%110 = inttoptr i64 %109 to double*
store double* %110, double** %42
%111 = call i32 (...) @alloc_LogGrid()
%112 = sext i32 %111 to i64
%113 = inttoptr i64 %112 to double*
store double* %113, double** %43
%114 = call i32 (...) @alloc_LogGrid()
%115 = sext i32 %114 to i64
%116 = inttoptr i64 %115 to double*
store double* %116, double** %47
%117 = call i32 (...) @alloc_LogGrid()
%118 = sext i32 %117 to i64
%119 = inttoptr i64 %118 to double*
store double* %119, double** %46
%120 = call i32 (...) @alloc_LogGrid()
%121 = sext i32 %120 to i64
%122 = inttoptr i64 %121 to double*
store double* %122, double** %45
%123 = call i32 (...) @alloc_LogGrid()
%124 = sext i32 %123 to i64
%125 = inttoptr i64 %124 to double*
store double* %125, double** %44
%126 = load double*, double** %12
%127 = load i32, i32* %23
%128 = sub nsw i32 %127, 1
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %126, i64 %129
%131 = load double, double* %130
%132 = load double, double* %32
%133 = fmul double 5.000000e-01, %132
%134 = load double*, double** %42
%135 = load i32, i32* %23
%136 = sub nsw i32 %135, 1
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %134, i64 %137
%139 = load double, double* %138
%140 = load double*, double** %42
%141 = load i32, i32* %23
%142 = sub nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %140, i64 %143
%145 = load double, double* %144
%146 = fmul double %139, %145
%147 = fdiv double %133, %146
%148 = fadd double %131, %147
store double %148, double* %26
store double 0.000000e+00, double* %27
store i32 0, i32* %17
br label %149
149: ; preds = %189, %101
%150 = load i32, i32* %17
%151 = load i32, i32* %23
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %192
153: ; preds = %149
%154 = load double*, double** %42
%155 = load i32, i32* %17
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
%158 = load double, double* %157
store double %158, double* %34
%159 = load double, double* %34
%160 = load double, double* %34
%161 = fmul double %159, %160
store double %161, double* %34
%162 = load double, double* %27
%163 = load double*, double** %12
%164 = load i32, i32* %17
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %163, i64 %165
%167 = load double, double* %166
%168 = load double, double* %32
%169 = fmul double 5.000000e-01, %168
%170 = load double, double* %34
%171 = fdiv double %169, %170
%172 = fadd double %167, %171
%173 = fcmp olt double %162, %172
br i1 %173, label %174, label %176
174: ; preds = %153
%175 = load double, double* %27
br label %187
176: ; preds = %153
%177 = load double*, double** %12
%178 = load i32, i32* %17
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = load double, double* %32
%183 = fmul double 5.000000e-01, %182
%184 = load double, double* %34
%185 = fdiv double %183, %184
%186 = fadd double %181, %185
br label %187
187: ; preds = %176, %174
%188 = phi double [ %175, %174 ], [ %186, %176 ]
store double %188, double* %27
br label %189
189: ; preds = %187
%190 = load i32, i32* %17
%191 = add nsw i32 %190, 1
store i32 %191, i32* %17
br label %149
192: ; preds = %149
%193 = load double, double* %24
%194 = load double, double* %26
%195 = fcmp ogt double %193, %194
br i1 %195, label %196, label %199
196: ; preds = %192
%197 = load double, double* %26
%198 = fmul double 1.250000e+00, %197
store double %198, double* %24
br label %199
199: ; preds = %196, %192
%200 = load double, double* %24
%201 = load double, double* %27
%202 = fcmp olt double %200, %201
br i1 %202, label %203, label %206
203: ; preds = %199
%204 = load double, double* %27
%205 = fmul double 7.500000e-01, %204
store double %205, double* %24
br label %206
206: ; preds = %203, %199
%207 = load double, double* %24
%208 = load double, double* %26
%209 = fcmp ogt double %207, %208
br i1 %209, label %210, label %215
210: ; preds = %206
%211 = load double, double* %26
%212 = load double, double* %27
%213 = fadd double %211, %212
%214 = fmul double 5.000000e-01, %213
store double %214, double* %24
br label %215
215: ; preds = %210, %206
store i32 0, i32* %17
br label %216
216: ; preds = %232, %215
%217 = load i32, i32* %17
%218 = icmp slt i32 %217, 4
br i1 %218, label %219, label %235
219: ; preds = %216
%220 = load double*, double** %15
%221 = load i32, i32* %17
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %220, i64 %222
store double 0.000000e+00, double* %223
%224 = load double*, double** %16
%225 = load i32, i32* %17
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
store double 0.000000e+00, double* %227
%228 = load double*, double** %47
%229 = load i32, i32* %17
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
store double 0.000000e+00, double* %231
br label %232
232: ; preds = %219
%233 = load i32, i32* %17
%234 = add nsw i32 %233, 1
store i32 %234, i32* %17
br label %216
235: ; preds = %216
store i32 0, i32* %19
br label %236
236: ; preds = %1049, %235
%237 = load i32, i32* %19
%238 = icmp slt i32 %237, 100
br i1 %238, label %239, label %1050
239: ; preds = %236
%240 = load i32, i32* %19
%241 = add nsw i32 %240, 1
store i32 %241, i32* %19
store i32 0, i32* %17
br label %242
242: ; preds = %272, %239
%243 = load i32, i32* %17
%244 = load i32, i32* %23
%245 = icmp slt i32 %243, %244
br i1 %245, label %246, label %275
246: ; preds = %242
%247 = load double*, double** %42
%248 = load i32, i32* %17
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %247, i64 %249
%251 = load double, double* %250
store double %251, double* %34
%252 = load double, double* %34
%253 = load double, double* %34
%254 = fmul double %252, %253
store double %254, double* %34
%255 = load double, double* %29
%256 = load double, double* %32
%257 = load double*, double** %12
%258 = load i32, i32* %17
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
%262 = load double, double* %24
%263 = fsub double %261, %262
%264 = fmul double 2.000000e+00, %263
%265 = load double, double* %34
%266 = call double @llvm.fmuladd.f64(double %264, double %265, double %256)
%267 = fmul double %255, %266
%268 = load double*, double** %43
%269 = load i32, i32* %17
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %268, i64 %270
store double %267, double* %271
br label %272
272: ; preds = %246
%273 = load i32, i32* %17
%274 = add nsw i32 %273, 1
store i32 %274, i32* %17
br label %242
275: ; preds = %242
%276 = load double*, double** %12
%277 = load double*, double** %44
%278 = call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %276, double* %277)
store i32 0, i32* %17
br label %279
279: ; preds = %378, %275
%280 = load i32, i32* %17
%281 = load i32, i32* %23
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %381
283: ; preds = %279
%284 = load double*, double** %42
%285 = load i32, i32* %17
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %284, i64 %286
%288 = load double, double* %287
%289 = load double*, double** %42
%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
store double %294, double* %34
%295 = load double, double* %29
%296 = load double, double* %34
%297 = fmul double %295, %296
%298 = load double, double* %30
%299 = fneg double %298
%300 = load double*, double** %12
%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 = load double, double* %24
%306 = fsub double %304, %305
%307 = fmul double %299, %306
%308 = load double*, double** %12
%309 = load i32, i32* %17
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %308, i64 %310
%312 = load double, double* %311
%313 = load double, double* %24
%314 = fsub double %312, %313
%315 = load double, double* %30
%316 = fmul double 5.000000e-01, %315
%317 = load double*, double** %44
%318 = load i32, i32* %17
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
%322 = fmul double %316, %321
%323 = load double*, double** %42
%324 = load i32, i32* %17
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %323, i64 %325
%327 = load double, double* %326
%328 = load double, double* %30
%329 = fmul double 5.000000e-01, %328
%330 = load double, double* %24
%331 = load double*, double** %12
%332 = load i32, i32* %17
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
%335 = load double, double* %334
%336 = fsub double %330, %335
%337 = call double @llvm.fmuladd.f64(double %329, double %336, double 1.000000e+00)
%338 = fmul double %327, %337
%339 = fdiv double %322, %338
%340 = call double @llvm.fmuladd.f64(double %307, double %314, double %339)
%341 = fmul double %297, %340
%342 = load double*, double** %46
%343 = load i32, i32* %17
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %342, i64 %344
store double %341, double* %345
%346 = load double, double* %28
%347 = fneg double %346
%348 = load double*, double** %42
%349 = load i32, i32* %17
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds double, double* %348, i64 %350
%352 = load double, double* %351
%353 = fmul double %347, %352
%354 = fmul double %353, 5.000000e-01
%355 = load double, double* %30
%356 = fmul double %354, %355
%357 = load double*, double** %44
%358 = load i32, i32* %17
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = fmul double %356, %361
%363 = load double, double* %30
%364 = fmul double 5.000000e-01, %363
%365 = load double, double* %24
%366 = load double*, double** %12
%367 = load i32, i32* %17
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double, double* %366, i64 %368
%370 = load double, double* %369
%371 = fsub double %365, %370
%372 = call double @llvm.fmuladd.f64(double %364, double %371, double 1.000000e+00)
%373 = fdiv double %362, %372
%374 = load double*, double** %45
%375 = load i32, i32* %17
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %374, i64 %376
store double %373, double* %377
br label %378
378: ; preds = %283
%379 = load i32, i32* %17
%380 = add nsw i32 %379, 1
store i32 %380, i32* %17
br label %279
381: ; preds = %279
%382 = load i32, i32* %23
%383 = sub nsw i32 %382, 1
store i32 %383, i32* %21
br label %384
384: ; preds = %415, %381
%385 = load double*, double** %43
%386 = load i32, i32* %21
%387 = sub nsw i32 %386, 1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %385, i64 %388
%390 = load double, double* %389
%391 = load double*, double** %43
%392 = load i32, i32* %21
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %391, i64 %393
%395 = load double, double* %394
%396 = fmul double %390, %395
%397 = fcmp ogt double %396, 0.000000e+00
br i1 %397, label %398, label %416
398: ; preds = %384
%399 = load i32, i32* %21
%400 = sub nsw i32 %399, 1
store i32 %400, i32* %21
%401 = load i32, i32* %21
%402 = icmp slt i32 %401, 2
br i1 %402, label %403, label %415
403: ; preds = %398
%404 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%405 = load double*, double** %43
%406 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %405)
%407 = load double*, double** %47
%408 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %407)
%409 = load double*, double** %46
%410 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %409)
%411 = load double*, double** %45
%412 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %411)
%413 = load double*, double** %44
%414 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %413)
br label %1066
415: ; preds = %398
br label %384
416: ; preds = %384
store double 1.000000e+00, double* %38
store i32 0, i32* %17
br label %417
417: ; preds = %427, %416
%418 = load i32, i32* %17
%419 = load i32, i32* %9
%420 = load i32, i32* %10
%421 = sub nsw i32 %419, %420
%422 = sub nsw i32 %421, 1
%423 = icmp slt i32 %418, %422
br i1 %423, label %424, label %430
424: ; preds = %417
%425 = load double, double* %38
%426 = fmul double %425, -1.000000e+00
store double %426, double* %38
br label %427
427: ; preds = %424
%428 = load i32, i32* %17
%429 = add nsw i32 %428, 1
store i32 %429, i32* %17
br label %417
430: ; preds = %417
store i32 0, i32* %17
br label %431
431: ; preds = %495, %430
%432 = load i32, i32* %17
%433 = icmp slt i32 %432, 4
br i1 %433, label %434, label %498
434: ; preds = %431
%435 = load double, double* %38
%436 = load double*, double** %42
%437 = load i32, i32* %17
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %436, i64 %438
%440 = load double, double* %439
%441 = load double, double* %31
%442 = call double @pow(double %440, double %441)
%443 = fmul double %435, %442
%444 = load double*, double** %15
%445 = load i32, i32* %17
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %444, i64 %446
store double %443, double* %447
%448 = load double, double* %28
%449 = load double, double* %31
%450 = fmul double %448, %449
%451 = load double*, double** %15
%452 = load i32, i32* %17
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %451, i64 %453
%455 = load double, double* %454
%456 = fmul double %450, %455
%457 = load double*, double** %16
%458 = load i32, i32* %17
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %457, i64 %459
store double %456, double* %460
%461 = load double, double* %28
%462 = load double*, double** %45
%463 = load i32, i32* %17
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %462, i64 %464
%466 = load double, double* %465
%467 = fadd double %461, %466
%468 = load double*, double** %16
%469 = load i32, i32* %17
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %468, i64 %470
%472 = load double, double* %471
%473 = load double*, double** %43
%474 = load i32, i32* %17
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %473, i64 %475
%477 = load double, double* %476
%478 = load double*, double** %46
%479 = load i32, i32* %17
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %478, i64 %480
%482 = load double, double* %481
%483 = fadd double %477, %482
%484 = load double*, double** %15
%485 = load i32, i32* %17
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %484, i64 %486
%488 = load double, double* %487
%489 = fmul double %483, %488
%490 = call double @llvm.fmuladd.f64(double %467, double %472, double %489)
%491 = load double*, double** %47
%492 = load i32, i32* %17
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %491, i64 %493
store double %490, double* %494
br label %495
495: ; preds = %434
%496 = load i32, i32* %17
%497 = add nsw i32 %496, 1
store i32 %497, i32* %17
br label %431
498: ; preds = %431
store i32 0, i32* %20
store i32 3, i32* %17
br label %499
499: ; preds = %609, %498
%500 = load i32, i32* %17
%501 = load i32, i32* %21
%502 = icmp slt i32 %500, %501
br i1 %502, label %503, label %612
503: ; preds = %499
%504 = load i32, i32* %17
%505 = load double*, double** %15
%506 = load double*, double** %16
%507 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_Out to i32 (i32, double*, double*, ...)*)(i32 %504, double* %505, double* %506)
%508 = sitofp i32 %507 to double
%509 = load double*, double** %15
%510 = load i32, i32* %17
%511 = add nsw i32 %510, 1
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %509, i64 %512
store double %508, double* %513
%514 = load i32, i32* %17
%515 = load double*, double** %16
%516 = load double*, double** %47
%517 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_Out to i32 (i32, double*, double*, ...)*)(i32 %514, double* %515, double* %516)
%518 = sitofp i32 %517 to double
%519 = load double*, double** %16
%520 = load i32, i32* %17
%521 = add nsw i32 %520, 1
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %519, i64 %522
store double %518, double* %523
store i32 0, i32* %18
br label %524
524: ; preds = %588, %503
%525 = load i32, i32* %18
%526 = icmp slt i32 %525, 6
br i1 %526, label %527, label %591
527: ; preds = %524
%528 = load double, double* %28
%529 = load double*, double** %45
%530 = load i32, i32* %17
%531 = add nsw i32 %530, 1
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %529, i64 %532
%534 = load double, double* %533
%535 = fadd double %528, %534
%536 = load double*, double** %16
%537 = load i32, i32* %17
%538 = add nsw i32 %537, 1
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %536, i64 %539
%541 = load double, double* %540
%542 = load double*, double** %43
%543 = load i32, i32* %17
%544 = add nsw i32 %543, 1
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %542, i64 %545
%547 = load double, double* %546
%548 = load double*, double** %46
%549 = load i32, i32* %17
%550 = add nsw i32 %549, 1
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds double, double* %548, i64 %551
%553 = load double, double* %552
%554 = fadd double %547, %553
%555 = load double*, double** %15
%556 = load i32, i32* %17
%557 = add nsw i32 %556, 1
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds double, double* %555, i64 %558
%560 = load double, double* %559
%561 = fmul double %554, %560
%562 = call double @llvm.fmuladd.f64(double %535, double %541, double %561)
%563 = load double*, double** %47
%564 = load i32, i32* %17
%565 = add nsw i32 %564, 1
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %563, i64 %566
store double %562, double* %567
%568 = load i32, i32* %17
%569 = load double*, double** %16
%570 = load double*, double** %47
%571 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_Out to i32 (i32, double*, double*, ...)*)(i32 %568, double* %569, double* %570)
%572 = sitofp i32 %571 to double
%573 = load double*, double** %16
%574 = load i32, i32* %17
%575 = add nsw i32 %574, 1
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds double, double* %573, i64 %576
store double %572, double* %577
%578 = load i32, i32* %17
%579 = load double*, double** %15
%580 = load double*, double** %16
%581 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_Out to i32 (i32, double*, double*, ...)*)(i32 %578, double* %579, double* %580)
%582 = sitofp i32 %581 to double
%583 = load double*, double** %15
%584 = load i32, i32* %17
%585 = add nsw i32 %584, 1
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %583, i64 %586
store double %582, double* %587
br label %588
588: ; preds = %527
%589 = load i32, i32* %18
%590 = add nsw i32 %589, 1
store i32 %590, i32* %18
br label %524
591: ; preds = %524
%592 = load double*, double** %15
%593 = load i32, i32* %17
%594 = add nsw i32 %593, 1
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double, double* %592, i64 %595
%597 = load double, double* %596
%598 = load double*, double** %15
%599 = load i32, i32* %17
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %598, i64 %600
%602 = load double, double* %601
%603 = fmul double %597, %602
%604 = fcmp ole double %603, 0.000000e+00
br i1 %604, label %605, label %608
605: ; preds = %591
%606 = load i32, i32* %20
%607 = add nsw i32 %606, 1
store i32 %607, i32* %20
br label %608
608: ; preds = %605, %591
br label %609
609: ; preds = %608
%610 = load i32, i32* %17
%611 = add nsw i32 %610, 1
store i32 %611, i32* %17
br label %499
612: ; preds = %499
%613 = load double*, double** %15
%614 = load i32, i32* %21
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds double, double* %613, i64 %615
%617 = load double, double* %616
store double %617, double* %39
%618 = load double*, double** %16
%619 = load i32, i32* %21
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %618, i64 %620
%622 = load double, double* %621
store double %622, double* %40
%623 = load i32, i32* %20
%624 = load i32, i32* %9
%625 = sub nsw i32 %623, %624
%626 = load i32, i32* %10
%627 = add nsw i32 %625, %626
%628 = add nsw i32 %627, 1
%629 = icmp slt i32 %628, 0
br i1 %629, label %630, label %636
630: ; preds = %612
%631 = load double, double* %24
store double %631, double* %27
%632 = load double, double* %27
%633 = load double, double* %26
%634 = fadd double %632, %633
%635 = fmul double 5.000000e-01, %634
store double %635, double* %24
br label %1049
636: ; preds = %612
%637 = load i32, i32* %20
%638 = load i32, i32* %9
%639 = sub nsw i32 %637, %638
%640 = load i32, i32* %10
%641 = add nsw i32 %639, %640
%642 = add nsw i32 %641, 1
%643 = icmp sgt i32 %642, 0
br i1 %643, label %644, label %650
644: ; preds = %636
%645 = load double, double* %24
store double %645, double* %26
%646 = load double, double* %27
%647 = load double, double* %26
%648 = fadd double %646, %647
%649 = fmul double 5.000000e-01, %648
store double %649, double* %24
br label %1048
650: ; preds = %636
%651 = load i32, i32* %21
%652 = sitofp i32 %651 to double
%653 = load double, double* %28
%654 = fdiv double 2.300000e+00, %653
%655 = call double @llvm.floor.f64(double %654)
%656 = fadd double %652, %655
%657 = fptosi double %656 to i32
store i32 %657, i32* %22
%658 = load i32, i32* %22
%659 = add nsw i32 %658, 5
%660 = load i32, i32* %23
%661 = icmp sgt i32 %659, %660
br i1 %661, label %662, label %665
662: ; preds = %650
%663 = load i32, i32* %23
%664 = sub nsw i32 %663, 5
store i32 %664, i32* %22
br label %665
665: ; preds = %662, %650
%666 = load double, double* %32
%667 = load double*, double** %42
%668 = load i32, i32* %22
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds double, double* %667, i64 %669
%671 = load double, double* %670
%672 = load double*, double** %42
%673 = load i32, i32* %22
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds double, double* %672, i64 %674
%676 = load double, double* %675
%677 = fmul double %671, %676
%678 = fdiv double %666, %677
%679 = load double*, double** %12
%680 = load i32, i32* %22
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %679, i64 %681
%683 = load double, double* %682
%684 = load double, double* %24
%685 = fsub double %683, %684
%686 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %685, double %678)
%687 = call double @sqrt(double %686)
store double %687, double* %36
%688 = load i32, i32* %22
store i32 %688, i32* %17
br label %689
689: ; preds = %768, %665
%690 = load i32, i32* %17
%691 = load i32, i32* %22
%692 = add nsw i32 %691, 4
%693 = icmp sle i32 %690, %692
br i1 %693, label %694, label %771
694: ; preds = %689
%695 = load double, double* %36
%696 = fneg double %695
%697 = load double*, double** %42
%698 = load i32, i32* %17
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds double, double* %697, i64 %699
%701 = load double, double* %700
%702 = load double*, double** %42
%703 = load i32, i32* %22
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds double, double* %702, i64 %704
%706 = load double, double* %705
%707 = fsub double %701, %706
%708 = fmul double %696, %707
%709 = call double @exp(double %708)
%710 = load double*, double** %15
%711 = load i32, i32* %17
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds double, double* %710, i64 %712
store double %709, double* %713
%714 = load double*, double** %42
%715 = load i32, i32* %17
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %714, i64 %716
%718 = load double, double* %717
%719 = fneg double %718
%720 = load double, double* %28
%721 = fmul double %719, %720
%722 = load double, double* %36
%723 = fmul double %721, %722
%724 = load double*, double** %15
%725 = load i32, i32* %17
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %724, i64 %726
%728 = load double, double* %727
%729 = fmul double %723, %728
%730 = load double*, double** %16
%731 = load i32, i32* %17
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds double, double* %730, i64 %732
store double %729, double* %733
%734 = load double, double* %28
%735 = load double*, double** %45
%736 = load i32, i32* %17
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
%739 = load double, double* %738
%740 = fadd double %734, %739
%741 = load double*, double** %16
%742 = load i32, i32* %17
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds double, double* %741, i64 %743
%745 = load double, double* %744
%746 = load double*, double** %43
%747 = load i32, i32* %17
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double, double* %746, i64 %748
%750 = load double, double* %749
%751 = load double*, double** %46
%752 = load i32, i32* %17
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds double, double* %751, i64 %753
%755 = load double, double* %754
%756 = fadd double %750, %755
%757 = load double*, double** %15
%758 = load i32, i32* %17
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %757, i64 %759
%761 = load double, double* %760
%762 = fmul double %756, %761
%763 = call double @llvm.fmuladd.f64(double %740, double %745, double %762)
%764 = load double*, double** %47
%765 = load i32, i32* %17
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds double, double* %764, i64 %766
store double %763, double* %767
br label %768
768: ; preds = %694
%769 = load i32, i32* %17
%770 = add nsw i32 %769, 1
store i32 %770, i32* %17
br label %689
771: ; preds = %689
%772 = load i32, i32* %22
store i32 %772, i32* %17
br label %773
773: ; preds = %867, %771
%774 = load i32, i32* %17
%775 = load i32, i32* %21
%776 = add nsw i32 %775, 1
%777 = icmp sge i32 %774, %776
br i1 %777, label %778, label %870
778: ; preds = %773
%779 = load i32, i32* %17
%780 = load double*, double** %15
%781 = load double*, double** %16
%782 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_In to i32 (i32, double*, double*, ...)*)(i32 %779, double* %780, double* %781)
%783 = sitofp i32 %782 to double
%784 = load double*, double** %15
%785 = load i32, i32* %17
%786 = sub nsw i32 %785, 1
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %784, i64 %787
store double %783, double* %788
%789 = load i32, i32* %17
%790 = load double*, double** %16
%791 = load double*, double** %47
%792 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_In to i32 (i32, double*, double*, ...)*)(i32 %789, double* %790, double* %791)
%793 = sitofp i32 %792 to double
%794 = load double*, double** %16
%795 = load i32, i32* %17
%796 = sub nsw i32 %795, 1
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds double, double* %794, i64 %797
store double %793, double* %798
store i32 0, i32* %18
br label %799
799: ; preds = %863, %778
%800 = load i32, i32* %18
%801 = icmp slt i32 %800, 6
br i1 %801, label %802, label %866
802: ; preds = %799
%803 = load double, double* %28
%804 = load double*, double** %45
%805 = load i32, i32* %17
%806 = sub nsw i32 %805, 1
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %804, i64 %807
%809 = load double, double* %808
%810 = fadd double %803, %809
%811 = load double*, double** %16
%812 = load i32, i32* %17
%813 = sub nsw i32 %812, 1
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds double, double* %811, i64 %814
%816 = load double, double* %815
%817 = load double*, double** %43
%818 = load i32, i32* %17
%819 = sub nsw i32 %818, 1
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds double, double* %817, i64 %820
%822 = load double, double* %821
%823 = load double*, double** %46
%824 = load i32, i32* %17
%825 = sub nsw i32 %824, 1
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds double, double* %823, i64 %826
%828 = load double, double* %827
%829 = fadd double %822, %828
%830 = load double*, double** %15
%831 = load i32, i32* %17
%832 = sub nsw i32 %831, 1
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %830, i64 %833
%835 = load double, double* %834
%836 = fmul double %829, %835
%837 = call double @llvm.fmuladd.f64(double %810, double %816, double %836)
%838 = load double*, double** %47
%839 = load i32, i32* %17
%840 = sub nsw i32 %839, 1
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds double, double* %838, i64 %841
store double %837, double* %842
%843 = load i32, i32* %17
%844 = load double*, double** %16
%845 = load double*, double** %47
%846 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_In to i32 (i32, double*, double*, ...)*)(i32 %843, double* %844, double* %845)
%847 = sitofp i32 %846 to double
%848 = load double*, double** %16
%849 = load i32, i32* %17
%850 = sub nsw i32 %849, 1
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds double, double* %848, i64 %851
store double %847, double* %852
%853 = load i32, i32* %17
%854 = load double*, double** %15
%855 = load double*, double** %16
%856 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_In to i32 (i32, double*, double*, ...)*)(i32 %853, double* %854, double* %855)
%857 = sitofp i32 %856 to double
%858 = load double*, double** %15
%859 = load i32, i32* %17
%860 = sub nsw i32 %859, 1
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds double, double* %858, i64 %861
store double %857, double* %862
br label %863
863: ; preds = %802
%864 = load i32, i32* %18
%865 = add nsw i32 %864, 1
store i32 %865, i32* %18
br label %799
866: ; preds = %799
br label %867
867: ; preds = %866
%868 = load i32, i32* %17
%869 = add nsw i32 %868, -1
store i32 %869, i32* %17
br label %773
870: ; preds = %773
%871 = load double, double* %39
%872 = load double*, double** %15
%873 = load i32, i32* %21
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %872, i64 %874
%876 = load double, double* %875
%877 = fdiv double %871, %876
store double %877, double* %37
%878 = load i32, i32* %21
store i32 %878, i32* %17
br label %879
879: ; preds = %906, %870
%880 = load i32, i32* %17
%881 = load i32, i32* %22
%882 = icmp sle i32 %880, %881
br i1 %882, label %883, label %909
883: ; preds = %879
%884 = load double, double* %37
%885 = load double*, double** %15
%886 = load i32, i32* %17
%887 = sext i32 %886 to i64
%888 = getelementptr inbounds double, double* %885, i64 %887
%889 = load double, double* %888
%890 = fmul double %884, %889
%891 = load double*, double** %15
%892 = load i32, i32* %17
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds double, double* %891, i64 %893
store double %890, double* %894
%895 = load double, double* %37
%896 = load double*, double** %16
%897 = load i32, i32* %17
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds double, double* %896, i64 %898
%900 = load double, double* %899
%901 = fmul double %895, %900
%902 = load double*, double** %16
%903 = load i32, i32* %17
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %902, i64 %904
store double %901, double* %905
br label %906
906: ; preds = %883
%907 = load i32, i32* %17
%908 = add nsw i32 %907, 1
store i32 %908, i32* %17
br label %879
909: ; preds = %879
%910 = load double*, double** %16
%911 = load i32, i32* %21
%912 = sext i32 %911 to i64
%913 = getelementptr inbounds double, double* %910, i64 %912
%914 = load double, double* %913
store double %914, double* %41
%915 = load i32, i32* %22
%916 = load double, double* %31
%917 = load double*, double** %15
%918 = call i32 (i32, double, double*, ...) bitcast (i32 (...)* @Norm_LogGrid to i32 (i32, double, double*, ...)*)(i32 %915, double %916, double* %917)
%919 = sitofp i32 %918 to double
store double %919, double* %35
%920 = load double, double* %35
%921 = call double @sqrt(double %920)
%922 = fdiv double 1.000000e+00, %921
store double %922, double* %35
%923 = load double, double* %35
%924 = load double, double* %39
%925 = fmul double %923, %924
store double %925, double* %39
%926 = load double, double* %35
%927 = load double, double* %40
%928 = fmul double %926, %927
store double %928, double* %40
%929 = load double, double* %35
%930 = load double, double* %41
%931 = fmul double %929, %930
store double %931, double* %41
store i32 0, i32* %17
br label %932
932: ; preds = %959, %909
%933 = load i32, i32* %17
%934 = load i32, i32* %22
%935 = icmp sle i32 %933, %934
br i1 %935, label %936, label %962
936: ; preds = %932
%937 = load double, double* %35
%938 = load double*, double** %15
%939 = load i32, i32* %17
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds double, double* %938, i64 %940
%942 = load double, double* %941
%943 = fmul double %937, %942
%944 = load double*, double** %15
%945 = load i32, i32* %17
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds double, double* %944, i64 %946
store double %943, double* %947
%948 = load double, double* %35
%949 = load double*, double** %16
%950 = load i32, i32* %17
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds double, double* %949, i64 %951
%953 = load double, double* %952
%954 = fmul double %948, %953
%955 = load double*, double** %16
%956 = load i32, i32* %17
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds double, double* %955, i64 %957
store double %954, double* %958
br label %959
959: ; preds = %936
%960 = load i32, i32* %17
%961 = add nsw i32 %960, 1
store i32 %961, i32* %17
br label %932
962: ; preds = %932
%963 = load i32, i32* %22
%964 = add nsw i32 %963, 1
store i32 %964, i32* %17
br label %965
965: ; preds = %978, %962
%966 = load i32, i32* %17
%967 = load i32, i32* %23
%968 = icmp slt i32 %966, %967
br i1 %968, label %969, label %981
969: ; preds = %965
%970 = load double*, double** %15
%971 = load i32, i32* %17
%972 = sext i32 %971 to i64
%973 = getelementptr inbounds double, double* %970, i64 %972
store double 0.000000e+00, double* %973
%974 = load double*, double** %16
%975 = load i32, i32* %17
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds double, double* %974, i64 %976
store double 0.000000e+00, double* %977
br label %978
978: ; preds = %969
%979 = load i32, i32* %17
%980 = add nsw i32 %979, 1
store i32 %980, i32* %17
br label %965
981: ; preds = %965
%982 = load double, double* %39
%983 = fmul double 5.000000e-01, %982
%984 = load double, double* %40
%985 = load double, double* %41
%986 = fsub double %984, %985
%987 = fmul double %983, %986
%988 = load double, double* %28
%989 = load double*, double** %42
%990 = load i32, i32* %21
%991 = sext i32 %990 to i64
%992 = getelementptr inbounds double, double* %989, i64 %991
%993 = load double, double* %992
%994 = fmul double %988, %993
%995 = fdiv double %987, %994
store double %995, double* %25
%996 = load double, double* %25
%997 = call double @llvm.fabs.f64(double %996)
%998 = load double, double* %24
%999 = call double @llvm.fabs.f64(double %998)
%1000 = fcmp ogt double %999, 2.000000e-01
br i1 %1000, label %1001, label %1004
1001: ; preds = %981
%1002 = load double, double* %24
%1003 = call double @llvm.fabs.f64(double %1002)
br label %1005
1004: ; preds = %981
br label %1005
1005: ; preds = %1004, %1001
%1006 = phi double [ %1003, %1001 ], [ 2.000000e-01, %1004 ]
%1007 = fmul double %1006, 1.000000e-10
%1008 = fcmp olt double %997, %1007
br i1 %1008, label %1009, label %1024
1009: ; preds = %1005
%1010 = load i32, i32* %21
%1011 = load i32*, i32** %13
store i32 %1010, i32* %1011
%1012 = load double, double* %24
%1013 = load double*, double** %14
store double %1012, double* %1013
%1014 = load double*, double** %43
%1015 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1014)
%1016 = load double*, double** %47
%1017 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1016)
%1018 = load double*, double** %46
%1019 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1018)
%1020 = load double*, double** %45
%1021 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1020)
%1022 = load double*, double** %44
%1023 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1022)
br label %1066
1024: ; preds = %1005
%1025 = load double, double* %25
%1026 = fcmp ogt double %1025, 0.000000e+00
br i1 %1026, label %1027, label %1029
1027: ; preds = %1024
%1028 = load double, double* %24
store double %1028, double* %27
br label %1031
1029: ; preds = %1024
%1030 = load double, double* %24
store double %1030, double* %26
br label %1031
1031: ; preds = %1029, %1027
%1032 = load double, double* %24
%1033 = load double, double* %25
%1034 = fadd double %1032, %1033
store double %1034, double* %24
%1035 = load double, double* %24
%1036 = load double, double* %26
%1037 = fcmp ogt double %1035, %1036
br i1 %1037, label %1042, label %1038
1038: ; preds = %1031
%1039 = load double, double* %24
%1040 = load double, double* %27
%1041 = fcmp olt double %1039, %1040
br i1 %1041, label %1042, label %1047
1042: ; preds = %1038, %1031
%1043 = load double, double* %27
%1044 = load double, double* %26
%1045 = fadd double %1043, %1044
%1046 = fmul double 5.000000e-01, %1045
store double %1046, double* %24
br label %1047
1047: ; preds = %1042, %1038
br label %1048
1048: ; preds = %1047, %644
br label %1049
1049: ; preds = %1048, %630
br label %236
1050: ; preds = %236
%1051 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.1, i64 0, i64 0), i32 100)
%1052 = load i32, i32* %21
%1053 = load i32*, i32** %13
store i32 %1052, i32* %1053
%1054 = load double, double* %24
%1055 = load double*, double** %14
store double %1054, double* %1055
%1056 = load double*, double** %43
%1057 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1056)
%1058 = load double*, double** %47
%1059 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1058)
%1060 = load double*, double** %46
%1061 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1060)
%1062 = load double*, double** %45
%1063 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1062)
%1064 = load double*, double** %44
%1065 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1064)
br label %1066
1066: ; preds = %1050, %1009, %403
ret void
}

LLVM IR (-O2):
@.str.1 = [40 x i8] c"Error R_Pauli: More than %d iterations\0A\00"
@str = [35 x i8] c"Error in R_Pauli: no turning point\00"
define void @R_Pauli(i32 %0, i32 %1, double %2, double* %3, i32* nocapture writeonly %4, double* nocapture %5, double* %6, double* %7) {
%9 = load double, double* %5
%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 %14, label %18
14: ; preds = %8
%15 = fmul double %2, 0xBF0BEB460CEF1CFC
%16 = tail call double @llvm.fmuladd.f64(double %15, double %2, double 1.000000e+00)
%17 = tail call double @sqrt(double %16)
br label %31
18: ; preds = %8
%19 = sitofp i32 %1 to double
%20 = fmul double %2, 0xBF0BEB460CEF1CFC
%21 = fmul double %20, %2
%22 = tail call double @llvm.fmuladd.f64(double %19, double %19, double %21)
%23 = tail call double @sqrt(double %22)
%24 = fadd double %19, 1.000000e+00
%25 = tail call double @llvm.fmuladd.f64(double %24, double %24, double %21)
%26 = tail call double @sqrt(double %25)
%27 = fmul double %24, %26
%28 = tail call double @llvm.fmuladd.f64(double %23, double %19, double %27)
%29 = tail call double @llvm.fmuladd.f64(double %19, double 2.000000e+00, double 1.000000e+00)
%30 = fdiv double %28, %29
br label %31
31: ; preds = %18, %14
%32 = phi double [ %17, %14 ], [ %30, %18 ]
%33 = tail call i32 (...) @N_LogGrid()
%34 = tail call i32 (...) @log_amesh_LogGrid()
%35 = sitofp i32 %34 to double
%36 = fmul double %35, %35
%37 = tail call i32 (...) @r_LogGrid()
%38 = sext i32 %37 to i64
%39 = inttoptr i64 %38 to double*
%40 = inttoptr i64 %38 to i8*
%41 = tail call i32 (...) @alloc_LogGrid()
%42 = sext i32 %41 to i64
%43 = inttoptr i64 %42 to double*
%44 = inttoptr i64 %42 to i8*
%45 = tail call i32 (...) @alloc_LogGrid()
%46 = sext i32 %45 to i64
%47 = inttoptr i64 %46 to double*
%48 = tail call i32 (...) @alloc_LogGrid()
%49 = sext i32 %48 to i64
%50 = inttoptr i64 %49 to double*
%51 = inttoptr i64 %49 to i8*
%52 = tail call i32 (...) @alloc_LogGrid()
%53 = sext i32 %52 to i64
%54 = inttoptr i64 %53 to double*
%55 = inttoptr i64 %53 to i8*
%56 = tail call i32 (...) @alloc_LogGrid()
%57 = sext i32 %56 to i64
%58 = inttoptr i64 %57 to double*
%59 = inttoptr i64 %57 to i8*
%60 = add nsw i32 %33, -1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %3, i64 %61
%63 = load double, double* %62
%64 = fmul double %12, 5.000000e-01
%65 = getelementptr inbounds double, double* %39, i64 %61
%66 = load double, double* %65
%67 = fmul double %66, %66
%68 = fdiv double %64, %67
%69 = fadd double %63, %68
%70 = icmp sgt i32 %33, 0
%71 = zext i32 %33 to i64
br i1 %70, label %72, label %118
72: ; preds = %31
%73 = and i64 %71, 1
%74 = icmp eq i32 %33, 1
br i1 %74, label %103, label %75
75: ; preds = %72
%76 = and i64 %71, 4294967294
br label %77
77: ; preds = %77, %75
%78 = phi i64 [ 0, %75 ], [ %100, %77 ]
%79 = phi double [ 0.000000e+00, %75 ], [ %99, %77 ]
%80 = phi i64 [ 0, %75 ], [ %101, %77 ]
%81 = getelementptr inbounds double, double* %39, i64 %78
%82 = load double, double* %81
%83 = fmul double %82, %82
%84 = getelementptr inbounds double, double* %3, i64 %78
%85 = load double, double* %84
%86 = fdiv double %64, %83
%87 = fadd double %85, %86
%88 = fcmp olt double %79, %87
%89 = select i1 %88, double %79, double %87
%90 = or i64 %78, 1
%91 = getelementptr inbounds double, double* %39, i64 %90
%92 = load double, double* %91
%93 = fmul double %92, %92
%94 = getelementptr inbounds double, double* %3, i64 %90
%95 = load double, double* %94
%96 = fdiv double %64, %93
%97 = fadd double %95, %96
%98 = fcmp olt double %89, %97
%99 = select i1 %98, double %89, double %97
%100 = add nuw nsw i64 %78, 2
%101 = add i64 %80, 2
%102 = icmp eq i64 %101, %76
br i1 %102, label %103, label %77
103: ; preds = %77, %72
%104 = phi double [ undef, %72 ], [ %99, %77 ]
%105 = phi i64 [ 0, %72 ], [ %100, %77 ]
%106 = phi double [ 0.000000e+00, %72 ], [ %99, %77 ]
%107 = icmp eq i64 %73, 0
br i1 %107, label %118, label %108
108: ; preds = %103
%109 = getelementptr inbounds double, double* %39, i64 %105
%110 = load double, double* %109
%111 = fmul double %110, %110
%112 = getelementptr inbounds double, double* %3, i64 %105
%113 = load double, double* %112
%114 = fdiv double %64, %111
%115 = fadd double %113, %114
%116 = fcmp olt double %106, %115
%117 = select i1 %116, double %106, double %115
br label %118
118: ; preds = %108, %103, %31
%119 = phi double [ 0.000000e+00, %31 ], [ %104, %103 ], [ %117, %108 ]
%120 = fcmp ogt double %9, %69
%121 = fmul double %69, 1.250000e+00
%122 = select i1 %120, double %121, double %9
%123 = fcmp olt double %122, %119
%124 = fmul double %119, 7.500000e-01
%125 = select i1 %123, double %124, double %122
%126 = fadd double %69, %119
%127 = fmul double %126, 5.000000e-01
store double 0.000000e+00, double* %6
store double 0.000000e+00, double* %7
store double 0.000000e+00, double* %47
%128 = getelementptr inbounds double, double* %6, i64 1
store double 0.000000e+00, double* %128
%129 = getelementptr inbounds double, double* %7, i64 1
store double 0.000000e+00, double* %129
%130 = getelementptr inbounds double, double* %47, i64 1
store double 0.000000e+00, double* %130
%131 = getelementptr inbounds double, double* %6, i64 2
store double 0.000000e+00, double* %131
%132 = getelementptr inbounds double, double* %7, i64 2
store double 0.000000e+00, double* %132
%133 = getelementptr inbounds double, double* %47, i64 2
store double 0.000000e+00, double* %133
%134 = getelementptr inbounds double, double* %6, i64 3
store double 0.000000e+00, double* %134
%135 = getelementptr inbounds double, double* %7, i64 3
store double 0.000000e+00, double* %135
%136 = getelementptr inbounds double, double* %47, i64 3
store double 0.000000e+00, double* %136
%137 = fcmp ogt double %125, %69
%138 = select i1 %137, double %127, double %125
%139 = fneg double %35
%140 = xor i32 %1, -1
%141 = add i32 %140, %0
%142 = icmp sgt i32 %141, 0
%143 = fmul double %32, %35
%144 = fdiv double 2.300000e+00, %35
%145 = tail call double @llvm.floor.f64(double %144)
%146 = add nsw i32 %33, -5
%147 = getelementptr inbounds double, double* %43, i64 %61
%148 = getelementptr inbounds double, double* %39, i64 1
%149 = getelementptr inbounds double, double* %54, i64 1
%150 = getelementptr inbounds double, double* %43, i64 1
%151 = getelementptr inbounds double, double* %50, i64 1
%152 = getelementptr inbounds double, double* %39, i64 2
%153 = getelementptr inbounds double, double* %54, i64 2
%154 = getelementptr inbounds double, double* %43, i64 2
%155 = getelementptr inbounds double, double* %50, i64 2
%156 = getelementptr inbounds double, double* %39, i64 3
%157 = getelementptr inbounds double, double* %54, i64 3
%158 = getelementptr inbounds double, double* %43, i64 3
%159 = getelementptr inbounds double, double* %50, i64 3
%160 = getelementptr double, double* %6, i64 1
%161 = getelementptr double, double* %7, i64 1
%162 = getelementptr double, double* %6, i64 1
%163 = getelementptr double, double* %7, i64 1
%164 = getelementptr double, double* %50, i64 %71
%165 = bitcast double* %164 to i8*
%166 = getelementptr double, double* %54, i64 %71
%167 = bitcast double* %166 to i8*
%168 = getelementptr double, double* %39, i64 %71
%169 = bitcast double* %168 to i8*
%170 = getelementptr double, double* %3, i64 %71
%171 = bitcast double* %170 to i8*
%172 = getelementptr double, double* %58, i64 %71
%173 = bitcast double* %172 to i8*
%174 = getelementptr double, double* %43, i64 %71
%175 = bitcast double* %174 to i8*
%176 = getelementptr double, double* %39, i64 %71
%177 = bitcast double* %176 to i8*
%178 = getelementptr double, double* %3, i64 %71
%179 = bitcast double* %178 to i8*
%180 = add i32 %0, -2
%181 = sub i32 %180, %1
%182 = icmp ult i32 %33, 4
%183 = icmp ult i8* %44, %177
%184 = icmp ult i8* %40, %175
%185 = and i1 %183, %184
%186 = icmp ult i8* %44, %179
%187 = icmp ugt double* %174, %3
%188 = and i1 %186, %187
%189 = or i1 %185, %188
%190 = and i64 %71, 4294967292
%191 = insertelement <2 x double> poison, double %12, i64 0
%192 = shufflevector <2 x double> %191, <2 x double> poison, <2 x i32> zeroinitializer
%193 = insertelement <2 x double> poison, double %12, i64 0
%194 = shufflevector <2 x double> %193, <2 x double> poison, <2 x i32> zeroinitializer
%195 = insertelement <2 x double> poison, double %36, i64 0
%196 = shufflevector <2 x double> %195, <2 x double> poison, <2 x i32> zeroinitializer
%197 = insertelement <2 x double> poison, double %36, i64 0
%198 = shufflevector <2 x double> %197, <2 x double> poison, <2 x i32> zeroinitializer
%199 = icmp eq i64 %190, %71
%200 = and i64 %71, 1
%201 = icmp eq i64 %200, 0
%202 = sub nsw i64 0, %71
%203 = icmp ult i32 %33, 2
%204 = icmp ult i8* %51, %167
%205 = icmp ult i8* %55, %165
%206 = and i1 %204, %205
%207 = icmp ult i8* %51, %169
%208 = icmp ult i8* %40, %165
%209 = and i1 %207, %208
%210 = or i1 %206, %209
%211 = icmp ult i8* %51, %171
%212 = icmp ugt double* %164, %3
%213 = and i1 %211, %212
%214 = or i1 %210, %213
%215 = icmp ult i8* %51, %173
%216 = icmp ult i8* %59, %165
%217 = and i1 %215, %216
%218 = or i1 %214, %217
%219 = icmp ult i8* %55, %169
%220 = icmp ult i8* %40, %167
%221 = and i1 %219, %220
%222 = or i1 %218, %221
%223 = icmp ult i8* %55, %171
%224 = icmp ugt double* %166, %3
%225 = and i1 %223, %224
%226 = or i1 %222, %225
%227 = icmp ult i8* %55, %173
%228 = icmp ult i8* %59, %167
%229 = and i1 %227, %228
%230 = or i1 %226, %229
%231 = and i64 %71, 4294967294
%232 = insertelement <2 x double> poison, double %36, i64 0
%233 = shufflevector <2 x double> %232, <2 x double> poison, <2 x i32> zeroinitializer
%234 = insertelement <2 x double> poison, double %139, i64 0
%235 = shufflevector <2 x double> %234, <2 x double> poison, <2 x i32> zeroinitializer
%236 = icmp eq i64 %231, %71
%237 = and i32 %141, 7
%238 = icmp ult i32 %181, 7
%239 = and i32 %141, -8
%240 = icmp eq i32 %237, 0
br label %241
241: ; preds = %118, %1138
%242 = phi i32 [ 0, %118 ], [ %246, %1138 ]
%243 = phi double [ %138, %118 ], [ %1141, %1138 ]
%244 = phi double [ %69, %118 ], [ %1140, %1138 ]
%245 = phi double [ %119, %118 ], [ %1139, %1138 ]
%246 = add nuw nsw i32 %242, 1
br i1 %70, label %247, label %303
247: ; preds = %241
%248 = select i1 %182, i1 true, i1 %189
br i1 %248, label %285, label %249
249: ; preds = %247
%250 = insertelement <2 x double> poison, double %243, i64 0
%251 = shufflevector <2 x double> %250, <2 x double> poison, <2 x i32> zeroinitializer
%252 = insertelement <2 x double> poison, double %243, i64 0
%253 = shufflevector <2 x double> %252, <2 x double> poison, <2 x i32> zeroinitializer
br label %254
254: ; preds = %254, %249
%255 = phi i64 [ 0, %249 ], [ %282, %254 ]
%256 = getelementptr inbounds double, double* %39, i64 %255
%257 = bitcast double* %256 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = getelementptr inbounds double, double* %256, i64 2
%260 = bitcast double* %259 to <2 x double>*
%261 = load <2 x double>, <2 x double>* %260
%262 = fmul <2 x double> %258, %258
%263 = fmul <2 x double> %261, %261
%264 = getelementptr inbounds double, double* %3, i64 %255
%265 = bitcast double* %264 to <2 x double>*
%266 = load <2 x double>, <2 x double>* %265
%267 = getelementptr inbounds double, double* %264, i64 2
%268 = bitcast double* %267 to <2 x double>*
%269 = load <2 x double>, <2 x double>* %268
%270 = fsub <2 x double> %266, %251
%271 = fsub <2 x double> %269, %253
%272 = fmul <2 x double> %270, <double 2.000000e+00, double 2.000000e+00>
%273 = fmul <2 x double> %271, <double 2.000000e+00, double 2.000000e+00>
%274 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %272, <2 x double> %262, <2 x double> %192)
%275 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %273, <2 x double> %263, <2 x double> %194)
%276 = fmul <2 x double> %196, %274
%277 = fmul <2 x double> %198, %275
%278 = getelementptr inbounds double, double* %43, i64 %255
%279 = bitcast double* %278 to <2 x double>*
store <2 x double> %276, <2 x double>* %279
%280 = getelementptr inbounds double, double* %278, i64 2
%281 = bitcast double* %280 to <2 x double>*
store <2 x double> %277, <2 x double>* %281
%282 = add nuw i64 %255, 4
%283 = icmp eq i64 %282, %190
br i1 %283, label %284, label %254
284: ; preds = %254
br i1 %199, label %330, label %285
285: ; preds = %247, %284
%286 = phi i64 [ 0, %247 ], [ %190, %284 ]
%287 = xor i64 %286, -1
br i1 %201, label %300, label %288
288: ; preds = %285
%289 = getelementptr inbounds double, double* %39, i64 %286
%290 = load double, double* %289
%291 = fmul double %290, %290
%292 = getelementptr inbounds double, double* %3, i64 %286
%293 = load double, double* %292
%294 = fsub double %293, %243
%295 = fmul double %294, 2.000000e+00
%296 = tail call double @llvm.fmuladd.f64(double %295, double %291, double %12)
%297 = fmul double %36, %296
%298 = getelementptr inbounds double, double* %43, i64 %286
store double %297, double* %298
%299 = or i64 %286, 1
br label %300
300: ; preds = %288, %285
%301 = phi i64 [ %286, %285 ], [ %299, %288 ]
%302 = icmp eq i64 %287, %202
br i1 %302, label %330, label %305
303: ; preds = %241
%304 = tail call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %3, double* %58)
br label %380
305: ; preds = %300, %305
%306 = phi i64 [ %328, %305 ], [ %301, %300 ]
%307 = getelementptr inbounds double, double* %39, i64 %306
%308 = load double, double* %307
%309 = fmul double %308, %308
%310 = getelementptr inbounds double, double* %3, i64 %306
%311 = load double, double* %310
%312 = fsub double %311, %243
%313 = fmul double %312, 2.000000e+00
%314 = tail call double @llvm.fmuladd.f64(double %313, double %309, double %12)
%315 = fmul double %36, %314
%316 = getelementptr inbounds double, double* %43, i64 %306
store double %315, double* %316
%317 = add nuw nsw i64 %306, 1
%318 = getelementptr inbounds double, double* %39, i64 %317
%319 = load double, double* %318
%320 = fmul double %319, %319
%321 = getelementptr inbounds double, double* %3, i64 %317
%322 = load double, double* %321
%323 = fsub double %322, %243
%324 = fmul double %323, 2.000000e+00
%325 = tail call double @llvm.fmuladd.f64(double %324, double %320, double %12)
%326 = fmul double %36, %325
%327 = getelementptr inbounds double, double* %43, i64 %317
store double %326, double* %327
%328 = add nuw nsw i64 %306, 2
%329 = icmp eq i64 %328, %71
br i1 %329, label %330, label %305
330: ; preds = %300, %305, %284
%331 = tail call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %3, double* %58)
%332 = select i1 %203, i1 true, i1 %230
br i1 %332, label %378, label %333
333: ; preds = %330
%334 = insertelement <2 x double> poison, double %243, i64 0
%335 = shufflevector <2 x double> %334, <2 x double> poison, <2 x i32> zeroinitializer
br label %336
336: ; preds = %336, %333
%337 = phi i64 [ 0, %333 ], [ %375, %336 ]
%338 = getelementptr inbounds double, double* %39, i64 %337
%339 = bitcast double* %338 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = fmul <2 x double> %340, %340
%342 = fmul <2 x double> %233, %341
%343 = getelementptr inbounds double, double* %3, i64 %337
%344 = bitcast double* %343 to <2 x double>*
%345 = load <2 x double>, <2 x double>* %344
%346 = fsub <2 x double> %345, %335
%347 = fmul <2 x double> %346, <double 0xBF0BEB460CEF1CFC, double 0xBF0BEB460CEF1CFC>
%348 = getelementptr inbounds double, double* %58, i64 %337
%349 = bitcast double* %348 to <2 x double>*
%350 = load <2 x double>, <2 x double>* %349
%351 = fmul <2 x double> %350, <double 0x3EFBEB460CEF1CFC, double 0x3EFBEB460CEF1CFC>
%352 = fsub <2 x double> %335, %345
%353 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %352, <2 x double> <double 0x3EFBEB460CEF1CFC, double 0x3EFBEB460CEF1CFC>, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%354 = fmul <2 x double> %340, %353
%355 = fdiv <2 x double> %351, %354
%356 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %347, <2 x double> %346, <2 x double> %355)
%357 = fmul <2 x double> %342, %356
%358 = getelementptr inbounds double, double* %50, i64 %337
%359 = bitcast double* %358 to <2 x double>*
store <2 x double> %357, <2 x double>* %359
%360 = bitcast double* %338 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = fmul <2 x double> %361, %235
%363 = fmul <2 x double> %362, <double 5.000000e-01, double 5.000000e-01>
%364 = fmul <2 x double> %363, <double 0x3F0BEB460CEF1CFC, double 0x3F0BEB460CEF1CFC>
%365 = bitcast double* %348 to <2 x double>*
%366 = load <2 x double>, <2 x double>* %365
%367 = fmul <2 x double> %366, %364
%368 = bitcast double* %343 to <2 x double>*
%369 = load <2 x double>, <2 x double>* %368
%370 = fsub <2 x double> %335, %369
%371 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %370, <2 x double> <double 0x3EFBEB460CEF1CFC, double 0x3EFBEB460CEF1CFC>, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%372 = fdiv <2 x double> %367, %371
%373 = getelementptr inbounds double, double* %54, i64 %337
%374 = bitcast double* %373 to <2 x double>*
store <2 x double> %372, <2 x double>* %374
%375 = add nuw i64 %337, 2
%376 = icmp eq i64 %375, %231
br i1 %376, label %377, label %336
377: ; preds = %336
br i1 %236, label %380, label %378
378: ; preds = %330, %377
%379 = phi i64 [ 0, %330 ], [ %231, %377 ]
br label %382
380: ; preds = %382, %377, %303
%381 = load double, double* %147
br label %415
382: ; preds = %378, %382
%383 = phi i64 [ %413, %382 ], [ %379, %378 ]
%384 = getelementptr inbounds double, double* %39, i64 %383
%385 = load double, double* %384
%386 = fmul double %385, %385
%387 = fmul double %36, %386
%388 = getelementptr inbounds double, double* %3, i64 %383
%389 = load double, double* %388
%390 = fsub double %389, %243
%391 = fmul double %390, 0xBF0BEB460CEF1CFC
%392 = getelementptr inbounds double, double* %58, i64 %383
%393 = load double, double* %392
%394 = fmul double %393, 0x3EFBEB460CEF1CFC
%395 = fsub double %243, %389
%396 = tail call double @llvm.fmuladd.f64(double %395, double 0x3EFBEB460CEF1CFC, double 1.000000e+00)
%397 = fmul double %385, %396
%398 = fdiv double %394, %397
%399 = tail call double @llvm.fmuladd.f64(double %391, double %390, double %398)
%400 = fmul double %387, %399
%401 = getelementptr inbounds double, double* %50, i64 %383
store double %400, double* %401
%402 = load double, double* %384
%403 = fmul double %402, %139
%404 = fmul double %403, 5.000000e-01
%405 = fmul double %404, 0x3F0BEB460CEF1CFC
%406 = load double, double* %392
%407 = fmul double %406, %405
%408 = load double, double* %388
%409 = fsub double %243, %408
%410 = tail call double @llvm.fmuladd.f64(double %409, double 0x3EFBEB460CEF1CFC, double 1.000000e+00)
%411 = fdiv double %407, %410
%412 = getelementptr inbounds double, double* %54, i64 %383
store double %411, double* %412
%413 = add nuw nsw i64 %383, 1
%414 = icmp eq i64 %413, %71
br i1 %414, label %380, label %382
415: ; preds = %380, %426
%416 = phi double [ %381, %380 ], [ %420, %426 ]
%417 = phi i64 [ %61, %380 ], [ %418, %426 ]
%418 = add nsw i64 %417, -1
%419 = getelementptr inbounds double, double* %43, i64 %418
%420 = load double, double* %419
%421 = fmul double %416, %420
%422 = fcmp ogt double %421, 0.000000e+00
br i1 %422, label %426, label %423
423: ; preds = %415
%424 = trunc i64 %417 to i32
br i1 %142, label %425, label %441
425: ; preds = %423
br i1 %238, label %434, label %492
426: ; preds = %415
%427 = icmp slt i64 %417, 3
br i1 %427, label %428, label %415
428: ; preds = %426
%429 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str, i64 0, i64 0))
%430 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %43)
%431 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %47)
%432 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %50)
%433 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %54)
br label %1150
434: ; preds = %492, %425
br i1 %240, label %441, label %435
435: ; preds = %434, %435
%436 = phi double [ %438, %435 ], [ 1.000000e+00, %434 ]
%437 = phi i32 [ %439, %435 ], [ 0, %434 ]
%438 = fneg double %436
%439 = add i32 %437, 1
%440 = icmp eq i32 %439, %237
br i1 %440, label %441, label %435
441: ; preds = %434, %435, %423
%442 = phi double [ 1.000000e+00, %423 ], [ 1.000000e+00, %434 ], [ %438, %435 ]
%443 = load double, double* %39
%444 = tail call double @pow(double %443, double %32)
%445 = fmul double %442, %444
store double %445, double* %6
%446 = fmul double %143, %445
store double %446, double* %7
%447 = load double, double* %54
%448 = fadd double %447, %35
%449 = load double, double* %43
%450 = load double, double* %50
%451 = fadd double %449, %450
%452 = load double, double* %6
%453 = fmul double %451, %452
%454 = tail call double @llvm.fmuladd.f64(double %448, double %446, double %453)
store double %454, double* %47
%455 = load double, double* %148
%456 = tail call double @pow(double %455, double %32)
%457 = fmul double %442, %456
store double %457, double* %128
%458 = fmul double %143, %457
store double %458, double* %129
%459 = load double, double* %149
%460 = fadd double %459, %35
%461 = load double, double* %150
%462 = load double, double* %151
%463 = fadd double %461, %462
%464 = load double, double* %128
%465 = fmul double %463, %464
%466 = tail call double @llvm.fmuladd.f64(double %460, double %458, double %465)
store double %466, double* %130
%467 = load double, double* %152
%468 = tail call double @pow(double %467, double %32)
%469 = fmul double %442, %468
store double %469, double* %131
%470 = fmul double %143, %469
store double %470, double* %132
%471 = load double, double* %153
%472 = fadd double %471, %35
%473 = load double, double* %154
%474 = load double, double* %155
%475 = fadd double %473, %474
%476 = load double, double* %131
%477 = fmul double %475, %476
%478 = tail call double @llvm.fmuladd.f64(double %472, double %470, double %477)
store double %478, double* %133
%479 = load double, double* %156
%480 = tail call double @pow(double %479, double %32)
%481 = fmul double %442, %480
store double %481, double* %134
%482 = fmul double %143, %481
store double %482, double* %135
%483 = load double, double* %157
%484 = fadd double %483, %35
%485 = load double, double* %158
%486 = load double, double* %159
%487 = fadd double %485, %486
%488 = load double, double* %134
%489 = fmul double %487, %488
%490 = tail call double @llvm.fmuladd.f64(double %484, double %482, double %489)
store double %490, double* %136
%491 = icmp sgt i32 %424, 3
br i1 %491, label %496, label %541
492: ; preds = %425, %492
%493 = phi i32 [ %494, %492 ], [ 0, %425 ]
%494 = add i32 %493, 8
%495 = icmp eq i32 %494, %239
br i1 %495, label %434, label %492
496: ; preds = %441
%497 = and i64 %417, 4294967295
br label %498
498: ; preds = %496, %533
%499 = phi i64 [ 3, %496 ], [ %504, %533 ]
%500 = phi i32 [ 0, %496 ], [ %539, %533 ]
%501 = trunc i64 %499 to i32
%502 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_Out to i32 (i32, double*, double*, ...)*)(i32 %501, double* %6, double* %7)
%503 = sitofp i32 %502 to double
%504 = add nuw nsw i64 %499, 1
%505 = getelementptr inbounds double, double* %6, i64 %504
store double %503, double* %505
%506 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_Out to i32 (i32, double*, double*, ...)*)(i32 %501, double* %7, double* %47)
%507 = sitofp i32 %506 to double
%508 = getelementptr inbounds double, double* %7, i64 %504
store double %507, double* %508
%509 = getelementptr inbounds double, double* %54, i64 %504
%510 = getelementptr inbounds double, double* %43, i64 %504
%511 = getelementptr inbounds double, double* %50, i64 %504
%512 = getelementptr inbounds double, double* %47, i64 %504
%513 = load double, double* %505
br label %514
514: ; preds = %531, %498
%515 = phi double [ %513, %498 ], [ %528, %531 ]
%516 = phi double [ %507, %498 ], [ %532, %531 ]
%517 = phi i32 [ 0, %498 ], [ %529, %531 ]
%518 = load double, double* %509
%519 = fadd double %518, %35
%520 = load double, double* %510
%521 = load double, double* %511
%522 = fadd double %520, %521
%523 = fmul double %515, %522
%524 = tail call double @llvm.fmuladd.f64(double %519, double %516, double %523)
store double %524, double* %512
%525 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_Out to i32 (i32, double*, double*, ...)*)(i32 %501, double* %7, double* %47)
%526 = sitofp i32 %525 to double
store double %526, double* %508
%527 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_Out to i32 (i32, double*, double*, ...)*)(i32 %501, double* %6, double* %7)
%528 = sitofp i32 %527 to double
store double %528, double* %505
%529 = add nuw nsw i32 %517, 1
%530 = icmp eq i32 %529, 6
br i1 %530, label %533, label %531
531: ; preds = %514
%532 = load double, double* %508
br label %514
533: ; preds = %514
%534 = getelementptr inbounds double, double* %6, i64 %499
%535 = load double, double* %534
%536 = fmul double %535, %528
%537 = fcmp ole double %536, 0.000000e+00
%538 = zext i1 %537 to i32
%539 = add nuw nsw i32 %500, %538
%540 = icmp eq i64 %504, %497
br i1 %540, label %541, label %498
541: ; preds = %533, %441
%542 = phi i32 [ 0, %441 ], [ %539, %533 ]
%543 = getelementptr inbounds double, double* %6, i64 %417
%544 = load double, double* %543
%545 = getelementptr inbounds double, double* %7, i64 %417
%546 = load double, double* %545
%547 = sub nsw i32 %542, %0
%548 = add nsw i32 %547, %1
%549 = icmp slt i32 %548, -1
br i1 %549, label %550, label %553
550: ; preds = %541
%551 = fadd double %243, %244
%552 = fmul double %551, 5.000000e-01
br label %1138
553: ; preds = %541
%554 = icmp sgt i32 %548, -1
br i1 %554, label %555, label %558
555: ; preds = %553
%556 = fadd double %243, %245
%557 = fmul double %556, 5.000000e-01
br label %1138
558: ; preds = %553
%559 = sitofp i32 %424 to double
%560 = fadd double %145, %559
%561 = fptosi double %560 to i32
%562 = add nsw i32 %561, 5
%563 = icmp sgt i32 %562, %33
%564 = select i1 %563, i32 %146, i32 %561
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %39, i64 %565
%567 = load double, double* %566
%568 = fmul double %567, %567
%569 = fdiv double %12, %568
%570 = getelementptr inbounds double, double* %3, i64 %565
%571 = load double, double* %570
%572 = fsub double %571, %243
%573 = tail call double @llvm.fmuladd.f64(double %572, double 2.000000e+00, double %569)
%574 = tail call double @sqrt(double %573)
%575 = fneg double %574
%576 = load double, double* %566
%577 = fsub double %576, %576
%578 = fmul double %577, %575
%579 = tail call double @exp(double %578)
%580 = getelementptr inbounds double, double* %6, i64 %565
store double %579, double* %580
%581 = load double, double* %566
%582 = fneg double %581
%583 = fmul double %35, %582
%584 = fmul double %574, %583
%585 = fmul double %579, %584
%586 = getelementptr inbounds double, double* %7, i64 %565
store double %585, double* %586
%587 = getelementptr inbounds double, double* %54, i64 %565
%588 = load double, double* %587
%589 = fadd double %588, %35
%590 = getelementptr inbounds double, double* %43, i64 %565
%591 = load double, double* %590
%592 = getelementptr inbounds double, double* %50, i64 %565
%593 = load double, double* %592
%594 = fadd double %591, %593
%595 = load double, double* %580
%596 = fmul double %594, %595
%597 = tail call double @llvm.fmuladd.f64(double %589, double %585, double %596)
%598 = getelementptr inbounds double, double* %47, i64 %565
store double %597, double* %598
%599 = add nsw i64 %565, 1
%600 = getelementptr inbounds double, double* %39, i64 %599
%601 = load double, double* %600
%602 = load double, double* %566
%603 = fsub double %601, %602
%604 = fmul double %603, %575
%605 = tail call double @exp(double %604)
%606 = getelementptr inbounds double, double* %6, i64 %599
store double %605, double* %606
%607 = load double, double* %600
%608 = fneg double %607
%609 = fmul double %35, %608
%610 = fmul double %574, %609
%611 = fmul double %605, %610
%612 = getelementptr inbounds double, double* %7, i64 %599
store double %611, double* %612
%613 = getelementptr inbounds double, double* %54, i64 %599
%614 = load double, double* %613
%615 = fadd double %614, %35
%616 = getelementptr inbounds double, double* %43, i64 %599
%617 = load double, double* %616
%618 = getelementptr inbounds double, double* %50, i64 %599
%619 = load double, double* %618
%620 = fadd double %617, %619
%621 = load double, double* %606
%622 = fmul double %620, %621
%623 = tail call double @llvm.fmuladd.f64(double %615, double %611, double %622)
%624 = getelementptr inbounds double, double* %47, i64 %599
store double %623, double* %624
%625 = add nsw i64 %565, 2
%626 = getelementptr inbounds double, double* %39, i64 %625
%627 = load double, double* %626
%628 = load double, double* %566
%629 = fsub double %627, %628
%630 = fmul double %629, %575
%631 = tail call double @exp(double %630)
%632 = getelementptr inbounds double, double* %6, i64 %625
store double %631, double* %632
%633 = load double, double* %626
%634 = fneg double %633
%635 = fmul double %35, %634
%636 = fmul double %574, %635
%637 = fmul double %631, %636
%638 = getelementptr inbounds double, double* %7, i64 %625
store double %637, double* %638
%639 = getelementptr inbounds double, double* %54, i64 %625
%640 = load double, double* %639
%641 = fadd double %640, %35
%642 = getelementptr inbounds double, double* %43, i64 %625
%643 = load double, double* %642
%644 = getelementptr inbounds double, double* %50, i64 %625
%645 = load double, double* %644
%646 = fadd double %643, %645
%647 = load double, double* %632
%648 = fmul double %646, %647
%649 = tail call double @llvm.fmuladd.f64(double %641, double %637, double %648)
%650 = getelementptr inbounds double, double* %47, i64 %625
store double %649, double* %650
%651 = add nsw i64 %565, 3
%652 = getelementptr inbounds double, double* %39, i64 %651
%653 = load double, double* %652
%654 = load double, double* %566
%655 = fsub double %653, %654
%656 = fmul double %655, %575
%657 = tail call double @exp(double %656)
%658 = getelementptr inbounds double, double* %6, i64 %651
store double %657, double* %658
%659 = load double, double* %652
%660 = fneg double %659
%661 = fmul double %35, %660
%662 = fmul double %574, %661
%663 = fmul double %657, %662
%664 = getelementptr inbounds double, double* %7, i64 %651
store double %663, double* %664
%665 = getelementptr inbounds double, double* %54, i64 %651
%666 = load double, double* %665
%667 = fadd double %666, %35
%668 = getelementptr inbounds double, double* %43, i64 %651
%669 = load double, double* %668
%670 = getelementptr inbounds double, double* %50, i64 %651
%671 = load double, double* %670
%672 = fadd double %669, %671
%673 = load double, double* %658
%674 = fmul double %672, %673
%675 = tail call double @llvm.fmuladd.f64(double %667, double %663, double %674)
%676 = getelementptr inbounds double, double* %47, i64 %651
store double %675, double* %676
%677 = add nsw i64 %565, 4
%678 = getelementptr inbounds double, double* %39, i64 %677
%679 = load double, double* %678
%680 = load double, double* %566
%681 = fsub double %679, %680
%682 = fmul double %681, %575
%683 = tail call double @exp(double %682)
%684 = getelementptr inbounds double, double* %6, i64 %677
store double %683, double* %684
%685 = load double, double* %678
%686 = fneg double %685
%687 = fmul double %35, %686
%688 = fmul double %574, %687
%689 = fmul double %683, %688
%690 = getelementptr inbounds double, double* %7, i64 %677
store double %689, double* %690
%691 = getelementptr inbounds double, double* %54, i64 %677
%692 = load double, double* %691
%693 = fadd double %692, %35
%694 = getelementptr inbounds double, double* %43, i64 %677
%695 = load double, double* %694
%696 = getelementptr inbounds double, double* %50, i64 %677
%697 = load double, double* %696
%698 = fadd double %695, %697
%699 = load double, double* %684
%700 = fmul double %698, %699
%701 = tail call double @llvm.fmuladd.f64(double %693, double %689, double %700)
%702 = getelementptr inbounds double, double* %47, i64 %677
store double %701, double* %702
%703 = icmp sgt i32 %564, %424
br i1 %703, label %704, label %743
704: ; preds = %558
%705 = shl i64 %417, 32
%706 = ashr exact i64 %705, 32
br label %709
707: ; preds = %724
%708 = icmp sgt i64 %714, %706
br i1 %708, label %709, label %743
709: ; preds = %704, %707
%710 = phi i64 [ %565, %704 ], [ %714, %707 ]
%711 = trunc i64 %710 to i32
%712 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_In to i32 (i32, double*, double*, ...)*)(i32 %711, double* %6, double* %7)
%713 = sitofp i32 %712 to double
%714 = add nsw i64 %710, -1
%715 = getelementptr inbounds double, double* %6, i64 %714
store double %713, double* %715
%716 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Predictor_In to i32 (i32, double*, double*, ...)*)(i32 %711, double* %7, double* %47)
%717 = sitofp i32 %716 to double
%718 = getelementptr inbounds double, double* %7, i64 %714
store double %717, double* %718
%719 = getelementptr inbounds double, double* %54, i64 %714
%720 = getelementptr inbounds double, double* %43, i64 %714
%721 = getelementptr inbounds double, double* %50, i64 %714
%722 = getelementptr inbounds double, double* %47, i64 %714
%723 = load double, double* %715
br label %724
724: ; preds = %741, %709
%725 = phi double [ %723, %709 ], [ %738, %741 ]
%726 = phi double [ %717, %709 ], [ %742, %741 ]
%727 = phi i32 [ 0, %709 ], [ %739, %741 ]
%728 = load double, double* %719
%729 = fadd double %728, %35
%730 = load double, double* %720
%731 = load double, double* %721
%732 = fadd double %730, %731
%733 = fmul double %725, %732
%734 = tail call double @llvm.fmuladd.f64(double %729, double %726, double %733)
store double %734, double* %722
%735 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_In to i32 (i32, double*, double*, ...)*)(i32 %711, double* %7, double* %47)
%736 = sitofp i32 %735 to double
store double %736, double* %718
%737 = tail call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @Corrector_In to i32 (i32, double*, double*, ...)*)(i32 %711, double* %6, double* %7)
%738 = sitofp i32 %737 to double
store double %738, double* %715
%739 = add nuw nsw i32 %727, 1
%740 = icmp eq i32 %739, 6
br i1 %740, label %707, label %741
741: ; preds = %724
%742 = load double, double* %718
br label %724
743: ; preds = %707, %558
%744 = load double, double* %543
%745 = fdiv double %544, %744
%746 = icmp slt i32 %564, %424
br i1 %746, label %836, label %747
747: ; preds = %743
%748 = shl i64 %417, 32
%749 = ashr exact i64 %748, 32
%750 = add i32 %564, 1
%751 = sub i32 %564, %424
%752 = zext i32 %751 to i64
%753 = add nuw nsw i64 %752, 1
%754 = icmp ult i32 %751, 3
br i1 %754, label %800, label %755
755: ; preds = %747
%756 = getelementptr double, double* %6, i64 %749
%757 = sub i32 %564, %424
%758 = zext i32 %757 to i64
%759 = add nsw i64 %749, %758
%760 = getelementptr double, double* %162, i64 %759
%761 = getelementptr double, double* %7, i64 %749
%762 = getelementptr double, double* %163, i64 %759
%763 = icmp ult double* %756, %762
%764 = icmp ult double* %761, %760
%765 = and i1 %763, %764
br i1 %765, label %800, label %766
766: ; preds = %755
%767 = and i64 %753, 8589934588
%768 = add nsw i64 %749, %767
%769 = insertelement <2 x double> poison, double %745, i64 0
%770 = shufflevector <2 x double> %769, <2 x double> poison, <2 x i32> zeroinitializer
%771 = insertelement <2 x double> poison, double %745, i64 0
%772 = shufflevector <2 x double> %771, <2 x double> poison, <2 x i32> zeroinitializer
br label %773
773: ; preds = %773, %766
%774 = phi i64 [ 0, %766 ], [ %796, %773 ]
%775 = add i64 %749, %774
%776 = getelementptr inbounds double, double* %6, i64 %775
%777 = bitcast double* %776 to <2 x double>*
%778 = load <2 x double>, <2 x double>* %777
%779 = getelementptr inbounds double, double* %776, i64 2
%780 = bitcast double* %779 to <2 x double>*
%781 = load <2 x double>, <2 x double>* %780
%782 = fmul <2 x double> %770, %778
%783 = fmul <2 x double> %772, %781
%784 = bitcast double* %776 to <2 x double>*
store <2 x double> %782, <2 x double>* %784
%785 = bitcast double* %779 to <2 x double>*
store <2 x double> %783, <2 x double>* %785
%786 = getelementptr inbounds double, double* %7, i64 %775
%787 = bitcast double* %786 to <2 x double>*
%788 = load <2 x double>, <2 x double>* %787
%789 = getelementptr inbounds double, double* %786, i64 2
%790 = bitcast double* %789 to <2 x double>*
%791 = load <2 x double>, <2 x double>* %790
%792 = fmul <2 x double> %770, %788
%793 = fmul <2 x double> %772, %791
%794 = bitcast double* %786 to <2 x double>*
store <2 x double> %792, <2 x double>* %794
%795 = bitcast double* %789 to <2 x double>*
store <2 x double> %793, <2 x double>* %795
%796 = add nuw i64 %774, 4
%797 = icmp eq i64 %796, %767
br i1 %797, label %798, label %773
798: ; preds = %773
%799 = icmp eq i64 %753, %767
br i1 %799, label %836, label %800
800: ; preds = %755, %747, %798
%801 = phi i64 [ %749, %755 ], [ %749, %747 ], [ %768, %798 ]
%802 = add i32 %564, 1
%803 = trunc i64 %801 to i32
%804 = sub i32 %802, %803
%805 = and i32 %804, 1
%806 = icmp eq i32 %805, 0
br i1 %806, label %815, label %807
807: ; preds = %800
%808 = getelementptr inbounds double, double* %6, i64 %801
%809 = load double, double* %808
%810 = fmul double %745, %809
store double %810, double* %808
%811 = getelementptr inbounds double, double* %7, i64 %801
%812 = load double, double* %811
%813 = fmul double %745, %812
store double %813, double* %811
%814 = add nsw i64 %801, 1
br label %815
815: ; preds = %807, %800
%816 = phi i64 [ %801, %800 ], [ %814, %807 ]
%817 = icmp eq i32 %564, %803
br i1 %817, label %836, label %818
818: ; preds = %815, %818
%819 = phi i64 [ %833, %818 ], [ %816, %815 ]
%820 = getelementptr inbounds double, double* %6, i64 %819
%821 = load double, double* %820
%822 = fmul double %745, %821
store double %822, double* %820
%823 = getelementptr inbounds double, double* %7, i64 %819
%824 = load double, double* %823
%825 = fmul double %745, %824
store double %825, double* %823
%826 = add nsw i64 %819, 1
%827 = getelementptr inbounds double, double* %6, i64 %826
%828 = load double, double* %827
%829 = fmul double %745, %828
store double %829, double* %827
%830 = getelementptr inbounds double, double* %7, i64 %826
%831 = load double, double* %830
%832 = fmul double %745, %831
store double %832, double* %830
%833 = add nsw i64 %819, 2
%834 = trunc i64 %833 to i32
%835 = icmp eq i32 %750, %834
br i1 %835, label %836, label %818
836: ; preds = %815, %818, %798, %743
%837 = load double, double* %545
%838 = tail call i32 (i32, double, double*, ...) bitcast (i32 (...)* @Norm_LogGrid to i32 (i32, double, double*, ...)*)(i32 %564, double %32, double* %6)
%839 = sitofp i32 %838 to double
%840 = tail call double @sqrt(double %839)
%841 = fdiv double 1.000000e+00, %840
%842 = fmul double %544, %841
%843 = fmul double %546, %841
%844 = fmul double %837, %841
%845 = icmp slt i32 %564, 0
%846 = add i32 %564, 1
br i1 %845, label %959, label %847
847: ; preds = %836
%848 = zext i32 %846 to i64
%849 = icmp ult i32 %846, 4
br i1 %849, label %942, label %850
850: ; preds = %847
%851 = getelementptr double, double* %6, i64 %848
%852 = getelementptr double, double* %7, i64 %848
%853 = icmp ugt double* %852, %6
%854 = icmp ugt double* %851, %7
%855 = and i1 %853, %854
br i1 %855, label %942, label %856
856: ; preds = %850
%857 = and i64 %848, 4294967292
%858 = insertelement <2 x double> poison, double %841, i64 0
%859 = shufflevector <2 x double> %858, <2 x double> poison, <2 x i32> zeroinitializer
%860 = insertelement <2 x double> poison, double %841, i64 0
%861 = shufflevector <2 x double> %860, <2 x double> poison, <2 x i32> zeroinitializer
%862 = add nsw i64 %857, -4
%863 = lshr exact i64 %862, 2
%864 = add nuw nsw i64 %863, 1
%865 = and i64 %864, 1
%866 = icmp eq i64 %862, 0
br i1 %866, label %916, label %867
867: ; preds = %856
%868 = and i64 %864, 9223372036854775806
br label %869
869: ; preds = %869, %867
%870 = phi i64 [ 0, %867 ], [ %913, %869 ]
%871 = phi i64 [ 0, %867 ], [ %914, %869 ]
%872 = getelementptr inbounds double, double* %6, i64 %870
%873 = bitcast double* %872 to <2 x double>*
%874 = load <2 x double>, <2 x double>* %873
%875 = getelementptr inbounds double, double* %872, i64 2
%876 = bitcast double* %875 to <2 x double>*
%877 = load <2 x double>, <2 x double>* %876
%878 = fmul <2 x double> %859, %874
%879 = fmul <2 x double> %861, %877
%880 = bitcast double* %872 to <2 x double>*
store <2 x double> %878, <2 x double>* %880
%881 = bitcast double* %875 to <2 x double>*
store <2 x double> %879, <2 x double>* %881
%882 = getelementptr inbounds double, double* %7, i64 %870
%883 = bitcast double* %882 to <2 x double>*
%884 = load <2 x double>, <2 x double>* %883
%885 = getelementptr inbounds double, double* %882, i64 2
%886 = bitcast double* %885 to <2 x double>*
%887 = load <2 x double>, <2 x double>* %886
%888 = fmul <2 x double> %859, %884
%889 = fmul <2 x double> %861, %887
%890 = bitcast double* %882 to <2 x double>*
store <2 x double> %888, <2 x double>* %890
%891 = bitcast double* %885 to <2 x double>*
store <2 x double> %889, <2 x double>* %891
%892 = or i64 %870, 4
%893 = getelementptr inbounds double, double* %6, i64 %892
%894 = bitcast double* %893 to <2 x double>*
%895 = load <2 x double>, <2 x double>* %894
%896 = getelementptr inbounds double, double* %893, i64 2
%897 = bitcast double* %896 to <2 x double>*
%898 = load <2 x double>, <2 x double>* %897
%899 = fmul <2 x double> %859, %895
%900 = fmul <2 x double> %861, %898
%901 = bitcast double* %893 to <2 x double>*
store <2 x double> %899, <2 x double>* %901
%902 = bitcast double* %896 to <2 x double>*
store <2 x double> %900, <2 x double>* %902
%903 = getelementptr inbounds double, double* %7, i64 %892
%904 = bitcast double* %903 to <2 x double>*
%905 = load <2 x double>, <2 x double>* %904
%906 = getelementptr inbounds double, double* %903, i64 2
%907 = bitcast double* %906 to <2 x double>*
%908 = load <2 x double>, <2 x double>* %907
%909 = fmul <2 x double> %859, %905
%910 = fmul <2 x double> %861, %908
%911 = bitcast double* %903 to <2 x double>*
store <2 x double> %909, <2 x double>* %911
%912 = bitcast double* %906 to <2 x double>*
store <2 x double> %910, <2 x double>* %912
%913 = add nuw i64 %870, 8
%914 = add i64 %871, 2
%915 = icmp eq i64 %914, %868
br i1 %915, label %916, label %869
916: ; preds = %869, %856
%917 = phi i64 [ 0, %856 ], [ %913, %869 ]
%918 = icmp eq i64 %865, 0
br i1 %918, label %940, label %919
919: ; preds = %916
%920 = getelementptr inbounds double, double* %6, i64 %917
%921 = bitcast double* %920 to <2 x double>*
%922 = load <2 x double>, <2 x double>* %921
%923 = getelementptr inbounds double, double* %920, i64 2
%924 = bitcast double* %923 to <2 x double>*
%925 = load <2 x double>, <2 x double>* %924
%926 = fmul <2 x double> %859, %922
%927 = fmul <2 x double> %861, %925
%928 = bitcast double* %920 to <2 x double>*
store <2 x double> %926, <2 x double>* %928
%929 = bitcast double* %923 to <2 x double>*
store <2 x double> %927, <2 x double>* %929
%930 = getelementptr inbounds double, double* %7, i64 %917
%931 = bitcast double* %930 to <2 x double>*
%932 = load <2 x double>, <2 x double>* %931
%933 = getelementptr inbounds double, double* %930, i64 2
%934 = bitcast double* %933 to <2 x double>*
%935 = load <2 x double>, <2 x double>* %934
%936 = fmul <2 x double> %859, %932
%937 = fmul <2 x double> %861, %935
%938 = bitcast double* %930 to <2 x double>*
store <2 x double> %936, <2 x double>* %938
%939 = bitcast double* %933 to <2 x double>*
store <2 x double> %937, <2 x double>* %939
br label %940
940: ; preds = %916, %919
%941 = icmp eq i64 %857, %848
br i1 %941, label %959, label %942
942: ; preds = %850, %847, %940
%943 = phi i64 [ 0, %850 ], [ 0, %847 ], [ %857, %940 ]
%944 = xor i64 %943, -1
%945 = and i64 %848, 1
%946 = icmp eq i64 %945, 0
br i1 %946, label %955, label %947
947: ; preds = %942
%948 = getelementptr inbounds double, double* %6, i64 %943
%949 = load double, double* %948
%950 = fmul double %841, %949
store double %950, double* %948
%951 = getelementptr inbounds double, double* %7, i64 %943
%952 = load double, double* %951
%953 = fmul double %841, %952
store double %953, double* %951
%954 = or i64 %943, 1
br label %955
955: ; preds = %947, %942
%956 = phi i64 [ %943, %942 ], [ %954, %947 ]
%957 = sub nsw i64 0, %848
%958 = icmp eq i64 %944, %957
br i1 %958, label %959, label %1074
959: ; preds = %955, %1074, %940, %836
%960 = icmp slt i32 %846, %33
br i1 %960, label %961, label %1107
961: ; preds = %959
%962 = sext i32 %846 to i64
%963 = sub i32 %33, %564
%964 = add i32 %963, -2
%965 = zext i32 %964 to i64
%966 = add nuw nsw i64 %965, 1
%967 = icmp ult i32 %964, 3
br i1 %967, label %1055, label %968
968: ; preds = %961
%969 = getelementptr double, double* %6, i64 %962
%970 = sub i32 %33, %564
%971 = add i32 %970, -2
%972 = zext i32 %971 to i64
%973 = add nsw i64 %962, %972
%974 = getelementptr double, double* %160, i64 %973
%975 = getelementptr double, double* %7, i64 %962
%976 = getelementptr double, double* %161, i64 %973
%977 = icmp ult double* %969, %976
%978 = icmp ult double* %975, %974
%979 = and i1 %977, %978
br i1 %979, label %1055, label %980
980: ; preds = %968
%981 = and i64 %966, 8589934588
%982 = add nsw i64 %981, %962
%983 = add nsw i64 %981, -4
%984 = lshr exact i64 %983, 2
%985 = add nuw nsw i64 %984, 1
%986 = and i64 %985, 3
%987 = icmp ult i64 %983, 12
br i1 %987, label %1035, label %988
988: ; preds = %980
%989 = and i64 %985, 9223372036854775804
br label %990
990: ; preds = %990, %988
%991 = phi i64 [ 0, %988 ], [ %1032, %990 ]
%992 = phi i64 [ 0, %988 ], [ %1033, %990 ]
%993 = add i64 %991, %962
%994 = getelementptr inbounds double, double* %6, i64 %993
%995 = bitcast double* %994 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %995
%996 = getelementptr inbounds double, double* %994, i64 2
%997 = bitcast double* %996 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %997
%998 = getelementptr inbounds double, double* %7, i64 %993
%999 = bitcast double* %998 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %999
%1000 = getelementptr inbounds double, double* %998, i64 2
%1001 = bitcast double* %1000 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1001
%1002 = or i64 %991, 4
%1003 = add i64 %1002, %962
%1004 = getelementptr inbounds double, double* %6, i64 %1003
%1005 = bitcast double* %1004 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1005
%1006 = getelementptr inbounds double, double* %1004, i64 2
%1007 = bitcast double* %1006 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1007
%1008 = getelementptr inbounds double, double* %7, i64 %1003
%1009 = bitcast double* %1008 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1009
%1010 = getelementptr inbounds double, double* %1008, i64 2
%1011 = bitcast double* %1010 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1011
%1012 = or i64 %991, 8
%1013 = add i64 %1012, %962
%1014 = getelementptr inbounds double, double* %6, i64 %1013
%1015 = bitcast double* %1014 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1015
%1016 = getelementptr inbounds double, double* %1014, i64 2
%1017 = bitcast double* %1016 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1017
%1018 = getelementptr inbounds double, double* %7, i64 %1013
%1019 = bitcast double* %1018 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1019
%1020 = getelementptr inbounds double, double* %1018, i64 2
%1021 = bitcast double* %1020 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1021
%1022 = or i64 %991, 12
%1023 = add i64 %1022, %962
%1024 = getelementptr inbounds double, double* %6, i64 %1023
%1025 = bitcast double* %1024 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1025
%1026 = getelementptr inbounds double, double* %1024, i64 2
%1027 = bitcast double* %1026 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1027
%1028 = getelementptr inbounds double, double* %7, i64 %1023
%1029 = bitcast double* %1028 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1029
%1030 = getelementptr inbounds double, double* %1028, i64 2
%1031 = bitcast double* %1030 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1031
%1032 = add nuw i64 %991, 16
%1033 = add nuw i64 %992, 4
%1034 = icmp eq i64 %1033, %989
br i1 %1034, label %1035, label %990
1035: ; preds = %990, %980
%1036 = phi i64 [ 0, %980 ], [ %1032, %990 ]
%1037 = icmp eq i64 %986, 0
br i1 %1037, label %1053, label %1038
1038: ; preds = %1035, %1038
%1039 = phi i64 [ %1050, %1038 ], [ %1036, %1035 ]
%1040 = phi i64 [ %1051, %1038 ], [ 0, %1035 ]
%1041 = add i64 %1039, %962
%1042 = getelementptr inbounds double, double* %6, i64 %1041
%1043 = bitcast double* %1042 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1043
%1044 = getelementptr inbounds double, double* %1042, i64 2
%1045 = bitcast double* %1044 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1045
%1046 = getelementptr inbounds double, double* %7, i64 %1041
%1047 = bitcast double* %1046 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1047
%1048 = getelementptr inbounds double, double* %1046, i64 2
%1049 = bitcast double* %1048 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %1049
%1050 = add nuw i64 %1039, 4
%1051 = add i64 %1040, 1
%1052 = icmp eq i64 %1051, %986
br i1 %1052, label %1053, label %1038
1053: ; preds = %1038, %1035
%1054 = icmp eq i64 %966, %981
br i1 %1054, label %1107, label %1055
1055: ; preds = %968, %961, %1053
%1056 = phi i64 [ %962, %968 ], [ %962, %961 ], [ %982, %1053 ]
%1057 = trunc i64 %1056 to i32
%1058 = sub i32 %33, %1057
%1059 = xor i32 %1057, -1
%1060 = add i32 %33, %1059
%1061 = and i32 %1058, 3
%1062 = icmp eq i32 %1061, 0
br i1 %1062, label %1071, label %1063
1063: ; preds = %1055, %1063
%1064 = phi i64 [ %1068, %1063 ], [ %1056, %1055 ]
%1065 = phi i32 [ %1069, %1063 ], [ 0, %1055 ]
%1066 = getelementptr inbounds double, double* %6, i64 %1064
store double 0.000000e+00, double* %1066
%1067 = getelementptr inbounds double, double* %7, i64 %1064
store double 0.000000e+00, double* %1067
%1068 = add nsw i64 %1064, 1
%1069 = add i32 %1065, 1
%1070 = icmp eq i32 %1069, %1061
br i1 %1070, label %1071, label %1063
1071: ; preds = %1063, %1055
%1072 = phi i64 [ %1056, %1055 ], [ %1068, %1063 ]
%1073 = icmp ult i32 %1060, 3
br i1 %1073, label %1107, label %1091
1074: ; preds = %955, %1074
%1075 = phi i64 [ %1089, %1074 ], [ %956, %955 ]
%1076 = getelementptr inbounds double, double* %6, i64 %1075
%1077 = load double, double* %1076
%1078 = fmul double %841, %1077
store double %1078, double* %1076
%1079 = getelementptr inbounds double, double* %7, i64 %1075
%1080 = load double, double* %1079
%1081 = fmul double %841, %1080
store double %1081, double* %1079
%1082 = add nuw nsw i64 %1075, 1
%1083 = getelementptr inbounds double, double* %6, i64 %1082
%1084 = load double, double* %1083
%1085 = fmul double %841, %1084
store double %1085, double* %1083
%1086 = getelementptr inbounds double, double* %7, i64 %1082
%1087 = load double, double* %1086
%1088 = fmul double %841, %1087
store double %1088, double* %1086
%1089 = add nuw nsw i64 %1075, 2
%1090 = icmp eq i64 %1089, %848
br i1 %1090, label %959, label %1074
1091: ; preds = %1071, %1091
%1092 = phi i64 [ %1104, %1091 ], [ %1072, %1071 ]
%1093 = getelementptr inbounds double, double* %6, i64 %1092
store double 0.000000e+00, double* %1093
%1094 = getelementptr inbounds double, double* %7, i64 %1092
store double 0.000000e+00, double* %1094
%1095 = add nsw i64 %1092, 1
%1096 = getelementptr inbounds double, double* %6, i64 %1095
store double 0.000000e+00, double* %1096
%1097 = getelementptr inbounds double, double* %7, i64 %1095
store double 0.000000e+00, double* %1097
%1098 = add nsw i64 %1092, 2
%1099 = getelementptr inbounds double, double* %6, i64 %1098
store double 0.000000e+00, double* %1099
%1100 = getelementptr inbounds double, double* %7, i64 %1098
store double 0.000000e+00, double* %1100
%1101 = add nsw i64 %1092, 3
%1102 = getelementptr inbounds double, double* %6, i64 %1101
store double 0.000000e+00, double* %1102
%1103 = getelementptr inbounds double, double* %7, i64 %1101
store double 0.000000e+00, double* %1103
%1104 = add nsw i64 %1092, 4
%1105 = trunc i64 %1104 to i32
%1106 = icmp eq i32 %33, %1105
br i1 %1106, label %1107, label %1091
1107: ; preds = %1071, %1091, %1053, %959
%1108 = fmul double %842, 5.000000e-01
%1109 = fsub double %843, %844
%1110 = fmul double %1108, %1109
%1111 = getelementptr inbounds double, double* %39, i64 %417
%1112 = load double, double* %1111
%1113 = fmul double %1112, %35
%1114 = fdiv double %1110, %1113
%1115 = tail call double @llvm.fabs.f64(double %1114)
%1116 = tail call double @llvm.fabs.f64(double %243)
%1117 = fcmp ogt double %1116, 2.000000e-01
%1118 = select i1 %1117, double %1116, double 2.000000e-01
%1119 = fmul double %1118, 1.000000e-10
%1120 = fcmp olt double %1115, %1119
br i1 %1120, label %1121, label %1127
1121: ; preds = %1107
%1122 = trunc i64 %417 to i32
store i32 %1122, i32* %4
store double %243, double* %5
%1123 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %43)
%1124 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %47)
%1125 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %50)
%1126 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %54)
br label %1150
1127: ; preds = %1107
%1128 = fcmp ogt double %1114, 0.000000e+00
%1129 = select i1 %1128, double %243, double %245
%1130 = select i1 %1128, double %244, double %243
%1131 = fadd double %243, %1114
%1132 = fcmp ogt double %1131, %1130
%1133 = fcmp olt double %1131, %1129
%1134 = select i1 %1132, i1 true, i1 %1133
br i1 %1134, label %1135, label %1138
1135: ; preds = %1127
%1136 = fadd double %1129, %1130
%1137 = fmul double %1136, 5.000000e-01
br label %1138
1138: ; preds = %1127, %555, %1135, %550
%1139 = phi double [ %243, %550 ], [ %245, %555 ], [ %1129, %1135 ], [ %1129, %1127 ]
%1140 = phi double [ %244, %550 ], [ %243, %555 ], [ %1130, %1135 ], [ %1130, %1127 ]
%1141 = phi double [ %552, %550 ], [ %557, %555 ], [ %1137, %1135 ], [ %1131, %1127 ]
%1142 = icmp eq i32 %246, 100
br i1 %1142, label %1143, label %241
1143: ; preds = %1138
%1144 = trunc i64 %417 to i32
%1145 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.1, i64 0, i64 0), i32 100)
store i32 %1144, i32* %4
store double %1141, double* %5
%1146 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %43)
%1147 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %47)
%1148 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %50)
%1149 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %54)
br label %1150
1150: ; preds = %1143, %1121, %428
%1151 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %58)
ret void
}