void solve_RelTroullier(int num_psp, int *n_psp, int *l_psp, int *s_psp,
                        double *e_psp, double *fill_psp, double *rcut_psp,
                        double **r_psi_psp, double **r_psi_prime_psp,
                        double *rho_psp, double *rho_semicore, double **V_psp,
                        double *eall_psp, double *eh_psp, double *ph_psp,
                        double *ex_psp, double *px_psp, double *ec_psp,
                        double *pc_psp) {
  int istate, i, l, k, p, s2, match, mch, Ngrid;
  double al, amesh, rmax, Zion;
  double gamma, gpr, nu0;
  double ldpsi_match;
  double el, eeig = 0.0;
  double ph, px, pc, eh, ex, ec;
  double *ul, *ul_prime;
  double *wl, *wl_prime;
  double *r, *Vh, *Vx, *Vc, *rho_total, *Vall, *Vl;
  Vall = Vall_Atom();
  r = r_LogGrid();
  Ngrid = N_LogGrid();
  al = log_amesh_LogGrid();
  amesh = amesh_LogGrid();
  Zion = 0.0;
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = 0.0;
  if (debug_print()) {
    printf("\n\nRelTroullier pseudopotential check\n\n");
    printf(
        "l\trcore     rmatch    E in       E psp      norm test slope test\n");
  }
  for (p = 0; p < (num_psp); ++p) {
    l = l_psp[p];
    s2 = s_psp[p];
    wl = r_psi_psp[p];
    wl_prime = r_psi_prime_psp[p];
    Vl = V_psp[p];
    if (fill_psp[p] < 1.e-15) {
      rmax = 10.0;
      solve_Scattering_State_Atom(n_psp[p], l_psp[p], e_psp[p], rmax);
      istate = Nvalence_Atom() + Ncore_Atom();
      if (s2 < 0)
        istate += 1;
      mch = (int)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_RelAtom(n_psp[p], l_psp[p], s_psp[p]);
    ul = r_psi_Atom(istate);
    ul_prime = r_psi_prime_Atom(istate);
    el = e_psp[p];
    match = (int)rint(log(rcut_psp[p] / 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[p], el, Vall, ul, ul_prime, Vl, wl,
                  wl_prime);
    psi_xpansion();
    dpsi_xpansion();
    psp_xpansion();
    if (fill_psp[p] > 1.e-14) {
      R_Schrodinger(l_psp[p] + 1, l_psp[p], Vl, &mch, &el, wl, wl_prime);
    } else {
      R_Schrodinger_Fixed_Logderiv(l_psp[p] + 1, l_psp[p], Vl, match,
                                   ldpsi_match, &el, wl, wl_prime);
      R_Schrodinger_Fixed_E(l_psp[p] + 1, l_psp[p], Vl, Ngrid - 1, el, wl,
                            wl_prime);
      rmax = 10.0;
      mch = rint(log(rmax / r[0]) / al);
      nu0 = Norm_LogGrid(mch, (l + 1.0), wl);
      nu0 = 1.0 / sqrt(nu0);
      for (i = 0; i < Ngrid; ++i) {
        wl[i] = wl[i] * nu0;
        wl_prime[i] = wl_prime[i] * nu0;
      }
    }
    gamma = fabs(ul[match] / wl[match]);
    gpr = fabs(ul_prime[match] / wl_prime[match]);
    if (debug_print()) {
      printf("%d\t%lf  %lf  %lf  %lf  %lf  %lf\n", l_psp[p], rcut_psp[p],
             r[match], e_psp[p], el, gamma, gpr);
    }
    el = e_psp[p];
    psi_xpansion();
    dpsi_xpansion();
    psp_xpansion();
    if (fill_psp[p] > 1.e-14) {
      eeig += fill_psp[p] * el;
      Zion += fill_psp[p];
      for (k = 0; k < Ngrid; ++k)
        rho_psp[k] += fill_psp[p] * pow(wl[k] / r[k], 2.0);
    }
  }
  Vh = alloc_LogGrid();
  Vx = alloc_LogGrid();
  Vc = alloc_LogGrid();
  ph = R_Hartree_DFT(rho_psp, Zion, Vh);
  eh = 0.5 * ph;
  rho_total = alloc_LogGrid();
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = rho_psp[k] + rho_semicore[k];
  R_Exchange_DFT(rho_total, Vx, &ex, &px);
  R_Correlation_DFT(rho_total, Vc, &ec, &pc);
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = (rho_psp[k]) * Vx[k];
  px = Integrate_LogGrid(rho_total);
  for (k = 0; k < Ngrid; ++k)
    rho_total[k] = (rho_psp[k]) * Vc[k];
  pc = Integrate_LogGrid(rho_total);
  *eall_psp = eeig + eh + ex + ec - ph - px - pc;
  *eh_psp = eh;
  *ph_psp = ph;
  *ex_psp = ex;
  *px_psp = px;
  *ec_psp = ec;
  *pc_psp = pc;
  for (p = 0; p < num_psp; ++p)
    for (k = 0; k < Ngrid; ++k)
      V_psp[p][k] = V_psp[p][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_RelTroullier>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    $0x0,%al
call   10a0 <Vall_Atom@plt>
cltq
mov    %rax,-0x128(%rbp)
mov    $0x0,%al
call   1100 <r_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    $0x0,%al
call   1210 <N_LogGrid@plt>
mov    %eax,-0x54(%rbp)
mov    $0x0,%al
call   1040 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    $0x0,%al
call   11e0 <amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    13d4 <solve_RelTroullier+0xe4>
mov    0x28(%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    13aa <solve_RelTroullier+0xba>
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     1400 <solve_RelTroullier+0x110>
lea    0xc65(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc7e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bb5 <solve_RelTroullier+0x8c5>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf8(%rbp)
mov    0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x130(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xb90(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1607 <solve_RelTroullier+0x317>
movsd  0xb85(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x70(%rbp),%xmm1
mov    $0x2,%al
call   1030 <solve_Scattering_State_Atom@plt>
mov    $0x0,%al
call   1080 <Nvalence_Atom@plt>
mov    %eax,-0x134(%rbp)
mov    $0x0,%al
call   10f0 <Ncore_Atom@plt>
mov    %eax,%ecx
mov    -0x134(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x48(%rbp)
jge    14f3 <solve_RelTroullier+0x203>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x100(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x60(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1090 <r_psi_Atom@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1050 <r_psi_prime_Atom@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    -0x50(%rbp),%edi
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  0xac9(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rsi
mov    $0x1,%al
call   1140 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   11a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xa93(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1602 <solve_RelTroullier+0x312>
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1598 <solve_RelTroullier+0x2a8>
jmp    1632 <solve_RelTroullier+0x342>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    $0x0,%al
call   10c0 <state_RelAtom@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1090 <r_psi_Atom@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1050 <r_psi_prime_Atom@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x60(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x4c(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1762 <solve_RelTroullier+0x472>
movsd  0x93c(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    175d <solve_RelTroullier+0x46d>
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16f3 <solve_RelTroullier+0x403>
jmp    1762 <solve_RelTroullier+0x472>
mov    -0x3c(%rbp),%edi
mov    -0x4c(%rbp),%esi
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x128(%rbp),%rdx
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%r8
mov    -0x130(%rbp),%r9
mov    -0xf0(%rbp),%r10
mov    -0xf8(%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   10b0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1150 <psp_xpansion@plt>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x847(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1834 <solve_RelTroullier+0x544>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x130(%rbp),%rdx
mov    -0xf0(%rbp),%r9
mov    -0xf8(%rbp),%rax
lea    -0x50(%rbp),%rcx
lea    -0xa0(%rbp),%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1190 <R_Schrodinger@plt>
jmp    19bd <solve_RelTroullier+0x6cd>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x130(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%r9
mov    -0xf8(%rbp),%rax
lea    -0xa0(%rbp),%r8
mov    %rax,(%rsp)
mov    $0x1,%al
call   1070 <R_Schrodinger_Fixed_Logderiv@plt>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x130(%rbp),%rdx
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%r8
mov    -0xf8(%rbp),%r9
mov    $0x1,%al
call   11f0 <R_Schrodinger_Fixed_E@plt>
movsd  0x746(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x100(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x60(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%edi
cvtsi2sdl -0x3c(%rbp),%xmm0
movsd  0x713(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rsi
mov    $0x1,%al
call   1140 <Norm_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   11a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x6dd(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    19b8 <solve_RelTroullier+0x6c8>
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0xf8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    194e <solve_RelTroullier+0x65e>
jmp    19bd <solve_RelTroullier+0x6cd>
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x65c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movaps 0x62c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    $0x0,%al
call   11c0 <debug_print@plt>
cmp    $0x0,%eax
je     1a88 <solve_RelTroullier+0x798>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm4
movsd  -0x88(%rbp),%xmm5
ff
lea    0x638(%rip),%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    $0x0,%al
call   1120 <psi_xpansion@plt>
mov    $0x0,%al
call   10b0 <dpsi_xpansion@plt>
mov    $0x0,%al
call   1150 <psp_xpansion@plt>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x561(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ba2 <solve_RelTroullier+0x8b2>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1b9d <solve_RelTroullier+0x8ad>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0xf0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x4cb(%rip),%xmm1
call   1170 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x140(%rbp),%xmm0
ff
mov    0x28(%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    1b1c <solve_RelTroullier+0x82c>
jmp    1ba2 <solve_RelTroullier+0x8b2>
jmp    1ba7 <solve_RelTroullier+0x8b7>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1407 <solve_RelTroullier+0x117>
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    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
mov    0x28(%rbp),%rdi
movsd  -0x78(%rbp),%xmm0
mov    -0x108(%rbp),%rsi
mov    $0x1,%al
call   1130 <R_Hartree_DFT@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x3f0(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    $0x0,%al
call   11d0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x120(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1c7b <solve_RelTroullier+0x98b>
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c37 <solve_RelTroullier+0x947>
mov    -0x120(%rbp),%rdi
mov    -0x110(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0xb8(%rbp),%rcx
mov    $0x0,%al
call   10d0 <R_Exchange_DFT@plt>
mov    -0x120(%rbp),%rdi
mov    -0x118(%rbp),%rsi
lea    -0xd8(%rbp),%rdx
lea    -0xc0(%rbp),%rcx
mov    $0x0,%al
call   1200 <R_Correlation_DFT@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1d0f <solve_RelTroullier+0xa1f>
mov    0x28(%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    -0x120(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1cc8 <solve_RelTroullier+0x9d8>
mov    -0x120(%rbp),%rdi
mov    $0x0,%al
call   1110 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1d77 <solve_RelTroullier+0xa87>
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d30 <solve_RelTroullier+0xa40>
mov    -0x120(%rbp),%rdi
mov    $0x0,%al
call   1110 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ed2 <solve_RelTroullier+0xbe2>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1ebf <solve_RelTroullier+0xbcf>
mov    0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%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    -0x118(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x44(%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    1e4b <solve_RelTroullier+0xb5b>
jmp    1ec4 <solve_RelTroullier+0xbd4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1e38 <solve_RelTroullier+0xb48>
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>
mov    -0x120(%rbp),%rdi
mov    $0x0,%al
call   11b0 <dealloc_LogGrid@plt>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_RelTroullier>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0x60(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,0x140(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x138(%rsp)
mov    %edi,%r13d
mov    0x1a8(%rsp),%r14
xor    %eax,%eax
call   10c0 <Vall_Atom@plt>
mov    %eax,0x40(%rsp)
xor    %eax,%eax
call   1120 <r_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1220 <N_LogGrid@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1050 <log_amesh_LogGrid@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   11f0 <amesh_LogGrid@plt>
mov    %ebp,%ebx
mov    %rbp,0x18(%rsp)
test   %ebp,%ebp
jle    1387 <solve_RelTroullier+0x87>
lea    0x0(,%rbx,8),%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   10b0 <memset@plt>
mov    %rbx,0x10(%rsp)
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
je     13af <solve_RelTroullier+0xaf>
lea    0x1cd3(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ced(%rip),%rdi
call   1040 <puts@plt>
mov    %r13d,%eax
mov    %rax,0xf0(%rsp)
test   %r13d,%r13d
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rbx
mov    %r13d,0xdc(%rsp)
jle    20cc <solve_RelTroullier+0xdcc>
movslq 0x40(%rsp),%rax
mov    %rax,0x130(%rsp)
movslq %r15d,%rax
cvtsi2sd %r12d,%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    %rax,%r12
mov    0x1a8(%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,0xb8(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb0(%rsp)
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,%rsi
mov    %rax,0xa8(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0xa0(%rsp)
neg    %rcx
mov    %rcx,0xc0(%rsp)
mov    %rdi,0x120(%rsp)
cmp    %r10,%rdi
setb   %cl
mov    %rdx,0x118(%rsp)
cmp    %rdx,%r9
setb   %al
and    %cl,%al
mov    %al,0x27(%rsp)
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rbp,0xe8(%rsp)
or     $0x1,%rbp
mov    %rbp,0x110(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x80(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x88(%rsp)
lea    -0x1(%r8),%eax
mov    %eax,0xe0(%rsp)
xor    %ebp,%ebp
mov    0x60(%rsp),%rdi
mov    0x58(%rsp),%r14
mov    %r12,0x68(%rsp)
mov    %rdx,0x128(%rsp)
jmp    14fa <solve_RelTroullier+0x1fa>
nopl   0x0(%rax,%rax,1)
mov    0x1a8(%rsp),%rsi
add    $0x1,%rbp
cmp    0xf0(%rsp),%rbp
je     20ee <solve_RelTroullier+0xdee>
mov    (%r14,%rbp,4),%esi
mov    0x140(%rsp),%rax
mov    (%rax,%rbp,4),%r14d
mov    0x198(%rsp),%rax
mov    (%rax,%rbp,8),%r15
mov    0x1a0(%rsp),%rax
mov    (%rax,%rbp,8),%r13
movsd  0x1ad6(%rip),%xmm0
ucomisd (%rdi,%rbp,8),%xmm0
mov    0x1b8(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    %rax,0x40(%rsp)
mov    0x138(%rsp),%rax
mov    (%rax,%rbp,4),%edi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mov    %rbp,0x70(%rsp)
movsd  %xmm0,0x90(%rsp)
jbe    1610 <solve_RelTroullier+0x310>
movsd  (%rbx,%rbp,8),%xmm0
mov    %esi,%ebp
movsd  0x1a93(%rip),%xmm1
mov    $0x2,%al
call   1030 <solve_Scattering_State_Atom@plt>
xor    %eax,%eax
call   1090 <Nvalence_Atom@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1110 <Ncore_Atom@plt>
shr    $0x1f,%r14d
add    %ebx,%r14d
add    %eax,%r14d
movsd  0x1a6a(%rip),%xmm0
divsd  (%r12),%xmm0
call   1180 <log@plt>
divsd  0xd0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x3c(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   10a0 <r_psi_Atom@plt>
movslq %eax,%rbx
mov    %r14d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
mov    %eax,%r12d
mov    0x3c(%rsp),%edi
movsd  0x90(%rsp),%xmm0
addsd  0x1a22(%rip),%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1160 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x1a21(%rip),%xmm0
jb     1630 <solve_RelTroullier+0x330>
sqrtsd %xmm0,%xmm0
jmp    1635 <solve_RelTroullier+0x335>
nop
mov    %esi,%ebp
mov    %r14d,%edx
xor    %eax,%eax
call   10e0 <state_RelAtom@plt>
mov    %eax,%r14d
jmp    1825 <solve_RelTroullier+0x525>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   11b0 <sqrt@plt>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rsi
test   %ecx,%ecx
jle    1820 <solve_RelTroullier+0x520>
movslq %r12d,%rax
movsd  0x19be(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x4,%ecx
jb     1675 <solve_RelTroullier+0x375>
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%rbx
jae    170a <solve_RelTroullier+0x40a>
lea    (%rbx,%rsi,8),%rcx
cmp    %rcx,%rax
jae    170a <solve_RelTroullier+0x40a>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%sil
je     16a3 <solve_RelTroullier+0x3a3>
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    0xc0(%rsp),%rdx
je     1820 <solve_RelTroullier+0x520>
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    16c0 <solve_RelTroullier+0x3c0>
jmp    1820 <solve_RelTroullier+0x520>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xb0(%rsp)
je     20a2 <solve_RelTroullier+0xda2>
mov    0xa0(%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    1730 <solve_RelTroullier+0x430>
testb  $0x1,0xa8(%rsp)
01
je     1800 <solve_RelTroullier+0x500>
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    0xb8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1677 <solve_RelTroullier+0x377>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rbx
mov    %r14d,%edi
xor    %eax,%eax
call   10a0 <r_psi_Atom@plt>
movslq %eax,%r12
mov    %r14d,%edi
xor    %eax,%eax
call   1060 <r_psi_prime_Atom@plt>
movslq %eax,%r14
mov    0x70(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    0x190(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rsp),%rax
divsd  (%rax),%xmm0
call   1180 <log@plt>
divsd  0xd0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%esi
movslq %esi,%rax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    %rax,0x150(%rsp)
movsd  (%r12,%rax,8),%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm1,0x148(%rsp)
ucomisd %xmm1,%xmm0
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rdx
movapd 0x1771(%rip),%xmm2
mov    0x40(%rsp),%r9
mov    %ebp,%edi
jbe    1ac0 <solve_RelTroullier+0x7c0>
test   %eax,%eax
jle    1ac0 <solve_RelTroullier+0x7c0>
cmp    $0x4,%eax
jb     18f3 <solve_RelTroullier+0x5f3>
lea    (%r14,%rdx,8),%rax
cmp    %rax,%r12
jae    1992 <solve_RelTroullier+0x692>
lea    (%r12,%rdx,8),%rax
cmp    %rax,%r14
jae    1992 <solve_RelTroullier+0x692>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dl
je     1924 <solve_RelTroullier+0x624>
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    0xc0(%rsp),%rcx
je     1ac0 <solve_RelTroullier+0x7c0>
cs nopw 0x0(%rax,%rax,1)
nop
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    1940 <solve_RelTroullier+0x640>
jmp    1ac0 <solve_RelTroullier+0x7c0>
cmpq   $0x0,0xb0(%rsp)
movapd 0x168d(%rip),%xmm3
je     208d <solve_RelTroullier+0xd8d>
mov    0xa0(%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    19c0 <solve_RelTroullier+0x6c0>
testb  $0x1,0xa8(%rsp)
01
je     1aa8 <solve_RelTroullier+0x7a8>
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    0xb8(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
jne    18f5 <solve_RelTroullier+0x5f5>
nopl   0x0(%rax)
mov    0x60(%rsp),%rbx
mov    0x70(%rsp),%rbp
movsd  (%rbx,%rbp,8),%xmm0
movsd  0x30(%rsp),%xmm1
mov    %r13,0x8(%rsp)
mov    %r15,(%rsp)
mov    %esi,0xe4(%rsp)
mov    0x130(%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   10d0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1170 <psp_xpansion@plt>
movsd  (%rbx,%rbp,8),%xmm0
mov    0x58(%rsp),%rbx
mov    (%rbx,%rbp,4),%esi
lea    0x1(%rsi),%edi
ucomisd 0x14f1(%rip),%xmm0
jbe    1b50 <solve_RelTroullier+0x850>
mov    %r13,(%rsp)
mov    0x40(%rsp),%rdx
lea    0x3c(%rsp),%rcx
lea    0x30(%rsp),%r8
mov    %r15,%r9
xor    %eax,%eax
call   11a0 <R_Schrodinger@plt>
mov    0x28(%rsp),%rsi
jmp    1e30 <solve_RelTroullier+0xb30>
movsd  0xc8(%rsp),%xmm0
divsd  0x148(%rsp),%xmm0
mov    %r13,(%rsp)
mov    0x40(%rsp),%rdx
mov    0xe4(%rsp),%ecx
lea    0x30(%rsp),%r8
mov    %r15,%r9
mov    $0x1,%al
call   1080 <R_Schrodinger_Fixed_Logderiv@plt>
mov    (%rbx,%rbp,4),%esi
lea    0x1(%rsi),%edi
movsd  0x30(%rsp),%xmm0
mov    0x40(%rsp),%rdx
mov    0xe0(%rsp),%ecx
mov    %r15,%r8
mov    %r13,%r9
mov    $0x1,%al
call   1200 <R_Schrodinger_Fixed_E@plt>
movsd  0x145a(%rip),%xmm0
mov    0x68(%rsp),%rax
divsd  (%rax),%xmm0
call   1180 <log@plt>
divsd  0xd0(%rsp),%xmm0
call   1100 <rint@plt>
cvttsd2si %xmm0,%edi
mov    %edi,0x3c(%rsp)
movsd  0x90(%rsp),%xmm0
addsd  0x142d(%rip),%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1160 <Norm_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd 0x142c(%rip),%xmm0
jb     1c10 <solve_RelTroullier+0x910>
sqrtsd %xmm0,%xmm0
jmp    1c15 <solve_RelTroullier+0x915>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   11b0 <sqrt@plt>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    0x70(%rsp),%rbp
test   %eax,%eax
jle    1e30 <solve_RelTroullier+0xb30>
movsd  0x13d7(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x4,%eax
jb     1c63 <solve_RelTroullier+0x963>
lea    0x0(,%rdx,8),%rax
add    %r13,%rax
cmp    %rax,%r15
jae    1d04 <solve_RelTroullier+0xa04>
lea    (%r15,%rdx,8),%rax
cmp    %rax,%r13
jae    1d04 <solve_RelTroullier+0xa04>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dl
je     1c96 <solve_RelTroullier+0x996>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xc0(%rsp),%rcx
je     1e30 <solve_RelTroullier+0xb30>
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1cb0 <solve_RelTroullier+0x9b0>
jmp    1e30 <solve_RelTroullier+0xb30>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xb0(%rsp)
je     20b7 <solve_RelTroullier+0xdb7>
mov    0xa0(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
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 0x20(%r15,%rax,8),%xmm2
movupd 0x30(%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r15,%rax,8)
movupd %xmm3,0x30(%r15,%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)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d30 <solve_RelTroullier+0xa30>
testb  $0x1,0xa8(%rsp)
01
je     1e1c <solve_RelTroullier+0xb1c>
movupd (%r15,%rax,8),%xmm2
movupd 0x10(%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
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)
mov    0xb8(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
jne    1c65 <solve_RelTroullier+0x965>
mov    0x150(%rsp),%rbx
movsd  (%r12,%rbx,8),%xmm0
movaps %xmm0,0x40(%rsp)
movsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  (%r14,%rbx,8),%xmm0
movaps %xmm0,0x70(%rsp)
movsd  0x0(%r13,%rbx,8),%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    %rsi,%r13
xor    %eax,%eax
call   11d0 <debug_print@plt>
test   %eax,%eax
mov    0x58(%rsp),%r14
mov    0x68(%rsp),%r12
je     1ee5 <solve_RelTroullier+0xbe5>
movapd 0x70(%rsp),%xmm5
divsd  0xc8(%rsp),%xmm5
movapd 0x11a4(%rip),%xmm0
andpd  %xmm0,%xmm5
movapd 0x40(%rsp),%xmm4
divsd  0x90(%rsp),%xmm4
andpd  %xmm0,%xmm4
mov    (%r14,%rbp,4),%esi
mov    0x190(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  (%r12,%rbx,8),%xmm1
movsd  0x0(%r13,%rbp,8),%xmm2
movsd  0x30(%rsp),%xmm3
lea    0x1172(%rip),%rdi
mov    $0x6,%al
call   1070 <printf@plt>
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
call   1140 <psi_xpansion@plt>
xor    %eax,%eax
call   10d0 <dpsi_xpansion@plt>
xor    %eax,%eax
call   1170 <psp_xpansion@plt>
mov    0x60(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm0
ucomisd 0x10ff(%rip),%xmm0
mov    %r13,%rbx
jbe    14e0 <solve_RelTroullier+0x1e0>
movsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x88(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x88(%rsp)
movsd  0x80(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x80(%rsp)
mov    0x18(%rsp),%rax
test   %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x1a8(%rsp),%rsi
mov    0x128(%rsp),%rdx
jle    14e8 <solve_RelTroullier+0x1e8>
movsd  (%r15),%xmm1
divsd  (%r12),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm1,%xmm0
addsd  (%rsi),%xmm0
movsd  %xmm0,(%rsi)
cmp    $0x1,%eax
je     14e8 <solve_RelTroullier+0x1e8>
mov    $0x1,%eax
cmpq   $0x2,0xe8(%rsp)
jb     2060 <solve_RelTroullier+0xd60>
lea    (%rdi,%rbp,8),%r11
lea    (%rdi,%rbp,8),%r8
add    $0x8,%r8
lea    0x8(%r15),%r13
lea    (%r15,%rcx,8),%r9
mov    0x120(%rsp),%rbx
cmp    %r8,%rbx
setb   %r10b
mov    0x118(%rsp),%r8
cmp    %r8,%r11
setb   %r11b
and    %r10b,%r11b
cmp    %r9,%rbx
setb   %r9b
cmp    %r8,%r13
setb   %bl
and    %r9b,%bl
or     %r11b,%bl
or     0x27(%rsp),%bl
mov    0x28(%rsp),%rbx
jne    2060 <solve_RelTroullier+0xd60>
movsd  (%rdi,%rbp,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
movupd 0x8(%r15,%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_RelTroullier+0xd10>
mov    0x110(%rsp),%rax
cmp    %rdx,0xe8(%rsp)
je     14e8 <solve_RelTroullier+0x1e8>
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
divsd  (%r12,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  (%rdi,%rbp,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    2060 <solve_RelTroullier+0xd60>
jmp    14e8 <solve_RelTroullier+0x1e8>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    1a64 <solve_RelTroullier+0x764>
jmp    1aa8 <solve_RelTroullier+0x7a8>
xor    %ecx,%ecx
testb  $0x1,0xa8(%rsp)
01
jne    17c4 <solve_RelTroullier+0x4c4>
jmp    1800 <solve_RelTroullier+0x500>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    1dd6 <solve_RelTroullier+0xad6>
jmp    1e1c <solve_RelTroullier+0xb1c>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x88(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x80(%rsp)
mov    0x1a8(%rsp),%rsi
mov    0x1c0(%rsp),%r12
xor    %eax,%eax
mov    %rsi,%rbx
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
movsd  0x80(%rsp),%xmm0
mov    %r13,%rsi
mov    $0x1,%al
call   1150 <R_Hartree_DFT@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
mov    0x18(%rsp),%rcx
movslq %r15d,%rbx
movslq %ebp,%r15
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  0xecf(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%rsp)
movslq %eax,%r14
test   %ecx,%ecx
movsd  %xmm0,0x40(%rsp)
jle    2189 <solve_RelTroullier+0xe89>
mov    0x1b0(%rsp),%rax
cmp    $0x4,%ecx
jae    21c8 <solve_RelTroullier+0xec8>
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
mov    0x1a8(%rsp),%rbp
jmp    22df <solve_RelTroullier+0xfdf>
lea    0x100(%rsp),%rdx
lea    0x98(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10f0 <R_Exchange_DFT@plt>
lea    0xf8(%rsp),%rdx
lea    0x108(%rsp),%rcx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1210 <R_Correlation_DFT@plt>
jmp    23e3 <solve_RelTroullier+0x10e3>
mov    0x10(%rsp),%r9
lea    (%r14,%r9,8),%rcx
mov    0x1a8(%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    22df <solve_RelTroullier+0xfdf>
and    %sil,%dl
jne    22df <solve_RelTroullier+0xfdf>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2a99 <solve_RelTroullier+0x1799>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xchg   %ax,%ax
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    2240 <solve_RelTroullier+0xf40>
test   $0x1,%sil
je     22d6 <solve_RelTroullier+0xfd6>
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     2383 <solve_RelTroullier+0x1083>
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     231b <solve_RelTroullier+0x101b>
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    2300 <solve_RelTroullier+0x1000>
cmp    $0x3,%rdx
jb     2383 <solve_RelTroullier+0x1083>
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    2330 <solve_RelTroullier+0x1030>
lea    0x100(%rsp),%rdx
lea    0x98(%rsp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10f0 <R_Exchange_DFT@plt>
lea    0xf8(%rsp),%rdx
lea    0x108(%rsp),%rcx
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1210 <R_Correlation_DFT@plt>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    23e3 <solve_RelTroullier+0x10e3>
cmp    $0x4,%eax
jae    26e4 <solve_RelTroullier+0x13e4>
xor    %eax,%eax
mov    0x10(%rsp),%rdi
mov    0x1a8(%rsp),%rbp
jmp    27fe <solve_RelTroullier+0x14fe>
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x98(%rsp)
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
mov    0x10(%rsp),%rbp
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x108(%rsp)
movsd  0x88(%rsp),%xmm4
movsd  0x70(%rsp),%xmm6
addsd  %xmm6,%xmm4
movsd  0x100(%rsp),%xmm1
addsd  %xmm1,%xmm4
movsd  0xf8(%rsp),%xmm2
addsd  %xmm2,%xmm4
movsd  0x40(%rsp),%xmm5
subsd  %xmm5,%xmm4
movsd  0x98(%rsp),%xmm3
subsd  %xmm3,%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,(%r12)
mov    0x1c8(%rsp),%rax
movsd  %xmm6,(%rax)
mov    0x1d0(%rsp),%rax
movsd  %xmm5,(%rax)
mov    0x1d8(%rsp),%rax
movsd  %xmm1,(%rax)
mov    0x1e0(%rsp),%rax
movsd  %xmm3,(%rax)
mov    0x1e8(%rsp),%rax
movsd  %xmm2,(%rax)
mov    0x1f0(%rsp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x0,0xdc(%rsp)
mov    0x18(%rsp),%r8
jle    26aa <solve_RelTroullier+0x13aa>
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
mov    %rax,0x70(%rsp)
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x68(%rsp)
lea    (%r15,%rbp,8),%rax
mov    %rax,0x60(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x58(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x40(%rsp)
lea    0x0(,%rbp,8),%rax
and    $0xffffffffffffffe0,%rax
xor    %ecx,%ecx
jmp    2522 <solve_RelTroullier+0x1222>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0xf0(%rsp),%rcx
je     26aa <solve_RelTroullier+0x13aa>
test   %r8d,%r8d
jle    2510 <solve_RelTroullier+0x1210>
mov    0x1b8(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
cmp    $0x4,%r8d
jae    2540 <solve_RelTroullier+0x1240>
xor    %edi,%edi
jmp    2620 <solve_RelTroullier+0x1320>
lea    (%rdx,%rbp,8),%rsi
cmp    0x70(%rsp),%rdx
setb   %r10b
cmp    %rsi,%r13
setb   %r11b
cmp    0x68(%rsp),%rdx
setb   %dil
cmp    %rsi,%rbx
setb   %r8b
cmp    0x60(%rsp),%rdx
setb   %r9b
cmp    %rsi,%r15
setb   %r12b
test   %r11b,%r10b
jne    2610 <solve_RelTroullier+0x1310>
and    %r8b,%dil
jne    2610 <solve_RelTroullier+0x1310>
mov    $0x0,%edi
and    %r12b,%r9b
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rbp
jne    2620 <solve_RelTroullier+0x1320>
xor    %esi,%esi
movupd (%rdx,%rsi,1),%xmm0
movupd 0x10(%rdx,%rsi,1),%xmm1
movupd 0x0(%r13,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r13,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rbx,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r15,%rsi,1),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm1,0x10(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    25a0 <solve_RelTroullier+0x12a0>
mov    0x58(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     2510 <solve_RelTroullier+0x1210>
jmp    2620 <solve_RelTroullier+0x1320>
xor    %edi,%edi
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rbp
nopl   0x0(%rax)
mov    %rdi,%rsi
test   $0x1,%bpl
je     264c <solve_RelTroullier+0x134c>
movsd  (%rdx,%rdi,8),%xmm0
subsd  0x0(%r13,%rdi,8),%xmm0
subsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x40(%rsp),%rdi
je     2510 <solve_RelTroullier+0x1210>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
subsd  0x0(%r13,%rsi,8),%xmm0
subsd  (%rbx,%rsi,8),%xmm0
subsd  (%r15,%rsi,8),%xmm0
movsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm0,(%rdx,%rsi,8)
subsd  0x8(%r13,%rsi,8),%xmm1
subsd  0x8(%rbx,%rsi,8),%xmm1
subsd  0x8(%r15,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    2660 <solve_RelTroullier+0x1360>
jmp    2510 <solve_RelTroullier+0x1210>
mov    %r13,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %r15,%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    0x10(%rsp),%rdi
lea    (%r14,%rdi,8),%rax
mov    0x1a8(%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    27fe <solve_RelTroullier+0x14fe>
and    %dl,%cl
jne    27fe <solve_RelTroullier+0x14fe>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2aaa <solve_RelTroullier+0x17aa>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rcx,8)
movupd %xmm0,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2760 <solve_RelTroullier+0x1460>
test   $0x1,%dl
je     27f5 <solve_RelTroullier+0x14f5>
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     2893 <solve_RelTroullier+0x1593>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     282b <solve_RelTroullier+0x152b>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2810 <solve_RelTroullier+0x1510>
cmp    $0x3,%rcx
jb     2893 <solve_RelTroullier+0x1593>
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    2840 <solve_RelTroullier+0x1540>
mov    %r14,%rdi
xor    %eax,%eax
call   1130 <Integrate_LogGrid@plt>
mov    0x1a8(%rsp),%rbp
mov    0x10(%rsp),%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x98(%rsp)
cmpl   $0x0,0x18(%rsp)
jle    23fd <solve_RelTroullier+0x10fd>
cmpl   $0x4,0x18(%rsp)
jae    297c <solve_RelTroullier+0x167c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     290c <solve_RelTroullier+0x160c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    28f0 <solve_RelTroullier+0x15f0>
cmp    $0x3,%rcx
jb     23fd <solve_RelTroullier+0x10fd>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r14,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
mulsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    2920 <solve_RelTroullier+0x1620>
jmp    23fd <solve_RelTroullier+0x10fd>
lea    (%r14,%rdi,8),%rax
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%r15,%rdi,8),%rdx
cmp    %rcx,%r14
setb   %sil
cmp    %rbp,%rax
seta   %r8b
cmp    %rdx,%r14
setb   %cl
cmp    %rax,%r15
setb   %dl
xor    %eax,%eax
test   %r8b,%sil
jne    28d2 <solve_RelTroullier+0x15d2>
and    %dl,%cl
jne    28d2 <solve_RelTroullier+0x15d2>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2aba <solve_RelTroullier+0x17ba>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r14,%rcx,8)
movupd %xmm0,0x30(%r14,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    29f0 <solve_RelTroullier+0x16f0>
test   $0x1,%dl
je     2a8b <solve_RelTroullier+0x178b>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rcx,8)
movupd %xmm0,0x10(%r14,%rcx,8)
cmp    %rdi,%rax
je     23fd <solve_RelTroullier+0x10fd>
jmp    28d2 <solve_RelTroullier+0x15d2>
xor    %edx,%edx
test   $0x1,%sil
jne    22aa <solve_RelTroullier+0xfaa>
jmp    22d6 <solve_RelTroullier+0xfd6>
xor    %ecx,%ecx
test   $0x1,%dl
jne    27c9 <solve_RelTroullier+0x14c9>
jmp    27f5 <solve_RelTroullier+0x14f5>
xor    %ecx,%ecx
test   $0x1,%dl
jne    2a5d <solve_RelTroullier+0x175d>
jmp    2a8b <solve_RelTroullier+0x178b>

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

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