void solve_Rappe(num_psp, n_psp, l_psp, e_psp, fill_psp, rcut_psp, r_psi_psp,
                 r_psi_prime_psp, rho_psp, rho_semicore, V_psp, eall_psp,
                 eh_psp, ph_psp, ex_psp, px_psp, ec_psp, pc_psp) int num_psp;
int n_psp[];
int l_psp[];
double e_psp[];
double fill_psp[];
double rcut_psp[];
double **r_psi_psp;
double **r_psi_prime_psp;
double *rho_psp;
double *rho_semicore;
double **V_psp;
double *eall_psp;
double *eh_psp;
double *ph_psp;
double *ex_psp;
double *px_psp;
double *ec_psp;
double *pc_psp;
{
  int istate, i, l, k, match, mch, Ngrid;
  double al, amesh, rmax, Zion;
  double gamma, gpr, nu0;
  double ldpsi_match;
  double el, eeig;
  double ph, px, pc, eh, ex, ec;
  double *ul, *ul_prime;
  double *wl, *wl_prime;
  double *r, *Vh, *Vx, *Vc, *rho_total, *Vall, *Vl;
  Vall = Vall_Atom();
  r = r_LogGrid();
  Ngrid = N_LogGrid();
  al = log_amesh_LogGrid();
  amesh = amesh_LogGrid();
  Zion = 0.0;
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = 0.0;
  if (debug_print()) {
    printf("\n\nRappe pseudopotential check\n\n");
    printf(
        "l\trcore     rmatch    E in       E psp      norm test slope test\n");
  }
  for (l = 0; l < (num_psp); ++l) {
    wl = r_psi_psp[l];
    wl_prime = r_psi_prime_psp[l];
    Vl = V_psp[l];
    if (fill_psp[l] == 0.0) {
      rmax = 10.0;
      solve_Scattering_State_Atom(n_psp[l], l_psp[l], e_psp[l], rmax);
      istate = Nvalence_Atom() + Ncore_Atom();
      mch = rint(log(rmax / r[0]) / al);
      ul = r_psi_Atom(istate);
      ul_prime = r_psi_prime_Atom(istate);
      nu0 = Norm_LogGrid(mch, (l + 1.0), ul);
      nu0 = 1.0 / sqrt(nu0);
      for (i = 0; i < Ngrid; ++i) {
        ul[i] = ul[i] * nu0;
        ul_prime[i] = ul_prime[i] * nu0;
      }
    } else
      istate = state_Atom(n_psp[l], l_psp[l]);
    ul = r_psi_Atom(istate);
    ul_prime = r_psi_prime_Atom(istate);
    el = e_psp[l];
    match = rint(log(rcut_psp[l] / r[0]) / al);
    ldpsi_match = ul_prime[match] / ul[match];
    init_xpansion(l, match, fill_psp[l], el, Vall, ul, ul_prime, Vl, wl,
                  wl_prime);
    psi_xpansion();
    dpsi_xpansion();
    psp_xpansion();
    if (fill_psp[l] > 0.0) {
      R_Schrodinger(l_psp[l] + 1, l_psp[l], Vl, &mch, &el, wl, wl_prime);
    } else {
      R_Schrodinger_Fixed_Logderiv(l_psp[l] + 1, l_psp[l], Vl, match,
                                   ldpsi_match, &el, wl, wl_prime);
      R_Schrodinger_Fixed_E(l_psp[l] + 1, l_psp[l], Vl, Ngrid - 1, el, wl,
                            wl_prime);
      rmax = 10.0;
      mch = rint(log(rmax / r[0]) / al);
      nu0 = Norm_LogGrid(mch, (l + 1.0), wl);
      nu0 = 1.0 / sqrt(nu0);
      for (i = 0; i < Ngrid; ++i) {
        wl[i] = wl[i] * nu0;
        wl_prime[i] = wl_prime[i] * nu0;
      }
    }
    gamma = fabs(ul[match] / wl[match]);
    gpr = fabs(ul_prime[match] / wl_prime[match]);
    if (debug_print()) {
      printf("%d\t%lf  %lf  %lf  %lf  %lf  %lf\n", l_psp[l], rcut_psp[l],
             r[match], e_psp[l], el, gamma, gpr);
    }
    el = e_psp[l];
    psi_xpansion();
    dpsi_xpansion();
    psp_xpansion();
    if (fill_psp[l] > 0.0) {
      eeig += fill_psp[l] * el;
      Zion += fill_psp[l];
      for (k = 0; k < Ngrid; ++k)
        rho_psp[k] += fill_psp[l] * pow(wl[k] / r[k], 2.0);
    }
  }
  Vh = alloc_LogGrid();
  Vx = alloc_LogGrid();
  Vc = alloc_LogGrid();
  ph = R_Hartree_DFT(rho_psp, Zion, Vh);
  eh = 0.5 * ph;
  rho_total = alloc_LogGrid();
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = rho_psp[k] + rho_semicore[k];
  R_Exchange_DFT(rho_total, Vx, &ex, &px);
  R_Correlation_DFT(rho_total, Vc, &ec, &pc);
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = (rho_psp[k]) * Vx[k];
  px = Integrate_LogGrid(rho_total);
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = (rho_psp[k]) * Vc[k];
  pc = Integrate_LogGrid(rho_total);
  *eall_psp = eeig + eh + ex + ec - ph - px - pc;
  *eh_psp = eh;
  *ph_psp = ph;
  *ex_psp = ex;
  *px_psp = px;
  *ec_psp = ec;
  *pc_psp = pc;
  for (l = 0; l < num_psp; ++l)
    for (k = 0; k < Ngrid; ++k)
      V_psp[l][k] = V_psp[l][k] - Vh[k] - Vx[k] - Vc[k];
  dealloc_LogGrid(Vh);
  dealloc_LogGrid(Vx);
  dealloc_LogGrid(Vc);
  dealloc_LogGrid(rho_total);
}


x86 assembly (clang, -O0):
<solve_Rappe>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x0,%al
call   10a0 <Vall_Atom@plt>
cltq
mov    %rax,-0x120(%rbp)
mov    $0x0,%al
call   10f0 <r_LogGrid@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   1210 <N_LogGrid@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    $0x0,%al
call   11e0 <amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13c5 <solve_Rappe+0xd5>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    139b <solve_Rappe+0xab>
mov    $0x0,%al
call   11b0 <debug_print@plt>
cmp    $0x0,%eax
je     13f1 <solve_Rappe+0x101>
lea    0xc54(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc66(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ac2 <solve_Rappe+0x7d2>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x128(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15ce <solve_Rappe+0x2de>
jp     15ce <solve_Rappe+0x2de>
movsd  0xbab(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    $0x2,%al
call   1030 <solve_Scattering_State_Atom@plt>
mov    $0x0,%al
call   1080 <Nvalence_Atom@plt>
mov    %eax,-0x12c(%rbp)
mov    $0x0,%al
call   10e0 <Ncore_Atom@plt>
mov    %eax,%ecx
mov    -0x12c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
divsd  (%rax),%xmm0
call   1150 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10d0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1090 <r_psi_Atom@plt>
cltq
mov    %rax,-0xd8(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1050 <r_psi_prime_Atom@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x48(%rbp),%edi
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  0xaf2(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rsi
mov    $0x1,%al
call   1130 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1190 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xabc(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    15c9 <solve_Rappe+0x2d9>
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    155f <solve_Rappe+0x26f>
jmp    15ee <solve_Rappe+0x2fe>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   11d0 <state_Atom@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1090 <r_psi_Atom@plt>
cltq
mov    %rax,-0xd8(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1050 <r_psi_prime_Atom@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
divsd  (%rax),%xmm0
call   1150 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10d0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0xe0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x3c(%rbp),%edi
mov    -0x44(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x120(%rbp),%rdx
mov    -0xd8(%rbp),%rcx
mov    -0xe0(%rbp),%r8
mov    -0x128(%rbp),%r9
mov    -0xe8(%rbp),%r10
mov    -0xf0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1170 <init_xpansion@plt>
mov    $0x0,%al
call   1110 <psi_xpansion@plt>
mov    $0x0,%al
call   10b0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1140 <psp_xpansion@plt>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    174c <solve_Rappe+0x45c>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x128(%rbp),%rdx
mov    -0xe8(%rbp),%r9
mov    -0xf0(%rbp),%rax
lea    -0x48(%rbp),%rcx
lea    -0x98(%rbp),%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1180 <R_Schrodinger@plt>
jmp    18d5 <solve_Rappe+0x5e5>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x128(%rbp),%rdx
mov    -0x44(%rbp),%ecx
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%r9
mov    -0xf0(%rbp),%rax
lea    -0x98(%rbp),%r8
mov    %rax,(%rsp)
mov    $0x1,%al
call   1070 <R_Schrodinger_Fixed_Logderiv@plt>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x128(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%r8
mov    -0xf0(%rbp),%r9
mov    $0x1,%al
call   11f0 <R_Schrodinger_Fixed_E@plt>
movsd  0x82e(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
divsd  (%rax),%xmm0
call   1150 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10d0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  0x7eb(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rsi
mov    $0x1,%al
call   1130 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1190 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x7b5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    18d0 <solve_Rappe+0x5e0>
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1866 <solve_Rappe+0x576>
jmp    18d5 <solve_Rappe+0x5e5>
mov    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x724(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0xe0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x6f4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    $0x0,%al
call   11b0 <debug_print@plt>
cmp    $0x0,%eax
je     199a <solve_Rappe+0x6aa>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm4
movsd  -0x80(%rbp),%xmm5
lea    0x6ff(%rip),%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   1110 <psi_xpansion@plt>
mov    $0x0,%al
call   10b0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1140 <psp_xpansion@plt>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1aaf <solve_Rappe+0x7bf>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1aaa <solve_Rappe+0x7ba>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xe8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x5a6(%rip),%xmm1
call   1160 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x138(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a29 <solve_Rappe+0x739>
jmp    1aaf <solve_Rappe+0x7bf>
jmp    1ab4 <solve_Rappe+0x7c4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f8 <solve_Rappe+0x108>
mov    $0x0,%al
call   11c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    $0x0,%al
call   11c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   11c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    0x20(%rbp),%rdi
movsd  -0x70(%rbp),%xmm0
mov    -0x100(%rbp),%rsi
mov    $0x1,%al
call   1120 <R_Hartree_DFT@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x4e3(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    $0x0,%al
call   11c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1b88 <solve_Rappe+0x898>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b44 <solve_Rappe+0x854>
mov    -0x118(%rbp),%rdi
mov    -0x108(%rbp),%rsi
lea    -0xc8(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
mov    $0x0,%al
call   10c0 <R_Exchange_DFT@plt>
mov    -0x118(%rbp),%rdi
mov    -0x110(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0xb8(%rbp),%rcx
mov    $0x0,%al
call   1200 <R_Correlation_DFT@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1c1c <solve_Rappe+0x92c>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1bd5 <solve_Rappe+0x8e5>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   1100 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1c84 <solve_Rappe+0x994>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x110(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c3d <solve_Rappe+0x94d>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   1100 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ddf <solve_Rappe+0xaef>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1dcc <solve_Rappe+0xadc>
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x110(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d58 <solve_Rappe+0xa68>
jmp    1dd1 <solve_Rappe+0xae1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d45 <solve_Rappe+0xa55>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   11a0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   11a0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   11a0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   11a0 <dealloc_LogGrid@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_Rappe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0xf0(%rsp)
mov    %r8,0x40(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,0x140(%rsp)
mov    %edi,0x74(%rsp)
mov    0x1a0(%rsp),%r13
xor    %eax,%eax
call   10c0 <Vall_Atom@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1110 <r_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1220 <N_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1050 <log_amesh_LogGrid@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   11f0 <amesh_LogGrid@plt>
mov    %r15d,%ebx
test   %r15d,%r15d
jle    1384 <solve_Rappe+0x84>
lea    0x0(,%rbx,8),%rdx
mov    %r13,%rdi
xor    %esi,%esi
call   10b0 <memset@plt>
mov    %rbx,0x10(%rsp)
xor    %eax,%eax
call   11c0 <debug_print@plt>
test   %eax,%eax
je     13ac <solve_Rappe+0xac>
lea    0x1cb6(%rip),%rdi
call   1040 <puts@plt>
lea    0x1cc9(%rip),%rdi
call   1040 <puts@plt>
mov    0x74(%rsp),%ecx
mov    %ecx,%eax
mov    %rax,0xf8(%rsp)
test   %ecx,%ecx
mov    %r15,0x20(%rsp)
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%r13
jle    1e88 <solve_Rappe+0xb88>
movslq %r14d,%rax
mov    %rax,0x138(%rsp)
movslq %ebp,%r14
cvtsi2sd %r12d,%xmm3
mov    0x1a0(%rsp),%rax
lea    0x8(%rax),%rsi
lea    (%rax,%rcx,8),%rdi
lea    0x8(%r14),%r8
lea    (%r14,%rcx,8),%r9
lea    -0x1(%rcx),%rax
mov    %ecx,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xd0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc8(%rsp)
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rbp,%rdx
mov    %rbp,0xc0(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xb8(%rsp)
neg    %rcx
mov    %rcx,0xe0(%rsp)
mov    %rsi,0x128(%rsp)
cmp    %r9,%rsi
setb   %cl
mov    %rdi,0x120(%rsp)
cmp    %rdi,%r8
setb   %dl
and    %cl,%dl
mov    %dl,0x1f(%rsp)
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rax,0xd8(%rsp)
or     $0x1,%rax
mov    %rax,0x118(%rsp)
xorpd  %xmm4,%xmm4
xorps  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
lea    -0x1(%r15),%eax
mov    %eax,0x88(%rsp)
xor    %ebp,%ebp
mov    0x40(%rsp),%r15
mov    %r14,0x38(%rsp)
movsd  %xmm3,0x68(%rsp)
mov    %rdx,0x130(%rsp)
jmp    14da <solve_Rappe+0x1da>
nopw   0x0(%rax,%rax,1)
mov    0x1a0(%rsp),%rdi
add    $0x1,%rbp
cmp    0xf8(%rsp),%rbp
je     1e99 <solve_Rappe+0xb99>
mov    0x190(%rsp),%rax
mov    (%rax,%rbp,8),%r12
mov    0x198(%rsp),%rax
mov    (%rax,%rbp,8),%r14
mov    0x1b0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    %rax,0xa0(%rsp)
movsd  (%r15,%rbp,8),%xmm0
ucomisd %xmm4,%xmm0
mov    0x140(%rsp),%rax
mov    (%rax,%rbp,4),%edi
mov    0x30(%rsp),%rax
mov    (%rax,%rbp,4),%esi
jne    15e0 <solve_Rappe+0x2e0>
jp     15e0 <solve_Rappe+0x2e0>
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  0x1ac2(%rip),%xmm1
mov    $0x2,%al
call   1030 <solve_Scattering_State_Atom@plt>
xor    %eax,%eax
call   1090 <Nvalence_Atom@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1100 <Ncore_Atom@plt>
mov    %eax,%r15d
add    %ebx,%r15d
movsd  0x1a9d(%rip),%xmm0
mov    0x38(%rsp),%rax
divsd  (%rax),%xmm0
call   1170 <log@plt>
divsd  0x68(%rsp),%xmm0
call   10f0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x54(%rsp)
mov    %r15d,%edi
xor    %eax,%eax
call   10a0 <r_psi_Atom@plt>
movslq %eax,%rbx
mov    %r15d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
mov    %eax,%r13d
mov    0x54(%rsp),%edi
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
addsd  0x1a57(%rip),%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1150 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x1a4e(%rip),%xmm0
jb     1600 <solve_Rappe+0x300>
sqrtsd %xmm0,%xmm0
jmp    1605 <solve_Rappe+0x305>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   11e0 <state_Atom@plt>
mov    %eax,%r15d
mov    %r13,%rbx
jmp    17f5 <solve_Rappe+0x4f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   11a0 <sqrt@plt>
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%rcx
test   %ecx,%ecx
jle    17f0 <solve_Rappe+0x4f0>
movslq %r13d,%rax
movsd  0x19e6(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x4,%ecx
jb     1645 <solve_Rappe+0x345>
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%rbx
jae    16da <solve_Rappe+0x3da>
lea    (%rbx,%rsi,8),%rcx
cmp    %rcx,%rax
jae    16da <solve_Rappe+0x3da>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%sil
je     1673 <solve_Rappe+0x373>
movsd  (%rbx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xe0(%rsp),%rdx
je     17f0 <solve_Rappe+0x4f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1690 <solve_Rappe+0x390>
jmp    17f0 <solve_Rappe+0x4f0>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xc8(%rsp)
je     1e5e <solve_Rappe+0xb5e>
mov    0xb8(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rax,%rcx,8)
movupd %xmm3,0x10(%rax,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm3,0x30(%rbx,%rcx,8)
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rax,%rcx,8)
movupd %xmm3,0x30(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1700 <solve_Rappe+0x400>
testb  $0x1,0xc0(%rsp)
01
je     17d0 <solve_Rappe+0x4d0>
movupd (%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm3,0x10(%rbx,%rcx,8)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rax,%rcx,8)
movupd %xmm3,0x10(%rax,%rcx,8)
mov    0xd0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1647 <solve_Rappe+0x347>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rbx
mov    %r15d,%edi
xor    %eax,%eax
call   10a0 <r_psi_Atom@plt>
movslq %eax,%r13
mov    %r15d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
movslq %eax,%r15
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0xf0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0x38(%rsp),%rax
divsd  (%rax),%xmm0
call   1170 <log@plt>
divsd  0x68(%rsp),%xmm0
call   10f0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x8c(%rsp)
movslq %eax,%rsi
movsd  (%r15,%rsi,8),%xmm0
movsd  %xmm0,0x150(%rsp)
movsd  0x0(%r13,%rsi,8),%xmm0
movsd  %xmm0,0x148(%rsp)
mov    0x40(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm0
movsd  0x48(%rsp),%xmm1
mov    %r14,0x8(%rsp)
mov    %r12,(%rsp)
mov    %ebp,%edi
mov    %rsi,0x60(%rsp)
mov    0x138(%rsp),%rdx
mov    %r13,0x90(%rsp)
mov    %r13,%rcx
mov    %r15,0x58(%rsp)
mov    %r15,%r8
mov    0xa0(%rsp),%r13
mov    %r13,%r9
mov    $0x2,%al
call   1180 <init_xpansion@plt>
xor    %eax,%eax
call   1130 <psi_xpansion@plt>
xor    %eax,%eax
call   10d0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1160 <psp_xpansion@plt>
movsd  (%rbx,%rbp,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1930 <solve_Rappe+0x630>
mov    0x30(%rsp),%rax
mov    (%rax,%rbp,4),%esi
lea    0x1(%rsi),%edi
mov    %r14,(%rsp)
mov    %r13,%rdx
lea    0x54(%rsp),%rcx
lea    0x48(%rsp),%r8
mov    %r12,%r9
xor    %eax,%eax
call   1190 <R_Schrodinger@plt>
mov    0x40(%rsp),%r15
mov    0x28(%rsp),%r13
mov    0x90(%rsp),%rsi
mov    0x60(%rsp),%rbx
mov    0x58(%rsp),%rdi
jmp    1c10 <solve_Rappe+0x910>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x150(%rsp),%xmm0
divsd  0x148(%rsp),%xmm0
mov    0x30(%rsp),%rbx
mov    (%rbx,%rbp,4),%esi
lea    0x1(%rsi),%edi
mov    %r14,(%rsp)
mov    %r13,%rdx
mov    0x8c(%rsp),%ecx
lea    0x48(%rsp),%r8
mov    %r12,%r9
mov    $0x1,%al
call   1080 <R_Schrodinger_Fixed_Logderiv@plt>
mov    (%rbx,%rbp,4),%esi
lea    0x1(%rsi),%edi
movsd  0x48(%rsp),%xmm0
mov    %r13,%rdx
mov    0x88(%rsp),%ecx
mov    %r12,%r8
mov    %r14,%r9
mov    $0x1,%al
call   1200 <R_Schrodinger_Fixed_E@plt>
movsd  0x166b(%rip),%xmm0
mov    0x38(%rsp),%rax
divsd  (%rax),%xmm0
call   1170 <log@plt>
divsd  0x68(%rsp),%xmm0
call   10f0 <rint@plt>
cvttsd2si %xmm0,%edi
mov    %edi,0x54(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
addsd  0x1643(%rip),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1150 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x163a(%rip),%xmm0
jb     19f0 <solve_Rappe+0x6f0>
sqrtsd %xmm0,%xmm0
jmp    19f5 <solve_Rappe+0x6f5>
cs nopw 0x0(%rax,%rax,1)
call   11a0 <sqrt@plt>
mov    0x10(%rsp),%rdx
mov    0x40(%rsp),%r15
mov    0x28(%rsp),%r13
mov    0x90(%rsp),%rsi
mov    0x60(%rsp),%rbx
mov    0x58(%rsp),%rdi
cmpl   $0x0,0x20(%rsp)
jle    1c10 <solve_Rappe+0x910>
movsd  0x15df(%rip),%xmm1
divsd  %xmm0,%xmm1
cmpl   $0x4,0x20(%rsp)
jb     1a4e <solve_Rappe+0x74e>
lea    (%r14,%rdx,8),%rax
cmp    %rax,%r12
jae    1ae2 <solve_Rappe+0x7e2>
lea    (%r12,%rdx,8),%rax
cmp    %rax,%r14
jae    1ae2 <solve_Rappe+0x7e2>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dl
je     1a7f <solve_Rappe+0x77f>
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xe0(%rsp),%rcx
je     1c10 <solve_Rappe+0x910>
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1a90 <solve_Rappe+0x790>
jmp    1c10 <solve_Rappe+0x910>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xc8(%rsp)
je     1e73 <solve_Rappe+0xb73>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r12,%rax,8)
movupd %xmm3,0x30(%r12,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm2
movupd 0x30(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r14,%rax,8)
movupd %xmm3,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b10 <solve_Rappe+0x810>
testb  $0x1,0xc0(%rsp)
01
je     1bf8 <solve_Rappe+0x8f8>
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
movupd (%r14,%rax,8),%xmm2
movupd 0x10(%r14,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r14,%rax,8)
movupd %xmm3,0x10(%r14,%rax,8)
mov    0xd0(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
jne    1a50 <solve_Rappe+0x750>
nopl   0x0(%rax)
movsd  (%rsi,%rbx,8),%xmm0
movaps %xmm0,0xa0(%rsp)
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  (%rdi,%rbx,8),%xmm0
movaps %xmm0,0x90(%rsp)
movsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,0x58(%rsp)
xor    %eax,%eax
call   11c0 <debug_print@plt>
test   %eax,%eax
mov    0x38(%rsp),%r14
je     1cb6 <solve_Rappe+0x9b6>
movapd 0x90(%rsp),%xmm5
divsd  0x58(%rsp),%xmm5
movapd 0x13b7(%rip),%xmm0
andpd  %xmm0,%xmm5
movapd 0xa0(%rsp),%xmm4
divsd  0x60(%rsp),%xmm4
andpd  %xmm0,%xmm4
mov    0x30(%rsp),%rax
mov    (%rax,%rbp,4),%esi
mov    0xf0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  (%r14,%rbx,8),%xmm1
movsd  0x0(%r13,%rbp,8),%xmm2
movsd  0x48(%rsp),%xmm3
lea    0x1381(%rip),%rdi
mov    $0x6,%al
call   1070 <printf@plt>
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x48(%rsp)
xor    %eax,%eax
call   1130 <psi_xpansion@plt>
xor    %eax,%eax
call   10d0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1160 <psp_xpansion@plt>
movsd  (%r15,%rbp,8),%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
jbe    14c0 <solve_Rappe+0x1c0>
movsd  0x48(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xe8(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0xe8(%rsp)
movsd  0x78(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x78(%rsp)
mov    0x20(%rsp),%rax
test   %eax,%eax
mov    0x10(%rsp),%rsi
mov    0x1a0(%rsp),%rdi
mov    0x130(%rsp),%rdx
jle    14c8 <solve_Rappe+0x1c8>
movsd  (%r12),%xmm1
divsd  (%r14),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
addsd  (%rdi),%xmm0
movsd  %xmm0,(%rdi)
cmp    $0x1,%eax
je     14c8 <solve_Rappe+0x1c8>
mov    $0x1,%eax
cmpq   $0x2,0xd8(%rsp)
jb     1e30 <solve_Rappe+0xb30>
lea    (%r15,%rbp,8),%r11
lea    (%r15,%rbp,8),%rcx
add    $0x8,%rcx
lea    0x8(%r12),%r8
lea    (%r12,%rsi,8),%r9
mov    0x128(%rsp),%rbx
cmp    %rcx,%rbx
setb   %r10b
mov    0x120(%rsp),%r13
cmp    %r13,%r11
setb   %cl
and    %r10b,%cl
cmp    %r9,%rbx
setb   %r9b
cmp    %r13,%r8
setb   %bl
and    %r9b,%bl
or     %cl,%bl
or     0x1f(%rsp),%bl
mov    0x28(%rsp),%r13
jne    1e30 <solve_Rappe+0xb30>
movsd  (%r15,%rbp,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%r12,%rax,8),%xmm1
movupd 0x8(%r14,%rax,8),%xmm2
divpd  %xmm2,%xmm1
mulpd  %xmm1,%xmm1
mulpd  %xmm0,%xmm1
movupd 0x8(%rdi,%rax,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1de0 <solve_Rappe+0xae0>
mov    0x118(%rsp),%rax
cmp    %rdx,0xd8(%rsp)
je     14c8 <solve_Rappe+0x1c8>
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm0
divsd  (%r14,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  (%r15,%rbp,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1e30 <solve_Rappe+0xb30>
jmp    14c8 <solve_Rappe+0x1c8>
xor    %ecx,%ecx
testb  $0x1,0xc0(%rsp)
01
jne    1794 <solve_Rappe+0x494>
jmp    17d0 <solve_Rappe+0x4d0>
xor    %eax,%eax
testb  $0x1,0xc0(%rsp)
01
jne    1bb4 <solve_Rappe+0x8b4>
jmp    1bf8 <solve_Rappe+0x8f8>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x1a0(%rsp),%rdi
mov    0x1b8(%rsp),%r12
xor    %eax,%eax
mov    %rdi,%rbx
call   11d0 <alloc_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   11d0 <alloc_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   11d0 <alloc_LogGrid@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
movsd  0x78(%rsp),%xmm0
mov    %r13,%rsi
mov    $0x1,%al
call   1140 <R_Hartree_DFT@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   11d0 <alloc_LogGrid@plt>
movslq %r15d,%rbx
movslq %ebp,%r15
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0x111c(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movslq %eax,%r14
mov    0x20(%rsp),%rcx
test   %ecx,%ecx
movsd  %xmm0,0x38(%rsp)
jle    1f31 <solve_Rappe+0xc31>
mov    0x1a8(%rsp),%rax
cmp    $0x4,%ecx
jae    1f70 <solve_Rappe+0xc70>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    0x1a0(%rsp),%rbp
jmp    208f <solve_Rappe+0xd8f>
lea    0x108(%rsp),%rdx
lea    0x80(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10e0 <R_Exchange_DFT@plt>
lea    0x100(%rsp),%rdx
lea    0x110(%rsp),%rcx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1210 <R_Correlation_DFT@plt>
jmp    2193 <solve_Rappe+0xe93>
mov    0x10(%rsp),%r9
lea    (%r14,%r9,8),%rcx
mov    0x1a0(%rsp),%rbp
lea    0x0(,%r9,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%r14
setb   %dil
cmp    %rbp,%rcx
seta   %r8b
lea    (%rax,%r9,8),%rdx
cmp    %rdx,%r14
setb   %dl
cmp    %rax,%rcx
seta   %sil
xor    %ecx,%ecx
test   %r8b,%dil
jne    208f <solve_Rappe+0xd8f>
and    %sil,%dl
jne    208f <solve_Rappe+0xd8f>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2849 <solve_Rappe+0x1549>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movupd (%rax,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdx,8)
movupd %xmm0,0x10(%r14,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm0
movupd 0x30(%rbp,%rdx,8),%xmm1
movupd 0x20(%rax,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rax,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rdx,8)
movupd %xmm0,0x30(%r14,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1ff0 <solve_Rappe+0xcf0>
test   $0x1,%sil
je     2086 <solve_Rappe+0xd86>
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movupd (%rax,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rdx,8)
movupd %xmm0,0x10(%r14,%rdx,8)
cmp    %r9,%rcx
je     2133 <solve_Rappe+0xe33>
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     20cb <solve_Rappe+0xdcb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    20b0 <solve_Rappe+0xdb0>
cmp    $0x3,%rdx
jb     2133 <solve_Rappe+0xe33>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
addsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
addsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    20e0 <solve_Rappe+0xde0>
lea    0x108(%rsp),%rdx
lea    0x80(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10e0 <R_Exchange_DFT@plt>
lea    0x100(%rsp),%rdx
lea    0x110(%rsp),%rcx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1210 <R_Correlation_DFT@plt>
cmpl   $0x0,0x20(%rsp)
jle    2193 <solve_Rappe+0xe93>
cmpl   $0x4,0x20(%rsp)
jae    2494 <solve_Rappe+0x1194>
xor    %eax,%eax
mov    0x10(%rsp),%rdi
mov    0x1a0(%rsp),%rbp
jmp    25ae <solve_Rappe+0x12ae>
mov    %r14,%rdi
xor    %eax,%eax
call   1120 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x80(%rsp)
mov    %r14,%rdi
xor    %eax,%eax
call   1120 <Integrate_LogGrid@plt>
mov    0x10(%rsp),%rbp
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x110(%rsp)
movsd  0xe8(%rsp),%xmm4
movsd  0x30(%rsp),%xmm6
addsd  %xmm6,%xmm4
movsd  0x108(%rsp),%xmm1
addsd  %xmm1,%xmm4
movsd  0x100(%rsp),%xmm2
addsd  %xmm2,%xmm4
movsd  0x38(%rsp),%xmm5
subsd  %xmm5,%xmm4
movsd  0x80(%rsp),%xmm3
subsd  %xmm3,%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,(%r12)
mov    0x1c0(%rsp),%rax
movsd  %xmm6,(%rax)
mov    0x1c8(%rsp),%rax
movsd  %xmm5,(%rax)
mov    0x1d0(%rsp),%rax
movsd  %xmm1,(%rax)
mov    0x1d8(%rsp),%rax
movsd  %xmm3,(%rax)
mov    0x1e0(%rsp),%rax
movsd  %xmm2,(%rax)
mov    0x1e8(%rsp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x0,0x74(%rsp)
mov    0x20(%rsp),%r8
jle    245a <solve_Rappe+0x115a>
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
mov    %rax,0x30(%rsp)
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x68(%rsp)
lea    (%r15,%rbp,8),%rax
mov    %rax,0x40(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0xa0(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x38(%rsp)
lea    0x0(,%rbp,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %ecx,%ecx
jmp    22d2 <solve_Rappe+0xfd2>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0xf8(%rsp),%rcx
je     245a <solve_Rappe+0x115a>
test   %r8d,%r8d
jle    22c0 <solve_Rappe+0xfc0>
mov    0x1b0(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
cmp    $0x4,%r8d
jae    22f0 <solve_Rappe+0xff0>
xor    %edi,%edi
jmp    23d0 <solve_Rappe+0x10d0>
lea    (%rdx,%rbp,8),%rsi
cmp    0x30(%rsp),%rdx
setb   %r10b
cmp    %rsi,%r13
setb   %r11b
cmp    0x68(%rsp),%rdx
setb   %dil
cmp    %rsi,%rbx
setb   %r8b
cmp    0x40(%rsp),%rdx
setb   %r9b
cmp    %rsi,%r15
setb   %r12b
test   %r11b,%r10b
jne    23c3 <solve_Rappe+0x10c3>
and    %r8b,%dil
jne    23c3 <solve_Rappe+0x10c3>
mov    $0x0,%edi
and    %r12b,%r9b
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%rbp
jne    23d0 <solve_Rappe+0x10d0>
xor    %esi,%esi
movupd (%rdx,%rsi,1),%xmm0
movupd 0x10(%rdx,%rsi,1),%xmm1
movupd 0x0(%r13,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r13,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm1,0x10(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    2350 <solve_Rappe+0x1050>
mov    0xa0(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     22c0 <solve_Rappe+0xfc0>
jmp    23d0 <solve_Rappe+0x10d0>
xor    %edi,%edi
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%rbp
nop
mov    %rdi,%rsi
test   $0x1,%bpl
je     23fc <solve_Rappe+0x10fc>
movsd  (%rdx,%rdi,8),%xmm0
subsd  0x0(%r13,%rdi,8),%xmm0
subsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x38(%rsp),%rdi
je     22c0 <solve_Rappe+0xfc0>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
subsd  0x0(%r13,%rsi,8),%xmm0
subsd  (%rbx,%rsi,8),%xmm0
subsd  (%r15,%rsi,8),%xmm0
movsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm0,(%rdx,%rsi,8)
subsd  0x8(%r13,%rsi,8),%xmm1
subsd  0x8(%rbx,%rsi,8),%xmm1
subsd  0x8(%r15,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    2410 <solve_Rappe+0x1110>
jmp    22c0 <solve_Rappe+0xfc0>
mov    %r13,%rdi
xor    %eax,%eax
call   11b0 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   11b0 <dealloc_LogGrid@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   11b0 <dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   11b0 <dealloc_LogGrid@plt>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%rdi
lea    (%r14,%rdi,8),%rax
mov    0x1a0(%rsp),%rbp
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%rbx,%rdi,8),%rdx
cmp    %rcx,%r14
setb   %sil
cmp    %rbp,%rax
seta   %r8b
cmp    %rdx,%r14
setb   %cl
cmp    %rax,%rbx
setb   %dl
xor    %eax,%eax
test   %r8b,%sil
jne    25ae <solve_Rappe+0x12ae>
and    %dl,%cl
jne    25ae <solve_Rappe+0x12ae>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     285a <solve_Rappe+0x155a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rcx,8)
movupd %xmm0,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2510 <solve_Rappe+0x1210>
test   $0x1,%dl
je     25a5 <solve_Rappe+0x12a5>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
cmp    %rdi,%rax
je     2643 <solve_Rappe+0x1343>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     25db <solve_Rappe+0x12db>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    25c0 <solve_Rappe+0x12c0>
cmp    $0x3,%rcx
jb     2643 <solve_Rappe+0x1343>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
mulsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    25f0 <solve_Rappe+0x12f0>
mov    %r14,%rdi
xor    %eax,%eax
call   1120 <Integrate_LogGrid@plt>
mov    0x1a0(%rsp),%rbp
mov    0x10(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x80(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    21ad <solve_Rappe+0xead>
cmpl   $0x4,0x20(%rsp)
jae    272c <solve_Rappe+0x142c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     26bc <solve_Rappe+0x13bc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    26a0 <solve_Rappe+0x13a0>
cmp    $0x3,%rcx
jb     21ad <solve_Rappe+0xead>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
mulsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    26d0 <solve_Rappe+0x13d0>
jmp    21ad <solve_Rappe+0xead>
lea    (%r14,%rdi,8),%rax
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%r15,%rdi,8),%rdx
cmp    %rcx,%r14
setb   %sil
cmp    %rbp,%rax
seta   %r8b
cmp    %rdx,%r14
setb   %cl
cmp    %rax,%r15
setb   %dl
xor    %eax,%eax
test   %r8b,%sil
jne    2682 <solve_Rappe+0x1382>
and    %dl,%cl
jne    2682 <solve_Rappe+0x1382>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     286a <solve_Rappe+0x156a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rcx,8)
movupd %xmm0,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    27a0 <solve_Rappe+0x14a0>
test   $0x1,%dl
je     283b <solve_Rappe+0x153b>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
cmp    %rdi,%rax
je     21ad <solve_Rappe+0xead>
jmp    2682 <solve_Rappe+0x1382>
xor    %edx,%edx
test   $0x1,%sil
jne    205a <solve_Rappe+0xd5a>
jmp    2086 <solve_Rappe+0xd86>
xor    %ecx,%ecx
test   $0x1,%dl
jne    2579 <solve_Rappe+0x1279>
jmp    25a5 <solve_Rappe+0x12a5>
xor    %ecx,%ecx
test   $0x1,%dl
jne    280d <solve_Rappe+0x150d>
jmp    283b <solve_Rappe+0x153b>

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

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