int paw_R_Pauli(n, l, Z, v, Eig, u, uprime)
int n, l;
double Z;
double v[];
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 = paw_N_LogGrid();
  log_amesh = paw_log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = paw_r_LogGrid();
  f_upp = paw_alloc_LogGrid();
  upp = paw_alloc_LogGrid();
  fr = paw_alloc_LogGrid();
  frp = paw_alloc_LogGrid();
  dv = paw_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 < 1000) {
    ++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);
    }
    paw_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 paw_R_Pauli: no turning point\n");
        paw_dealloc_LogGrid(f_upp);
        paw_dealloc_LogGrid(upp);
        paw_dealloc_LogGrid(fr);
        paw_dealloc_LogGrid(frp);
        paw_dealloc_LogGrid(dv);
        return 0;
      }
    }
    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] = paw_Predictor_Out(i, u, uprime);
      uprime[i + 1] = paw_Predictor_Out(i, uprime, upp);
      for (j = 0; j < 6; ++j) {
        upp[i + 1] = (log_amesh + frp[i + 1]) * uprime[i + 1] +
                     (f_upp[i + 1] + fr[i + 1]) * u[i + 1];
        uprime[i + 1] = paw_Corrector_Out(i, uprime, upp);
        u[i + 1] = paw_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] = paw_Predictor_In(i, u, uprime);
        uprime[i - 1] = paw_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] = paw_Corrector_In(i, uprime, upp);
          u[i - 1] = paw_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 = paw_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)) {
        *Eig = E;
        paw_dealloc_LogGrid(f_upp);
        paw_dealloc_LogGrid(upp);
        paw_dealloc_LogGrid(fr);
        paw_dealloc_LogGrid(frp);
        paw_dealloc_LogGrid(dv);
        return 1;
      }
      if (de > 0.0)
        Emin = E;
      else
        Emax = E;
      E = E + de;
      if ((E > Emax) || (E < Emin))
        E = 0.5 * (Emin + Emax);
    }
  }
  printf("Error paw_R_Pauli: More than %d iterations. ", 1000);
  printf("n=%d, l=%d, Eig=%le\n", n, l, E);
  *Eig = E;
  paw_dealloc_LogGrid(f_upp);
  paw_dealloc_LogGrid(upp);
  paw_dealloc_LogGrid(fr);
  paw_dealloc_LogGrid(frp);
  paw_dealloc_LogGrid(dv);
  return 0;
}


x86 assembly (clang, -O0):
<paw_R_Pauli>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x1dad(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
cmpl   $0x0,-0xc(%rbp)
jne    12c8 <paw_R_Pauli+0xc8>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d56(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  %xmm0,-0x98(%rbp)
ff
jmp    13dc <paw_R_Pauli+0x1dc>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0x1ccd(%rip),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  0x1cbd(%rip),%xmm2
addsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  -0x128(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x120(%rbp),%xmm0
ff
movsd  0x1c64(%rip),%xmm3
addsd  -0xa8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
movsd  0x1c3c(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   1050 <paw_N_LogGrid@plt>
mov    %eax,-0x54(%rbp)
mov    $0x0,%al
call   1060 <paw_log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   1080 <paw_r_LogGrid@plt>
cltq
mov    %rax,-0xf0(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   10a0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1b8e(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mov    -0xf0(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    15a2 <paw_R_Pauli+0x3a2>
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1aea(%rip),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
divsd  -0xb0(%rbp),%xmm2
ff
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1556 <paw_R_Pauli+0x356>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1587 <paw_R_Pauli+0x387>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1aa5(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
divsd  -0xb0(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14d0 <paw_R_Pauli+0x2d0>
movsd  -0x60(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    15c4 <paw_R_Pauli+0x3c4>
movsd  0x1a5e(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15ea <paw_R_Pauli+0x3ea>
movsd  0x1a40(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1615 <paw_R_Pauli+0x415>
movsd  -0x70(%rbp),%xmm1
addsd  -0x78(%rbp),%xmm1
movsd  0x1a04(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1667 <paw_R_Pauli+0x467>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    161c <paw_R_Pauli+0x41c>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3e8,-0x44(%rbp)
jge    240d <paw_R_Pauli+0x120d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1727 <paw_R_Pauli+0x527>
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x60(%rbp),%xmm3
movsd  0x1957(%rip),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    168b <paw_R_Pauli+0x48b>
mov    -0x20(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    $0x0,%al
call   10e0 <paw_Derivative_LogGrid@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    18f5 <paw_R_Pauli+0x6f5>
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x60(%rbp),%xmm3
movsd  0x183d(%rip),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
mov    -0x100(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x180d(%rip),%xmm5
mulsd  -0x90(%rbp),%xmm5
ff
movsd  -0x60(%rbp),%xmm6
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm6,%xmm5
movsd  0x17df(%rip),%xmm6
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
divsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x110(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x178b(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x100(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x1767(%rip),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1739(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1740 <paw_R_Pauli+0x540>
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0xf8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19a8 <paw_R_Pauli+0x7a8>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x2,-0x4c(%rbp)
jge    19a3 <paw_R_Pauli+0x7a3>
lea    0x1716(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
movl   $0x0,-0x4(%rbp)
jmp    2493 <paw_R_Pauli+0x1293>
jmp    18fe <paw_R_Pauli+0x6fe>
movsd  0x1658(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    19f9 <paw_R_Pauli+0x7f9>
movsd  0x1665(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    19bf <paw_R_Pauli+0x7bf>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x4,-0x3c(%rbp)
jge    1aef <paw_R_Pauli+0x8ef>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a00 <paw_R_Pauli+0x800>
movl   $0x0,-0x48(%rbp)
movl   $0x3,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1c9b <paw_R_Pauli+0xa9b>
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1090 <paw_Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    -0x118(%rbp),%rdx
mov    $0x0,%al
call   1090 <paw_Predictor_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    1c53 <paw_R_Pauli+0xa53>
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    -0x118(%rbp),%rdx
mov    $0x0,%al
call   1030 <paw_Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1030 <paw_Corrector_Out@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b63 <paw_R_Pauli+0x963>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     1c88 <paw_R_Pauli+0xa88>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1c8d <paw_R_Pauli+0xa8d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1afd <paw_R_Pauli+0x8fd>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jge    1d04 <paw_R_Pauli+0xb04>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x131a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    2408 <paw_R_Pauli+0x1208>
mov    -0x48(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
jle    1d43 <paw_R_Pauli+0xb43>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0x12db(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    2403 <paw_R_Pauli+0x1203>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x12d0(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
call   1120 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x140(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    $0x5,%eax
cmp    -0x54(%rbp),%eax
jle    1d90 <paw_R_Pauli+0xb90>
mov    -0x54(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x60(%rbp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   1100 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x50(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jg     1f12 <paw_R_Pauli+0xd12>
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1070 <exp@plt>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1de9 <paw_R_Pauli+0xbe9>
mov    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     2086 <paw_R_Pauli+0xe86>
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   10c0 <paw_Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    -0x118(%rbp),%rdx
mov    $0x0,%al
call   10c0 <paw_Predictor_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    2073 <paw_R_Pauli+0xe73>
movsd  -0x80(%rbp),%xmm0
mov    -0x108(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xf8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    -0x118(%rbp),%rdx
mov    $0x0,%al
call   1110 <paw_Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1110 <paw_Corrector_In@plt>
cvtsi2sd %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1f83 <paw_R_Pauli+0xd83>
jmp    2078 <paw_R_Pauli+0xe78>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1f18 <paw_R_Pauli+0xd18>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2107 <paw_R_Pauli+0xf07>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    20a9 <paw_R_Pauli+0xea9>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x50(%rbp),%edi
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rsi
mov    $0x1,%al
call   10f0 <paw_Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1100 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xeb2(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     220f <paw_R_Pauli+0x100f>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    21b1 <paw_R_Pauli+0xfb1>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    2252 <paw_R_Pauli+0x1052>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2218 <paw_R_Pauli+0x1018>
movsd  0xdb6(%rip),%xmm0
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0xdb0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movaps 0xd98(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xd6c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    22eb <paw_R_Pauli+0x10eb>
movsd  -0x60(%rbp),%xmm0
movaps 0xd76(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    2300 <paw_R_Pauli+0x1100>
movsd  0xd3d(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    2300 <paw_R_Pauli+0x1100>
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  0xd20(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    2385 <paw_R_Pauli+0x1185>
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
movl   $0x1,-0x4(%rbp)
jmp    2493 <paw_R_Pauli+0x1293>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    23a6 <paw_R_Pauli+0x11a6>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    23b0 <paw_R_Pauli+0x11b0>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
ja     23e3 <paw_R_Pauli+0x11e3>
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    23fe <paw_R_Pauli+0x11fe>
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xc1b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    2403 <paw_R_Pauli+0x1203>
jmp    2408 <paw_R_Pauli+0x1208>
jmp    166e <paw_R_Pauli+0x46e>
lea    0xc74(%rip),%rdi
mov    $0x3e8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
movsd  -0x60(%rbp),%xmm0
lea    0xc83(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xf8(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10d0 <paw_dealloc_LogGrid@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_R_Pauli>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x258,%rsp
mov    %r9,%r13
mov    %r8,%r12
mov    %rdx,%r14
mov    %esi,%r15d
mov    %edi,0x4c(%rsp)
mov    %rcx,0x128(%rsp)
movsd  (%rcx),%xmm2
lea    0x1(%r15),%eax
imul   %esi,%eax
cvtsi2sd %eax,%xmm1
movapd %xmm1,0x110(%rsp)
test   %esi,%esi
movapd %xmm2,0x60(%rsp)
je     1294 <paw_R_Pauli+0x84>
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
movsd  0x1d95(%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,(%rsp)
jb     12c6 <paw_R_Pauli+0xb6>
sqrtsd %xmm0,%xmm0
jmp    12e0 <paw_R_Pauli+0xd0>
movsd  0x1d64(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  0x1d5c(%rip),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jb     1344 <paw_R_Pauli+0x134>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    134d <paw_R_Pauli+0x13d>
movsd  %xmm3,0x10(%rsp)
call   1110 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x10(%rsp),%xmm3
movsd  (%rsp),%xmm1
movsd  %xmm0,0x28(%rsp)
movsd  0x1d1a(%rip),%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm4,%xmm0
jb     130a <paw_R_Pauli+0xfa>
sqrtsd %xmm0,%xmm0
jmp    1320 <paw_R_Pauli+0x110>
movsd  %xmm2,0x10(%rsp)
call   1110 <sqrt@plt>
movsd  0x10(%rsp),%xmm2
movsd  (%rsp),%xmm1
mulsd  %xmm0,%xmm2
movsd  0x28(%rsp),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm1
addsd  0x1cca(%rip),%xmm1
divsd  %xmm1,%xmm0
jmp    134d <paw_R_Pauli+0x13d>
movapd %xmm1,%xmm0
call   1110 <sqrt@plt>
movsd  %xmm0,0x28(%rsp)
xor    %eax,%eax
call   1060 <paw_N_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <paw_log_amesh_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x80(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0xd0(%rsp)
xor    %eax,%eax
call   1090 <paw_r_LogGrid@plt>
movslq %eax,%rbx
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,0x10(%rsp)
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,(%rsp)
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,0x18(%rsp)
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,0x30(%rsp)
xor    %eax,%eax
call   10b0 <paw_alloc_LogGrid@plt>
cltq
mov    %rax,0x40(%rsp)
movslq %ebp,%rax
add    $0xffffffff,%ebp
mov    %ebp,0xb4(%rsp)
lea    -0x1(%rax),%rcx
mov    %rcx,0xa0(%rsp)
movsd  0x1c20(%rip),%xmm0
mulsd  0x110(%rsp),%xmm0
movsd  -0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm4
divsd  %xmm1,%xmm4
addsd  -0x8(%r14,%rax,8),%xmm4
mov    %eax,%edx
xorpd  %xmm5,%xmm5
test   %eax,%eax
jle    149d <paw_R_Pauli+0x28d>
cmp    $0x1,%edx
jne    142d <paw_R_Pauli+0x21d>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
jmp    1481 <paw_R_Pauli+0x271>
mov    %edx,%ecx
and    $0xfffffffe,%ecx
xorpd  %xmm5,%xmm5
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm1
movsd  0x8(%rbx,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
movapd %xmm0,%xmm3
divsd  %xmm1,%xmm3
addsd  (%r14,%rax,8),%xmm3
mulsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
divsd  %xmm2,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
minsd  %xmm3,%xmm5
minsd  %xmm1,%xmm5
add    $0x2,%rax
cmp    %rax,%rcx
jne    1440 <paw_R_Pauli+0x230>
test   $0x1,%dl
je     149d <paw_R_Pauli+0x28d>
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
addsd  (%r14,%rax,8),%xmm0
minsd  %xmm0,%xmm5
movsd  0x1b73(%rip),%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm4,%xmm1
movapd 0x60(%rsp),%xmm2
cmpltsd %xmm2,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm2,%xmm1
orpd   %xmm0,%xmm1
movsd  0x1b54(%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,0x100(%rsp)
addsd  %xmm5,%xmm0
mulsd  0x1b12(%rip),%xmm0
orpd   %xmm3,%xmm2
movq   $0x0,(%r12)
movq   $0x0,0x0(%r13)
mov    (%rsp),%rax
movq   $0x0,(%rax)
lea    0x8(%r12),%rcx
mov    %rcx,0x140(%rsp)
movq   $0x0,0x8(%r12)
lea    0x8(%r13),%rcx
mov    %rcx,0x148(%rsp)
movq   $0x0,0x8(%r13)
movq   $0x0,0x8(%rax)
lea    0x10(%r12),%rcx
mov    %rcx,0x138(%rsp)
movq   $0x0,0x10(%r12)
lea    0x10(%r13),%rcx
mov    %rcx,0x130(%rsp)
movq   $0x0,0x10(%r13)
movq   $0x0,0x10(%rax)
movq   $0x0,0x18(%r12)
movq   $0x0,0x18(%r13)
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 0x1a9a(%rip),%xmm0
movapd 0x80(%rsp),%xmm1
xorpd  %xmm1,%xmm0
movapd %xmm0,0x1c0(%rsp)
mov    %r15d,%eax
not    %eax
add    0x4c(%rsp),%eax
mov    %eax,0xb0(%rsp)
movsd  0x28(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xc8(%rsp)
movsd  0x1a21(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %rdx,0x8(%rsp)
call   1130 <floor@plt>
movsd  %xmm0,0x200(%rsp)
mov    0x8(%rsp),%rax
add    $0xfffffffb,%eax
mov    %eax,0xf4(%rsp)
mov    %r15,%rdx
mov    0x18(%rsp),%r15
mov    0x8(%rsp),%rax
lea    (%r15,%rax,8),%rdi
mov    0x30(%rsp),%r11
mov    0x8(%rsp),%rax
lea    (%r11,%rax,8),%r10
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,8),%rax
mov    0x8(%rsp),%rcx
lea    (%r14,%rcx,8),%r9
mov    0x40(%rsp),%rsi
mov    0x8(%rsp),%rcx
lea    (%rsi,%rcx,8),%r8
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rcx
lea    (%r14,%rcx,8),%rbp
mov    0x4c(%rsp),%ecx
mov    %rdx,0x168(%rsp)
sub    %edx,%ecx
add    $0xfffffffe,%ecx
mov    %ecx,0xfc(%rsp)
cmp    %rax,%r14
setb   %bl
cmp    %rbp,0x58(%rsp)
setb   %cl
and    %bl,%cl
cmp    %r9,%r14
setb   %bl
cmp    0x50(%rsp),%rbp
mov    0x50(%rsp),%rbp
seta   %dl
and    %bl,%dl
or     %cl,%dl
mov    %dl,0x27(%rsp)
mov    0x8(%rsp),%rcx
and    $0xfffffffc,%ecx
mov    %rcx,0x218(%rsp)
movapd 0x110(%rsp),%xmm9
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
movapd 0xd0(%rsp),%xmm10
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
mov    0x8(%rsp),%rcx
neg    %rcx
mov    %rcx,0x220(%rsp)
cmp    %r10,%r15
setb   %cl
cmp    %rdi,%r11
setb   %bl
and    %cl,%bl
cmp    %rax,%r15
setb   %cl
cmp    %rdi,0x58(%rsp)
setb   %dl
and    %cl,%dl
or     %bl,%dl
cmp    %r9,%r15
setb   %bl
cmp    %rbp,%rdi
seta   %cl
and    %bl,%cl
or     %dl,%cl
cmp    %r8,%r15
mov    %r14,%rbx
mov    0x58(%rsp),%r15
setb   %r14b
cmp    %rdi,%rsi
setb   %dl
and    %r14b,%dl
cmp    %rax,%r11
setb   %dil
cmp    %r10,%r15
setb   %al
and    %dil,%al
or     %dl,%al
cmp    %r9,%r11
setb   %dil
cmp    %rbp,%r10
seta   %dl
and    %dil,%dl
or     %al,%dl
or     %cl,%dl
mov    %r11,%r14
cmp    %r8,%r11
setb   %al
cmp    %r10,%rsi
mov    0x8(%rsp),%r10
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x26(%rsp)
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x210(%rsp)
pshufd $0x44,0x1c0(%rsp),%xmm0
movdqa %xmm0,0x240(%rsp)
mov    0xb0(%rsp),%ecx
mov    %ecx,%eax
and    $0x7,%eax
mov    %eax,0xac(%rsp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %eax,0xf8(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,%rcx
and    $0xffffffffffffffe0,%rcx
and    $0xfffffffffffffff0,%rax
mov    %rax,0x208(%rsp)
mov    0xa0(%rsp),%rax
lea    (%r15,%rax,8),%rdx
mov    %rdx,0x1f8(%rsp)
mov    %rax,%rdx
shl    $0x20,%rdx
mov    %rdx,0x238(%rsp)
mov    $0xfffffffc,%edx
sub    %r10d,%edx
mov    %rdx,0x178(%rsp)
mov    0xb4(%rsp),%edx
mov    %rdx,0x228(%rsp)
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rdx,0x1f0(%rsp)
lea    (%r12,%rax,8),%rdx
mov    %rdx,0x158(%rsp)
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    %rdx,0x160(%rsp)
lea    -0x8(%rbx,%rax,8),%rax
mov    %rax,0x230(%rsp)
lea    0x70(%r13),%rax
mov    %rax,0x1e0(%rsp)
lea    0x70(%r12),%rax
mov    %rax,0x1d8(%rsp)
xor    %edx,%edx
movapd %xmm6,0x190(%rsp)
mov    %rcx,0x170(%rsp)
movapd %xmm5,0x1b0(%rsp)
test   %r10d,%r10d
mov    %edx,0x3c(%rsp)
jle    18d0 <paw_R_Pauli+0x6c0>
cmp    $0x4,%r10d
setb   %al
or     0x27(%rsp),%al
je     1910 <paw_R_Pauli+0x700>
xor    %ecx,%ecx
movapd 0x70(%rsp),%xmm7
jmp    1991 <paw_R_Pauli+0x781>
mov    %rbp,%rdi
xor    %eax,%eax
call   10f0 <paw_Derivative_LogGrid@plt>
movsd  0x1725(%rip),%xmm11
mov    0x18(%rsp),%rdx
mov    0xa0(%rsp),%r9
xorpd  %xmm8,%xmm8
movabs $0xffffffff00000000,%r10
ff ff ff
jmp    1ce8 <paw_R_Pauli+0xad8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x70(%rsp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
movupd (%r15,%rax,1),%xmm1
movupd 0x10(%r15,%rax,1),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movupd 0x0(%rbp,%rax,1),%xmm3
movupd 0x10(%rbp,%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,(%rbx,%rax,1)
movupd %xmm4,0x10(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    1920 <paw_R_Pauli+0x710>
mov    0x218(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     1a41 <paw_R_Pauli+0x831>
mov    %rcx,%rax
test   $0x1,%r10b
je     19cc <paw_R_Pauli+0x7bc>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x220(%rsp),%rcx
je     1a41 <paw_R_Pauli+0x831>
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
subsd  %xmm7,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    19e0 <paw_R_Pauli+0x7d0>
cmp    $0x2,%r10d
setb   %r14b
mov    %rbp,%rdi
xor    %eax,%eax
call   10f0 <paw_Derivative_LogGrid@plt>
or     0x26(%rsp),%r14b
test   $0x1,%r14b
je     1ae0 <paw_R_Pauli+0x8d0>
xor    %eax,%eax
mov    0x40(%rsp),%rcx
mov    0x30(%rsp),%r14
mov    0x18(%rsp),%rdx
movapd 0xd0(%rsp),%xmm10
mov    0xa0(%rsp),%r9
mov    0x8(%rsp),%rdi
xorpd  %xmm8,%xmm8
movapd 0x70(%rsp),%xmm7
movapd 0x1c0(%rsp),%xmm9
movsd  0x1559(%rip),%xmm6
movsd  0x1581(%rip),%xmm5
movsd  0x1550(%rip),%xmm11
movsd  0x154f(%rip),%xmm12
movsd  0x156e(%rip),%xmm13
movabs $0xffffffff00000000,%r10
ff ff ff
jmp    1c50 <paw_R_Pauli+0xa40>
nopl   0x0(%rax)
movapd 0x70(%rsp),%xmm7
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%rcx
mov    0x30(%rsp),%r14
mov    0x18(%rsp),%rdx
mov    0xa0(%rsp),%r9
xorpd  %xmm8,%xmm8
movapd 0x1c0(%rsp),%xmm9
movapd 0x190(%rsp),%xmm10
movapd 0x240(%rsp),%xmm15
mov    0x208(%rsp),%rdi
movsd  0x14cd(%rip),%xmm11
movsd  0x14cc(%rip),%xmm12
movsd  0x14eb(%rip),%xmm13
movapd 0x152b(%rip),%xmm6
movapd 0x1533(%rip),%xmm5
movapd 0x154a(%rip),%xmm14
movabs $0xffffffff00000000,%r10
ff ff ff
movupd (%r15,%rax,1),%xmm1
movupd 0x0(%rbp,%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  0x14c7(%rip),%xmm4
movupd (%rcx,%rax,1),%xmm5
mulpd  %xmm6,%xmm5
divpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movapd 0x14ca(%rip),%xmm5
mulpd  %xmm1,%xmm4
movupd %xmm4,(%rdx,%rax,1)
movupd (%r15,%rax,1),%xmm1
mulpd  %xmm15,%xmm1
mulpd  0x14be(%rip),%xmm1
mulpd  %xmm14,%xmm1
movupd (%rcx,%rax,1),%xmm2
mulpd  %xmm1,%xmm2
movupd 0x0(%rbp,%rax,1),%xmm1
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm5,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,(%r14,%rax,1)
add    $0x10,%rax
cmp    %rax,%rdi
jne    1b70 <paw_R_Pauli+0x960>
mov    0x210(%rsp),%r8
mov    %r8,%rax
mov    0x8(%rsp),%rdi
cmp    %rdi,%r8
movapd 0xd0(%rsp),%xmm10
movsd  0x13be(%rip),%xmm6
movsd  0x13e6(%rip),%xmm5
je     1ce8 <paw_R_Pauli+0xad8>
movsd  (%r15,%rax,8),%xmm0
movsd  0x0(%rbp,%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  (%rcx,%rax,8),%xmm4
mulsd  %xmm5,%xmm4
divsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rdx,%rax,8)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm13,%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movapd %xmm7,%xmm1
subsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm11,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1c50 <paw_R_Pauli+0xa40>
mov    0x3c(%rsp),%r8d
add    $0x1,%r8d
mov    0x10(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
mov    0xb4(%rsp),%esi
mov    0x178(%rsp),%rax
mov    %eax,%ebx
mov    0x238(%rsp),%rdi
xor    %ebp,%ebp
movapd 0x1341(%rip),%xmm2
mov    0x230(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
movsd  (%rcx,%rbp,8),%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm8,%xmm1
jbe    1d70 <paw_R_Pauli+0xb60>
add    %r10,%rdi
lea    (%r9,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rbp
add    $0x1,%rax
add    $0x1,%ebx
add    $0xffffffff,%esi
cmp    $0x2,%rax
jg     1d30 <paw_R_Pauli+0xb20>
jmp    2e07 <paw_R_Pauli+0x1bf7>
nopl   0x0(%rax,%rax,1)
mov    0x228(%rsp),%rax
add    %rbp,%rax
mov    %rax,0xc0(%rsp)
movapd %xmm11,%xmm0
cmpl   $0x0,0xb0(%rsp)
jle    1dd9 <paw_R_Pauli+0xbc9>
mov    0xf8(%rsp),%eax
cmpl   $0x7,0xfc(%rsp)
07
jb     1db5 <paw_R_Pauli+0xba5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xfffffff8,%eax
jne    1db0 <paw_R_Pauli+0xba0>
movapd %xmm11,%xmm0
cmpl   $0x0,0xac(%rsp)
je     1dd9 <paw_R_Pauli+0xbc9>
mov    0xac(%rsp),%eax
movapd %xmm11,%xmm0
xorpd  %xmm2,%xmm0
add    $0xffffffff,%eax
jne    1dd0 <paw_R_Pauli+0xbc0>
movapd %xmm0,0x60(%rsp)
mov    %rbx,0x1e8(%rsp)
mov    %esi,0xf0(%rsp)
mov    %rdi,0x150(%rsp)
mov    %rbp,0xb8(%rsp)
mov    %r8d,0x3c(%rsp)
movsd  (%r15),%xmm0
movsd  0x28(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r14),%xmm1
addsd  0x80(%rsp),%xmm1
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm2
mov    0x18(%rsp),%rax
addsd  (%rax),%xmm2
mov    %rax,%rbp
mulsd  (%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    (%rsp),%rax
movsd  %xmm1,(%rax)
movsd  0x8(%r15),%xmm0
mov    %r15,%rbx
movsd  0x28(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  0x8(%r14),%xmm1
addsd  0x80(%rsp),%xmm1
mov    0x10(%rsp),%r15
movsd  0x8(%r15),%xmm2
addsd  0x8(%rbp),%xmm2
mulsd  0x8(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mov    (%rsp),%rbp
movsd  %xmm1,0x8(%rbp)
movsd  0x10(%rbx),%xmm0
movsd  0x28(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x10(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
movsd  0x10(%r14),%xmm1
addsd  0x80(%rsp),%xmm1
movsd  0x10(%r15),%xmm2
mov    0x18(%rsp),%rbx
addsd  0x10(%rbx),%xmm2
mulsd  0x10(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rbp)
mov    0x58(%rsp),%rax
movsd  0x18(%rax),%xmm0
movsd  0x28(%rsp),%xmm1
call   10c0 <pow@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x18(%r12)
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x18(%r13)
movsd  0x18(%r14),%xmm1
movsd  0x18(%r15),%xmm2
addsd  0x18(%rbx),%xmm2
addsd  0x80(%rsp),%xmm1
mulsd  0x18(%r12),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rbp)
xor    %ebx,%ebx
cmpl   $0x3,0xc0(%rsp)
03
jle    20c0 <paw_R_Pauli+0xeb0>
mov    0xa0(%rsp),%rax
mov    0xb8(%rsp),%rcx
add    %rcx,%rax
mov    %eax,%eax
mov    %rax,0x60(%rsp)
xor    %ebx,%ebx
mov    $0x3,%ebp
jmp    1fdf <paw_R_Pauli+0xdcf>
nop
mulsd  (%r12,%rbp,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
sbb    $0xffffffff,%ebx
mov    %r15,%rbp
cmp    0x60(%rsp),%r15
je     20c0 <paw_R_Pauli+0xeb0>
mov    %ebp,%edi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10a0 <paw_Predictor_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    0x1(%rbp),%r15
movsd  %xmm0,0x8(%r12,%rbp,8)
mov    %ebp,%edi
mov    %r13,%rsi
mov    (%rsp),%rdx
xor    %eax,%eax
call   10a0 <paw_Predictor_Out@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0x8(%r13,%rbp,8)
movsd  0x8(%r12,%rbp,8),%xmm0
mov    $0x5,%r14d
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
mov    0x30(%rsp),%rax
movsd  (%rax,%r15,8),%xmm2
addsd  0x80(%rsp),%xmm2
mov    0x10(%rsp),%rax
movsd  (%rax,%r15,8),%xmm3
addsd  (%rcx,%r15,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    (%rsp),%rdx
movsd  %xmm3,(%rdx,%r15,8)
mov    %ebp,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <paw_Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
mov    %ebp,%edi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1030 <paw_Corrector_Out@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r15,8)
sub    $0x1,%r14d
jb     1fc0 <paw_R_Pauli+0xdb0>
movsd  0x0(%r13,%r15,8),%xmm1
jmp    2030 <paw_R_Pauli+0xe20>
nopl   0x0(%rax)
sub    0x4c(%rsp),%ebx
mov    0x168(%rsp),%rax
add    %eax,%ebx
cmp    $0xfffffffe,%ebx
movapd 0x110(%rsp),%xmm9
movapd 0x70(%rsp),%xmm2
movapd 0x1b0(%rsp),%xmm5
movapd 0x190(%rsp),%xmm6
mov    0x170(%rsp),%rcx
jg     2120 <paw_R_Pauli+0xf10>
movapd %xmm2,0x100(%rsp)
movapd %xmm2,%xmm0
addsd  0x98(%rsp),%xmm0
jmp    213a <paw_R_Pauli+0xf2a>
cs nopw 0x0(%rax,%rax,1)
nop
test   %ebx,%ebx
js     2185 <paw_R_Pauli+0xf75>
movsd  %xmm2,0x98(%rsp)
movapd %xmm2,%xmm0
addsd  0x100(%rsp),%xmm0
mulsd  0xece(%rip),%xmm0
movapd %xmm0,0x70(%rsp)
mov    0x50(%rsp),%rbp
mov    0x40(%rsp),%rsi
mov    0x30(%rsp),%r14
mov    0x10(%rsp),%rbx
movapd 0xd0(%rsp),%xmm10
mov    0x58(%rsp),%r15
mov    0x8(%rsp),%r10
mov    0x3c(%rsp),%edx
cmp    $0x3e8,%edx
jne    18ad <paw_R_Pauli+0x69d>
jmp    2da5 <paw_R_Pauli+0x1b95>
mov    0x158(%rsp),%rax
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps %xmm0,0x1a0(%rsp)
mov    0x160(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x1d0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc0(%rsp),%xmm0
addsd  0x200(%rsp),%xmm0
cvttsd2si %xmm0,%ecx
lea    0x5(%rcx),%eax
cmp    0x8(%rsp),%eax
cmovg  0xf4(%rsp),%ecx
mov    %rcx,0xe8(%rsp)
movslq %ecx,%rbx
mov    0x58(%rsp),%r14
movsd  (%r14,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm9,%xmm1
divsd  %xmm0,%xmm1
mov    0x50(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
subsd  %xmm2,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    0x10(%rsp),%rbp
jb     222e <paw_R_Pauli+0x101e>
sqrtsd %xmm0,%xmm0
jmp    2233 <paw_R_Pauli+0x1023>
call   1110 <sqrt@plt>
movapd %xmm0,0x60(%rsp)
movapd %xmm0,%xmm1
movapd 0xe1b(%rip),%xmm0
xorpd  %xmm0,%xmm1
movapd %xmm1,0x180(%rsp)
movsd  (%r14,%rbx,8),%xmm0
subsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
call   1080 <exp@plt>
movsd  %xmm0,(%r12,%rbx,8)
movsd  (%r14,%rbx,8),%xmm1
xorpd  0xde7(%rip),%xmm1
movapd 0x80(%rsp),%xmm2
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm3
mulsd  0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
mov    0x30(%rsp),%r15
movsd  (%r15,%rbx,8),%xmm0
movsd  0x0(%rbp,%rbx,8),%xmm2
mov    0x18(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm2
mulsd  (%r12,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x8(%r14,%rbx,8),%xmm0
subsd  (%r14,%rbx,8),%xmm0
mulsd  0x180(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x8(%r12,%rbx,8)
movsd  0x8(%r14,%rbx,8),%xmm1
xorpd  0xd5e(%rip),%xmm1
movapd 0x80(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rbx,8)
movsd  0x8(%r15,%rbx,8),%xmm0
movsd  0x8(%rbp,%rbx,8),%xmm2
mov    0x18(%rsp),%rbp
addsd  0x8(%rbp,%rbx,8),%xmm2
mulsd  0x8(%r12,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,0x8(%rax,%rbx,8)
movsd  0x10(%r14,%rbx,8),%xmm0
subsd  (%r14,%rbx,8),%xmm0
mulsd  0x180(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x10(%r12,%rbx,8)
movsd  0x10(%r14,%rbx,8),%xmm1
xorpd  0xcda(%rip),%xmm1
movapd 0x80(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13,%rbx,8)
movsd  0x10(%r15,%rbx,8),%xmm0
mov    0x10(%rsp),%rax
movsd  0x10(%rax,%rbx,8),%xmm2
addsd  0x10(%rbp,%rbx,8),%xmm2
mulsd  0x10(%r12,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,0x10(%rax,%rbx,8)
movsd  0x18(%r14,%rbx,8),%xmm0
subsd  (%r14,%rbx,8),%xmm0
mulsd  0x180(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x18(%r12,%rbx,8)
movsd  0x18(%r14,%rbx,8),%xmm1
xorpd  0xc56(%rip),%xmm1
movapd 0x80(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r13,%rbx,8)
movsd  0x18(%r15,%rbx,8),%xmm0
mov    0x10(%rsp),%rbp
movsd  0x18(%rbp,%rbx,8),%xmm2
mov    0x18(%rsp),%r15
addsd  0x18(%r15,%rbx,8),%xmm2
mulsd  0x18(%r12,%rbx,8),%xmm2
addsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,0x18(%rax,%rbx,8)
movsd  0x20(%r14,%rbx,8),%xmm0
subsd  (%r14,%rbx,8),%xmm0
mulsd  0x180(%rsp),%xmm0
call   1080 <exp@plt>
movsd  %xmm0,0x20(%r12,%rbx,8)
movsd  0x20(%r14,%rbx,8),%xmm1
xorpd  0xbcc(%rip),%xmm1
movapd 0x80(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  0x60(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r13,%rbx,8)
mov    0x30(%rsp),%rax
movsd  0x20(%rax,%rbx,8),%xmm0
addsd  %xmm2,%xmm0
movsd  0x20(%rbp,%rbx,8),%xmm2
addsd  0x20(%r15,%rbx,8),%xmm2
mulsd  0x20(%r12,%rbx,8),%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    (%rsp),%rax
movsd  %xmm0,0x20(%rax,%rbx,8)
mov    0xc0(%rsp),%rax
cmp    %eax,0xe8(%rsp)
jle    25f9 <paw_R_Pauli+0x13e9>
mov    0x150(%rsp),%r15
sar    $0x20,%r15
jmp    2519 <paw_R_Pauli+0x1309>
nopw   0x0(%rax,%rax,1)
cmp    %r15,%rbx
jle    25f9 <paw_R_Pauli+0x13e9>
mov    %rbx,%r14
mov    %r14d,%edi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10d0 <paw_Predictor_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
add    $0xffffffffffffffff,%rbx
movsd  %xmm0,-0x8(%r12,%r14,8)
mov    %r14d,%edi
mov    %r13,%rsi
mov    (%rsp),%rdx
xor    %eax,%eax
call   10d0 <paw_Predictor_In@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,-0x8(%r13,%r14,8)
movsd  -0x8(%r12,%r14,8),%xmm0
mov    $0x5,%ebp
nopl   0x0(%rax)
mov    0x18(%rsp),%rcx
mov    0x30(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
addsd  0x80(%rsp),%xmm2
mov    0x10(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm3
addsd  (%rcx,%rbx,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mov    (%rsp),%rdx
movsd  %xmm3,(%rdx,%rbx,8)
mov    %r14d,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1120 <paw_Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
mov    %r14d,%edi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1120 <paw_Corrector_In@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbx,8)
sub    $0x1,%ebp
jb     2510 <paw_R_Pauli+0x1300>
movsd  0x0(%r13,%rbx,8),%xmm1
jmp    2570 <paw_R_Pauli+0x1360>
mov    0xe8(%rsp),%rdi
cmp    0xc0(%rsp),%edi
mov    0x30(%rsp),%r14
mov    0x10(%rsp),%rbx
mov    0x58(%rsp),%r15
mov    0xb8(%rsp),%r8
mov    0x150(%rsp),%r9
jl     27ee <paw_R_Pauli+0x15de>
movapd 0x1a0(%rsp),%xmm0
mov    0x158(%rsp),%rax
divsd  (%rax,%r8,8),%xmm0
sar    $0x20,%r9
lea    0x5(%rdi),%eax
mov    0x178(%rsp),%rcx
add    %rcx,%rax
sub    %r8,%rax
cmp    $0x3,%eax
jb     274e <paw_R_Pauli+0x153e>
lea    (%r12,%r9,8),%rdx
add    %edi,%ecx
sub    %r8d,%ecx
add    $0x5,%ecx
add    %r9,%rcx
mov    0x148(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    26a2 <paw_R_Pauli+0x1492>
mov    0x140(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    0x0(,%r9,8),%rdx
add    %r13,%rdx
cmp    %rcx,%rdx
jb     274e <paw_R_Pauli+0x153e>
mov    %eax,%r10d
add    $0x1,%r10
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rcx,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    0x1e8(%rsp),%rax
lea    (%rdi,%rax,1),%edx
add    $0x5,%edx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
movslq 0xf0(%rsp),%rax
mov    0x138(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    0x130(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
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    2700 <paw_R_Pauli+0x14f0>
cmp    %rcx,%r10
je     27ee <paw_R_Pauli+0x15de>
lea    0x1(%rdi),%ecx
mov    %ecx,%eax
sub    %r9d,%eax
test   $0x1,%al
jne    2767 <paw_R_Pauli+0x1557>
mov    %r9,%rax
cmp    %r9d,%edi
jne    2795 <paw_R_Pauli+0x1585>
jmp    27ee <paw_R_Pauli+0x15de>
movsd  (%r12,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r9,8)
movsd  0x0(%r13,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r9,8)
mov    %r9,%rax
add    $0x1,%rax
cmp    %r9d,%edi
je     27ee <paw_R_Pauli+0x15de>
mov    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %eax,%ecx
jne    27a0 <paw_R_Pauli+0x1590>
mov    0x160(%rsp),%rax
movsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x28(%rsp),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1100 <paw_Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
jb     2829 <paw_R_Pauli+0x1619>
sqrtsd %xmm0,%xmm0
jmp    2832 <paw_R_Pauli+0x1622>
call   1110 <sqrt@plt>
xorpd  %xmm4,%xmm4
movapd 0x110(%rsp),%xmm9
movapd 0xd0(%rsp),%xmm10
mov    0x8(%rsp),%r10
movapd 0x100(%rsp),%xmm8
movapd 0x70(%rsp),%xmm7
movapd 0x190(%rsp),%xmm6
movsd  0x79c(%rip),%xmm1
movsd  0x79b(%rip),%xmm11
xorpd  %xmm5,%xmm5
divsd  %xmm0,%xmm1
mov    0xe8(%rsp),%r8
lea    0x1(%r8),%eax
test   %r8d,%r8d
mov    0x50(%rsp),%rbp
movapd 0x1a0(%rsp),%xmm3
js     2aa3 <paw_R_Pauli+0x1893>
mov    %eax,%ecx
cmp    $0x4,%eax
jb     28c8 <paw_R_Pauli+0x16b8>
lea    0x0(,%rcx,8),%rdx
add    %r13,%rdx
cmp    %r12,%rdx
jbe    2964 <paw_R_Pauli+0x1754>
lea    (%r12,%rcx,8),%rdx
cmp    %r13,%rdx
jbe    2964 <paw_R_Pauli+0x1754>
xor    %edx,%edx
mov    %rdx,%rsi
test   $0x1,%cl
je     28fb <paw_R_Pauli+0x16eb>
movsd  (%r12,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
mov    %rdx,%rsi
or     $0x1,%rsi
not    %rdx
add    %rcx,%rdx
je     2aa3 <paw_R_Pauli+0x1893>
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
movsd  0x0(%r13,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
movsd  0x8(%r12,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rsi,8)
movsd  0x8(%r13,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    2910 <paw_R_Pauli+0x1700>
jmp    2aa3 <paw_R_Pauli+0x1893>
mov    %ecx,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2a3e <paw_R_Pauli+0x182e>
mov    %rbp,%rdi
and    0x1f0(%rsp),%rdi
xor    %esi,%esi
cs 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 0x0(%r13,%rsi,8),%xmm2
movupd 0x10(%r13,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rsi,8)
movupd %xmm3,0x10(%r13,%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(%r13,%rsi,8),%xmm2
movupd 0x30(%r13,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r13,%rsi,8)
movupd %xmm3,0x30(%r13,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    29a0 <paw_R_Pauli+0x1790>
jmp    2a40 <paw_R_Pauli+0x1830>
xor    %esi,%esi
test   $0x1,%bpl
je     2a8c <paw_R_Pauli+0x187c>
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 0x0(%r13,%rsi,8),%xmm2
movupd 0x10(%r13,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rsi,8)
movupd %xmm3,0x10(%r13,%rsi,8)
cmp    %rcx,%rdx
mov    0x50(%rsp),%rbp
movapd 0x1a0(%rsp),%xmm3
jne    28ca <paw_R_Pauli+0x16ba>
cmp    %r10d,%eax
jge    2ca0 <paw_R_Pauli+0x1a90>
cltq
mov    %r10d,%r9d
sub    %r8d,%r9d
add    $0xfffffffe,%r9d
cmp    $0x3,%r9d
jb     2c15 <paw_R_Pauli+0x1a05>
lea    (%r12,%rax,8),%rsi
mov    %r10d,%edx
sub    %r8d,%edx
add    $0xfffffffe,%edx
add    %rax,%rdx
mov    0x148(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdi
cmp    %rdi,%rsi
jae    2b03 <paw_R_Pauli+0x18f3>
mov    0x140(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
cmp    %rdx,%rsi
jb     2c15 <paw_R_Pauli+0x1a05>
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    2b2f <paw_R_Pauli+0x191f>
xor    %ebp,%ebp
jmp    2bb8 <paw_R_Pauli+0x19a8>
and    $0xfffffffffffffffc,%rdi
mov    0x1e0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x1d8(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
xor    %ebp,%ebp
nopl   (%rax)
movupd %xmm5,-0x70(%rdx,%rbp,8)
movupd %xmm5,-0x60(%rdx,%rbp,8)
movupd %xmm5,-0x70(%rcx,%rbp,8)
movupd %xmm5,-0x60(%rcx,%rbp,8)
movupd %xmm5,-0x50(%rdx,%rbp,8)
movupd %xmm5,-0x40(%rdx,%rbp,8)
movupd %xmm5,-0x50(%rcx,%rbp,8)
movupd %xmm5,-0x40(%rcx,%rbp,8)
movupd %xmm5,-0x30(%rdx,%rbp,8)
movupd %xmm5,-0x20(%rdx,%rbp,8)
movupd %xmm5,-0x30(%rcx,%rbp,8)
movupd %xmm5,-0x20(%rcx,%rbp,8)
movupd %xmm5,-0x10(%rdx,%rbp,8)
movupd %xmm5,(%rdx,%rbp,8)
movupd %xmm5,-0x10(%rcx,%rbp,8)
movupd %xmm5,(%rcx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    2b50 <paw_R_Pauli+0x1940>
test   %rsi,%rsi
je     2bff <paw_R_Pauli+0x19ef>
add    %rax,%rbp
mov    0x130(%rsp),%rcx
lea    (%rcx,%rbp,8),%rdx
mov    0x138(%rsp),%rcx
lea    (%rcx,%rbp,8),%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
xchg   %ax,%ax
movupd %xmm5,-0x10(%rdi,%rbp,1)
movupd %xmm5,(%rdi,%rbp,1)
movupd %xmm5,-0x10(%rdx,%rbp,1)
movupd %xmm5,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    2be0 <paw_R_Pauli+0x19d0>
cmp    %r8,%r9
mov    0x50(%rsp),%rbp
mov    0x30(%rsp),%r14
je     2ca0 <paw_R_Pauli+0x1a90>
add    %r8,%rax
mov    %r10d,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %r10d,%ecx
and    $0x3,%edx
je     2c4a <paw_R_Pauli+0x1a3a>
cs nopw 0x0(%rax,%rax,1)
movq   $0x0,(%r12,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    2c30 <paw_R_Pauli+0x1a20>
cmp    $0x3,%ecx
jb     2ca0 <paw_R_Pauli+0x1a90>
nop
movq   $0x0,(%r12,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,0x8(%r12,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
movq   $0x0,0x10(%r12,%rax,8)
movq   $0x0,0x10(%r13,%rax,8)
movq   $0x0,0x18(%r12,%rax,8)
movq   $0x0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %eax,%r10d
jne    2c50 <paw_R_Pauli+0x1a40>
mulsd  %xmm1,%xmm3
movsd  0x1d0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x60(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm11,%xmm3
mulsd  %xmm0,%xmm3
mov    0x1f8(%rsp),%rax
mov    0xb8(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x80(%rsp),%xmm0
divsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
movapd 0x3ca(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm7,%xmm1
andpd  %xmm2,%xmm1
maxsd  0x336(%rip),%xmm1
mulsd  0x336(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     2e65 <paw_R_Pauli+0x1c55>
ucomisd %xmm4,%xmm3
ja     2d2b <paw_R_Pauli+0x1b1b>
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    0x40(%rsp),%rsi
mov    0x170(%rsp),%rcx
mov    0x3c(%rsp),%edx
movapd %xmm0,0x100(%rsp)
ja     2d7c <paw_R_Pauli+0x1b6c>
ucomisd %xmm7,%xmm0
ja     2d7c <paw_R_Pauli+0x1b6c>
movapd %xmm7,0x70(%rsp)
jmp    2d90 <paw_R_Pauli+0x1b80>
addsd  0x98(%rsp),%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm0,0x70(%rsp)
movapd 0x1b0(%rsp),%xmm5
cmp    $0x3e8,%edx
jne    18ad <paw_R_Pauli+0x69d>
lea    0x324(%rip),%rdi
xor    %r12d,%r12d
mov    $0x3e8,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x33b(%rip),%rdi
mov    0x4c(%rsp),%esi
mov    0x168(%rsp),%rdx
movaps 0x70(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x128(%rsp),%rax
movaps 0x70(%rsp),%xmm0
movsd  %xmm0,(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    (%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
jmp    2e33 <paw_R_Pauli+0x1c23>
mov    %rdx,%rbp
lea    0x301(%rip),%rdi
call   1040 <puts@plt>
xor    %r12d,%r12d
mov    0x10(%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    (%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    0x40(%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %r12d,%eax
add    $0x258,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x128(%rsp),%rax
movsd  %xmm7,(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    (%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   10e0 <paw_dealloc_LogGrid@plt>
mov    $0x1,%r12d
jmp    2e44 <paw_R_Pauli+0x1c34>

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

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