void solve_Troullier(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,
                     kb_expansion, r_psi_extra, r_psi_prime_extra) 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 kb_expansion[];
double **r_psi_extra;
double **r_psi_prime_extra;
{
  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();
  eeig = 0.0;
  Zion = 0.0;
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = 0.0;
  if (debug_print()) {
    printf("\n\nTroullier 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 = 20.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];
    if (ul[match] < 0.0) {
      nu0 = -1.0;
      for (i = 0; i < Ngrid; ++i) {
        ul[i] = ul[i] * nu0;
        ul_prime[i] = ul_prime[i] * nu0;
      }
    }
    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 = 20.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);
    }
  }
  if (debug_print()) {
    printf("\n\nTroullier pseudopotential extra states\n\n");
    printf("l\tn\tE psp\n");
  }
  i = 0;
  for (l = 0; l < num_psp; ++l) {
    Vl = V_psp[l];
    el = e_psp[l] + 0.1;
    for (k = 0; k < (kb_expansion[l_psp[l]] - 1); ++k) {
      wl = r_psi_extra[i];
      wl_prime = r_psi_prime_extra[i];
      R_Schrodinger(l_psp[l] + 2 + k, l_psp[l], Vl, &mch, &el, wl, wl_prime);
      ++i;
      if (debug_print())
        printf("%d\t%d\t%lf\n", l_psp[l], l_psp[l] + 2 + k, el);
    }
  }
  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);
  R_Screening_Cut(Vx);
  R_Screening_Cut(Vc);
  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_Troullier>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
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   10b0 <Vall_Atom@plt>
cltq
mov    %rax,-0x120(%rbp)
mov    $0x0,%al
call   1100 <r_LogGrid@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   1220 <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   11f0 <amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13ef <solve_Troullier+0xef>
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    13c5 <solve_Troullier+0xc5>
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     141b <solve_Troullier+0x11b>
lea    0x1c3a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1c50(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b8b <solve_Troullier+0x88b>
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    15f8 <solve_Troullier+0x2f8>
jp     15f8 <solve_Troullier+0x2f8>
movsd  0x1b89(%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   1090 <Nvalence_Atom@plt>
mov    %eax,-0x12c(%rbp)
mov    $0x0,%al
call   10f0 <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   1160 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   10a0 <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  0x1ad0(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rsi
mov    $0x1,%al
call   1140 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   11a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x1a9a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    15f3 <solve_Troullier+0x2f3>
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    1589 <solve_Troullier+0x289>
jmp    1618 <solve_Troullier+0x318>
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   11e0 <state_Atom@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   10a0 <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   1160 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10e0 <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    -0xd8(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1748 <solve_Troullier+0x448>
movsd  0x1956(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1743 <solve_Troullier+0x443>
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    16d9 <solve_Troullier+0x3d9>
jmp    1748 <solve_Troullier+0x448>
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   1180 <init_xpansion@plt>
mov    $0x0,%al
call   1120 <psi_xpansion@plt>
mov    $0x0,%al
call   10c0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1150 <psp_xpansion@plt>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1815 <solve_Troullier+0x515>
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   1190 <R_Schrodinger@plt>
jmp    199e <solve_Troullier+0x69e>
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   1080 <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   1200 <R_Schrodinger_Fixed_E@plt>
movsd  0x176d(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x58(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  0x172a(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rsi
mov    $0x1,%al
call   1140 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   11a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x16f4(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1999 <solve_Troullier+0x699>
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    192f <solve_Troullier+0x62f>
jmp    199e <solve_Troullier+0x69e>
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 0x166b(%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 0x163b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     1a63 <solve_Troullier+0x763>
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    0x164a(%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   1120 <psi_xpansion@plt>
mov    $0x0,%al
call   10c0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1150 <psp_xpansion@plt>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b78 <solve_Troullier+0x878>
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    1b73 <solve_Troullier+0x873>
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  0x14ed(%rip),%xmm1
call   1170 <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    1af2 <solve_Troullier+0x7f2>
jmp    1b78 <solve_Troullier+0x878>
jmp    1b7d <solve_Troullier+0x87d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1422 <solve_Troullier+0x122>
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     1bb7 <solve_Troullier+0x8b7>
lea    0x1525(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1542(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d0a <solve_Troullier+0xa0a>
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x128(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x1414(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x70(%rbp),%rcx
mov    -0x18(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1cf7 <solve_Troullier+0x9f7>
mov    0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
mov    0x80(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x2,%edi
add    -0x40(%rbp),%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   1190 <R_Schrodinger@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     1ce4 <solve_Troullier+0x9e4>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x2,%edx
add    -0x40(%rbp),%edx
movsd  -0x98(%rbp),%xmm0
ff
lea    0x1420(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
jmp    1ce9 <solve_Troullier+0x9e9>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c08 <solve_Troullier+0x908>
jmp    1cfc <solve_Troullier+0x9fc>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1bc5 <solve_Troullier+0x8c5>
mov    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    0x20(%rbp),%rdi
movsd  -0x70(%rbp),%xmm0
mov    -0x100(%rbp),%rsi
mov    $0x1,%al
call   1130 <R_Hartree_DFT@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x129b(%rip),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1dd0 <solve_Troullier+0xad0>
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    1d8c <solve_Troullier+0xa8c>
mov    -0x118(%rbp),%rdi
mov    -0x108(%rbp),%rsi
lea    -0xc8(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
mov    $0x0,%al
call   10d0 <R_Exchange_DFT@plt>
mov    -0x118(%rbp),%rdi
mov    -0x110(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0xb8(%rbp),%rcx
mov    $0x0,%al
call   1210 <R_Correlation_DFT@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   1070 <R_Screening_Cut@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   1070 <R_Screening_Cut@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1e80 <solve_Troullier+0xb80>
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    1e39 <solve_Troullier+0xb39>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   1110 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1ee8 <solve_Troullier+0xbe8>
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    1ea1 <solve_Troullier+0xba1>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   1110 <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    2043 <solve_Troullier+0xd43>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    2030 <solve_Troullier+0xd30>
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    1fbc <solve_Troullier+0xcbc>
jmp    2035 <solve_Troullier+0xd35>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fa9 <solve_Troullier+0xca9>
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   11b0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   11b0 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   11b0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   11b0 <dealloc_LogGrid@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_Troullier>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0x100(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x148(%rsp)
mov    %edi,0x54(%rsp)
mov    0x1a0(%rsp),%r13
xor    %eax,%eax
call   10d0 <Vall_Atom@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1120 <r_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1230 <N_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1050 <log_amesh_LogGrid@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1200 <amesh_LogGrid@plt>
mov    %ebp,%ebx
mov    %rbp,0x20(%rsp)
test   %ebp,%ebp
jle    1397 <solve_Troullier+0x87>
lea    0x0(,%rbx,8),%rdx
mov    %r13,%rdi
xor    %esi,%esi
call   10c0 <memset@plt>
mov    %rbx,0x18(%rsp)
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
je     13bf <solve_Troullier+0xaf>
lea    0x1d02(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d19(%rip),%rdi
call   1040 <puts@plt>
mov    0x54(%rsp),%ecx
mov    %ecx,%eax
mov    %rax,0xe8(%rsp)
test   %ecx,%ecx
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rcx
mov    0x38(%rsp),%rbx
jle    20ce <solve_Troullier+0xdbe>
movslq %r14d,%rax
mov    %rax,0x140(%rsp)
cvtsi2sd %r12d,%xmm0
movsd  %xmm0,0xe0(%rsp)
movslq %r15d,%r12
mov    0x1a0(%rsp),%rax
lea    0x8(%rax),%rdi
lea    (%rax,%rcx,8),%rdx
lea    0x8(%r12),%r9
lea    (%r12,%rcx,8),%r10
lea    -0x1(%rcx),%rbp
mov    %ecx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc0(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,%rsi
mov    %rax,0xb0(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0xa8(%rsp)
neg    %rcx
mov    %rcx,0xc8(%rsp)
mov    %rdi,0x130(%rsp)
cmp    %r10,%rdi
setb   %cl
mov    %rdx,0x128(%rsp)
cmp    %rdx,%r9
setb   %al
and    %cl,%al
mov    %al,0x2f(%rsp)
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rbp,0xf8(%rsp)
or     $0x1,%rbp
mov    %rbp,0x120(%rsp)
xorpd  %xmm3,%xmm3
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x80(%rsp)
lea    -0x1(%r8),%eax
mov    %eax,0xf0(%rsp)
xor    %r15d,%r15d
mov    0x48(%rsp),%r14
mov    %r12,0x70(%rsp)
mov    %rdx,0x138(%rsp)
jmp    14f2 <solve_Troullier+0x1e2>
nopl   (%rax)
add    $0x1,%r15
cmp    0xe8(%rsp),%r15
je     20ea <solve_Troullier+0xdda>
mov    0x190(%rsp),%rax
mov    (%rax,%r15,8),%r13
mov    0x198(%rsp),%rax
mov    (%rax,%r15,8),%rbp
mov    0x1b0(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    %rax,0x60(%rsp)
movsd  (%rbx,%r15,8),%xmm0
ucomisd %xmm3,%xmm0
mov    0x148(%rsp),%rax
mov    (%rax,%r15,4),%edi
mov    0x58(%rsp),%rax
mov    (%rax,%r15,4),%esi
mov    %r15,0x90(%rsp)
jne    1600 <solve_Troullier+0x2f0>
jp     1600 <solve_Troullier+0x2f0>
movsd  (%r14,%r15,8),%xmm0
movsd  0x1aa4(%rip),%xmm1
mov    $0x2,%al
call   1030 <solve_Scattering_State_Atom@plt>
xor    %eax,%eax
call   10a0 <Nvalence_Atom@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1110 <Ncore_Atom@plt>
mov    %eax,%r14d
add    %ebx,%r14d
movsd  0x1a7f(%rip),%xmm0
divsd  (%r12),%xmm0
call   1180 <log@plt>
divsd  0xe0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x44(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   10b0 <r_psi_Atom@plt>
movslq %eax,%rbx
mov    %r14d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
mov    %eax,%r12d
mov    0x44(%rsp),%edi
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
addsd  0x1a38(%rip),%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1160 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x1a37(%rip),%xmm0
jb     1610 <solve_Troullier+0x300>
sqrtsd %xmm0,%xmm0
jmp    1615 <solve_Troullier+0x305>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   11f0 <state_Atom@plt>
mov    %eax,%r14d
jmp    1805 <solve_Troullier+0x4f5>
nop
call   11b0 <sqrt@plt>
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rsi
test   %ecx,%ecx
jle    1800 <solve_Troullier+0x4f0>
movslq %r12d,%rax
movsd  0x19d6(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x4,%ecx
jb     1655 <solve_Troullier+0x345>
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%rbx
jae    16ea <solve_Troullier+0x3da>
lea    (%rbx,%rsi,8),%rcx
cmp    %rcx,%rax
jae    16ea <solve_Troullier+0x3da>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%sil
je     1683 <solve_Troullier+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    0xc8(%rsp),%rdx
je     1800 <solve_Troullier+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    16a0 <solve_Troullier+0x390>
jmp    1800 <solve_Troullier+0x4f0>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xb8(%rsp)
je     20a4 <solve_Troullier+0xd94>
mov    0xa8(%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    1710 <solve_Troullier+0x400>
testb  $0x1,0xb0(%rsp)
01
je     17e0 <solve_Troullier+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    0xc0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1657 <solve_Troullier+0x347>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x38(%rsp),%rbx
mov    %r14d,%edi
xor    %eax,%eax
call   10b0 <r_psi_Atom@plt>
movslq %eax,%r12
mov    %r14d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
movslq %eax,%r14
mov    0x48(%rsp),%rax
mov    0x90(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    0x100(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rsp),%rax
divsd  (%rax),%xmm0
call   1180 <log@plt>
divsd  0xe0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%esi
movslq %esi,%rax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0xd8(%rsp)
mov    %rax,0x150(%rsp)
movsd  (%r12,%rax,8),%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm1,0xd0(%rsp)
ucomisd %xmm1,%xmm0
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%rdx
movapd 0x1789(%rip),%xmm2
mov    0x60(%rsp),%r9
jbe    1aa0 <solve_Troullier+0x790>
test   %eax,%eax
jle    1aa0 <solve_Troullier+0x790>
cmp    $0x4,%eax
jb     18d9 <solve_Troullier+0x5c9>
lea    (%r14,%rdx,8),%rax
cmp    %rax,%r12
jae    1972 <solve_Troullier+0x662>
lea    (%r12,%rdx,8),%rax
cmp    %rax,%r14
jae    1972 <solve_Troullier+0x662>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dl
je     190a <solve_Troullier+0x5fa>
movsd  (%r12,%rcx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r12,%rcx,8)
movsd  (%r14,%rcx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r14,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xc8(%rsp),%rcx
je     1aa0 <solve_Troullier+0x790>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r12,%rax,8)
movsd  (%r14,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r14,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%r12,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1920 <solve_Troullier+0x610>
jmp    1aa0 <solve_Troullier+0x790>
cmpq   $0x0,0xb8(%rsp)
movapd 0x16ad(%rip),%xmm3
je     208f <solve_Troullier+0xd7f>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm0
movupd 0x30(%r12,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r12,%rax,8)
movupd %xmm1,0x30(%r12,%rax,8)
movupd 0x20(%r14,%rax,8),%xmm0
movupd 0x30(%r14,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r14,%rax,8)
movupd %xmm1,0x30(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    19a0 <solve_Troullier+0x690>
testb  $0x1,0xb0(%rsp)
01
je     1a88 <solve_Troullier+0x778>
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
mov    0xc0(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
jne    18db <solve_Troullier+0x5cb>
nopl   0x0(%rax)
mov    0x90(%rsp),%r15
movsd  (%rbx,%r15,8),%xmm0
movsd  0x30(%rsp),%xmm1
mov    %rbp,0x8(%rsp)
mov    %r13,(%rsp)
mov    %r15d,%edi
mov    %esi,0xf4(%rsp)
mov    0x140(%rsp),%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    $0x2,%al
call   1190 <init_xpansion@plt>
xor    %eax,%eax
call   1140 <psi_xpansion@plt>
xor    %eax,%eax
call   10e0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1170 <psp_xpansion@plt>
movsd  (%rbx,%r15,8),%xmm0
mov    0x58(%rsp),%rbx
mov    (%rbx,%r15,4),%esi
lea    0x1(%rsi),%edi
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b40 <solve_Troullier+0x830>
mov    %rbp,(%rsp)
mov    0x60(%rsp),%rdx
lea    0x44(%rsp),%rcx
lea    0x30(%rsp),%r8
mov    %r13,%r9
xor    %eax,%eax
call   11a0 <R_Schrodinger@plt>
mov    0x38(%rsp),%rbx
jmp    1e20 <solve_Troullier+0xb10>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0xd8(%rsp),%xmm0
divsd  0xd0(%rsp),%xmm0
mov    %rbp,(%rsp)
mov    0x60(%rsp),%rdx
mov    0xf4(%rsp),%ecx
lea    0x30(%rsp),%r8
mov    %r13,%r9
mov    $0x1,%al
call   1090 <R_Schrodinger_Fixed_Logderiv@plt>
mov    (%rbx,%r15,4),%esi
lea    0x1(%rsi),%edi
movsd  0x30(%rsp),%xmm0
mov    0x60(%rsp),%rdx
mov    0xf0(%rsp),%ecx
mov    %r13,%r8
mov    %rbp,%r9
mov    $0x1,%al
call   1210 <R_Schrodinger_Fixed_E@plt>
movsd  0x1461(%rip),%xmm0
mov    0x70(%rsp),%rax
divsd  (%rax),%xmm0
call   1180 <log@plt>
divsd  0xe0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%edi
mov    %edi,0x44(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
addsd  0x1435(%rip),%xmm0
mov    %r13,%rsi
mov    $0x1,%al
call   1160 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x1434(%rip),%xmm0
jb     1c00 <solve_Troullier+0x8f0>
sqrtsd %xmm0,%xmm0
jmp    1c05 <solve_Troullier+0x8f5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   11b0 <sqrt@plt>
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%rdx
mov    0x38(%rsp),%rbx
test   %eax,%eax
jle    1e20 <solve_Troullier+0xb10>
movsd  0x13e4(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x4,%eax
jb     1c55 <solve_Troullier+0x945>
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
cmp    %rax,%r13
jae    1cf2 <solve_Troullier+0x9e2>
lea    0x0(,%rdx,8),%rax
add    %r13,%rax
cmp    %rax,%rbp
jae    1cf2 <solve_Troullier+0x9e2>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dl
je     1c88 <solve_Troullier+0x978>
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xc8(%rsp),%rcx
je     1e20 <solve_Troullier+0xb10>
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1ca0 <solve_Troullier+0x990>
jmp    1e20 <solve_Troullier+0xb10>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xb8(%rsp)
je     20b9 <solve_Troullier+0xda9>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%r13,%rax,8),%xmm2
movupd 0x10(%r13,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
movupd 0x20(%r13,%rax,8),%xmm2
movupd 0x30(%r13,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r13,%rax,8)
movupd %xmm3,0x30(%r13,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm2
movupd 0x30(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%rbp,%rax,8)
movupd %xmm3,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d20 <solve_Troullier+0xa10>
testb  $0x1,0xb0(%rsp)
01
je     1e04 <solve_Troullier+0xaf4>
movupd 0x0(%r13,%rax,8),%xmm2
movupd 0x10(%r13,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm3,0x10(%r13,%rax,8)
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x0(%rbp,%rax,8)
movupd %xmm3,0x10(%rbp,%rax,8)
mov    0xc0(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
jne    1c57 <solve_Troullier+0x947>
nopl   0x0(%rax,%rax,1)
mov    0x150(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
movaps %xmm0,0x60(%rsp)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0xd8(%rsp)
movsd  (%r14,%rax,8),%xmm0
movaps %xmm0,0x90(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    %rax,%rbp
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
mov    0x48(%rsp),%r14
mov    0x70(%rsp),%r12
je     1ee0 <solve_Troullier+0xbd0>
movapd 0x90(%rsp),%xmm5
divsd  0xd0(%rsp),%xmm5
movapd 0x11ae(%rip),%xmm0
andpd  %xmm0,%xmm5
movapd 0x60(%rsp),%xmm4
divsd  0xd8(%rsp),%xmm4
andpd  %xmm0,%xmm4
mov    0x58(%rsp),%rax
mov    (%rax,%r15,4),%esi
mov    0x100(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
movsd  (%r12,%rbp,8),%xmm1
movsd  (%r14,%r15,8),%xmm2
movsd  0x30(%rsp),%xmm3
lea    0x1177(%rip),%rdi
mov    $0x6,%al
call   1070 <printf@plt>
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
call   1140 <psi_xpansion@plt>
xor    %eax,%eax
call   10e0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1170 <psp_xpansion@plt>
movsd  (%rbx,%r15,8),%xmm0
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jbe    14e0 <solve_Troullier+0x1d0>
movsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x80(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x80(%rsp)
movsd  0x78(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x78(%rsp)
mov    0x20(%rsp),%rax
test   %eax,%eax
mov    0x18(%rsp),%rbp
mov    0x1a0(%rsp),%rsi
mov    0x138(%rsp),%rdx
jle    14e0 <solve_Troullier+0x1d0>
movsd  0x0(%r13),%xmm1
divsd  (%r12),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
addsd  (%rsi),%xmm0
movsd  %xmm0,(%rsi)
cmp    $0x1,%eax
je     14e0 <solve_Troullier+0x1d0>
mov    $0x1,%eax
cmpq   $0x2,0xf8(%rsp)
jb     2060 <solve_Troullier+0xd50>
lea    (%rbx,%r15,8),%rcx
lea    (%rbx,%r15,8),%rdi
add    $0x8,%rdi
lea    0x8(%r13),%r8
lea    0x0(,%rbp,8),%r9
add    %r13,%r9
mov    0x130(%rsp),%rbx
cmp    %rdi,%rbx
setb   %r10b
mov    0x128(%rsp),%rdi
cmp    %rdi,%rcx
setb   %cl
and    %r10b,%cl
cmp    %r9,%rbx
setb   %r9b
cmp    %rdi,%r8
setb   %bl
and    %r9b,%bl
or     %cl,%bl
or     0x2f(%rsp),%bl
mov    0x38(%rsp),%rbx
jne    2060 <solve_Troullier+0xd50>
movsd  (%rbx,%r15,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%r13,%rax,8),%xmm1
movupd 0x8(%r12,%rax,8),%xmm2
divpd  %xmm2,%xmm1
mulpd  %xmm1,%xmm1
mulpd  %xmm0,%xmm1
movupd 0x8(%rsi,%rax,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    2010 <solve_Troullier+0xd00>
mov    0x120(%rsp),%rax
cmp    %rdx,0xf8(%rsp)
je     14e0 <solve_Troullier+0x1d0>
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
divsd  (%r12,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  (%rbx,%r15,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    2060 <solve_Troullier+0xd50>
jmp    14e0 <solve_Troullier+0x1d0>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    1a44 <solve_Troullier+0x734>
jmp    1a88 <solve_Troullier+0x778>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    17a4 <solve_Troullier+0x494>
jmp    17e0 <solve_Troullier+0x4d0>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    1dc0 <solve_Troullier+0xab0>
jmp    1e04 <solve_Troullier+0xaf4>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x80(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x48(%rsp),%r14
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
je     210d <solve_Troullier+0xdfd>
lea    0xf80(%rip),%rdi
call   1040 <puts@plt>
lea    0xf9e(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x54(%rsp)
mov    0x58(%rsp),%r12
jle    2223 <solve_Troullier+0xf13>
movsd  0xeeb(%rip),%xmm1
xor    %r13d,%r13d
xor    %edx,%edx
jmp    2156 <solve_Troullier+0xe46>
nopl   0x0(%rax)
mov    0x60(%rsp),%edx
add    %r14d,%edx
mov    0x48(%rsp),%r14
movsd  0xecc(%rip),%xmm1
add    $0x1,%r13
cmp    0xe8(%rsp),%r13
je     2223 <solve_Troullier+0xf13>
mov    0x1b0(%rsp),%rax
mov    (%rax,%r13,8),%rbx
movsd  (%r14,%r13,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rsp)
movslq (%r12,%r13,4),%rsi
mov    0x1f0(%rsp),%rax
cmpl   $0x2,(%rax,%rsi,4)
jl     2144 <solve_Troullier+0xe34>
mov    %edx,0x60(%rsp)
movslq %edx,%rax
mov    0x1f8(%rsp),%rdx
lea    (%rdx,%rax,8),%r15
mov    0x200(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
xor    %r14d,%r14d
jmp    21cf <solve_Troullier+0xebf>
nopl   0x0(%rax,%rax,1)
movslq (%r12,%r13,4),%rsi
mov    0x1f0(%rsp),%rax
mov    (%rax,%rsi,4),%eax
add    $0xffffffff,%eax
add    $0x1,%r14
cmp    %eax,%r14d
jge    2130 <solve_Troullier+0xe20>
mov    (%r15,%r14,8),%r9
mov    0x0(%rbp,%r14,8),%rax
lea    (%r14,%rsi,1),%edi
add    $0x2,%edi
mov    %rax,(%rsp)
mov    %rbx,%rdx
lea    0x44(%rsp),%rcx
lea    0x30(%rsp),%r8
xor    %eax,%eax
call   11a0 <R_Schrodinger@plt>
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
je     21b0 <solve_Troullier+0xea0>
mov    (%r12,%r13,4),%esi
lea    (%r14,%rsi,1),%edx
add    $0x2,%edx
movsd  0x30(%rsp),%xmm0
lea    0xe57(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
jmp    21b0 <solve_Troullier+0xea0>
mov    0x1b8(%rsp),%r13
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r15
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
mov    %eax,%ebp
mov    0x1a0(%rsp),%rdi
movsd  0x78(%rsp),%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1150 <R_Hartree_DFT@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %ebx,%rbx
movslq %ebp,%r12
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0xd99(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x90(%rsp)
movslq %eax,%r14
mov    0x20(%rsp),%rcx
test   %ecx,%ecx
movsd  %xmm0,0x60(%rsp)
jle    22bf <solve_Troullier+0xfaf>
mov    0x1a8(%rsp),%rax
cmp    $0x4,%ecx
jae    2312 <solve_Troullier+0x1002>
xor    %ecx,%ecx
mov    0x18(%rsp),%r9
mov    0x1a0(%rsp),%rbp
jmp    242f <solve_Troullier+0x111f>
lea    0x110(%rsp),%rdx
lea    0x88(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10f0 <R_Exchange_DFT@plt>
lea    0x108(%rsp),%rdx
lea    0x118(%rsp),%rcx
mov    %r14,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1220 <R_Correlation_DFT@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <R_Screening_Cut@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1080 <R_Screening_Cut@plt>
jmp    2547 <solve_Troullier+0x1237>
mov    0x18(%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    242f <solve_Troullier+0x111f>
and    %sil,%dl
jne    242f <solve_Troullier+0x111f>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2c09 <solve_Troullier+0x18f9>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   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    2390 <solve_Troullier+0x1080>
test   $0x1,%sil
je     2426 <solve_Troullier+0x1116>
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     24d3 <solve_Troullier+0x11c3>
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     246b <solve_Troullier+0x115b>
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    2450 <solve_Troullier+0x1140>
cmp    $0x3,%rdx
jb     24d3 <solve_Troullier+0x11c3>
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    2480 <solve_Troullier+0x1170>
lea    0x110(%rsp),%rdx
lea    0x88(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10f0 <R_Exchange_DFT@plt>
lea    0x108(%rsp),%rdx
lea    0x118(%rsp),%rcx
mov    %r14,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1220 <R_Correlation_DFT@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <R_Screening_Cut@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1080 <R_Screening_Cut@plt>
mov    0x20(%rsp),%rax
test   %eax,%eax
jle    2547 <solve_Troullier+0x1237>
cmp    $0x4,%eax
jae    2853 <solve_Troullier+0x1543>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x1a0(%rsp),%rbp
jmp    296e <solve_Troullier+0x165e>
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x88(%rsp)
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
mov    0x18(%rsp),%rbp
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x118(%rsp)
movsd  0x80(%rsp),%xmm4
movsd  0x90(%rsp),%xmm6
addsd  %xmm6,%xmm4
movsd  0x110(%rsp),%xmm1
addsd  %xmm1,%xmm4
movsd  0x108(%rsp),%xmm2
addsd  %xmm2,%xmm4
movsd  0x60(%rsp),%xmm5
subsd  %xmm5,%xmm4
movsd  0x88(%rsp),%xmm3
subsd  %xmm3,%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,0x0(%r13)
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,0x54(%rsp)
mov    0x20(%rsp),%r8
jle    2819 <solve_Troullier+0x1509>
lea    (%r15,%rbp,8),%rax
mov    %rax,0x90(%rsp)
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x58(%rsp)
lea    (%r12,%rbp,8),%rax
mov    %rax,0x48(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x70(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x60(%rsp)
lea    0x0(,%rbp,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %ecx,%ecx
jmp    2682 <solve_Troullier+0x1372>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0xe8(%rsp),%rcx
je     2819 <solve_Troullier+0x1509>
test   %r8d,%r8d
jle    2670 <solve_Troullier+0x1360>
mov    0x1b0(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
cmp    $0x4,%r8d
jae    26a0 <solve_Troullier+0x1390>
xor    %edi,%edi
jmp    2790 <solve_Troullier+0x1480>
lea    (%rdx,%rbp,8),%rsi
cmp    0x90(%rsp),%rdx
setb   %r10b
cmp    %rsi,%r15
setb   %r11b
cmp    0x58(%rsp),%rdx
setb   %dil
cmp    %rsi,%rbx
setb   %r8b
cmp    0x48(%rsp),%rdx
setb   %r9b
cmp    %rsi,%r12
setb   %r13b
test   %r11b,%r10b
jne    277f <solve_Troullier+0x146f>
and    %r8b,%dil
jne    277f <solve_Troullier+0x146f>
mov    $0x0,%edi
and    %r13b,%r9b
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rbp
jne    2790 <solve_Troullier+0x1480>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rdx,%rsi,1),%xmm0
movupd 0x10(%rdx,%rsi,1),%xmm1
movupd (%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%r12,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r12,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm1,0x10(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    2710 <solve_Troullier+0x1400>
mov    0x70(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     2670 <solve_Troullier+0x1360>
jmp    2790 <solve_Troullier+0x1480>
xor    %edi,%edi
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rsi
test   $0x1,%bpl
je     27bb <solve_Troullier+0x14ab>
movsd  (%rdx,%rdi,8),%xmm0
subsd  (%r15,%rdi,8),%xmm0
subsd  (%rbx,%rdi,8),%xmm0
subsd  (%r12,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x60(%rsp),%rdi
je     2670 <solve_Troullier+0x1360>
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm0
subsd  (%r15,%rsi,8),%xmm0
subsd  (%rbx,%rsi,8),%xmm0
subsd  (%r12,%rsi,8),%xmm0
movsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm0,(%rdx,%rsi,8)
subsd  0x8(%r15,%rsi,8),%xmm1
subsd  0x8(%rbx,%rsi,8),%xmm1
subsd  0x8(%r12,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    27d0 <solve_Troullier+0x14c0>
jmp    2670 <solve_Troullier+0x1360>
mov    %r15,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x18(%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    296e <solve_Troullier+0x165e>
and    %dl,%cl
jne    296e <solve_Troullier+0x165e>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2c1a <solve_Troullier+0x190a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs 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    28d0 <solve_Troullier+0x15c0>
test   $0x1,%dl
je     2965 <solve_Troullier+0x1655>
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     2a03 <solve_Troullier+0x16f3>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     299b <solve_Troullier+0x168b>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2980 <solve_Troullier+0x1670>
cmp    $0x3,%rcx
jb     2a03 <solve_Troullier+0x16f3>
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    29b0 <solve_Troullier+0x16a0>
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
mov    0x1a0(%rsp),%rbp
mov    0x18(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x88(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    2561 <solve_Troullier+0x1251>
cmpl   $0x4,0x20(%rsp)
jae    2aec <solve_Troullier+0x17dc>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     2a7c <solve_Troullier+0x176c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2a60 <solve_Troullier+0x1750>
cmp    $0x3,%rcx
jb     2561 <solve_Troullier+0x1251>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
mulsd  0x18(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    2a90 <solve_Troullier+0x1780>
jmp    2561 <solve_Troullier+0x1251>
lea    (%r14,%rdi,8),%rax
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%r12,%rdi,8),%rdx
cmp    %rcx,%r14
setb   %sil
cmp    %rbp,%rax
seta   %r8b
cmp    %rdx,%r14
setb   %cl
cmp    %rax,%r12
setb   %dl
xor    %eax,%eax
test   %r8b,%sil
jne    2a42 <solve_Troullier+0x1732>
and    %dl,%cl
jne    2a42 <solve_Troullier+0x1732>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2c2a <solve_Troullier+0x191a>
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 (%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%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(%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r12,%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    2b60 <solve_Troullier+0x1850>
test   $0x1,%dl
je     2bfb <solve_Troullier+0x18eb>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
cmp    %rdi,%rax
je     2561 <solve_Troullier+0x1251>
jmp    2a42 <solve_Troullier+0x1732>
xor    %edx,%edx
test   $0x1,%sil
jne    23fa <solve_Troullier+0x10ea>
jmp    2426 <solve_Troullier+0x1116>
xor    %ecx,%ecx
test   $0x1,%dl
jne    2939 <solve_Troullier+0x1629>
jmp    2965 <solve_Troullier+0x1655>
xor    %ecx,%ecx
test   $0x1,%dl
jne    2bcd <solve_Troullier+0x18bd>
jmp    2bfb <solve_Troullier+0x18eb>

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

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