void solve_Vanderbilt(num_psp, n_psp, l_psp, e_psp, fill_psp, rcut_psp, rlocal,
                      clocal, ns, indx_il, indx_ijl, r_hard_psi_psp, r_psi_psp,
                      r_psi_prime_psp, rho_psp, rho_semicore, V_psp, Vlocal, D0,
                      q, eall_psp, eh_psp, ph_psp, ex_psp, px_psp, ec_psp,
                      pc_psp) int num_psp;
int n_psp[];
int l_psp[];
double e_psp[];
double fill_psp[];
double rcut_psp[];
double rlocal, clocal;
int ns[10], indx_il[4][10], indx_ijl[4][4][10];
double **r_hard_psi_psp;
double **r_psi_psp;
double **r_psi_prime_psp;
double *rho_psp;
double *rho_semicore;
double **V_psp;
double *Vlocal;
double *D0, *q;
double *eall_psp;
double *eh_psp;
double *ph_psp;
double *ex_psp;
double *px_psp;
double *ec_psp;
double *pc_psp;
{
  int i, l, j, k, it, match, match_R, Ngrid;
  double al, amesh, Zion;
  double f;
  double el, eeig, scale;
  double sum1, sum2;
  double ph, px, pc, eh, ex, ec;
  double *ul, *ul_prime;
  double *wl, *wl_prime;
  double *r, *Vh, *Vx, *Vc, *rho_valence, *Vall, *Vl;
  double *chi;
  int lmax, Nc, Nv;
  double B[250], Binv[250], bb[250], aa[250];
  double D_shift;
  Vall = Vall_Atom();
  r = r_LogGrid();
  Ngrid = N_LogGrid();
  al = log_amesh_LogGrid();
  amesh = amesh_LogGrid();
  Nc = Ncore_Atom();
  Nv = Nvalence_Atom();
  Zion = 0.0;
  for (i = Nc; i < (Nc + Nv); ++i)
    Zion += fill_Atom(i);
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = 0.0;
  for (k = 0; k < Ngrid; ++k) {
    f = (r[k] / rlocal);
    f = pow(f, 3.5);
    f = exp(-f);
    Vlocal[k] = (1.0 - f) * Vall[k] + clocal * f;
  }
  printf("\n\nVanderbilt pseudopotential check\n\n");
  printf("l\trcore     rmatch    E in       E psp      norm test slope test\n");
  lmax = 0;
  Vl = alloc_LogGrid();
  for (l = 0; l < (num_psp); ++l) {
    match_R = rint(log((10.0) / r[0]) / al);
    match = rint(log(rcut_psp[l] / r[0]) / al);
    el = e_psp[l];
    wl = r_psi_psp[l];
    wl_prime = r_psi_prime_psp[l];
    ul = r_hard_psi_psp[l];
    ul_prime = alloc_LogGrid();
    chi = V_psp[l];
    if (l_psp[l] > lmax)
      lmax = l_psp[l];
    R_Schrodinger_Fixed_E(n_psp[l], l_psp[l], Vall, match_R, el, ul, ul_prime);
    match = rint(log(rcut_psp[l] / r[0]) / al);
    scale = fabs(1.0 / ul[match]);
    for (it = 1; it <= 2; ++it) {
      for (k = 0; k < Ngrid; ++k) {
        ul[k] *= scale;
        ul_prime[k] *= scale;
      }
      if (ul[match] < 0.0) {
        for (k = 0; k < Ngrid; ++k) {
          ul[k] = -ul[k];
          ul_prime[k] = -ul_prime[k];
        }
      }
      if (init_xpansion2(l_psp[l], match, el, Vall, ul, ul_prime, chi, wl,
                         wl_prime)) {
        psi_xpansion2();
        dpsi_xpansion2();
        chi_xpansion2();
      } else {
        psi_xpansion2();
        dpsi_xpansion2();
        chi_xpansion2();
      }
      if (it == 2)
        printf("%s\t%lf  %lf  %lf  %lf  %lf  %lf\n", spd_Name(l_psp[l]),
               rcut_psp[l], r[match], e_psp[l], el, fabs(ul[match] / wl[match]),
               fabs(ul_prime[match] / wl_prime[match]));
      for (k = 0; k < Ngrid; ++k)
        chi[k] = chi[k] - Vlocal[k] * wl[k];
      for (k = 0; k < Ngrid; ++k)
        Vl[k] = wl[k] * chi[k] / (r[k] * r[k]);
      scale = fabs(Integrate_LogGrid(Vl));
      scale = 1.0 / sqrt(scale);
    }
    dealloc_LogGrid(ul_prime);
  }
  for (l = 0; l <= lmax; ++l) {
    for (i = 0; i < ns[l]; ++i) {
      wl = r_psi_psp[indx_il[i][l]];
      for (j = 0; j < ns[l]; ++j) {
        chi = V_psp[indx_il[j][l]];
        for (k = 0; k < Ngrid; ++k)
          Vl[k] = wl[k] * chi[k] / (r[k] * r[k]);
        B[indx_ijl[i][j][l]] = Integrate_LogGrid(Vl);
      }
    }
    for (i = 0; i < (ns[l] * ns[l]); ++i)
      bb[i] = 0.0;
    for (i = 0; i < ns[l]; ++i) {
      bb[i + i * ns[l]] = 1.0;
      for (j = 0; j < ns[l]; ++j)
        aa[i + j * ns[l]] = B[indx_ijl[i][j][l]];
    }
    gaussj(ns[l], aa, ns[l], bb);
    for (i = 0; i < ns[l]; ++i)
      for (j = 0; j < ns[l]; ++j) {
        Binv[indx_ijl[i][j][l]] = bb[i + j * ns[l]];
      }
    for (k = 0; k < Ngrid; ++k) {
      for (i = 0; i < ns[l]; ++i) {
        bb[i] = 0.0;
        for (j = 0; j < ns[l]; ++j) {
          chi = V_psp[indx_il[j][l]];
          bb[i] = bb[i] + Binv[indx_ijl[i][j][l]] * chi[k];
        }
      }
      for (i = 0; i < ns[l]; ++i) {
        chi = V_psp[indx_il[i][l]];
        chi[k] = bb[i];
      }
    }
  }
  rho_valence = rho_valence_Atom();
  for (k = 0; k < Ngrid; ++k)
    Vl[k] = rho_valence[k] * Vlocal[k];
  D_shift = Integrate_LogGrid(Vl);
  for (l = 0; l <= lmax; ++l) {
    for (i = 0; i < ns[l]; ++i) {
      ul = r_hard_psi_psp[indx_il[i][l]];
      wl = r_psi_psp[indx_il[i][l]];
      for (j = 0; j < ns[l]; ++j) {
        ul_prime = r_hard_psi_psp[indx_il[j][l]];
        wl_prime = r_psi_psp[indx_il[j][l]];
        for (k = 0; k < Ngrid; ++k)
          Vl[k] = ul[k] * ul_prime[k] / (r[k] * r[k]);
        sum1 = Integrate_LogGrid(Vl);
        for (k = 0; k < Ngrid; ++k)
          Vl[k] = wl[k] * wl_prime[k] / (r[k] * r[k]);
        sum2 = Integrate_LogGrid(Vl);
        q[indx_ijl[i][j][l]] = sum1 - sum2;
        D0[indx_ijl[i][j][l]] = B[indx_ijl[i][j][l]] +
                                e_psp[indx_il[j][l]] * q[indx_ijl[i][j][l]] -
                                D_shift;
      }
    }
  }
  dealloc_LogGrid(Vl);
  printf("\n\nVanderbilt matrix elements\n");
  for (l = 0; l <= lmax; ++l) {
    printf("\n");
    printf("B(i,j)   l=%s : ", spd_Name(l));
    for (i = 0; i < ns[l]; ++i) {
      for (j = 0; j < ns[l]; ++j)
        printf("%le ", B[indx_ijl[i][j][l]]);
      printf("\n");
      printf("               ");
    }
  }
  for (l = 0; l <= lmax; ++l) {
    printf("\n");
    printf("D0(i,j)  l=%s : ", spd_Name(l));
    for (i = 0; i < ns[l]; ++i) {
      for (j = 0; j < ns[l]; ++j)
        printf("%le ", D0[indx_ijl[i][j][l]]);
      printf("\n");
      printf("               ");
    }
  }
  for (l = 0; l <= lmax; ++l) {
    printf("\n");
    printf("q(i,j)  l=%s : ", spd_Name(l));
    for (i = 0; i < ns[l]; ++i) {
      for (j = 0; j < ns[l]; ++j)
        printf("%le ", q[indx_ijl[i][j][l]]);
      printf("\n");
      printf("              ");
    }
  }
  Vh = alloc_LogGrid();
  Vx = alloc_LogGrid();
  Vc = alloc_LogGrid();
  ph = R_Hartree_DFT(rho_valence, Zion, Vh);
  eh = 0.5 * ph;
  R_Exchange_DFT(rho_valence, Vx, &ex, &px);
  R_Correlation_DFT(rho_valence, Vc, &ec, &pc);
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = (rho_valence[k]) * Vx[k];
  px = Integrate_LogGrid(rho_psp);
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = (rho_valence[k]) * Vc[k];
  pc = Integrate_LogGrid(rho_psp);
  eeig = 0.0;
  for (i = Nc; i < (Nc + Nv); ++i)
    eeig += fill_Atom(i) * eigenvalue_Atom(i);
  *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 (k = 0; k < Ngrid; ++k)
    Vlocal[k] = Vlocal[k] - Vh[k] - Vx[k] - Vc[k];
  for (k = 0; k < Ngrid; ++k)
    rho_psp[k] = rho_valence[k];
  dealloc_LogGrid(Vh);
  dealloc_LogGrid(Vx);
  dealloc_LogGrid(Vc);
}


x86 assembly (clang, -O0):
<solve_Vanderbilt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20b0,%rsp
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
mov    $0x0,%al
call   10b0 <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   11f0 <N_LogGrid@plt>
mov    %eax,-0x60(%rbp)
mov    $0x0,%al
call   1060 <log_amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    $0x0,%al
call   11c0 <amesh_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    $0x0,%al
call   10f0 <Ncore_Atom@plt>
mov    %eax,-0x140(%rbp)
mov    $0x0,%al
call   1090 <Nvalence_Atom@plt>
mov    %eax,-0x144(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x140(%rbp),%ecx
add    -0x144(%rbp),%ecx
cmp    %ecx,%eax
jge    1409 <solve_Vanderbilt+0x139>
mov    -0x44(%rbp),%edi
mov    $0x0,%al
call   1040 <fill_Atom@plt>
cvtsi2sd %eax,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13cc <solve_Vanderbilt+0xfc>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    143a <solve_Vanderbilt+0x16a>
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1410 <solve_Vanderbilt+0x140>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    14ee <solve_Vanderbilt+0x21e>
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  0x1ba4(%rip),%xmm1
call   1170 <pow@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1130 <exp@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  0x1b5c(%rip),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    -0x128(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1441 <solve_Vanderbilt+0x171>
lea    0x1b3b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x1b52(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x13c(%rbp)
mov    $0x0,%al
call   11b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x130(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a77 <solve_Vanderbilt+0x7a7>
mov    -0x100(%rbp),%rax
movsd  0x1aca(%rip),%xmm0
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x68(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x68(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf8(%rbp)
mov    0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe0(%rbp)
mov    $0x0,%al
call   11b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x138(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x13c(%rbp),%eax
jle    1627 <solve_Vanderbilt+0x357>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x128(%rbp),%rdx
mov    -0x5c(%rbp),%ecx
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%r8
mov    -0xe8(%rbp),%r9
mov    $0x1,%al
call   11d0 <R_Schrodinger_Fixed_E@plt>
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
divsd  (%rax),%xmm0
call   1160 <log@plt>
divsd  -0x68(%rbp),%xmm0
call   10e0 <rint@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  0x1963(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movaps 0x196f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x1,-0x54(%rbp)
cmpl   $0x2,-0x54(%rbp)
jg     1a5b <solve_Vanderbilt+0x78b>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1729 <solve_Vanderbilt+0x459>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xe8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16d5 <solve_Vanderbilt+0x405>
mov    -0xe0(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    17d6 <solve_Vanderbilt+0x506>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    17d1 <solve_Vanderbilt+0x501>
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xe8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1749 <solve_Vanderbilt+0x479>
jmp    17d6 <solve_Vanderbilt+0x506>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x58(%rbp),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x128(%rbp),%rdx
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%r8
mov    -0x138(%rbp),%r9
mov    -0xf0(%rbp),%r10
mov    -0xf8(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x1,%al
call   1110 <init_xpansion2@plt>
cmp    $0x0,%eax
je     1849 <solve_Vanderbilt+0x579>
mov    $0x0,%al
call   11a0 <psi_xpansion2@plt>
mov    $0x0,%al
call   1070 <dpsi_xpansion2@plt>
mov    $0x0,%al
call   1050 <chi_xpansion2@plt>
jmp    185e <solve_Vanderbilt+0x58e>
mov    $0x0,%al
call   11a0 <psi_xpansion2@plt>
mov    $0x0,%al
call   1070 <dpsi_xpansion2@plt>
mov    $0x0,%al
call   1050 <chi_xpansion2@plt>
cmpl   $0x2,-0x54(%rbp)
jne    1912 <solve_Vanderbilt+0x642>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1030 <spd_Name@plt>
mov    %eax,%esi
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
mov    -0xe0(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0xf0(%rbp),%rax
movslq -0x58(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm4
movaps 0x174b(%rip),%xmm5
pand   %xmm5,%xmm4
mov    -0xe8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0xf8(%rbp),%rax
movslq -0x58(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm5
movaps 0x1720(%rip),%xmm6
pand   %xmm6,%xmm5
lea    0x178c(%rip),%rdi
mov    $0x6,%al
call   1080 <printf@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    198f <solve_Vanderbilt+0x6bf>
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1919 <solve_Vanderbilt+0x649>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1a04 <solve_Vanderbilt+0x734>
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1996 <solve_Vanderbilt+0x6c6>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movaps 0x1603(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1180 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x15c7(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16c4 <solve_Vanderbilt+0x3f4>
mov    -0xe8(%rbp),%rdi
mov    $0x0,%al
call   1190 <dealloc_LogGrid@plt>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    152b <solve_Vanderbilt+0x25b>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x13c(%rbp),%eax
jg     1f58 <solve_Vanderbilt+0xc88>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1be5 <solve_Vanderbilt+0x915>
mov    0x30(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1bd2 <solve_Vanderbilt+0x902>
mov    0x50(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x138(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1b84 <solve_Vanderbilt+0x8b4>
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1b16 <solve_Vanderbilt+0x846>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  %xmm0,-0x920(%rbp,%rax,8)
ff ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1ad5 <solve_Vanderbilt+0x805>
jmp    1bd7 <solve_Vanderbilt+0x907>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a94 <solve_Vanderbilt+0x7c4>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x10(%rbp),%rdx
movslq -0x48(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jge    1c2c <solve_Vanderbilt+0x95c>
movslq -0x44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18c0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1bec <solve_Vanderbilt+0x91c>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1cf7 <solve_Vanderbilt+0xa27>
mov    -0x44(%rbp),%eax
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x48(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
add    %ecx,%eax
cltq
movsd  0x13a3(%rip),%xmm0
movsd  %xmm0,-0x18c0(%rbp,%rax,8)
ff ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1ce4 <solve_Vanderbilt+0xa14>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x920(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
mov    -0x4c(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x48(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
add    %ecx,%eax
cltq
movsd  %xmm0,-0x2090(%rbp,%rax,8)
ff ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c75 <solve_Vanderbilt+0x9a5>
jmp    1ce9 <solve_Vanderbilt+0xa19>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c33 <solve_Vanderbilt+0x963>
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
lea    -0x2090(%rbp),%rsi
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    -0x18c0(%rbp),%rcx
mov    $0x0,%al
call   10a0 <gaussj@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1dc6 <solve_Vanderbilt+0xaf6>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1db3 <solve_Vanderbilt+0xae3>
mov    -0x44(%rbp),%eax
mov    -0x4c(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x48(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
add    %ecx,%eax
cltq
movsd  -0x18c0(%rbp,%rax,8),%xmm0
ff ff
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  %xmm0,-0x10f0(%rbp,%rax,8)
ff ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d44 <solve_Vanderbilt+0xa74>
jmp    1db8 <solve_Vanderbilt+0xae8>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1d29 <solve_Vanderbilt+0xa59>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1f45 <solve_Vanderbilt+0xc75>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1ec6 <solve_Vanderbilt+0xbf6>
movslq -0x44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18c0(%rbp,%rax,8)
ff ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1eb3 <solve_Vanderbilt+0xbe3>
mov    0x50(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x138(%rbp)
movslq -0x44(%rbp),%rax
movsd  -0x18c0(%rbp,%rax,8),%xmm1
ff ff
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x10f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x18c0(%rbp,%rax,8)
ff ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e0b <solve_Vanderbilt+0xb3b>
jmp    1eb8 <solve_Vanderbilt+0xbe8>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1de0 <solve_Vanderbilt+0xb10>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1f32 <solve_Vanderbilt+0xc62>
mov    0x50(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x138(%rbp)
movslq -0x44(%rbp),%rax
movsd  -0x18c0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x138(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1ecd <solve_Vanderbilt+0xbfd>
jmp    1f37 <solve_Vanderbilt+0xc67>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1dcd <solve_Vanderbilt+0xafd>
jmp    1f4a <solve_Vanderbilt+0xc7a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a7e <solve_Vanderbilt+0x7ae>
mov    $0x0,%al
call   10c0 <rho_valence_Atom@plt>
cltq
mov    %rax,-0x120(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1fb6 <solve_Vanderbilt+0xce6>
mov    -0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x130(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1f6f <solve_Vanderbilt+0xc9f>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x2098(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x13c(%rbp),%eax
jg     22fe <solve_Vanderbilt+0x102e>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    22eb <solve_Vanderbilt+0x101b>
mov    0x28(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe0(%rbp)
mov    0x30(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    22d8 <solve_Vanderbilt+0x1008>
mov    0x28(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
mov    0x30(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf8(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    2129 <solve_Vanderbilt+0xe59>
mov    -0xe0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    20bb <solve_Vanderbilt+0xdeb>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    21b8 <solve_Vanderbilt+0xee8>
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    214a <solve_Vanderbilt+0xe7a>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0xa0,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x920(%rbp,%rax,8),%xmm1
ff ff
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0xa0,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x2098(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0xa0,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2054 <solve_Vanderbilt+0xd84>
jmp    22dd <solve_Vanderbilt+0x100d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1fed <solve_Vanderbilt+0xd1d>
jmp    22f0 <solve_Vanderbilt+0x1020>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1fd7 <solve_Vanderbilt+0xd07>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   1190 <dealloc_LogGrid@plt>
lea    0xda5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x13c(%rbp),%eax
jg     2415 <solve_Vanderbilt+0x1145>
lea    0xd1c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%edi
mov    $0x0,%al
call   1030 <spd_Name@plt>
mov    %eax,%esi
lea    0xd85(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    2402 <solve_Vanderbilt+0x1132>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    23d8 <solve_Vanderbilt+0x1108>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x920(%rbp,%rax,8),%xmm0
ff ff
lea    0xd24(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    237a <solve_Vanderbilt+0x10aa>
lea    0xc74(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0xcff(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    235f <solve_Vanderbilt+0x108f>
jmp    2407 <solve_Vanderbilt+0x1137>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2321 <solve_Vanderbilt+0x1051>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x13c(%rbp),%eax
jg     2510 <solve_Vanderbilt+0x1240>
lea    0xc21(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%edi
mov    $0x0,%al
call   1030 <spd_Name@plt>
mov    %eax,%esi
lea    0xcb0(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    24fd <solve_Vanderbilt+0x122d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    24d3 <solve_Vanderbilt+0x1203>
mov    0x60(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0xa0,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc29(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2475 <solve_Vanderbilt+0x11a5>
lea    0xb79(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0xc04(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    245a <solve_Vanderbilt+0x118a>
jmp    2502 <solve_Vanderbilt+0x1232>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    241c <solve_Vanderbilt+0x114c>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x13c(%rbp),%eax
jg     260b <solve_Vanderbilt+0x133b>
lea    0xb26(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x48(%rbp),%edi
mov    $0x0,%al
call   1030 <spd_Name@plt>
mov    %eax,%esi
lea    0xbc6(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    25f8 <solve_Vanderbilt+0x1328>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    25ce <solve_Vanderbilt+0x12fe>
mov    0x68(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x44(%rbp),%rdx
imul   $0xa0,%rdx,%rdx
add    %rdx,%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xb2e(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2570 <solve_Vanderbilt+0x12a0>
lea    0xa7e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0xb0a(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2555 <solve_Vanderbilt+0x1285>
jmp    25fd <solve_Vanderbilt+0x132d>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2517 <solve_Vanderbilt+0x1247>
mov    $0x0,%al
call   11b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   11b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   11b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
mov    -0x120(%rbp),%rdi
movsd  -0x78(%rbp),%xmm0
mov    -0x108(%rbp),%rsi
mov    $0x1,%al
call   1140 <R_Hartree_DFT@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x997(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
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   11e0 <R_Correlation_DFT@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    270d <solve_Vanderbilt+0x143d>
mov    -0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x110(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    26c6 <solve_Vanderbilt+0x13f6>
mov    0x40(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    2772 <solve_Vanderbilt+0x14a2>
mov    -0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    272b <solve_Vanderbilt+0x145b>
mov    0x40(%rbp),%rdi
mov    $0x0,%al
call   1120 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x140(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x140(%rbp),%ecx
add    -0x144(%rbp),%ecx
cmp    %ecx,%eax
jge    27fb <solve_Vanderbilt+0x152b>
mov    -0x44(%rbp),%edi
mov    $0x0,%al
call   1040 <fill_Atom@plt>
mov    %eax,-0x209c(%rbp)
mov    -0x44(%rbp),%edi
mov    $0x0,%al
call   1150 <eigenvalue_Atom@plt>
mov    %eax,%ecx
mov    -0x209c(%rbp),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    279d <solve_Vanderbilt+0x14cd>
movsd  -0x90(%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    0x70(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x88(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x90(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x98(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0xa0(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    2915 <solve_Vanderbilt+0x1645>
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x110(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    28b1 <solve_Vanderbilt+0x15e1>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    2953 <solve_Vanderbilt+0x1683>
mov    -0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    291c <solve_Vanderbilt+0x164c>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   1190 <dealloc_LogGrid@plt>
mov    -0x110(%rbp),%rdi
mov    $0x0,%al
call   1190 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   1190 <dealloc_LogGrid@plt>
add    $0x20b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_Vanderbilt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2098,%rsp
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,(%rsp)
mov    %r9,0xb0(%rsp)
mov    %rcx,0xc0(%rsp)
mov    %rdx,0x78(%rsp)
mov    %rsi,0x110(%rsp)
mov    %edi,0x28(%rsp)
xor    %eax,%eax
call   10e0 <Vall_Atom@plt>
mov    %eax,%r12d
xor    %eax,%eax
call   1130 <r_LogGrid@plt>
mov    %eax,%r13d
xor    %eax,%eax
call   1220 <N_LogGrid@plt>
mov    %eax,0x14(%rsp)
xor    %eax,%eax
call   1080 <log_amesh_LogGrid@plt>
mov    %eax,0x20(%rsp)
xor    %eax,%eax
call   11f0 <amesh_LogGrid@plt>
xor    %eax,%eax
call   1120 <Ncore_Atom@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   10b0 <Nvalence_Atom@plt>
mov    %ebx,%ebp
add    %eax,%ebp
mov    %eax,0xd8(%rsp)
test   %eax,%eax
mov    %ebx,0xd4(%rsp)
xorpd  %xmm0,%xmm0
jle    13df <solve_Vanderbilt+0xdf>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0xa0(%rsp)
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <fill_Atom@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xa0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp)
movsd  0xa0(%rsp),%xmm0
add    $0x1,%ebx
cmp    %ebp,%ebx
jl     13a0 <solve_Vanderbilt+0xa0>
movsd  %xmm0,0xa0(%rsp)
mov    %ebp,0xd0(%rsp)
mov    0x2118(%rsp),%r14
movslq %r12d,%rbp
movslq %r13d,%r15
mov    0x14(%rsp),%eax
mov    %eax,%r12d
test   %eax,%eax
jle    1480 <solve_Vanderbilt+0x180>
lea    0x0(,%r12,8),%rdx
xor    %ebx,%ebx
mov    0x2100(%rsp),%rdi
xor    %esi,%esi
call   10c0 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
divsd  (%rsp),%xmm0
movsd  0x2bbd(%rip),%xmm1
call   11a0 <pow@plt>
xorpd  0x2be0(%rip),%xmm0
call   1160 <exp@plt>
movsd  0x2bab(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm0
mulsd  0x0(%rbp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1430 <solve_Vanderbilt+0x130>
mov    %rbp,0x98(%rsp)
mov    0x20e0(%rsp),%rax
mov    %rax,0xe0(%rsp)
lea    0x2c19(%rip),%rdi
call   1050 <puts@plt>
lea    0x2c31(%rip),%rdi
call   1050 <puts@plt>
xor    %ebp,%ebp
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r13
mov    0x28(%rsp),%eax
test   %eax,%eax
mov    %r12,%rbx
mov    %r12,0x8(%rsp)
mov    %r15,0x18(%rsp)
jle    1fc0 <solve_Vanderbilt+0xcc0>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    %eax,%eax
mov    %rax,0x108(%rsp)
lea    0x0(%r13,%rbx,8),%rdx
lea    (%r15,%rbx,8),%rax
lea    (%r14,%rbx,8),%rsi
mov    %rsi,0xf8(%rsp)
mov    %ebx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0x38(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xa8(%rsp)
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %ebx,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x130(%rsp)
add    $0xfffffffffffffffe,%rsi
mov    %rsi,0x128(%rsp)
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
mov    %rdi,%rsi
mov    %rdi,0xb8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x58(%rsp)
mov    %rbx,%rsi
neg    %rsi
mov    %rsi,0x20(%rsp)
cmp    %rax,%r13
setb   %al
mov    %rdx,0x100(%rsp)
cmp    %rdx,%r15
setb   %dl
and    %al,%dl
mov    %dl,0x37(%rsp)
mov    %rbp,%rax
mov    %rbp,0x120(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x118(%rsp)
lea    0x0(,%rbx,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x138(%rsp)
xor    %ebp,%ebp
xor    %eax,%eax
mov    %rax,0x48(%rsp)
jmp    15fc <solve_Vanderbilt+0x2fc>
nopl   0x0(%rax)
mov    0x48(%rsp),%rax
mov    0xdc(%rsp),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %rax,0x48(%rsp)
mov    %r12,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    0x40(%rsp),%rbp
add    $0x1,%rbp
cmp    0x108(%rsp),%rbp
mov    0x18(%rsp),%r15
je     1fb3 <solve_Vanderbilt+0xcb3>
movsd  0x2a0c(%rip),%xmm0
divsd  (%r15),%xmm0
call   1190 <log@plt>
divsd  0xe8(%rsp),%xmm0
call   1110 <rint@plt>
movapd %xmm0,%xmm2
mov    0xb0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
divsd  (%r15),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    1f9f <solve_Vanderbilt+0xc9f>
cvttsd2si %xmm2,%eax
mov    %eax,(%rsp)
mov    0xc0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,0x80(%rsp)
mov    0x20f0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    %rax,0x28(%rsp)
mov    0x20f8(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    %rax,0x70(%rsp)
mov    0x20e8(%rsp),%rax
mov    (%rax,%rbp,8),%r15
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r12
mov    0x2110(%rsp),%rax
mov    %rbp,%rcx
mov    %rbp,0x40(%rsp)
mov    (%rax,%rbp,8),%rbp
mov    0x78(%rsp),%rax
mov    (%rax,%rcx,4),%esi
mov    0x110(%rsp),%rax
mov    (%rax,%rcx,4),%edi
mov    %esi,0xdc(%rsp)
mov    0x98(%rsp),%rdx
mov    (%rsp),%ecx
movsd  0x80(%rsp),%xmm0
mov    %r15,%r8
mov    %r12,%r9
mov    $0x1,%al
call   1200 <R_Schrodinger_Fixed_E@plt>
mov    0xb0(%rsp),%rax
mov    0x40(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rsp),%rax
divsd  (%rax),%xmm0
call   1190 <log@plt>
divsd  0xe8(%rsp),%xmm0
call   1110 <rint@plt>
mov    0x28(%rsp),%r10
lea    (%r10,%rbx,8),%r8
lea    0x0(,%rbx,8),%rcx
add    %rbp,%rcx
lea    (%r15,%rbx,8),%rdx
lea    (%r12,%rbx,8),%rsi
cmp    %rsi,%r15
setb   %al
cmp    %rdx,%r12
setb   %dl
and    %al,%dl
mov    %dl,0x68(%rsp)
cmp    0xf8(%rsp),%rbp
setb   %al
cmp    %r14,%rcx
seta   %dl
and    %al,%dl
cmp    %r8,%rbp
setb   %sil
cmp    %rcx,%r10
setb   %al
and    %sil,%al
cvttsd2si %xmm0,%edi
or     %dl,%al
mov    %al,0x88(%rsp)
cmp    %r8,%r13
setb   %al
mov    0x100(%rsp),%rsi
cmp    %rsi,%r10
setb   %dl
and    %al,%dl
mov    %edi,0x90(%rsp)
movslq %edi,%rax
movsd  0x2870(%rip),%xmm1
mov    %rax,0x60(%rsp)
divsd  (%r15,%rax,8),%xmm1
andpd  0x2895(%rip),%xmm1
cmp    %rcx,%r13
setb   %al
cmp    %rsi,%rbp
setb   %cl
and    %al,%cl
or     %dl,%cl
or     0x37(%rsp),%cl
mov    %cl,0x50(%rsp)
movl   $0x1,(%rsp)
mov    0x14(%rsp),%edx
movapd 0x285a(%rip),%xmm4
movapd 0x2852(%rip),%xmm5
jmp    181c <solve_Vanderbilt+0x51c>
call   11b0 <sqrt@plt>
movapd 0x2843(%rip),%xmm4
movapd 0x283b(%rip),%xmm5
movsd  0x280b(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    (%rsp),%eax
add    $0x1,%eax
mov    %eax,(%rsp)
cmp    $0x3,%eax
mov    0x14(%rsp),%edx
mov    0x28(%rsp),%r10
je     15c0 <solve_Vanderbilt+0x2c0>
test   %edx,%edx
jle    19ed <solve_Vanderbilt+0x6ed>
cmp    $0x4,%edx
setb   %al
or     0x68(%rsp),%al
je     1840 <solve_Vanderbilt+0x540>
xor    %ecx,%ecx
jmp    1959 <solve_Vanderbilt+0x659>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x0,0xa8(%rsp)
je     1f60 <solve_Vanderbilt+0xc60>
mov    0x58(%rsp),%rcx
xor    %eax,%eax
xchg   %ax,%ax
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 (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
movupd 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(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x20(%r12,%rax,8)
movupd %xmm3,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1860 <solve_Vanderbilt+0x560>
testb  $0x1,0xb8(%rsp)
01
je     1948 <solve_Vanderbilt+0x648>
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 (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
mov    0x38(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     19ed <solve_Vanderbilt+0x6ed>
mov    %rcx,%rax
test   $0x1,%bl
je     1988 <solve_Vanderbilt+0x688>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x20(%rsp),%rcx
je     19ed <solve_Vanderbilt+0x6ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    19a0 <solve_Vanderbilt+0x6a0>
xorpd  %xmm0,%xmm0
mov    0x60(%rsp),%rax
ucomisd (%r15,%rax,8),%xmm0
jbe    1bd0 <solve_Vanderbilt+0x8d0>
test   %edx,%edx
jle    1bd0 <solve_Vanderbilt+0x8d0>
cmp    $0x4,%edx
setb   %al
or     0x68(%rsp),%al
je     1a20 <solve_Vanderbilt+0x720>
xor    %ecx,%ecx
jmp    1b39 <solve_Vanderbilt+0x839>
nopl   (%rax)
cmpq   $0x0,0xa8(%rsp)
je     1f75 <solve_Vanderbilt+0xc75>
mov    0x58(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,(%r15,%rax,8)
movupd %xmm1,0x10(%r15,%rax,8)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,0x20(%r15,%rax,8)
movupd %xmm1,0x30(%r15,%rax,8)
movupd 0x20(%r12,%rax,8),%xmm0
movupd 0x30(%r12,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,0x20(%r12,%rax,8)
movupd %xmm1,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1a40 <solve_Vanderbilt+0x740>
testb  $0x1,0xb8(%rsp)
01
je     1b28 <solve_Vanderbilt+0x828>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,(%r15,%rax,8)
movupd %xmm1,0x10(%r15,%rax,8)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
xorpd  %xmm5,%xmm0
xorpd  %xmm5,%xmm1
movupd %xmm0,(%r12,%rax,8)
movupd %xmm1,0x10(%r12,%rax,8)
mov    0x38(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     1bd0 <solve_Vanderbilt+0x8d0>
mov    %rcx,%rax
test   $0x1,%bl
je     1b68 <solve_Vanderbilt+0x868>
movsd  (%r15,%rcx,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,(%r15,%rcx,8)
movsd  (%r12,%rcx,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x20(%rsp),%rcx
je     1bd0 <solve_Vanderbilt+0x8d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,(%r15,%rax,8)
movsd  (%r12,%rax,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,0x8(%r15,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
xorpd  %xmm4,%xmm0
movlpd %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1b80 <solve_Vanderbilt+0x880>
nopl   (%rax)
mov    0x78(%rsp),%rax
mov    0x40(%rsp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x90(%rsp),%esi
movsd  0x80(%rsp),%xmm0
mov    0x98(%rsp),%rdx
mov    %r15,%rcx
mov    %r12,%r8
mov    %rbp,%r9
mov    $0x1,%al
push   0x70(%rsp)
push   %r10
call   1140 <init_xpansion2@plt>
add    $0x10,%rsp
xor    %eax,%eax
call   11d0 <psi_xpansion2@plt>
xor    %eax,%eax
call   1090 <dpsi_xpansion2@plt>
xor    %eax,%eax
call   1070 <chi_xpansion2@plt>
cmpl   $0x2,(%rsp)
jne    1cbf <solve_Vanderbilt+0x9bf>
mov    0x78(%rsp),%rax
mov    0x40(%rsp),%r14
mov    (%rax,%r14,4),%edi
xor    %eax,%eax
call   1040 <spd_Name@plt>
mov    0xb0(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm0
mov    0x18(%rsp),%rcx
mov    0x60(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mov    0xc0(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm2
mov    0x2118(%rsp),%r14
movsd  (%r15,%rdx,8),%xmm4
mov    0x28(%rsp),%rcx
divsd  (%rcx,%rdx,8),%xmm4
movapd 0x23b2(%rip),%xmm3
andpd  %xmm3,%xmm4
movsd  (%r12,%rdx,8),%xmm5
mov    0x70(%rsp),%rcx
divsd  (%rcx,%rdx,8),%xmm5
andpd  %xmm3,%xmm5
lea    0x23a3(%rip),%rdi
mov    %eax,%esi
movsd  0x80(%rsp),%xmm3
mov    $0x6,%al
call   10a0 <printf@plt>
mov    0x14(%rsp),%edx
test   %edx,%edx
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rdi
jle    1f30 <solve_Vanderbilt+0xc30>
cmp    $0x4,%edx
setb   %al
or     0x88(%rsp),%al
je     1cf0 <solve_Vanderbilt+0x9f0>
xor    %ecx,%ecx
jmp    1d56 <solve_Vanderbilt+0xa56>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x138(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,1),%xmm0
movupd 0x10(%rbp,%rax,1),%xmm1
movupd (%r14,%rax,1),%xmm2
movupd 0x10(%r14,%rax,1),%xmm3
movupd (%rdi,%rax,1),%xmm4
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm0
movupd 0x10(%rdi,%rax,1),%xmm2
mulpd  %xmm3,%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,0x0(%rbp,%rax,1)
movupd %xmm1,0x10(%rbp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    1d00 <solve_Vanderbilt+0xa00>
mov    0x38(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     1dd1 <solve_Vanderbilt+0xad1>
mov    %rcx,%rax
test   $0x1,%bl
je     1d80 <solve_Vanderbilt+0xa80>
movsd  (%r14,%rcx,8),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x20(%rsp),%rcx
je     1dd1 <solve_Vanderbilt+0xad1>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  0x8(%rdi,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1d90 <solve_Vanderbilt+0xa90>
test   %edx,%edx
jle    1f30 <solve_Vanderbilt+0xc30>
cmp    $0x1,%edx
sete   %al
or     0x50(%rsp),%al
je     1dec <solve_Vanderbilt+0xaec>
xor    %ecx,%ecx
jmp    1ea3 <solve_Vanderbilt+0xba3>
cmpq   $0x0,0x128(%rsp)
je     1f8a <solve_Vanderbilt+0xc8a>
mov    0x118(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rdi,%rax,8),%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rax,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rax,8)
movupd 0x10(%rdi,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd 0x10(%rsi,%rax,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r13,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1e10 <solve_Vanderbilt+0xb10>
testb  $0x1,0x120(%rsp)
01
je     1e8f <solve_Vanderbilt+0xb8f>
movupd (%rdi,%rax,8),%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rax,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rax,8)
mov    0x130(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     1f30 <solve_Vanderbilt+0xc30>
mov    %rcx,%rax
test   $0x1,%bl
je     1ed1 <solve_Vanderbilt+0xbd1>
movsd  (%rdi,%rcx,8),%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x20(%rsp),%rcx
je     1f30 <solve_Vanderbilt+0xc30>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  0x8(%rbp,%rax,8),%xmm0
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1ee0 <solve_Vanderbilt+0xbe0>
nopl   0x0(%rax)
mov    %r13,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
andpd  0x20f7(%rip),%xmm0
ucomisd 0x20cf(%rip),%xmm0
jb     17e0 <solve_Vanderbilt+0x4e0>
sqrtsd %xmm0,%xmm0
jmp    17e5 <solve_Vanderbilt+0x4e5>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
jne    1904 <solve_Vanderbilt+0x604>
jmp    1948 <solve_Vanderbilt+0x648>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
jne    1ae4 <solve_Vanderbilt+0x7e4>
jmp    1b28 <solve_Vanderbilt+0x828>
xor    %eax,%eax
testb  $0x1,0x120(%rsp)
01
jne    1e6c <solve_Vanderbilt+0xb6c>
jmp    1e8f <solve_Vanderbilt+0xb8f>
movsd  %xmm2,(%rsp)
call   1190 <log@plt>
movsd  (%rsp),%xmm2
jmp    1640 <solve_Vanderbilt+0x340>
mov    0x48(%rsp),%rbp
test   %ebp,%ebp
js     2769 <solve_Vanderbilt+0x1469>
mov    %rbp,0x48(%rsp)
lea    0x1(%rbp),%eax
mov    %rax,0x88(%rsp)
lea    0x0(,%rbx,8),%rdx
add    %r13,%rdx
lea    (%r15,%rbx,8),%rax
mov    %ebx,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x70(%rsp)
add    $0xfffffffffffffffe,%rsi
mov    %rsi,0x60(%rsp)
shr    %rsi
add    $0x1,%rsi
cmp    %rax,%r13
setb   %al
mov    %rdx,0x40(%rsp)
cmp    %rdx,%r15
setb   %cl
and    %al,%cl
mov    %cl,0x78(%rsp)
mov    %rsi,%rax
mov    %rsi,0x68(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x98(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x20(%rsp)
mov    0x20d8(%rsp),%r12
mov    0x20e0(%rsp),%rax
mov    %rax,0x38(%rsp)
xor    %edx,%edx
mov    0x14(%rsp),%r11d
mov    0x2110(%rsp),%r15
jmp    2080 <solve_Vanderbilt+0xd80>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%rdx
add    $0x1,%rdx
addq   $0x4,0x38(%rsp)
add    $0x4,%r12
cmp    0x88(%rsp),%rdx
je     275f <solve_Vanderbilt+0x145f>
mov    0x20d0(%rsp),%rax
mov    (%rax,%rdx,4),%ebp
test   %ebp,%ebp
mov    0x18(%rsp),%rsi
mov    %rdx,(%rsp)
jle    2320 <solve_Vanderbilt+0x1020>
xor    %ecx,%ecx
jmp    20c0 <solve_Vanderbilt+0xdc0>
mov    0x2110(%rsp),%r15
mov    0x90(%rsp),%rcx
movslq %ebp,%rax
add    $0x1,%rcx
cmp    %rax,%rcx
jge    2320 <solve_Vanderbilt+0x1020>
test   %ebp,%ebp
jle    20b0 <solve_Vanderbilt+0xdb0>
mov    %rcx,0x90(%rsp)
lea    (%rcx,%rcx,4),%rcx
mov    0x20d8(%rsp),%rax
mov    %rcx,0x28(%rsp)
lea    (%rax,%rcx,8),%rax
movslq (%rax,%rdx,4),%rax
mov    0x20f0(%rsp),%rcx
mov    (%rcx,%rax,8),%r15
lea    (%r15,%rbx,8),%rax
cmp    %rax,%r13
setb   %al
cmp    0x40(%rsp),%r15
setb   %cl
and    %al,%cl
mov    %cl,0x80(%rsp)
xor    %r14d,%r14d
jmp    217a <solve_Vanderbilt+0xe7a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
mov    (%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x14(%rsp),%r11d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x28(%rsp),%rax
shl    $0x5,%rax
add    0x20e0(%rsp),%rax
lea    (%rax,%rbp,8),%rax
movslq (%rax,%rdx,4),%rax
movsd  %xmm0,0x10f0(%rsp,%rax,8)
add    $0x1,%r14
mov    0x20d0(%rsp),%rax
movslq (%rax,%rdx,4),%rbp
cmp    %rbp,%r14
jge    20a0 <solve_Vanderbilt+0xda0>
lea    (%r14,%r14,4),%rbp
test   %r11d,%r11d
jle    2120 <solve_Vanderbilt+0xe20>
mov    0x20d8(%rsp),%rax
lea    (%rax,%rbp,8),%rax
movslq (%rax,%rdx,4),%rax
mov    0x2110(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
cmp    $0x1,%r11d
je     21ca <solve_Vanderbilt+0xeca>
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%r13
setb   %cl
cmp    0x40(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x80(%rsp),%dl
or     0x78(%rsp),%dl
je     225f <solve_Vanderbilt+0xf5f>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     21fa <solve_Vanderbilt+0xefa>
movsd  (%r15,%rdx,8),%xmm0
mulsd  (%rax,%rdx,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x20(%rsp),%rdx
je     2120 <solve_Vanderbilt+0xe20>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
mulsd  0x8(%rax,%rcx,8),%xmm0
movsd  0x8(%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    2210 <solve_Vanderbilt+0xf10>
jmp    2120 <solve_Vanderbilt+0xe20>
cmpq   $0x0,0x60(%rsp)
je     2313 <solve_Vanderbilt+0x1013>
mov    0x98(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r15,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
movupd 0x10(%r15,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r13,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2280 <solve_Vanderbilt+0xf80>
testb  $0x1,0x68(%rsp)
je     22fd <solve_Vanderbilt+0xffd>
movupd (%r15,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
mov    0x70(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
je     2120 <solve_Vanderbilt+0xe20>
jmp    21cc <solve_Vanderbilt+0xecc>
xor    %ecx,%ecx
testb  $0x1,0x68(%rsp)
jne    22da <solve_Vanderbilt+0xfda>
jmp    22fd <solve_Vanderbilt+0xffd>
xchg   %ax,%ax
mov    %ebp,%eax
imul   %ebp,%eax
test   %eax,%eax
je     233e <solve_Vanderbilt+0x103e>
mov    %eax,%edx
shl    $0x3,%rdx
lea    0x150(%rsp),%rdi
xor    %esi,%esi
call   10c0 <memset@plt>
test   %ebp,%ebp
jle    2440 <solve_Vanderbilt+0x1140>
mov    %ebp,%eax
mov    %eax,%r11d
and    $0xfffffffe,%r11d
mov    %rax,%r14
shl    $0x4,%r14
lea    0x18c0(%rsp),%r8
mov    0x38(%rsp),%r9
xor    %r10d,%r10d
jmp    2388 <solve_Vanderbilt+0x1088>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0xa0,%r9
add    $0x8,%r8
cmp    %rax,%r10
je     2440 <solve_Vanderbilt+0x1140>
mov    %ebp,%ecx
imul   %r10d,%ecx
movslq %ecx,%rcx
add    %r10,%rcx
movabs $0x3ff0000000000000,%rdx
mov    %rdx,0x150(%rsp,%rcx,8)
cmp    $0x1,%ebp
jne    23b0 <solve_Vanderbilt+0x10b0>
xor    %edi,%edi
jmp    23f2 <solve_Vanderbilt+0x10f2>
nop
mov    %r8,%rsi
mov    %r9,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movslq (%rcx),%rdx
movsd  0x10f0(%rsp,%rdx,8),%xmm0
movsd  %xmm0,(%rsi)
movslq 0x28(%rcx),%rdx
movsd  0x10f0(%rsp,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x2,%rdi
add    $0x50,%rcx
add    %r14,%rsi
cmp    %rdi,%r11
jne    23c0 <solve_Vanderbilt+0x10c0>
test   $0x1,%al
je     2370 <solve_Vanderbilt+0x1070>
lea    (%r10,%r10,4),%rcx
shl    $0x5,%rcx
add    0x20e0(%rsp),%rcx
lea    (%rdi,%rdi,4),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    (%rsp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  0x10f0(%rsp,%rcx,8),%xmm0
imul   %rax,%rdi
add    %r10,%rdi
movsd  %xmm0,0x18c0(%rsp,%rdi,8)
jmp    2370 <solve_Vanderbilt+0x1070>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
lea    0x18c0(%rsp),%rsi
mov    %ebp,%edx
lea    0x150(%rsp),%rcx
xor    %eax,%eax
call   10d0 <gaussj@plt>
mov    0x20d0(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%r9d
test   %r9d,%r9d
mov    0x2118(%rsp),%r14
jle    2560 <solve_Vanderbilt+0x1260>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
mov    %r9,%rdx
shl    $0x4,%rdx
mov    0x38(%rsp),%r8
lea    0x150(%rsp),%r10
xor    %r11d,%r11d
jmp    24b8 <solve_Vanderbilt+0x11b8>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x8,%r10
add    $0xa0,%r8
cmp    %r9,%r11
je     2560 <solve_Vanderbilt+0x1260>
cmp    $0x1,%r9d
jne    24d0 <solve_Vanderbilt+0x11d0>
xor    %esi,%esi
jmp    2513 <solve_Vanderbilt+0x1213>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rax
mov    %r10,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm0
movslq (%rax),%rbp
movsd  %xmm0,0x920(%rsp,%rbp,8)
movsd  (%rdi,%r9,8),%xmm0
movslq 0x28(%rax),%rbp
movsd  %xmm0,0x920(%rsp,%rbp,8)
add    $0x2,%rsi
add    %rdx,%rdi
add    $0x50,%rax
cmp    %rsi,%rcx
jne    24e0 <solve_Vanderbilt+0x11e0>
test   $0x1,%r9b
je     24a0 <solve_Vanderbilt+0x11a0>
mov    %rsi,%rax
imul   %r9,%rax
add    %r11,%rax
movsd  0x150(%rsp,%rax,8),%xmm0
lea    (%r11,%r11,4),%rax
shl    $0x5,%rax
add    0x20e0(%rsp),%rax
lea    (%rsi,%rsi,4),%rsi
lea    (%rax,%rsi,8),%rax
mov    (%rsp),%rsi
movslq (%rax,%rsi,4),%rax
movsd  %xmm0,0x920(%rsp,%rax,8)
jmp    24a0 <solve_Vanderbilt+0x11a0>
nopw   0x0(%rax,%rax,1)
mov    0x14(%rsp),%r11d
test   %r11d,%r11d
jle    2060 <solve_Vanderbilt+0xd60>
lea    -0x1(%r9),%r8
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
xor    %esi,%esi
jmp    258d <solve_Vanderbilt+0x128d>
nopl   (%rax)
add    $0x1,%rsi
cmp    %rbx,%rsi
je     2060 <solve_Vanderbilt+0xd60>
test   %r9d,%r9d
jle    2580 <solve_Vanderbilt+0x1280>
mov    0x38(%rsp),%rdi
xor    %ebp,%ebp
jmp    25b9 <solve_Vanderbilt+0x12b9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0xa0,%rdi
cmp    %r9,%rbp
mov    0x8(%rsp),%rbx
je     26c0 <solve_Vanderbilt+0x13c0>
movq   $0x0,0x150(%rsp,%rbp,8)
xorpd  %xmm0,%xmm0
test   %r8,%r8
je     2650 <solve_Vanderbilt+0x1350>
mov    $0x28,%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
movslq -0x28(%r12,%rax,1),%rbx
mov    (%r15,%rbx,8),%rbx
movslq -0x28(%rdi,%rax,1),%rdx
movsd  0x920(%rsp,%rdx,8),%xmm1
mulsd  (%rbx,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x150(%rsp,%rbp,8)
movslq (%r12,%rax,1),%rdx
mov    (%r15,%rdx,8),%rdx
movslq (%rdi,%rax,1),%rbx
movsd  0x920(%rsp,%rbx,8),%xmm0
mulsd  (%rdx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x150(%rsp,%rbp,8)
add    $0x2,%rcx
add    $0x50,%rax
cmp    %rcx,%r10
jne    25e0 <solve_Vanderbilt+0x12e0>
test   $0x1,%r9b
je     25a0 <solve_Vanderbilt+0x12a0>
jmp    265c <solve_Vanderbilt+0x135c>
nopl   0x0(%rax)
xor    %ecx,%ecx
test   $0x1,%r9b
je     25a0 <solve_Vanderbilt+0x12a0>
shl    $0x3,%rcx
lea    (%rcx,%rcx,4),%rax
mov    0x20d8(%rsp),%rcx
add    %rax,%rcx
mov    (%rsp),%rbx
movslq (%rcx,%rbx,4),%rcx
mov    (%r15,%rcx,8),%rcx
lea    0x0(,%rbp,4),%rdx
add    %rbp,%rdx
shl    $0x5,%rdx
add    0x20e0(%rsp),%rdx
add    %rax,%rdx
movslq (%rdx,%rbx,4),%rax
movsd  0x920(%rsp,%rax,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x150(%rsp,%rbp,8)
jmp    25a0 <solve_Vanderbilt+0x12a0>
nopl   0x0(%rax)
test   %r9d,%r9d
jle    2580 <solve_Vanderbilt+0x1280>
test   %r8,%r8
je     2724 <solve_Vanderbilt+0x1424>
mov    %r12,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq (%rcx),%rdx
mov    (%r15,%rdx,8),%rdx
movsd  0x150(%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movslq 0x28(%rcx),%rdx
mov    (%r15,%rdx,8),%rdx
movsd  0x158(%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x2,%rax
add    $0x50,%rcx
cmp    %rax,%r10
jne    26e0 <solve_Vanderbilt+0x13e0>
test   $0x1,%r9b
je     2580 <solve_Vanderbilt+0x1280>
jmp    2730 <solve_Vanderbilt+0x1430>
xor    %eax,%eax
test   $0x1,%r9b
je     2580 <solve_Vanderbilt+0x1280>
lea    (%rax,%rax,4),%rcx
mov    0x20d8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    (%rsp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%r15,%rcx,8),%rcx
movsd  0x150(%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
jmp    2580 <solve_Vanderbilt+0x1280>
movl   $0x0,0x58(%rsp)
jmp    276f <solve_Vanderbilt+0x146f>
mov    $0x1,%al
mov    %eax,0x58(%rsp)
mov    0x20d0(%rsp),%r12
xor    %eax,%eax
call   10f0 <rho_valence_Atom@plt>
movslq %eax,%rdi
mov    0x14(%rsp),%eax
test   %eax,%eax
jle    2954 <solve_Vanderbilt+0x1654>
cmp    $0x4,%eax
jae    283c <solve_Vanderbilt+0x153c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
mov    %rbx,%rdx
and    $0x3,%rdx
je     27cc <solve_Vanderbilt+0x14cc>
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    27b0 <solve_Vanderbilt+0x14b0>
cmp    $0x3,%rcx
jb     2954 <solve_Vanderbilt+0x1654>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm0
mulsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rdi,%rax,8),%xmm0
mulsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    27e0 <solve_Vanderbilt+0x14e0>
jmp    2954 <solve_Vanderbilt+0x1654>
lea    0x0(,%rbx,8),%rax
add    %r13,%rax
lea    (%rdi,%rbx,8),%rcx
lea    (%r14,%rbx,8),%rdx
cmp    %rcx,%r13
setb   %sil
cmp    %rax,%rdi
setb   %bl
cmp    %rdx,%r13
setb   %cl
cmp    %r14,%rax
seta   %dl
xor    %eax,%eax
test   %bl,%sil
jne    3975 <solve_Vanderbilt+0x2675>
and    %dl,%cl
mov    0x8(%rsp),%rbx
jne    2798 <solve_Vanderbilt+0x1498>
mov    %ebx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     3a8a <solve_Vanderbilt+0x278a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd (%rdi,%rcx,8),%xmm0
movupd 0x10(%rdi,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm0,0x10(%r13,%rcx,8)
movupd 0x20(%rdi,%rcx,8),%xmm0
movupd 0x30(%rdi,%rcx,8),%xmm1
movupd 0x20(%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r13,%rcx,8)
movupd %xmm0,0x30(%r13,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    28b0 <solve_Vanderbilt+0x15b0>
test   $0x1,%dl
je     294b <solve_Vanderbilt+0x164b>
movupd (%rdi,%rcx,8),%xmm0
movupd 0x10(%rdi,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rcx,8)
movupd %xmm0,0x10(%r13,%rcx,8)
cmp    %rbx,%rax
jne    2798 <solve_Vanderbilt+0x1498>
mov    %rdi,0x50(%rsp)
mov    %r13,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
cmpb   $0x0,0x58(%rsp)
je     2985 <solve_Vanderbilt+0x1685>
mov    %r13,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
lea    0x17a2(%rip),%rdi
call   1050 <puts@plt>
jmp    3175 <solve_Vanderbilt+0x1e75>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x48(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x48(%rsp)
lea    0x0(,%rbx,8),%rdx
add    %r13,%rdx
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbx,8),%rax
mov    %ebx,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x90(%rsp)
add    $0xfffffffffffffffe,%rsi
mov    %rsi,0x38(%rsp)
shr    %rsi
add    $0x1,%rsi
cmp    %rax,%r13
setb   %al
mov    %rdx,0x60(%rsp)
cmp    %rdx,%rcx
setb   %cl
and    %al,%cl
mov    %cl,0x68(%rsp)
mov    %rsi,%rax
mov    %rsi,0x88(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xa8(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x70(%rsp)
xor    %esi,%esi
mov    0x14(%rsp),%edx
jmp    2a2f <solve_Vanderbilt+0x172f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    0x48(%rsp),%rsi
je     2f6b <solve_Vanderbilt+0x1c6b>
mov    (%r12,%rsi,4),%eax
test   %eax,%eax
jle    2a20 <solve_Vanderbilt+0x1720>
xor    %edi,%edi
mov    %rsi,0x40(%rsp)
jmp    2a59 <solve_Vanderbilt+0x1759>
mov    0x40(%rsp),%rsi
mov    0xb8(%rsp),%rdi
movslq %eax,%rcx
add    $0x1,%rdi
cmp    %rcx,%rdi
jge    2a20 <solve_Vanderbilt+0x1720>
test   %eax,%eax
jle    2a4d <solve_Vanderbilt+0x174d>
mov    %rdi,0xb8(%rsp)
lea    (%rdi,%rdi,4),%rcx
mov    0x20d8(%rsp),%rax
mov    %rcx,0x80(%rsp)
lea    (%rax,%rcx,8),%rax
movslq (%rax,%rsi,4),%rax
mov    0x20e8(%rsp),%rcx
mov    (%rcx,%rax,8),%rbp
mov    0x20f0(%rsp),%rcx
mov    (%rcx,%rax,8),%r15
lea    (%r15,%rbx,8),%rdi
lea    0x0(,%rbx,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%r13
setb   %cl
mov    0x60(%rsp),%rsi
cmp    %rsi,%rbp
setb   %al
and    %cl,%al
mov    %al,0x98(%rsp)
cmp    %rdi,%r13
setb   %al
cmp    %rsi,%r15
setb   %cl
and    %al,%cl
mov    %cl,0xb0(%rsp)
xor    %ecx,%ecx
jmp    2b9d <solve_Vanderbilt+0x189d>
xchg   %ax,%ax
mov    0x20d0(%rsp),%r14
mov    0x20(%rsp),%rcx
mov    0x40(%rsp),%r12
lea    (%rcx,%r12,4),%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %r13,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
mov    0x80(%rsp),%rax
shl    $0x5,%rax
add    0x20e0(%rsp),%rax
mov    0x28(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
movslq (%rax,%r12,4),%rax
mov    0x2128(%rsp),%rcx
movapd %xmm1,%xmm0
movsd  %xmm1,(%rcx,%rax,8)
movslq (%rbx),%rcx
mov    0xc0(%rsp),%rdx
mulsd  (%rdx,%rcx,8),%xmm0
addsd  0x10f0(%rsp,%rax,8),%xmm0
subsd  0x78(%rsp),%xmm0
mov    0x2120(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    (%rsp),%rcx
add    $0x1,%rcx
movslq (%r14,%r12,4),%rax
cmp    %rax,%rcx
mov    0x8(%rsp),%rbx
mov    0x14(%rsp),%edx
mov    %r14,%r12
jge    2a40 <solve_Vanderbilt+0x1740>
lea    (%rcx,%rcx,4),%r14
mov    0x20d8(%rsp),%rax
lea    (%rax,%r14,8),%rsi
test   %edx,%edx
mov    %rcx,(%rsp)
mov    %r14,0x28(%rsp)
jle    2c00 <solve_Vanderbilt+0x1900>
mov    0x40(%rsp),%rax
mov    %rsi,0x20(%rsp)
movslq (%rsi,%rax,4),%rcx
mov    0x20e8(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    0x20f0(%rsp),%rsi
mov    (%rsi,%rcx,8),%r12
cmp    $0x1,%edx
jne    2c20 <solve_Vanderbilt+0x1920>
xor    %edx,%edx
mov    0x18(%rsp),%rsi
jmp    2d10 <solve_Vanderbilt+0x1a10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
xor    %eax,%eax
mov    %rsi,%rbx
call   1150 <Integrate_LogGrid@plt>
mov    %rbx,%rcx
mov    %r12,%r14
jmp    2aed <solve_Vanderbilt+0x17ed>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rbx,8),%rcx
cmp    %rcx,%r13
setb   %cl
cmp    0x60(%rsp),%rax
setb   %dl
and    %cl,%dl
or     0x98(%rsp),%dl
or     0x68(%rsp),%dl
mov    0x18(%rsp),%rsi
je     2c4d <solve_Vanderbilt+0x194d>
xor    %edx,%edx
jmp    2d10 <solve_Vanderbilt+0x1a10>
cmpq   $0x0,0x38(%rsp)
je     2f41 <solve_Vanderbilt+0x1c41>
mov    0xa8(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
movupd 0x10(%rbp,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r13,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2c70 <solve_Vanderbilt+0x1970>
testb  $0x1,0x88(%rsp)
01
je     2cef <solve_Vanderbilt+0x19ef>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd (%rax,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
mov    0x90(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
je     2d99 <solve_Vanderbilt+0x1a99>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rcx
test   $0x1,%bl
je     2d3e <solve_Vanderbilt+0x1a3e>
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  (%rax,%rdx,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x70(%rsp),%rdx
je     2d99 <solve_Vanderbilt+0x1a99>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
mulsd  0x8(%rax,%rcx,8),%xmm0
movsd  0x8(%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    2d50 <solve_Vanderbilt+0x1a50>
mov    %r13,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
jle    2ae0 <solve_Vanderbilt+0x17e0>
cmp    $0x1,%ecx
jne    2dc0 <solve_Vanderbilt+0x1ac0>
xor    %edx,%edx
mov    0x18(%rsp),%rsi
jmp    2eb0 <solve_Vanderbilt+0x1bb0>
lea    (%r12,%rbx,8),%rcx
cmp    %rcx,%r13
setb   %cl
cmp    0x60(%rsp),%r12
setb   %dl
and    %cl,%dl
or     0xb0(%rsp),%dl
or     0x68(%rsp),%dl
mov    0x18(%rsp),%rsi
je     2ded <solve_Vanderbilt+0x1aed>
xor    %edx,%edx
jmp    2eb0 <solve_Vanderbilt+0x1bb0>
cmpq   $0x0,0x38(%rsp)
je     2f56 <solve_Vanderbilt+0x1c56>
mov    0xa8(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r15,%rcx,8),%xmm0
movupd (%r12,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
movupd 0x10(%r15,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r13,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2e10 <solve_Vanderbilt+0x1b10>
testb  $0x1,0x88(%rsp)
01
je     2e93 <solve_Vanderbilt+0x1b93>
movupd (%r15,%rcx,8),%xmm0
movupd (%r12,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd (%rsi,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
mov    0x90(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
je     2ae0 <solve_Vanderbilt+0x17e0>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%bl
je     2edf <solve_Vanderbilt+0x1bdf>
movsd  (%r15,%rdx,8),%xmm0
mulsd  (%r12,%rdx,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x70(%rsp),%rdx
je     2ae0 <solve_Vanderbilt+0x17e0>
nopl   (%rax)
movsd  (%r15,%rcx,8),%xmm0
mulsd  (%r12,%rcx,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
mulsd  0x8(%r12,%rcx,8),%xmm0
movsd  0x8(%rsi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    2ef0 <solve_Vanderbilt+0x1bf0>
jmp    2ae0 <solve_Vanderbilt+0x17e0>
xor    %ecx,%ecx
testb  $0x1,0x88(%rsp)
01
jne    2ccc <solve_Vanderbilt+0x19cc>
jmp    2cef <solve_Vanderbilt+0x19ef>
xor    %ecx,%ecx
testb  $0x1,0x88(%rsp)
01
jne    2e6f <solve_Vanderbilt+0x1b6f>
jmp    2e93 <solve_Vanderbilt+0x1b93>
mov    %r13,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
lea    0x11a1(%rip),%rdi
call   1050 <puts@plt>
cmpb   $0x0,0x58(%rsp)
jne    3175 <solve_Vanderbilt+0x1e75>
mov    0x20e0(%rsp),%rax
mov    %rax,(%rsp)
xor    %ebx,%ebx
jmp    2fb4 <solve_Vanderbilt+0x1cb4>
nopl   0x0(%rax)
add    $0x1,%rbx
addq   $0x4,(%rsp)
cmp    0x48(%rsp),%rbx
je     306a <solve_Vanderbilt+0x1d6a>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1040 <spd_Name@plt>
lea    0x10a3(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    (%r12,%rbx,4),%eax
test   %eax,%eax
jle    2fa0 <solve_Vanderbilt+0x1ca0>
mov    (%rsp),%rcx
mov    %rcx,0x18(%rsp)
xor    %r13d,%r13d
jmp    3025 <solve_Vanderbilt+0x1d25>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1086(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
add    $0x1,%r13
movslq (%r15,%rbx,4),%rax
addq   $0xa0,0x18(%rsp)
cmp    %rax,%r13
mov    %r15,%r12
jge    2fa0 <solve_Vanderbilt+0x1ca0>
test   %eax,%eax
mov    %r12,%r15
lea    0x1051(%rip),%r14
jle    2ff0 <solve_Vanderbilt+0x1cf0>
mov    0x18(%rsp),%rbp
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movslq 0x0(%rbp),%rax
movsd  0x10f0(%rsp,%rax,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
add    $0x1,%r12
movslq (%r15,%rbx,4),%rax
add    $0x28,%rbp
cmp    %rax,%r12
jl     3040 <solve_Vanderbilt+0x1d40>
jmp    2ff0 <solve_Vanderbilt+0x1cf0>
cmpb   $0x0,0x58(%rsp)
jne    3175 <solve_Vanderbilt+0x1e75>
mov    0x20e0(%rsp),%rax
mov    %rax,0x28(%rsp)
xor    %ebx,%ebx
jmp    30a5 <solve_Vanderbilt+0x1da5>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
addq   $0x4,0x28(%rsp)
cmp    0x48(%rsp),%rbx
je     316a <solve_Vanderbilt+0x1e6a>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1040 <spd_Name@plt>
lea    0xfd8(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    (%r12,%rbx,4),%eax
test   %eax,%eax
jle    3090 <solve_Vanderbilt+0x1d90>
mov    0x28(%rsp),%rcx
mov    %rcx,(%rsp)
xor    %ecx,%ecx
jmp    3119 <solve_Vanderbilt+0x1e19>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xf96(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
movslq (%r15,%rbx,4),%rax
addq   $0xa0,(%rsp)
cmp    %rax,%rcx
mov    %r15,%r12
jge    3090 <solve_Vanderbilt+0x1d90>
mov    %rcx,0x18(%rsp)
test   %eax,%eax
mov    %r12,%r15
mov    0x2120(%rsp),%r14
lea    0xf50(%rip),%r13
jle    30e0 <solve_Vanderbilt+0x1de0>
mov    (%rsp),%rbp
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movslq 0x0(%rbp),%rax
movsd  (%r14,%rax,8),%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
add    $0x1,%r12
movslq (%r15,%rbx,4),%rax
add    $0x28,%rbp
cmp    %rax,%r12
jl     3140 <solve_Vanderbilt+0x1e40>
jmp    30e0 <solve_Vanderbilt+0x1de0>
cmpb   $0x0,0x58(%rsp)
je     3998 <solve_Vanderbilt+0x2698>
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r14
xor    %eax,%eax
call   11e0 <alloc_LogGrid@plt>
movslq %eax,%r12
mov    0x50(%rsp),%rbp
mov    %rbp,%rdi
movsd  0xa0(%rsp),%xmm0
mov    %r13,%rsi
mov    $0x1,%al
call   1170 <R_Hartree_DFT@plt>
mov    %eax,%r15d
lea    0x148(%rsp),%rdx
lea    0xc8(%rsp),%rcx
mov    %rbp,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1100 <R_Exchange_DFT@plt>
lea    0x140(%rsp),%rdx
lea    0xf0(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1210 <R_Correlation_DFT@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,(%rsp)
mov    0x14(%rsp),%eax
test   %eax,%eax
jle    32b8 <solve_Vanderbilt+0x1fb8>
cmp    $0x4,%eax
mov    0x2100(%rsp),%rbp
jae    32df <solve_Vanderbilt+0x1fdf>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    0x50(%rsp),%rbx
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
and    $0x3,%rdx
je     324b <solve_Vanderbilt+0x1f4b>
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    3230 <solve_Vanderbilt+0x1f30>
cmp    $0x3,%rcx
mov    0x8(%rsp),%rcx
jb     3403 <solve_Vanderbilt+0x2103>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
mulsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
mulsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    3260 <solve_Vanderbilt+0x1f60>
jmp    3403 <solve_Vanderbilt+0x2103>
mov    0x2100(%rsp),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xc8(%rsp)
jmp    35f3 <solve_Vanderbilt+0x22f3>
mov    0x8(%rsp),%rdx
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
mov    0x50(%rsp),%rbx
lea    (%rbx,%rdx,8),%rcx
lea    (%r14,%rdx,8),%rdx
cmp    %rbp,%rcx
seta   %sil
cmp    %rax,%rbx
setb   %dil
cmp    %rbp,%rdx
seta   %cl
cmp    %rax,%r14
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    397f <solve_Vanderbilt+0x267f>
and    %dl,%cl
mov    0x8(%rsp),%rdx
jne    3221 <solve_Vanderbilt+0x1f21>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     3a9a <solve_Vanderbilt+0x279a>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm0
movupd 0x30(%rbx,%rcx,8),%xmm1
movupd 0x20(%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbp,%rcx,8)
movupd %xmm0,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    3360 <solve_Vanderbilt+0x2060>
test   $0x1,%dl
je     33f5 <solve_Vanderbilt+0x20f5>
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r14,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
jne    3221 <solve_Vanderbilt+0x1f21>
mov    %rbp,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
mov    0x50(%rsp),%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    0x14(%rsp),%eax
test   %eax,%eax
jle    35f3 <solve_Vanderbilt+0x22f3>
cmp    $0x4,%eax
jae    343a <solve_Vanderbilt+0x213a>
xor    %eax,%eax
jmp    3555 <solve_Vanderbilt+0x2255>
mov    0x8(%rsp),%rdx
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
lea    (%rbx,%rdx,8),%rcx
lea    (%r12,%rdx,8),%rdx
cmp    %rbp,%rcx
seta   %sil
cmp    %rax,%rbx
setb   %dil
cmp    %rbp,%rdx
seta   %cl
cmp    %rax,%r12
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    3555 <solve_Vanderbilt+0x2255>
and    %dl,%cl
mov    0x8(%rsp),%rdx
jne    355a <solve_Vanderbilt+0x225a>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     3c08 <solve_Vanderbilt+0x2908>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm0
movupd 0x30(%rbx,%rcx,8),%xmm1
movupd 0x20(%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r12,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbp,%rcx,8)
movupd %xmm0,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    34b0 <solve_Vanderbilt+0x21b0>
test   $0x1,%dl
je     3545 <solve_Vanderbilt+0x2245>
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r12,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r12,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm0,0x10(%rbp,%rcx,8)
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
je     35f3 <solve_Vanderbilt+0x22f3>
jmp    355a <solve_Vanderbilt+0x225a>
mov    0x8(%rsp),%rdx
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
and    $0x3,%rdx
je     358b <solve_Vanderbilt+0x228b>
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    3570 <solve_Vanderbilt+0x2270>
cmp    $0x3,%rcx
mov    0x8(%rsp),%rcx
jb     35f3 <solve_Vanderbilt+0x22f3>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
mulsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
mulsd  0x18(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    35a0 <solve_Vanderbilt+0x22a0>
mov    0x2160(%rsp),%r15
mov    0x2158(%rsp),%rbx
movsd  0xa0d(%rip),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %rbp,%rdi
xor    %eax,%eax
call   1150 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xf0(%rsp)
cmpl   $0x0,0xd8(%rsp)
jle    36bf <solve_Vanderbilt+0x23bf>
mov    %r13,%rbx
xorpd  %xmm6,%xmm6
mov    0xd4(%rsp),%r13d
mov    0xd0(%rsp),%r15d
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm6,0x18(%rsp)
mov    %r13d,%edi
xor    %eax,%eax
call   1060 <fill_Atom@plt>
mov    %eax,%ebp
mov    %r13d,%edi
xor    %eax,%eax
call   1180 <eigenvalue_Atom@plt>
movsd  0x18(%rsp),%xmm6
imul   %ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%r13d
cmp    %r15d,%r13d
jl     3660 <solve_Vanderbilt+0x2360>
movsd  0xf0(%rsp),%xmm0
mov    0x2100(%rsp),%rbp
mov    %rbx,%r13
mov    0x2160(%rsp),%r15
mov    0x2158(%rsp),%rbx
jmp    36c3 <solve_Vanderbilt+0x23c3>
xorpd  %xmm6,%xmm6
movsd  0x28(%rsp),%xmm5
addsd  %xmm5,%xmm6
movsd  0x148(%rsp),%xmm1
addsd  %xmm1,%xmm6
movsd  0x140(%rsp),%xmm2
addsd  %xmm2,%xmm6
movsd  (%rsp),%xmm4
subsd  %xmm4,%xmm6
movsd  0xc8(%rsp),%xmm3
subsd  %xmm3,%xmm6
subsd  %xmm0,%xmm6
mov    0x2130(%rsp),%rax
movsd  %xmm6,(%rax)
mov    0x2138(%rsp),%rax
movsd  %xmm5,(%rax)
mov    0x2140(%rsp),%rax
movsd  %xmm4,(%rax)
mov    0x2148(%rsp),%rax
movsd  %xmm1,(%rax)
mov    0x2150(%rsp),%rax
movsd  %xmm3,(%rax)
movsd  %xmm2,(%rbx)
movsd  %xmm0,(%r15)
mov    0x14(%rsp),%edi
test   %edi,%edi
mov    0x50(%rsp),%rbx
jle    3bd8 <solve_Vanderbilt+0x28d8>
cmp    $0x4,%edi
jae    380c <solve_Vanderbilt+0x250c>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
je     379b <solve_Vanderbilt+0x249b>
mov    0x2118(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
subsd  0x0(%r13,%rax,8),%xmm0
subsd  (%r14,%rax,8),%xmm0
subsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
or     $0x1,%rax
mov    0x8(%rsp),%rdx
add    %rdx,%rcx
mov    0x2118(%rsp),%rcx
je     390d <solve_Vanderbilt+0x260d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
subsd  0x0(%r13,%rax,8),%xmm0
subsd  (%r14,%rax,8),%xmm0
subsd  (%r12,%rax,8),%xmm0
movsd  0x8(%rcx,%rax,8),%xmm1
movsd  %xmm0,(%rcx,%rax,8)
subsd  0x8(%r13,%rax,8),%xmm1
subsd  0x8(%r14,%rax,8),%xmm1
subsd  0x8(%r12,%rax,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    37c0 <solve_Vanderbilt+0x24c0>
jmp    390d <solve_Vanderbilt+0x260d>
mov    0x8(%rsp),%rsi
mov    0x2118(%rsp),%rdx
lea    (%rdx,%rsi,8),%rax
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
lea    (%r14,%rsi,8),%r10
lea    (%r12,%rsi,8),%rsi
cmp    %rdx,%rcx
seta   %r8b
cmp    %rax,%r13
setb   %r9b
cmp    %rdx,%r10
seta   %cl
cmp    %rax,%r14
setb   %r11b
cmp    %rdx,%rsi
seta   %dl
cmp    %rax,%r12
setb   %r10b
xor    %eax,%eax
test   %r9b,%r8b
jne    3989 <solve_Vanderbilt+0x2689>
and    %r11b,%cl
jne    3989 <solve_Vanderbilt+0x2689>
and    %r10b,%dl
mov    0x8(%rsp),%rdx
mov    0x2118(%rsp),%rsi
mov    0x50(%rsp),%rbx
jne    3767 <solve_Vanderbilt+0x2467>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    0x0(,%rdx,8),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd (%rsi,%rdx,1),%xmm0
movupd 0x10(%rsi,%rdx,1),%xmm1
movupd 0x0(%r13,%rdx,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r13,%rdx,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%r14,%rdx,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r14,%rdx,1),%xmm2
subpd  %xmm2,%xmm1
movupd (%r12,%rdx,1),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r12,%rdx,1),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%rsi,%rdx,1)
movupd %xmm1,0x10(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rcx
jne    38a0 <solve_Vanderbilt+0x25a0>
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
jne    3767 <solve_Vanderbilt+0x2467>
test   %edi,%edi
jle    3bd8 <solve_Vanderbilt+0x28d8>
cmp    $0x4,%edi
jae    3926 <solve_Vanderbilt+0x2626>
xor    %eax,%eax
mov    0x8(%rsp),%rdx
jmp    3b69 <solve_Vanderbilt+0x2869>
mov    0x8(%rsp),%rdx
lea    (%rbx,%rdx,8),%rax
cmp    %rbp,%rax
jbe    394b <solve_Vanderbilt+0x264b>
lea    0x0(,%rdx,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    394b <solve_Vanderbilt+0x264b>
xor    %eax,%eax
jmp    3b69 <solve_Vanderbilt+0x2869>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0xc,%rsi
jae    3aaa <solve_Vanderbilt+0x27aa>
xor    %esi,%esi
jmp    3b1d <solve_Vanderbilt+0x281d>
mov    0x8(%rsp),%rbx
jmp    2798 <solve_Vanderbilt+0x1498>
mov    0x8(%rsp),%rdx
jmp    3221 <solve_Vanderbilt+0x1f21>
mov    0x8(%rsp),%rdx
mov    0x50(%rsp),%rbx
jmp    3767 <solve_Vanderbilt+0x2467>
xor    %ebx,%ebx
jmp    39b8 <solve_Vanderbilt+0x26b8>
nopl   0x0(%rax)
add    $0x1,%rbx
addq   $0x4,0xe0(%rsp)
cmp    0x48(%rsp),%rbx
je     3175 <solve_Vanderbilt+0x1e75>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   1040 <spd_Name@plt>
lea    0x6d6(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    (%r12,%rbx,4),%eax
test   %eax,%eax
jle    39a0 <solve_Vanderbilt+0x26a0>
mov    0xe0(%rsp),%rcx
mov    %rcx,(%rsp)
xor    %ecx,%ecx
jmp    3a39 <solve_Vanderbilt+0x2739>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x677(%rip),%rdi
xor    %eax,%eax
call   10a0 <printf@plt>
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
movslq (%r14,%rbx,4),%rax
addq   $0xa0,(%rsp)
cmp    %rax,%rcx
mov    %r14,%r12
jge    39a0 <solve_Vanderbilt+0x26a0>
mov    %rcx,0x18(%rsp)
test   %eax,%eax
mov    %r12,%r14
mov    0x2128(%rsp),%r13
lea    0x630(%rip),%rbp
jle    3a00 <solve_Vanderbilt+0x2700>
mov    (%rsp),%r15
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movslq (%r15),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
add    $0x1,%r12
movslq (%r14,%rbx,4),%rax
add    $0x28,%r15
cmp    %rax,%r12
jl     3a60 <solve_Vanderbilt+0x2760>
jmp    3a00 <solve_Vanderbilt+0x2700>
xor    %ecx,%ecx
test   $0x1,%dl
jne    291d <solve_Vanderbilt+0x161d>
jmp    294b <solve_Vanderbilt+0x164b>
xor    %ecx,%ecx
test   $0x1,%dl
jne    33c9 <solve_Vanderbilt+0x20c9>
jmp    33f5 <solve_Vanderbilt+0x20f5>
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopl   (%rax)
movups (%rbx,%rsi,8),%xmm0
movups 0x10(%rbx,%rsi,8),%xmm1
movups %xmm0,0x0(%rbp,%rsi,8)
movups %xmm1,0x10(%rbp,%rsi,8)
movups 0x20(%rbx,%rsi,8),%xmm0
movups 0x30(%rbx,%rsi,8),%xmm1
movups %xmm0,0x20(%rbp,%rsi,8)
movups %xmm1,0x30(%rbp,%rsi,8)
movups 0x40(%rbx,%rsi,8),%xmm0
movups 0x50(%rbx,%rsi,8),%xmm1
movups %xmm0,0x40(%rbp,%rsi,8)
movups %xmm1,0x50(%rbp,%rsi,8)
movupd 0x60(%rbx,%rsi,8),%xmm0
movupd 0x70(%rbx,%rsi,8),%xmm1
movupd %xmm0,0x60(%rbp,%rsi,8)
movupd %xmm1,0x70(%rbp,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    3ac0 <solve_Vanderbilt+0x27c0>
test   %rcx,%rcx
je     3b5f <solve_Vanderbilt+0x285f>
lea    0x10(,%rsi,8),%rdx
add    %rbp,%rdx
lea    (%rbx,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    3b40 <solve_Vanderbilt+0x2840>
mov    0x8(%rsp),%rdx
cmp    %rdx,%rax
je     3bd8 <solve_Vanderbilt+0x28d8>
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
and    $0x3,%rdx
je     3b95 <solve_Vanderbilt+0x2895>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    3b80 <solve_Vanderbilt+0x2880>
cmp    $0x3,%rcx
mov    0x8(%rsp),%rcx
jb     3bd8 <solve_Vanderbilt+0x28d8>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    3ba0 <solve_Vanderbilt+0x28a0>
mov    %r13,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   11c0 <dealloc_LogGrid@plt>
add    $0x2098,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    3519 <solve_Vanderbilt+0x2219>
jmp    3545 <solve_Vanderbilt+0x2245>

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

LLVM IR (-O2):
@.str.2 = [33 x i8] c"%s\09%lf %lf %lf %lf %lf %lf\0A\00"
@.str.5 = [17 x i8] c"B(i,j) l=%s : \00"
@.str.6 = [5 x i8] c"%le \00"
@.str.7 = [16 x i8] c" \00"
@.str.8 = [17 x i8] c"D0(i,j) l=%s : \00"
@.str.9 = [16 x i8] c"q(i,j) l=%s : \00"
@.str.10 = [15 x i8] c" \00"
@str = [36 x i8] c"\0A\0AVanderbilt pseudopotential check\0A\00"
@str.11 = [65 x i8] c"l\09rcore rmatch E in E psp norm test slope test\00"
@str.12 = [29 x i8] c"\0A\0AVanderbilt matrix elements\00"
define void @solve_Vanderbilt(i32 %0, i32* nocapture %1, i32* nocapture %2, double* nocapture %3, double* nocapture readnone %4, double* nocapture %5, double %6, double %7, i32* nocapture %8, [10 x i32]* nocapture %9, [4 x [10 x i32]]* nocapture %10, double** nocapture %11, double** nocapture %12, double** nocapture %13, double* %14, double* nocapture readnone %15, double** nocapture %16, double* nocapture %17, double* nocapture %18, double* nocapture %19, double* nocapture writeonly %20, double* nocapture writeonly %21, double* nocapture writeonly %22, double* nocapture writeonly %23, double* nocapture writeonly %24, double* nocapture writeonly %25, double* nocapture writeonly %26) {
%28 = bitcast double* %14 to i8*
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca [250 x double]
%34 = alloca [250 x double]
%35 = alloca [250 x double]
%36 = bitcast [250 x double]* %35 to i8*
%37 = alloca [250 x double]
%38 = bitcast double* %29 to i8*
%39 = bitcast double* %30 to i8*
%40 = bitcast double* %31 to i8*
%41 = bitcast double* %32 to i8*
%42 = bitcast [250 x double]* %33 to i8*
%43 = bitcast [250 x double]* %34 to i8*
%44 = bitcast [250 x double]* %37 to i8*
%45 = tail call i32 (...) @Vall_Atom()
%46 = sext i32 %45 to i64
%47 = inttoptr i64 %46 to double*
%48 = tail call i32 (...) @r_LogGrid()
%49 = sext i32 %48 to i64
%50 = inttoptr i64 %49 to double*
%51 = inttoptr i64 %49 to i8*
%52 = tail call i32 (...) @N_LogGrid()
%53 = tail call i32 (...) @log_amesh_LogGrid()
%54 = sitofp i32 %53 to double
%55 = tail call i32 (...) @amesh_LogGrid()
%56 = tail call i32 (...) @Ncore_Atom()
%57 = tail call i32 (...) @Nvalence_Atom()
%58 = add nsw i32 %57, %56
%59 = icmp sgt i32 %57, 0
br i1 %59, label %63, label %60
60: ; preds = %63, %27
%61 = phi double [ 0.000000e+00, %27 ], [ %68, %63 ]
%62 = icmp sgt i32 %52, 0
br i1 %62, label %71, label %91
63: ; preds = %27, %63
%64 = phi i32 [ %69, %63 ], [ %56, %27 ]
%65 = phi double [ %68, %63 ], [ 0.000000e+00, %27 ]
%66 = tail call i32 (i32, ...) bitcast (i32 (...)* @fill_Atom to i32 (i32, ...)*)(i32 %64)
%67 = sitofp i32 %66 to double
%68 = fadd double %65, %67
%69 = add nsw i32 %64, 1
%70 = icmp slt i32 %69, %58
br i1 %70, label %63, label %60
71: ; preds = %60
%72 = zext i32 %52 to i64
%73 = shl nuw nsw i64 %72, 3
%74 = zext i32 %52 to i64
br label %75
75: ; preds = %71, %75
%76 = phi i64 [ 0, %71 ], [ %89, %75 ]
%77 = getelementptr inbounds double, double* %50, i64 %76
%78 = load double, double* %77
%79 = fdiv double %78, %6
%80 = tail call double @pow(double %79, double 3.500000e+00)
%81 = fneg double %80
%82 = tail call double @exp(double %81)
%83 = fsub double 1.000000e+00, %82
%84 = getelementptr inbounds double, double* %47, i64 %76
%85 = load double, double* %84
%86 = fmul double %82, %7
%87 = tail call double @llvm.fmuladd.f64(double %83, double %85, double %86)
%88 = getelementptr inbounds double, double* %17, i64 %76
store double %87, double* %88
%89 = add nuw nsw i64 %76, 1
%90 = icmp eq i64 %89, %74
br i1 %90, label %91, label %75
91: ; preds = %75, %60
%92 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str, i64 0, i64 0))
%93 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.11, i64 0, i64 0))
%94 = tail call i32 (...) @alloc_LogGrid()
%95 = sext i32 %94 to i64
%96 = inttoptr i64 %95 to double*
%97 = inttoptr i64 %95 to i8*
%98 = icmp sgt i32 %0, 0
br i1 %98, label %99, label %160
99: ; preds = %91
%100 = icmp slt i32 %52, 1
%101 = zext i32 %0 to i64
%102 = zext i32 %52 to i64
%103 = zext i32 %52 to i64
%104 = zext i32 %52 to i64
%105 = zext i32 %52 to i64
%106 = getelementptr double, double* %96, i64 %102
%107 = bitcast double* %106 to i8*
%108 = getelementptr double, double* %50, i64 %102
%109 = bitcast double* %108 to i8*
%110 = getelementptr double, double* %17, i64 %102
%111 = and i64 %102, 4294967292
%112 = add nsw i64 %111, -4
%113 = lshr exact i64 %112, 2
%114 = add nuw nsw i64 %113, 1
%115 = and i64 %102, 4294967294
%116 = add nsw i64 %115, -2
%117 = lshr exact i64 %116, 1
%118 = add nuw i64 %117, 1
%119 = icmp ult i32 %52, 4
%120 = and i64 %102, 4294967292
%121 = and i64 %114, 1
%122 = icmp eq i64 %112, 0
%123 = and i64 %114, 9223372036854775806
%124 = icmp eq i64 %121, 0
%125 = icmp eq i64 %120, %102
%126 = and i64 %102, 1
%127 = icmp eq i64 %126, 0
%128 = sub nsw i64 0, %102
%129 = icmp ult i32 %52, 4
%130 = and i64 %102, 4294967292
%131 = and i64 %114, 1
%132 = icmp eq i64 %112, 0
%133 = and i64 %114, 9223372036854775806
%134 = icmp eq i64 %131, 0
%135 = icmp eq i64 %130, %102
%136 = and i64 %102, 1
%137 = icmp eq i64 %136, 0
%138 = sub nsw i64 0, %102
%139 = icmp ult i32 %52, 4
%140 = and i64 %102, 4294967292
%141 = icmp eq i64 %140, %102
%142 = and i64 %102, 1
%143 = icmp eq i64 %142, 0
%144 = sub nsw i64 0, %102
%145 = icmp eq i32 %52, 1
%146 = icmp ult i8* %97, %109
%147 = icmp ult i8* %51, %107
%148 = and i1 %146, %147
%149 = and i64 %102, 4294967294
%150 = and i64 %118, 1
%151 = icmp eq i64 %116, 0
%152 = and i64 %118, -2
%153 = icmp eq i64 %150, 0
%154 = icmp eq i64 %149, %102
%155 = and i64 %102, 1
%156 = icmp eq i64 %155, 0
%157 = sub nsw i64 0, %102
br label %189
158: ; preds = %695
%159 = icmp slt i32 %696, 0
br i1 %159, label %1072, label %160
160: ; preds = %91, %158
%161 = phi i32 [ %696, %158 ], [ 0, %91 ]
%162 = getelementptr inbounds [250 x double], [250 x double]* %37, i64 0, i64 0
%163 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 0
%164 = add nuw i32 %161, 1
%165 = zext i32 %164 to i64
%166 = zext i32 %52 to i64
%167 = zext i32 %52 to i64
%168 = getelementptr double, double* %96, i64 %166
%169 = bitcast double* %168 to i8*
%170 = getelementptr double, double* %50, i64 %166
%171 = bitcast double* %170 to i8*
%172 = and i64 %166, 4294967294
%173 = add nsw i64 %172, -2
%174 = lshr exact i64 %173, 1
%175 = add nuw i64 %174, 1
%176 = icmp eq i32 %52, 1
%177 = icmp ult i8* %97, %171
%178 = icmp ult i8* %51, %169
%179 = and i1 %177, %178
%180 = and i64 %166, 4294967294
%181 = and i64 %175, 1
%182 = icmp eq i64 %173, 0
%183 = and i64 %175, -2
%184 = icmp eq i64 %181, 0
%185 = icmp eq i64 %180, %166
%186 = and i64 %166, 1
%187 = icmp eq i64 %186, 0
%188 = sub nsw i64 0, %166
br label %700
189: ; preds = %99, %695
%190 = phi i64 [ 0, %99 ], [ %698, %695 ]
%191 = phi i32 [ 0, %99 ], [ %696, %695 ]
%192 = load double, double* %50
%193 = fdiv double 1.000000e+01, %192
%194 = tail call double @log(double %193)
%195 = fdiv double %194, %54
%196 = tail call double @llvm.rint.f64(double %195)
%197 = fptosi double %196 to i32
%198 = getelementptr inbounds double, double* %5, i64 %190
%199 = load double, double* %198
%200 = load double, double* %50
%201 = fdiv double %199, %200
%202 = fcmp ugt double %201, 0.000000e+00
br i1 %202, label %205, label %203
203: ; preds = %189
%204 = tail call double @log(double %201)
br label %205
205: ; preds = %189, %203
%206 = getelementptr inbounds double, double* %3, i64 %190
%207 = load double, double* %206
%208 = getelementptr inbounds double*, double** %12, i64 %190
%209 = load double*, double** %208
%210 = getelementptr inbounds double*, double** %13, i64 %190
%211 = load double*, double** %210
%212 = getelementptr inbounds double*, double** %11, i64 %190
%213 = load double*, double** %212
%214 = tail call i32 (...) @alloc_LogGrid()
%215 = sext i32 %214 to i64
%216 = inttoptr i64 %215 to double*
%217 = inttoptr i64 %215 to i8*
%218 = getelementptr inbounds double*, double** %16, i64 %190
%219 = load double*, double** %218
%220 = getelementptr inbounds i32, i32* %2, i64 %190
%221 = load i32, i32* %220
%222 = icmp sgt i32 %221, %191
%223 = getelementptr inbounds i32, i32* %1, i64 %190
%224 = load i32, i32* %223
%225 = tail 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 %224, i32 %221, double* %47, i32 %197, double %207, double* %213, double* %216)
%226 = load double, double* %198
%227 = load double, double* %50
%228 = fdiv double %226, %227
%229 = tail call double @log(double %228)
%230 = fdiv double %229, %54
%231 = tail call double @llvm.rint.f64(double %230)
%232 = fptosi double %231 to i32
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %213, i64 %233
%235 = load double, double* %234
%236 = fdiv double 1.000000e+00, %235
%237 = tail call double @llvm.fabs.f64(double %236)
%238 = getelementptr inbounds double, double* %50, i64 %233
%239 = getelementptr inbounds double, double* %209, i64 %233
%240 = getelementptr inbounds double, double* %216, i64 %233
%241 = getelementptr inbounds double, double* %211, i64 %233
%242 = getelementptr double, double* %209, i64 %102
%243 = bitcast double* %242 to i8*
%244 = getelementptr double, double* %219, i64 %102
%245 = bitcast double* %244 to i8*
%246 = getelementptr double, double* %219, i64 %102
%247 = getelementptr double, double* %209, i64 %102
%248 = getelementptr double, double* %213, i64 %102
%249 = bitcast double* %248 to i8*
%250 = getelementptr double, double* %216, i64 %102
%251 = getelementptr double, double* %213, i64 %102
%252 = bitcast double* %251 to i8*
%253 = getelementptr double, double* %216, i64 %102
%254 = icmp ult double* %213, %253
%255 = icmp ult i8* %217, %252
%256 = and i1 %254, %255
%257 = icmp ult double* %213, %250
%258 = icmp ult i8* %217, %249
%259 = and i1 %257, %258
%260 = icmp ult double* %219, %110
%261 = icmp ugt double* %246, %17
%262 = and i1 %260, %261
%263 = icmp ult double* %219, %247
%264 = icmp ult double* %209, %246
%265 = and i1 %263, %264
%266 = or i1 %262, %265
%267 = icmp ult i8* %97, %243
%268 = icmp ult double* %209, %106
%269 = and i1 %267, %268
%270 = icmp ult i8* %97, %245
%271 = icmp ult double* %219, %106
%272 = and i1 %270, %271
%273 = or i1 %269, %272
%274 = or i1 %273, %148
br label %275
275: ; preds = %205, %687
%276 = phi i32 [ 1, %205 ], [ %693, %687 ]
%277 = phi double [ %237, %205 ], [ %692, %687 ]
br i1 %62, label %278, label %387
278: ; preds = %275
%279 = select i1 %119, i1 true, i1 %256
br i1 %279, label %356, label %280
280: ; preds = %278
%281 = insertelement <2 x double> poison, double %277, i64 0
%282 = shufflevector <2 x double> %281, <2 x double> poison, <2 x i32> zeroinitializer
%283 = insertelement <2 x double> poison, double %277, i64 0
%284 = shufflevector <2 x double> %283, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %122, label %332, label %285
285: ; preds = %280, %285
%286 = phi i64 [ %329, %285 ], [ 0, %280 ]
%287 = phi i64 [ %330, %285 ], [ 0, %280 ]
%288 = getelementptr inbounds double, double* %213, i64 %286
%289 = bitcast double* %288 to <2 x double>*
%290 = load <2 x double>, <2 x double>* %289
%291 = getelementptr inbounds double, double* %288, i64 2
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = fmul <2 x double> %282, %290
%295 = fmul <2 x double> %284, %293
%296 = bitcast double* %288 to <2 x double>*
store <2 x double> %294, <2 x double>* %296
%297 = bitcast double* %291 to <2 x double>*
store <2 x double> %295, <2 x double>* %297
%298 = getelementptr inbounds double, double* %216, i64 %286
%299 = bitcast double* %298 to <2 x double>*
%300 = load <2 x double>, <2 x double>* %299
%301 = getelementptr inbounds double, double* %298, i64 2
%302 = bitcast double* %301 to <2 x double>*
%303 = load <2 x double>, <2 x double>* %302
%304 = fmul <2 x double> %282, %300
%305 = fmul <2 x double> %284, %303
%306 = bitcast double* %298 to <2 x double>*
store <2 x double> %304, <2 x double>* %306
%307 = bitcast double* %301 to <2 x double>*
store <2 x double> %305, <2 x double>* %307
%308 = or i64 %286, 4
%309 = getelementptr inbounds double, double* %213, i64 %308
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = getelementptr inbounds double, double* %309, i64 2
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = fmul <2 x double> %282, %311
%316 = fmul <2 x double> %284, %314
%317 = bitcast double* %309 to <2 x double>*
store <2 x double> %315, <2 x double>* %317
%318 = bitcast double* %312 to <2 x double>*
store <2 x double> %316, <2 x double>* %318
%319 = getelementptr inbounds double, double* %216, i64 %308
%320 = bitcast double* %319 to <2 x double>*
%321 = load <2 x double>, <2 x double>* %320
%322 = getelementptr inbounds double, double* %319, i64 2
%323 = bitcast double* %322 to <2 x double>*
%324 = load <2 x double>, <2 x double>* %323
%325 = fmul <2 x double> %282, %321
%326 = fmul <2 x double> %284, %324
%327 = bitcast double* %319 to <2 x double>*
store <2 x double> %325, <2 x double>* %327
%328 = bitcast double* %322 to <2 x double>*
store <2 x double> %326, <2 x double>* %328
%329 = add nuw i64 %286, 8
%330 = add i64 %287, 2
%331 = icmp eq i64 %330, %123
br i1 %331, label %332, label %285
332: ; preds = %285, %280
%333 = phi i64 [ 0, %280 ], [ %329, %285 ]
br i1 %124, label %355, label %334
334: ; preds = %332
%335 = getelementptr inbounds double, double* %213, i64 %333
%336 = bitcast double* %335 to <2 x double>*
%337 = load <2 x double>, <2 x double>* %336
%338 = getelementptr inbounds double, double* %335, i64 2
%339 = bitcast double* %338 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = fmul <2 x double> %282, %337
%342 = fmul <2 x double> %284, %340
%343 = bitcast double* %335 to <2 x double>*
store <2 x double> %341, <2 x double>* %343
%344 = bitcast double* %338 to <2 x double>*
store <2 x double> %342, <2 x double>* %344
%345 = getelementptr inbounds double, double* %216, i64 %333
%346 = bitcast double* %345 to <2 x double>*
%347 = load <2 x double>, <2 x double>* %346
%348 = getelementptr inbounds double, double* %345, i64 2
%349 = bitcast double* %348 to <2 x double>*
%350 = load <2 x double>, <2 x double>* %349
%351 = fmul <2 x double> %282, %347
%352 = fmul <2 x double> %284, %350
%353 = bitcast double* %345 to <2 x double>*
store <2 x double> %351, <2 x double>* %353
%354 = bitcast double* %348 to <2 x double>*
store <2 x double> %352, <2 x double>* %354
br label %355
355: ; preds = %332, %334
br i1 %125, label %387, label %356
356: ; preds = %278, %355
%357 = phi i64 [ 0, %278 ], [ %120, %355 ]
%358 = xor i64 %357, -1
br i1 %127, label %367, label %359
359: ; preds = %356
%360 = getelementptr inbounds double, double* %213, i64 %357
%361 = load double, double* %360
%362 = fmul double %277, %361
store double %362, double* %360
%363 = getelementptr inbounds double, double* %216, i64 %357
%364 = load double, double* %363
%365 = fmul double %277, %364
store double %365, double* %363
%366 = or i64 %357, 1
br label %367
367: ; preds = %359, %356
%368 = phi i64 [ %357, %356 ], [ %366, %359 ]
%369 = icmp eq i64 %358, %128
br i1 %369, label %387, label %370
370: ; preds = %367, %370
%371 = phi i64 [ %385, %370 ], [ %368, %367 ]
%372 = getelementptr inbounds double, double* %213, i64 %371
%373 = load double, double* %372
%374 = fmul double %277, %373
store double %374, double* %372
%375 = getelementptr inbounds double, double* %216, i64 %371
%376 = load double, double* %375
%377 = fmul double %277, %376
store double %377, double* %375
%378 = add nuw nsw i64 %371, 1
%379 = getelementptr inbounds double, double* %213, i64 %378
%380 = load double, double* %379
%381 = fmul double %277, %380
store double %381, double* %379
%382 = getelementptr inbounds double, double* %216, i64 %378
%383 = load double, double* %382
%384 = fmul double %277, %383
store double %384, double* %382
%385 = add nuw nsw i64 %371, 2
%386 = icmp eq i64 %385, %102
br i1 %386, label %387, label %370
387: ; preds = %367, %370, %355, %275
%388 = load double, double* %234
%389 = fcmp uge double %388, 0.000000e+00
%390 = select i1 %389, i1 true, i1 %100
br i1 %390, label %496, label %391
391: ; preds = %387
%392 = select i1 %129, i1 true, i1 %259
br i1 %392, label %465, label %393
393: ; preds = %391
br i1 %132, label %441, label %394
394: ; preds = %393, %394
%395 = phi i64 [ %438, %394 ], [ 0, %393 ]
%396 = phi i64 [ %439, %394 ], [ 0, %393 ]
%397 = getelementptr inbounds double, double* %213, i64 %395
%398 = bitcast double* %397 to <2 x double>*
%399 = load <2 x double>, <2 x double>* %398
%400 = getelementptr inbounds double, double* %397, i64 2
%401 = bitcast double* %400 to <2 x double>*
%402 = load <2 x double>, <2 x double>* %401
%403 = fneg <2 x double> %399
%404 = fneg <2 x double> %402
%405 = bitcast double* %397 to <2 x double>*
store <2 x double> %403, <2 x double>* %405
%406 = bitcast double* %400 to <2 x double>*
store <2 x double> %404, <2 x double>* %406
%407 = getelementptr inbounds double, double* %216, i64 %395
%408 = bitcast double* %407 to <2 x double>*
%409 = load <2 x double>, <2 x double>* %408
%410 = getelementptr inbounds double, double* %407, i64 2
%411 = bitcast double* %410 to <2 x double>*
%412 = load <2 x double>, <2 x double>* %411
%413 = fneg <2 x double> %409
%414 = fneg <2 x double> %412
%415 = bitcast double* %407 to <2 x double>*
store <2 x double> %413, <2 x double>* %415
%416 = bitcast double* %410 to <2 x double>*
store <2 x double> %414, <2 x double>* %416
%417 = or i64 %395, 4
%418 = getelementptr inbounds double, double* %213, i64 %417
%419 = bitcast double* %418 to <2 x double>*
%420 = load <2 x double>, <2 x double>* %419
%421 = getelementptr inbounds double, double* %418, i64 2
%422 = bitcast double* %421 to <2 x double>*
%423 = load <2 x double>, <2 x double>* %422
%424 = fneg <2 x double> %420
%425 = fneg <2 x double> %423
%426 = bitcast double* %418 to <2 x double>*
store <2 x double> %424, <2 x double>* %426
%427 = bitcast double* %421 to <2 x double>*
store <2 x double> %425, <2 x double>* %427
%428 = getelementptr inbounds double, double* %216, i64 %417
%429 = bitcast double* %428 to <2 x double>*
%430 = load <2 x double>, <2 x double>* %429
%431 = getelementptr inbounds double, double* %428, i64 2
%432 = bitcast double* %431 to <2 x double>*
%433 = load <2 x double>, <2 x double>* %432
%434 = fneg <2 x double> %430
%435 = fneg <2 x double> %433
%436 = bitcast double* %428 to <2 x double>*
store <2 x double> %434, <2 x double>* %436
%437 = bitcast double* %431 to <2 x double>*
store <2 x double> %435, <2 x double>* %437
%438 = add nuw i64 %395, 8
%439 = add i64 %396, 2
%440 = icmp eq i64 %439, %133
br i1 %440, label %441, label %394
441: ; preds = %394, %393
%442 = phi i64 [ 0, %393 ], [ %438, %394 ]
br i1 %134, label %464, label %443
443: ; preds = %441
%444 = getelementptr inbounds double, double* %213, i64 %442
%445 = bitcast double* %444 to <2 x double>*
%446 = load <2 x double>, <2 x double>* %445
%447 = getelementptr inbounds double, double* %444, i64 2
%448 = bitcast double* %447 to <2 x double>*
%449 = load <2 x double>, <2 x double>* %448
%450 = fneg <2 x double> %446
%451 = fneg <2 x double> %449
%452 = bitcast double* %444 to <2 x double>*
store <2 x double> %450, <2 x double>* %452
%453 = bitcast double* %447 to <2 x double>*
store <2 x double> %451, <2 x double>* %453
%454 = getelementptr inbounds double, double* %216, i64 %442
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = getelementptr inbounds double, double* %454, i64 2
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = fneg <2 x double> %456
%461 = fneg <2 x double> %459
%462 = bitcast double* %454 to <2 x double>*
store <2 x double> %460, <2 x double>* %462
%463 = bitcast double* %457 to <2 x double>*
store <2 x double> %461, <2 x double>* %463
br label %464
464: ; preds = %441, %443
br i1 %135, label %496, label %465
465: ; preds = %391, %464
%466 = phi i64 [ 0, %391 ], [ %130, %464 ]
%467 = xor i64 %466, -1
br i1 %137, label %476, label %468
468: ; preds = %465
%469 = getelementptr inbounds double, double* %213, i64 %466
%470 = load double, double* %469
%471 = fneg double %470
store double %471, double* %469
%472 = getelementptr inbounds double, double* %216, i64 %466
%473 = load double, double* %472
%474 = fneg double %473
store double %474, double* %472
%475 = or i64 %466, 1
br label %476
476: ; preds = %468, %465
%477 = phi i64 [ %466, %465 ], [ %475, %468 ]
%478 = icmp eq i64 %467, %138
br i1 %478, label %496, label %479
479: ; preds = %476, %479
%480 = phi i64 [ %494, %479 ], [ %477, %476 ]
%481 = getelementptr inbounds double, double* %213, i64 %480
%482 = load double, double* %481
%483 = fneg double %482
store double %483, double* %481
%484 = getelementptr inbounds double, double* %216, i64 %480
%485 = load double, double* %484
%486 = fneg double %485
store double %486, double* %484
%487 = add nuw nsw i64 %480, 1
%488 = getelementptr inbounds double, double* %213, i64 %487
%489 = load double, double* %488
%490 = fneg double %489
store double %490, double* %488
%491 = getelementptr inbounds double, double* %216, i64 %487
%492 = load double, double* %491
%493 = fneg double %492
store double %493, double* %491
%494 = add nuw nsw i64 %480, 2
%495 = icmp eq i64 %494, %103
br i1 %495, label %496, label %479
496: ; preds = %476, %479, %464, %387
%497 = load i32, i32* %220
%498 = tail call i32 (i32, i32, double, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @init_xpansion2 to i32 (i32, i32, double, double*, double*, double*, double*, double*, double*, ...)*)(i32 %497, i32 %232, double %207, double* %47, double* %213, double* %216, double* %219, double* %209, double* %211)
%499 = tail call i32 (...) @psi_xpansion2()
%500 = tail call i32 (...) @dpsi_xpansion2()
%501 = tail call i32 (...) @chi_xpansion2()
%502 = icmp eq i32 %276, 2
br i1 %502, label %503, label %518
503: ; preds = %496
%504 = load i32, i32* %220
%505 = tail call i32 (i32, ...) bitcast (i32 (...)* @spd_Name to i32 (i32, ...)*)(i32 %504)
%506 = load double, double* %198
%507 = load double, double* %238
%508 = load double, double* %206
%509 = load double, double* %234
%510 = load double, double* %239
%511 = fdiv double %509, %510
%512 = tail call double @llvm.fabs.f64(double %511)
%513 = load double, double* %240
%514 = load double, double* %241
%515 = fdiv double %513, %514
%516 = tail call double @llvm.fabs.f64(double %515)
%517 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i32 %505, double %506, double %507, double %508, double %207, double %512, double %516)
br label %518
518: ; preds = %503, %496
br i1 %62, label %519, label %687
519: ; preds = %518
%520 = select i1 %139, i1 true, i1 %266
br i1 %520, label %550, label %521
521: ; preds = %519, %521
%522 = phi i64 [ %547, %521 ], [ 0, %519 ]
%523 = getelementptr inbounds double, double* %219, i64 %522
%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 = getelementptr inbounds double, double* %17, i64 %522
%530 = bitcast double* %529 to <2 x double>*
%531 = load <2 x double>, <2 x double>* %530
%532 = getelementptr inbounds double, double* %529, i64 2
%533 = bitcast double* %532 to <2 x double>*
%534 = load <2 x double>, <2 x double>* %533
%535 = getelementptr inbounds double, double* %209, i64 %522
%536 = bitcast double* %535 to <2 x double>*
%537 = load <2 x double>, <2 x double>* %536
%538 = getelementptr inbounds double, double* %535, i64 2
%539 = bitcast double* %538 to <2 x double>*
%540 = load <2 x double>, <2 x double>* %539
%541 = fneg <2 x double> %531
%542 = fneg <2 x double> %534
%543 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %541, <2 x double> %537, <2 x double> %525)
%544 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %542, <2 x double> %540, <2 x double> %528)
%545 = bitcast double* %523 to <2 x double>*
store <2 x double> %543, <2 x double>* %545
%546 = bitcast double* %526 to <2 x double>*
store <2 x double> %544, <2 x double>* %546
%547 = add nuw i64 %522, 4
%548 = icmp eq i64 %547, %140
br i1 %548, label %549, label %521
549: ; preds = %521
br i1 %141, label %566, label %550
550: ; preds = %519, %549
%551 = phi i64 [ 0, %519 ], [ %140, %549 ]
%552 = xor i64 %551, -1
br i1 %143, label %563, label %553
553: ; preds = %550
%554 = getelementptr inbounds double, double* %219, i64 %551
%555 = load double, double* %554
%556 = getelementptr inbounds double, double* %17, i64 %551
%557 = load double, double* %556
%558 = getelementptr inbounds double, double* %209, i64 %551
%559 = load double, double* %558
%560 = fneg double %557
%561 = tail call double @llvm.fmuladd.f64(double %560, double %559, double %555)
store double %561, double* %554
%562 = or i64 %551, 1
br label %563
563: ; preds = %553, %550
%564 = phi i64 [ %551, %550 ], [ %562, %553 ]
%565 = icmp eq i64 %552, %144
br i1 %565, label %566, label %641
566: ; preds = %563, %641, %549
br i1 %62, label %567, label %687
567: ; preds = %566
%568 = select i1 %145, i1 true, i1 %274
br i1 %568, label %623, label %569
569: ; preds = %567
br i1 %151, label %605, label %570
570: ; preds = %569, %570
%571 = phi i64 [ %602, %570 ], [ 0, %569 ]
%572 = phi i64 [ %603, %570 ], [ 0, %569 ]
%573 = getelementptr inbounds double, double* %209, i64 %571
%574 = bitcast double* %573 to <2 x double>*
%575 = load <2 x double>, <2 x double>* %574
%576 = getelementptr inbounds double, double* %219, i64 %571
%577 = bitcast double* %576 to <2 x double>*
%578 = load <2 x double>, <2 x double>* %577
%579 = fmul <2 x double> %575, %578
%580 = getelementptr inbounds double, double* %50, i64 %571
%581 = bitcast double* %580 to <2 x double>*
%582 = load <2 x double>, <2 x double>* %581
%583 = fmul <2 x double> %582, %582
%584 = fdiv <2 x double> %579, %583
%585 = getelementptr inbounds double, double* %96, i64 %571
%586 = bitcast double* %585 to <2 x double>*
store <2 x double> %584, <2 x double>* %586
%587 = or i64 %571, 2
%588 = getelementptr inbounds double, double* %209, i64 %587
%589 = bitcast double* %588 to <2 x double>*
%590 = load <2 x double>, <2 x double>* %589
%591 = getelementptr inbounds double, double* %219, i64 %587
%592 = bitcast double* %591 to <2 x double>*
%593 = load <2 x double>, <2 x double>* %592
%594 = fmul <2 x double> %590, %593
%595 = getelementptr inbounds double, double* %50, i64 %587
%596 = bitcast double* %595 to <2 x double>*
%597 = load <2 x double>, <2 x double>* %596
%598 = fmul <2 x double> %597, %597
%599 = fdiv <2 x double> %594, %598
%600 = getelementptr inbounds double, double* %96, i64 %587
%601 = bitcast double* %600 to <2 x double>*
store <2 x double> %599, <2 x double>* %601
%602 = add nuw i64 %571, 4
%603 = add nuw i64 %572, 2
%604 = icmp eq i64 %603, %152
br i1 %604, label %605, label %570
605: ; preds = %570, %569
%606 = phi i64 [ 0, %569 ], [ %602, %570 ]
br i1 %153, label %622, label %607
607: ; preds = %605
%608 = getelementptr inbounds double, double* %209, i64 %606
%609 = bitcast double* %608 to <2 x double>*
%610 = load <2 x double>, <2 x double>* %609
%611 = getelementptr inbounds double, double* %219, i64 %606
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = fmul <2 x double> %610, %613
%615 = getelementptr inbounds double, double* %50, i64 %606
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = fmul <2 x double> %617, %617
%619 = fdiv <2 x double> %614, %618
%620 = getelementptr inbounds double, double* %96, i64 %606
%621 = bitcast double* %620 to <2 x double>*
store <2 x double> %619, <2 x double>* %621
br label %622
622: ; preds = %605, %607
br i1 %154, label %687, label %623
623: ; preds = %567, %622
%624 = phi i64 [ 0, %567 ], [ %149, %622 ]
%625 = xor i64 %624, -1
br i1 %156, label %638, label %626
626: ; preds = %623
%627 = getelementptr inbounds double, double* %209, i64 %624
%628 = load double, double* %627
%629 = getelementptr inbounds double, double* %219, i64 %624
%630 = load double, double* %629
%631 = fmul double %628, %630
%632 = getelementptr inbounds double, double* %50, i64 %624
%633 = load double, double* %632
%634 = fmul double %633, %633
%635 = fdiv double %631, %634
%636 = getelementptr inbounds double, double* %96, i64 %624
store double %635, double* %636
%637 = or i64 %624, 1
br label %638
638: ; preds = %626, %623
%639 = phi i64 [ %624, %623 ], [ %637, %626 ]
%640 = icmp eq i64 %625, %157
br i1 %640, label %687, label %662
641: ; preds = %563, %641
%642 = phi i64 [ %660, %641 ], [ %564, %563 ]
%643 = getelementptr inbounds double, double* %219, i64 %642
%644 = load double, double* %643
%645 = getelementptr inbounds double, double* %17, i64 %642
%646 = load double, double* %645
%647 = getelementptr inbounds double, double* %209, i64 %642
%648 = load double, double* %647
%649 = fneg double %646
%650 = tail call double @llvm.fmuladd.f64(double %649, double %648, double %644)
store double %650, double* %643
%651 = add nuw nsw i64 %642, 1
%652 = getelementptr inbounds double, double* %219, i64 %651
%653 = load double, double* %652
%654 = getelementptr inbounds double, double* %17, i64 %651
%655 = load double, double* %654
%656 = getelementptr inbounds double, double* %209, i64 %651
%657 = load double, double* %656
%658 = fneg double %655
%659 = tail call double @llvm.fmuladd.f64(double %658, double %657, double %653)
store double %659, double* %652
%660 = add nuw nsw i64 %642, 2
%661 = icmp eq i64 %660, %104
br i1 %661, label %566, label %641
662: ; preds = %638, %662
%663 = phi i64 [ %685, %662 ], [ %639, %638 ]
%664 = getelementptr inbounds double, double* %209, i64 %663
%665 = load double, double* %664
%666 = getelementptr inbounds double, double* %219, i64 %663
%667 = load double, double* %666
%668 = fmul double %665, %667
%669 = getelementptr inbounds double, double* %50, i64 %663
%670 = load double, double* %669
%671 = fmul double %670, %670
%672 = fdiv double %668, %671
%673 = getelementptr inbounds double, double* %96, i64 %663
store double %672, double* %673
%674 = add nuw nsw i64 %663, 1
%675 = getelementptr inbounds double, double* %209, i64 %674
%676 = load double, double* %675
%677 = getelementptr inbounds double, double* %219, i64 %674
%678 = load double, double* %677
%679 = fmul double %676, %678
%680 = getelementptr inbounds double, double* %50, i64 %674
%681 = load double, double* %680
%682 = fmul double %681, %681
%683 = fdiv double %679, %682
%684 = getelementptr inbounds double, double* %96, i64 %674
store double %683, double* %684
%685 = add nuw nsw i64 %663, 2
%686 = icmp eq i64 %685, %105
br i1 %686, label %687, label %662
687: ; preds = %638, %662, %622, %518, %566
%688 = tail call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
%689 = sitofp i32 %688 to double
%690 = tail call double @llvm.fabs.f64(double %689)
%691 = tail call double @sqrt(double %690)
%692 = fdiv double 1.000000e+00, %691
%693 = add nuw nsw i32 %276, 1
%694 = icmp eq i32 %693, 3
br i1 %694, label %695, label %275
695: ; preds = %687
%696 = select i1 %222, i32 %221, i32 %191
%697 = tail call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %216)
%698 = add nuw nsw i64 %190, 1
%699 = icmp eq i64 %698, %101
br i1 %699, label %158, label %189
700: ; preds = %160, %1069
%701 = phi i64 [ 0, %160 ], [ %1070, %1069 ]
%702 = getelementptr inbounds i32, i32* %8, i64 %701
%703 = load i32, i32* %702
%704 = icmp sgt i32 %703, 0
br i1 %704, label %712, label %705
705: ; preds = %851, %700
%706 = phi i32 [ %703, %700 ], [ %852, %851 ]
%707 = mul i32 %706, %706
%708 = icmp eq i32 %707, 0
br i1 %708, label %856, label %709
709: ; preds = %705
%710 = zext i32 %707 to i64
%711 = shl nuw nsw i64 %710, 3
br label %856
712: ; preds = %700, %851
%713 = phi i32 [ %852, %851 ], [ %703, %700 ]
%714 = phi i64 [ %854, %851 ], [ 0, %700 ]
%715 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %714, i64 %701
%716 = load i32, i32* %715
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double*, double** %12, i64 %717
%719 = load double*, double** %718
%720 = icmp sgt i32 %713, 0
br i1 %720, label %721, label %851
721: ; preds = %712
%722 = getelementptr double, double* %719, i64 %166
%723 = bitcast double* %722 to i8*
%724 = icmp ult i8* %97, %723
%725 = icmp ult double* %719, %168
%726 = and i1 %724, %725
br label %727
727: ; preds = %721, %840
%728 = phi i64 [ %847, %840 ], [ 0, %721 ]
%729 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %728, i64 %701
%730 = load i32, i32* %729
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double*, double** %16, i64 %731
%733 = load double*, double** %732
br i1 %62, label %734, label %840
734: ; preds = %727
br i1 %176, label %797, label %735
735: ; preds = %734
%736 = getelementptr double, double* %733, i64 %166
%737 = bitcast double* %736 to i8*
%738 = icmp ult i8* %97, %737
%739 = icmp ult double* %733, %168
%740 = and i1 %738, %739
%741 = or i1 %726, %740
%742 = or i1 %741, %179
br i1 %742, label %797, label %743
743: ; preds = %735
br i1 %182, label %779, label %744
744: ; preds = %743, %744
%745 = phi i64 [ %776, %744 ], [ 0, %743 ]
%746 = phi i64 [ %777, %744 ], [ 0, %743 ]
%747 = getelementptr inbounds double, double* %719, i64 %745
%748 = bitcast double* %747 to <2 x double>*
%749 = load <2 x double>, <2 x double>* %748
%750 = getelementptr inbounds double, double* %733, i64 %745
%751 = bitcast double* %750 to <2 x double>*
%752 = load <2 x double>, <2 x double>* %751
%753 = fmul <2 x double> %749, %752
%754 = getelementptr inbounds double, double* %50, i64 %745
%755 = bitcast double* %754 to <2 x double>*
%756 = load <2 x double>, <2 x double>* %755
%757 = fmul <2 x double> %756, %756
%758 = fdiv <2 x double> %753, %757
%759 = getelementptr inbounds double, double* %96, i64 %745
%760 = bitcast double* %759 to <2 x double>*
store <2 x double> %758, <2 x double>* %760
%761 = or i64 %745, 2
%762 = getelementptr inbounds double, double* %719, i64 %761
%763 = bitcast double* %762 to <2 x double>*
%764 = load <2 x double>, <2 x double>* %763
%765 = getelementptr inbounds double, double* %733, i64 %761
%766 = bitcast double* %765 to <2 x double>*
%767 = load <2 x double>, <2 x double>* %766
%768 = fmul <2 x double> %764, %767
%769 = getelementptr inbounds double, double* %50, i64 %761
%770 = bitcast double* %769 to <2 x double>*
%771 = load <2 x double>, <2 x double>* %770
%772 = fmul <2 x double> %771, %771
%773 = fdiv <2 x double> %768, %772
%774 = getelementptr inbounds double, double* %96, i64 %761
%775 = bitcast double* %774 to <2 x double>*
store <2 x double> %773, <2 x double>* %775
%776 = add nuw i64 %745, 4
%777 = add nuw i64 %746, 2
%778 = icmp eq i64 %777, %183
br i1 %778, label %779, label %744
779: ; preds = %744, %743
%780 = phi i64 [ 0, %743 ], [ %776, %744 ]
br i1 %184, label %796, label %781
781: ; preds = %779
%782 = getelementptr inbounds double, double* %719, i64 %780
%783 = bitcast double* %782 to <2 x double>*
%784 = load <2 x double>, <2 x double>* %783
%785 = getelementptr inbounds double, double* %733, i64 %780
%786 = bitcast double* %785 to <2 x double>*
%787 = load <2 x double>, <2 x double>* %786
%788 = fmul <2 x double> %784, %787
%789 = getelementptr inbounds double, double* %50, i64 %780
%790 = bitcast double* %789 to <2 x double>*
%791 = load <2 x double>, <2 x double>* %790
%792 = fmul <2 x double> %791, %791
%793 = fdiv <2 x double> %788, %792
%794 = getelementptr inbounds double, double* %96, i64 %780
%795 = bitcast double* %794 to <2 x double>*
store <2 x double> %793, <2 x double>* %795
br label %796
796: ; preds = %779, %781
br i1 %185, label %840, label %797
797: ; preds = %735, %734, %796
%798 = phi i64 [ 0, %735 ], [ 0, %734 ], [ %180, %796 ]
%799 = xor i64 %798, -1
br i1 %187, label %812, label %800
800: ; preds = %797
%801 = getelementptr inbounds double, double* %719, i64 %798
%802 = load double, double* %801
%803 = getelementptr inbounds double, double* %733, i64 %798
%804 = load double, double* %803
%805 = fmul double %802, %804
%806 = getelementptr inbounds double, double* %50, i64 %798
%807 = load double, double* %806
%808 = fmul double %807, %807
%809 = fdiv double %805, %808
%810 = getelementptr inbounds double, double* %96, i64 %798
store double %809, double* %810
%811 = or i64 %798, 1
br label %812
812: ; preds = %800, %797
%813 = phi i64 [ %798, %797 ], [ %811, %800 ]
%814 = icmp eq i64 %799, %188
br i1 %814, label %840, label %815
815: ; preds = %812, %815
%816 = phi i64 [ %838, %815 ], [ %813, %812 ]
%817 = getelementptr inbounds double, double* %719, i64 %816
%818 = load double, double* %817
%819 = getelementptr inbounds double, double* %733, i64 %816
%820 = load double, double* %819
%821 = fmul double %818, %820
%822 = getelementptr inbounds double, double* %50, i64 %816
%823 = load double, double* %822
%824 = fmul double %823, %823
%825 = fdiv double %821, %824
%826 = getelementptr inbounds double, double* %96, i64 %816
store double %825, double* %826
%827 = add nuw nsw i64 %816, 1
%828 = getelementptr inbounds double, double* %719, i64 %827
%829 = load double, double* %828
%830 = getelementptr inbounds double, double* %733, i64 %827
%831 = load double, double* %830
%832 = fmul double %829, %831
%833 = getelementptr inbounds double, double* %50, i64 %827
%834 = load double, double* %833
%835 = fmul double %834, %834
%836 = fdiv double %832, %835
%837 = getelementptr inbounds double, double* %96, i64 %827
store double %836, double* %837
%838 = add nuw nsw i64 %816, 2
%839 = icmp eq i64 %838, %166
br i1 %839, label %840, label %815
840: ; preds = %812, %815, %796, %727
%841 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
%842 = sitofp i32 %841 to double
%843 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %714, i64 %728, i64 %701
%844 = load i32, i32* %843
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %845
store double %842, double* %846
%847 = add nuw nsw i64 %728, 1
%848 = load i32, i32* %702
%849 = sext i32 %848 to i64
%850 = icmp slt i64 %847, %849
br i1 %850, label %727, label %851
851: ; preds = %840, %712
%852 = phi i32 [ %713, %712 ], [ %848, %840 ]
%853 = sext i32 %852 to i64
%854 = add nuw nsw i64 %714, 1
%855 = icmp slt i64 %854, %853
br i1 %855, label %712, label %705
856: ; preds = %709, %705
%857 = icmp sgt i32 %706, 0
br i1 %857, label %858, label %909
858: ; preds = %856
%859 = zext i32 %706 to i64
%860 = zext i32 %706 to i64
%861 = and i64 %860, 1
%862 = icmp eq i32 %706, 1
%863 = and i64 %860, 4294967294
%864 = icmp eq i64 %861, 0
br label %865
865: ; preds = %906, %858
%866 = phi i64 [ 0, %858 ], [ %907, %906 ]
%867 = trunc i64 %866 to i32
%868 = mul nsw i32 %706, %867
%869 = sext i32 %868 to i64
%870 = add nsw i64 %866, %869
%871 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %870
store double 1.000000e+00, double* %871
br i1 %862, label %895, label %872
872: ; preds = %865, %872
%873 = phi i64 [ %892, %872 ], [ 0, %865 ]
%874 = phi i64 [ %893, %872 ], [ 0, %865 ]
%875 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %866, i64 %873, i64 %701
%876 = load i32, i32* %875
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %877
%879 = load double, double* %878
%880 = mul nsw i64 %873, %859
%881 = add nuw nsw i64 %880, %866
%882 = getelementptr inbounds [250 x double], [250 x double]* %37, i64 0, i64 %881
store double %879, double* %882
%883 = or i64 %873, 1
%884 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %866, i64 %883, i64 %701
%885 = load i32, i32* %884
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %886
%888 = load double, double* %887
%889 = mul nsw i64 %883, %859
%890 = add nuw nsw i64 %889, %866
%891 = getelementptr inbounds [250 x double], [250 x double]* %37, i64 0, i64 %890
store double %888, double* %891
%892 = add nuw nsw i64 %873, 2
%893 = add i64 %874, 2
%894 = icmp eq i64 %893, %863
br i1 %894, label %895, label %872
895: ; preds = %872, %865
%896 = phi i64 [ 0, %865 ], [ %892, %872 ]
br i1 %864, label %906, label %897
897: ; preds = %895
%898 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %866, i64 %896, i64 %701
%899 = load i32, i32* %898
%900 = sext i32 %899 to i64
%901 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %900
%902 = load double, double* %901
%903 = mul nsw i64 %896, %859
%904 = add nuw nsw i64 %903, %866
%905 = getelementptr inbounds [250 x double], [250 x double]* %37, i64 0, i64 %904
store double %902, double* %905
br label %906
906: ; preds = %895, %897
%907 = add nuw nsw i64 %866, 1
%908 = icmp eq i64 %907, %860
br i1 %908, label %909, label %865
909: ; preds = %906, %856
%910 = call i32 (i32, double*, i32, double*, ...) bitcast (i32 (...)* @gaussj to i32 (i32, double*, i32, double*, ...)*)(i32 %706, double* %162, i32 %706, double* %163)
%911 = load i32, i32* %702
%912 = icmp sgt i32 %911, 0
br i1 %912, label %913, label %920
913: ; preds = %909
%914 = zext i32 %911 to i64
%915 = zext i32 %911 to i64
%916 = and i64 %915, 1
%917 = icmp eq i32 %911, 1
%918 = and i64 %915, 4294967294
%919 = icmp eq i64 %916, 0
br label %932
920: ; preds = %968, %909
br i1 %62, label %921, label %1069
921: ; preds = %920
%922 = zext i32 %911 to i64
%923 = add nsw i64 %922, -1
%924 = and i64 %922, 1
%925 = icmp eq i64 %923, 0
%926 = and i64 %922, 4294967294
%927 = icmp eq i64 %924, 0
%928 = and i64 %922, 1
%929 = icmp eq i64 %923, 0
%930 = and i64 %922, 4294967294
%931 = icmp eq i64 %928, 0
br label %971
932: ; preds = %968, %913
%933 = phi i64 [ 0, %913 ], [ %969, %968 ]
br i1 %917, label %957, label %934
934: ; preds = %932, %934
%935 = phi i64 [ %954, %934 ], [ 0, %932 ]
%936 = phi i64 [ %955, %934 ], [ 0, %932 ]
%937 = mul nsw i64 %935, %914
%938 = add nuw nsw i64 %937, %933
%939 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %938
%940 = load double, double* %939
%941 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %933, i64 %935, i64 %701
%942 = load i32, i32* %941
%943 = sext i32 %942 to i64
%944 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %943
store double %940, double* %944
%945 = or i64 %935, 1
%946 = mul nsw i64 %945, %914
%947 = add nuw nsw i64 %946, %933
%948 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %947
%949 = load double, double* %948
%950 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %933, i64 %945, i64 %701
%951 = load i32, i32* %950
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %952
store double %949, double* %953
%954 = add nuw nsw i64 %935, 2
%955 = add i64 %936, 2
%956 = icmp eq i64 %955, %918
br i1 %956, label %957, label %934
957: ; preds = %934, %932
%958 = phi i64 [ 0, %932 ], [ %954, %934 ]
br i1 %919, label %968, label %959
959: ; preds = %957
%960 = mul nsw i64 %958, %914
%961 = add nuw nsw i64 %960, %933
%962 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %961
%963 = load double, double* %962
%964 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %933, i64 %958, i64 %701
%965 = load i32, i32* %964
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %966
store double %963, double* %967
br label %968
968: ; preds = %957, %959
%969 = add nuw nsw i64 %933, 1
%970 = icmp eq i64 %969, %915
br i1 %970, label %920, label %932
971: ; preds = %921, %1066
%972 = phi i64 [ 0, %921 ], [ %1067, %1066 ]
br i1 %912, label %975, label %1066
973: ; preds = %1029
br i1 %912, label %974, label %1066
974: ; preds = %973
br i1 %929, label %1055, label %1032
975: ; preds = %971, %1029
%976 = phi i64 [ %1030, %1029 ], [ 0, %971 ]
%977 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %976
store double 0.000000e+00, double* %977
br i1 %925, label %1012, label %978
978: ; preds = %975, %978
%979 = phi double [ %1008, %978 ], [ 0.000000e+00, %975 ]
%980 = phi i64 [ %1009, %978 ], [ 0, %975 ]
%981 = phi i64 [ %1010, %978 ], [ 0, %975 ]
%982 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %980, i64 %701
%983 = load i32, i32* %982
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds double*, double** %16, i64 %984
%986 = load double*, double** %985
%987 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %976, i64 %980, i64 %701
%988 = load i32, i32* %987
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %989
%991 = load double, double* %990
%992 = getelementptr inbounds double, double* %986, i64 %972
%993 = load double, double* %992
%994 = call double @llvm.fmuladd.f64(double %991, double %993, double %979)
store double %994, double* %977
%995 = or i64 %980, 1
%996 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %995, i64 %701
%997 = load i32, i32* %996
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds double*, double** %16, i64 %998
%1000 = load double*, double** %999
%1001 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %976, i64 %995, i64 %701
%1002 = load i32, i32* %1001
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %1003
%1005 = load double, double* %1004
%1006 = getelementptr inbounds double, double* %1000, i64 %972
%1007 = load double, double* %1006
%1008 = call double @llvm.fmuladd.f64(double %1005, double %1007, double %994)
store double %1008, double* %977
%1009 = add nuw nsw i64 %980, 2
%1010 = add i64 %981, 2
%1011 = icmp eq i64 %1010, %926
br i1 %1011, label %1012, label %978
1012: ; preds = %978, %975
%1013 = phi double [ 0.000000e+00, %975 ], [ %1008, %978 ]
%1014 = phi i64 [ 0, %975 ], [ %1009, %978 ]
br i1 %927, label %1029, label %1015
1015: ; preds = %1012
%1016 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1014, i64 %701
%1017 = load i32, i32* %1016
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds double*, double** %16, i64 %1018
%1020 = load double*, double** %1019
%1021 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %976, i64 %1014, i64 %701
%1022 = load i32, i32* %1021
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds [250 x double], [250 x double]* %34, i64 0, i64 %1023
%1025 = load double, double* %1024
%1026 = getelementptr inbounds double, double* %1020, i64 %972
%1027 = load double, double* %1026
%1028 = call double @llvm.fmuladd.f64(double %1025, double %1027, double %1013)
store double %1028, double* %977
br label %1029
1029: ; preds = %1012, %1015
%1030 = add nuw nsw i64 %976, 1
%1031 = icmp eq i64 %1030, %922
br i1 %1031, label %973, label %975
1032: ; preds = %974, %1032
%1033 = phi i64 [ %1052, %1032 ], [ 0, %974 ]
%1034 = phi i64 [ %1053, %1032 ], [ 0, %974 ]
%1035 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1033, i64 %701
%1036 = load i32, i32* %1035
%1037 = sext i32 %1036 to i64
%1038 = getelementptr inbounds double*, double** %16, i64 %1037
%1039 = load double*, double** %1038
%1040 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %1033
%1041 = load double, double* %1040
%1042 = getelementptr inbounds double, double* %1039, i64 %972
store double %1041, double* %1042
%1043 = or i64 %1033, 1
%1044 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1043, i64 %701
%1045 = load i32, i32* %1044
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds double*, double** %16, i64 %1046
%1048 = load double*, double** %1047
%1049 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %1043
%1050 = load double, double* %1049
%1051 = getelementptr inbounds double, double* %1048, i64 %972
store double %1050, double* %1051
%1052 = add nuw nsw i64 %1033, 2
%1053 = add i64 %1034, 2
%1054 = icmp eq i64 %1053, %930
br i1 %1054, label %1055, label %1032
1055: ; preds = %1032, %974
%1056 = phi i64 [ 0, %974 ], [ %1052, %1032 ]
br i1 %931, label %1066, label %1057
1057: ; preds = %1055
%1058 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1056, i64 %701
%1059 = load i32, i32* %1058
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds double*, double** %16, i64 %1060
%1062 = load double*, double** %1061
%1063 = getelementptr inbounds [250 x double], [250 x double]* %35, i64 0, i64 %1056
%1064 = load double, double* %1063
%1065 = getelementptr inbounds double, double* %1062, i64 %972
store double %1064, double* %1065
br label %1066
1066: ; preds = %1057, %1055, %971, %973
%1067 = add nuw nsw i64 %972, 1
%1068 = icmp eq i64 %1067, %167
br i1 %1068, label %1069, label %971
1069: ; preds = %1066, %920
%1070 = add nuw nsw i64 %701, 1
%1071 = icmp eq i64 %1070, %165
br i1 %1071, label %1072, label %700
1072: ; preds = %1069, %158
%1073 = phi i1 [ true, %158 ], [ false, %1069 ]
%1074 = phi i32 [ %696, %158 ], [ %161, %1069 ]
%1075 = call i32 (...) @rho_valence_Atom()
%1076 = sext i32 %1075 to i64
%1077 = inttoptr i64 %1076 to double*
%1078 = inttoptr i64 %1076 to i8*
br i1 %62, label %1079, label %1224
1079: ; preds = %1072
%1080 = zext i32 %52 to i64
%1081 = icmp ult i32 %52, 4
br i1 %1081, label %1172, label %1082
1082: ; preds = %1079
%1083 = getelementptr double, double* %96, i64 %1080
%1084 = bitcast double* %1083 to i8*
%1085 = getelementptr double, double* %1077, i64 %1080
%1086 = bitcast double* %1085 to i8*
%1087 = getelementptr double, double* %17, i64 %1080
%1088 = bitcast double* %1087 to i8*
%1089 = icmp ult i8* %97, %1086
%1090 = icmp ult i8* %1078, %1084
%1091 = and i1 %1089, %1090
%1092 = icmp ult i8* %97, %1088
%1093 = icmp ugt double* %1083, %17
%1094 = and i1 %1092, %1093
%1095 = or i1 %1091, %1094
br i1 %1095, label %1172, label %1096
1096: ; preds = %1082
%1097 = and i64 %1080, 4294967292
%1098 = add nsw i64 %1097, -4
%1099 = lshr exact i64 %1098, 2
%1100 = add nuw nsw i64 %1099, 1
%1101 = and i64 %1100, 1
%1102 = icmp eq i64 %1098, 0
br i1 %1102, label %1148, label %1103
1103: ; preds = %1096
%1104 = and i64 %1100, 9223372036854775806
br label %1105
1105: ; preds = %1105, %1103
%1106 = phi i64 [ 0, %1103 ], [ %1145, %1105 ]
%1107 = phi i64 [ 0, %1103 ], [ %1146, %1105 ]
%1108 = getelementptr inbounds double, double* %1077, i64 %1106
%1109 = bitcast double* %1108 to <2 x double>*
%1110 = load <2 x double>, <2 x double>* %1109
%1111 = getelementptr inbounds double, double* %1108, i64 2
%1112 = bitcast double* %1111 to <2 x double>*
%1113 = load <2 x double>, <2 x double>* %1112
%1114 = getelementptr inbounds double, double* %17, i64 %1106
%1115 = bitcast double* %1114 to <2 x double>*
%1116 = load <2 x double>, <2 x double>* %1115
%1117 = getelementptr inbounds double, double* %1114, i64 2
%1118 = bitcast double* %1117 to <2 x double>*
%1119 = load <2 x double>, <2 x double>* %1118
%1120 = fmul <2 x double> %1110, %1116
%1121 = fmul <2 x double> %1113, %1119
%1122 = getelementptr inbounds double, double* %96, i64 %1106
%1123 = bitcast double* %1122 to <2 x double>*
store <2 x double> %1120, <2 x double>* %1123
%1124 = getelementptr inbounds double, double* %1122, i64 2
%1125 = bitcast double* %1124 to <2 x double>*
store <2 x double> %1121, <2 x double>* %1125
%1126 = or i64 %1106, 4
%1127 = getelementptr inbounds double, double* %1077, i64 %1126
%1128 = bitcast double* %1127 to <2 x double>*
%1129 = load <2 x double>, <2 x double>* %1128
%1130 = getelementptr inbounds double, double* %1127, i64 2
%1131 = bitcast double* %1130 to <2 x double>*
%1132 = load <2 x double>, <2 x double>* %1131
%1133 = getelementptr inbounds double, double* %17, i64 %1126
%1134 = bitcast double* %1133 to <2 x double>*
%1135 = load <2 x double>, <2 x double>* %1134
%1136 = getelementptr inbounds double, double* %1133, i64 2
%1137 = bitcast double* %1136 to <2 x double>*
%1138 = load <2 x double>, <2 x double>* %1137
%1139 = fmul <2 x double> %1129, %1135
%1140 = fmul <2 x double> %1132, %1138
%1141 = getelementptr inbounds double, double* %96, i64 %1126
%1142 = bitcast double* %1141 to <2 x double>*
store <2 x double> %1139, <2 x double>* %1142
%1143 = getelementptr inbounds double, double* %1141, i64 2
%1144 = bitcast double* %1143 to <2 x double>*
store <2 x double> %1140, <2 x double>* %1144
%1145 = add nuw i64 %1106, 8
%1146 = add i64 %1107, 2
%1147 = icmp eq i64 %1146, %1104
br i1 %1147, label %1148, label %1105
1148: ; preds = %1105, %1096
%1149 = phi i64 [ 0, %1096 ], [ %1145, %1105 ]
%1150 = icmp eq i64 %1101, 0
br i1 %1150, label %1170, label %1151
1151: ; preds = %1148
%1152 = getelementptr inbounds double, double* %1077, i64 %1149
%1153 = bitcast double* %1152 to <2 x double>*
%1154 = load <2 x double>, <2 x double>* %1153
%1155 = getelementptr inbounds double, double* %1152, i64 2
%1156 = bitcast double* %1155 to <2 x double>*
%1157 = load <2 x double>, <2 x double>* %1156
%1158 = getelementptr inbounds double, double* %17, i64 %1149
%1159 = bitcast double* %1158 to <2 x double>*
%1160 = load <2 x double>, <2 x double>* %1159
%1161 = getelementptr inbounds double, double* %1158, i64 2
%1162 = bitcast double* %1161 to <2 x double>*
%1163 = load <2 x double>, <2 x double>* %1162
%1164 = fmul <2 x double> %1154, %1160
%1165 = fmul <2 x double> %1157, %1163
%1166 = getelementptr inbounds double, double* %96, i64 %1149
%1167 = bitcast double* %1166 to <2 x double>*
store <2 x double> %1164, <2 x double>* %1167
%1168 = getelementptr inbounds double, double* %1166, i64 2
%1169 = bitcast double* %1168 to <2 x double>*
store <2 x double> %1165, <2 x double>* %1169
br label %1170
1170: ; preds = %1148, %1151
%1171 = icmp eq i64 %1097, %1080
br i1 %1171, label %1224, label %1172
1172: ; preds = %1082, %1079, %1170
%1173 = phi i64 [ 0, %1082 ], [ 0, %1079 ], [ %1097, %1170 ]
%1174 = xor i64 %1173, -1
%1175 = add nsw i64 %1174, %1080
%1176 = and i64 %1080, 3
%1177 = icmp eq i64 %1176, 0
br i1 %1177, label %1190, label %1178
1178: ; preds = %1172, %1178
%1179 = phi i64 [ %1187, %1178 ], [ %1173, %1172 ]
%1180 = phi i64 [ %1188, %1178 ], [ 0, %1172 ]
%1181 = getelementptr inbounds double, double* %1077, i64 %1179
%1182 = load double, double* %1181
%1183 = getelementptr inbounds double, double* %17, i64 %1179
%1184 = load double, double* %1183
%1185 = fmul double %1182, %1184
%1186 = getelementptr inbounds double, double* %96, i64 %1179
store double %1185, double* %1186
%1187 = add nuw nsw i64 %1179, 1
%1188 = add i64 %1180, 1
%1189 = icmp eq i64 %1188, %1176
br i1 %1189, label %1190, label %1178
1190: ; preds = %1178, %1172
%1191 = phi i64 [ %1173, %1172 ], [ %1187, %1178 ]
%1192 = icmp ult i64 %1175, 3
br i1 %1192, label %1224, label %1193
1193: ; preds = %1190, %1193
%1194 = phi i64 [ %1222, %1193 ], [ %1191, %1190 ]
%1195 = getelementptr inbounds double, double* %1077, i64 %1194
%1196 = load double, double* %1195
%1197 = getelementptr inbounds double, double* %17, i64 %1194
%1198 = load double, double* %1197
%1199 = fmul double %1196, %1198
%1200 = getelementptr inbounds double, double* %96, i64 %1194
store double %1199, double* %1200
%1201 = add nuw nsw i64 %1194, 1
%1202 = getelementptr inbounds double, double* %1077, i64 %1201
%1203 = load double, double* %1202
%1204 = getelementptr inbounds double, double* %17, i64 %1201
%1205 = load double, double* %1204
%1206 = fmul double %1203, %1205
%1207 = getelementptr inbounds double, double* %96, i64 %1201
store double %1206, double* %1207
%1208 = add nuw nsw i64 %1194, 2
%1209 = getelementptr inbounds double, double* %1077, i64 %1208
%1210 = load double, double* %1209
%1211 = getelementptr inbounds double, double* %17, i64 %1208
%1212 = load double, double* %1211
%1213 = fmul double %1210, %1212
%1214 = getelementptr inbounds double, double* %96, i64 %1208
store double %1213, double* %1214
%1215 = add nuw nsw i64 %1194, 3
%1216 = getelementptr inbounds double, double* %1077, i64 %1215
%1217 = load double, double* %1216
%1218 = getelementptr inbounds double, double* %17, i64 %1215
%1219 = load double, double* %1218
%1220 = fmul double %1217, %1219
%1221 = getelementptr inbounds double, double* %96, i64 %1215
store double %1220, double* %1221
%1222 = add nuw nsw i64 %1194, 4
%1223 = icmp eq i64 %1222, %1080
br i1 %1223, label %1224, label %1193
1224: ; preds = %1190, %1193, %1170, %1072
%1225 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
%1226 = sitofp i32 %1225 to double
br i1 %1073, label %1672, label %1227
1227: ; preds = %1224
%1228 = add i32 %1074, 1
%1229 = zext i32 %1228 to i64
%1230 = zext i32 %52 to i64
%1231 = zext i32 %52 to i64
%1232 = getelementptr double, double* %96, i64 %1230
%1233 = bitcast double* %1232 to i8*
%1234 = getelementptr double, double* %50, i64 %1230
%1235 = bitcast double* %1234 to i8*
%1236 = getelementptr double, double* %96, i64 %1230
%1237 = bitcast double* %1236 to i8*
%1238 = getelementptr double, double* %50, i64 %1230
%1239 = bitcast double* %1238 to i8*
%1240 = and i64 %1230, 4294967294
%1241 = add nsw i64 %1240, -2
%1242 = lshr exact i64 %1241, 1
%1243 = add nuw i64 %1242, 1
%1244 = icmp eq i32 %52, 1
%1245 = icmp ult i8* %97, %1239
%1246 = icmp ult i8* %51, %1237
%1247 = and i1 %1245, %1246
%1248 = and i64 %1230, 4294967294
%1249 = and i64 %1243, 1
%1250 = icmp eq i64 %1241, 0
%1251 = and i64 %1243, -2
%1252 = icmp eq i64 %1249, 0
%1253 = icmp eq i64 %1248, %1230
%1254 = and i64 %1230, 1
%1255 = icmp eq i64 %1254, 0
%1256 = sub nsw i64 0, %1230
%1257 = icmp eq i32 %52, 1
%1258 = icmp ult i8* %97, %1235
%1259 = icmp ult i8* %51, %1233
%1260 = and i1 %1258, %1259
%1261 = and i64 %1230, 4294967294
%1262 = and i64 %1243, 1
%1263 = icmp eq i64 %1241, 0
%1264 = and i64 %1243, -2
%1265 = icmp eq i64 %1262, 0
%1266 = icmp eq i64 %1261, %1230
%1267 = and i64 %1230, 1
%1268 = icmp eq i64 %1267, 0
%1269 = sub nsw i64 0, %1230
br label %1270
1270: ; preds = %1227, %1550
%1271 = phi i64 [ 0, %1227 ], [ %1551, %1550 ]
%1272 = getelementptr inbounds i32, i32* %8, i64 %1271
%1273 = load i32, i32* %1272
%1274 = icmp sgt i32 %1273, 0
br i1 %1274, label %1275, label %1550
1275: ; preds = %1270, %1545
%1276 = phi i32 [ %1546, %1545 ], [ %1273, %1270 ]
%1277 = phi i64 [ %1548, %1545 ], [ 0, %1270 ]
%1278 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1277, i64 %1271
%1279 = load i32, i32* %1278
%1280 = sext i32 %1279 to i64
%1281 = getelementptr inbounds double*, double** %11, i64 %1280
%1282 = load double*, double** %1281
%1283 = getelementptr inbounds double*, double** %12, i64 %1280
%1284 = load double*, double** %1283
%1285 = icmp sgt i32 %1276, 0
br i1 %1285, label %1286, label %1545
1286: ; preds = %1275
%1287 = getelementptr double, double* %1284, i64 %1230
%1288 = bitcast double* %1287 to i8*
%1289 = getelementptr double, double* %1282, i64 %1230
%1290 = bitcast double* %1289 to i8*
%1291 = icmp ult i8* %97, %1290
%1292 = icmp ult double* %1282, %1236
%1293 = and i1 %1291, %1292
%1294 = icmp ult i8* %97, %1288
%1295 = icmp ult double* %1284, %1232
%1296 = and i1 %1294, %1295
br label %1297
1297: ; preds = %1286, %1522
%1298 = phi i64 [ %1541, %1522 ], [ 0, %1286 ]
%1299 = getelementptr inbounds [10 x i32], [10 x i32]* %9, i64 %1298, i64 %1271
%1300 = load i32, i32* %1299
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds double*, double** %11, i64 %1301
%1303 = load double*, double** %1302
%1304 = getelementptr inbounds double*, double** %12, i64 %1301
%1305 = load double*, double** %1304
br i1 %62, label %1306, label %1387
1306: ; preds = %1297
br i1 %1244, label %1369, label %1307
1307: ; preds = %1306
%1308 = getelementptr double, double* %1303, i64 %1230
%1309 = bitcast double* %1308 to i8*
%1310 = icmp ult i8* %97, %1309
%1311 = icmp ult double* %1303, %1236
%1312 = and i1 %1310, %1311
%1313 = or i1 %1293, %1312
%1314 = or i1 %1313, %1247
br i1 %1314, label %1369, label %1315
1315: ; preds = %1307
br i1 %1250, label %1351, label %1316
1316: ; preds = %1315, %1316
%1317 = phi i64 [ %1348, %1316 ], [ 0, %1315 ]
%1318 = phi i64 [ %1349, %1316 ], [ 0, %1315 ]
%1319 = getelementptr inbounds double, double* %1282, i64 %1317
%1320 = bitcast double* %1319 to <2 x double>*
%1321 = load <2 x double>, <2 x double>* %1320
%1322 = getelementptr inbounds double, double* %1303, i64 %1317
%1323 = bitcast double* %1322 to <2 x double>*
%1324 = load <2 x double>, <2 x double>* %1323
%1325 = fmul <2 x double> %1321, %1324
%1326 = getelementptr inbounds double, double* %50, i64 %1317
%1327 = bitcast double* %1326 to <2 x double>*
%1328 = load <2 x double>, <2 x double>* %1327
%1329 = fmul <2 x double> %1328, %1328
%1330 = fdiv <2 x double> %1325, %1329
%1331 = getelementptr inbounds double, double* %96, i64 %1317
%1332 = bitcast double* %1331 to <2 x double>*
store <2 x double> %1330, <2 x double>* %1332
%1333 = or i64 %1317, 2
%1334 = getelementptr inbounds double, double* %1282, i64 %1333
%1335 = bitcast double* %1334 to <2 x double>*
%1336 = load <2 x double>, <2 x double>* %1335
%1337 = getelementptr inbounds double, double* %1303, i64 %1333
%1338 = bitcast double* %1337 to <2 x double>*
%1339 = load <2 x double>, <2 x double>* %1338
%1340 = fmul <2 x double> %1336, %1339
%1341 = getelementptr inbounds double, double* %50, i64 %1333
%1342 = bitcast double* %1341 to <2 x double>*
%1343 = load <2 x double>, <2 x double>* %1342
%1344 = fmul <2 x double> %1343, %1343
%1345 = fdiv <2 x double> %1340, %1344
%1346 = getelementptr inbounds double, double* %96, i64 %1333
%1347 = bitcast double* %1346 to <2 x double>*
store <2 x double> %1345, <2 x double>* %1347
%1348 = add nuw i64 %1317, 4
%1349 = add nuw i64 %1318, 2
%1350 = icmp eq i64 %1349, %1251
br i1 %1350, label %1351, label %1316
1351: ; preds = %1316, %1315
%1352 = phi i64 [ 0, %1315 ], [ %1348, %1316 ]
br i1 %1252, label %1368, label %1353
1353: ; preds = %1351
%1354 = getelementptr inbounds double, double* %1282, i64 %1352
%1355 = bitcast double* %1354 to <2 x double>*
%1356 = load <2 x double>, <2 x double>* %1355
%1357 = getelementptr inbounds double, double* %1303, i64 %1352
%1358 = bitcast double* %1357 to <2 x double>*
%1359 = load <2 x double>, <2 x double>* %1358
%1360 = fmul <2 x double> %1356, %1359
%1361 = getelementptr inbounds double, double* %50, i64 %1352
%1362 = bitcast double* %1361 to <2 x double>*
%1363 = load <2 x double>, <2 x double>* %1362
%1364 = fmul <2 x double> %1363, %1363
%1365 = fdiv <2 x double> %1360, %1364
%1366 = getelementptr inbounds double, double* %96, i64 %1352
%1367 = bitcast double* %1366 to <2 x double>*
store <2 x double> %1365, <2 x double>* %1367
br label %1368
1368: ; preds = %1351, %1353
br i1 %1253, label %1414, label %1369
1369: ; preds = %1307, %1306, %1368
%1370 = phi i64 [ 0, %1307 ], [ 0, %1306 ], [ %1248, %1368 ]
%1371 = xor i64 %1370, -1
br i1 %1255, label %1384, label %1372
1372: ; preds = %1369
%1373 = getelementptr inbounds double, double* %1282, i64 %1370
%1374 = load double, double* %1373
%1375 = getelementptr inbounds double, double* %1303, i64 %1370
%1376 = load double, double* %1375
%1377 = fmul double %1374, %1376
%1378 = getelementptr inbounds double, double* %50, i64 %1370
%1379 = load double, double* %1378
%1380 = fmul double %1379, %1379
%1381 = fdiv double %1377, %1380
%1382 = getelementptr inbounds double, double* %96, i64 %1370
store double %1381, double* %1382
%1383 = or i64 %1370, 1
br label %1384
1384: ; preds = %1372, %1369
%1385 = phi i64 [ %1370, %1369 ], [ %1383, %1372 ]
%1386 = icmp eq i64 %1371, %1256
br i1 %1386, label %1414, label %1389
1387: ; preds = %1297
%1388 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
br label %1522
1389: ; preds = %1384, %1389
%1390 = phi i64 [ %1412, %1389 ], [ %1385, %1384 ]
%1391 = getelementptr inbounds double, double* %1282, i64 %1390
%1392 = load double, double* %1391
%1393 = getelementptr inbounds double, double* %1303, i64 %1390
%1394 = load double, double* %1393
%1395 = fmul double %1392, %1394
%1396 = getelementptr inbounds double, double* %50, i64 %1390
%1397 = load double, double* %1396
%1398 = fmul double %1397, %1397
%1399 = fdiv double %1395, %1398
%1400 = getelementptr inbounds double, double* %96, i64 %1390
store double %1399, double* %1400
%1401 = add nuw nsw i64 %1390, 1
%1402 = getelementptr inbounds double, double* %1282, i64 %1401
%1403 = load double, double* %1402
%1404 = getelementptr inbounds double, double* %1303, i64 %1401
%1405 = load double, double* %1404
%1406 = fmul double %1403, %1405
%1407 = getelementptr inbounds double, double* %50, i64 %1401
%1408 = load double, double* %1407
%1409 = fmul double %1408, %1408
%1410 = fdiv double %1406, %1409
%1411 = getelementptr inbounds double, double* %96, i64 %1401
store double %1410, double* %1411
%1412 = add nuw nsw i64 %1390, 2
%1413 = icmp eq i64 %1412, %1230
br i1 %1413, label %1414, label %1389
1414: ; preds = %1384, %1389, %1368
%1415 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
br i1 %62, label %1416, label %1522
1416: ; preds = %1414
br i1 %1257, label %1479, label %1417
1417: ; preds = %1416
%1418 = getelementptr double, double* %1305, i64 %1230
%1419 = bitcast double* %1418 to i8*
%1420 = icmp ult i8* %97, %1419
%1421 = icmp ult double* %1305, %1232
%1422 = and i1 %1420, %1421
%1423 = or i1 %1296, %1422
%1424 = or i1 %1423, %1260
br i1 %1424, label %1479, label %1425
1425: ; preds = %1417
br i1 %1263, label %1461, label %1426
1426: ; preds = %1425, %1426
%1427 = phi i64 [ %1458, %1426 ], [ 0, %1425 ]
%1428 = phi i64 [ %1459, %1426 ], [ 0, %1425 ]
%1429 = getelementptr inbounds double, double* %1284, i64 %1427
%1430 = bitcast double* %1429 to <2 x double>*
%1431 = load <2 x double>, <2 x double>* %1430
%1432 = getelementptr inbounds double, double* %1305, i64 %1427
%1433 = bitcast double* %1432 to <2 x double>*
%1434 = load <2 x double>, <2 x double>* %1433
%1435 = fmul <2 x double> %1431, %1434
%1436 = getelementptr inbounds double, double* %50, i64 %1427
%1437 = bitcast double* %1436 to <2 x double>*
%1438 = load <2 x double>, <2 x double>* %1437
%1439 = fmul <2 x double> %1438, %1438
%1440 = fdiv <2 x double> %1435, %1439
%1441 = getelementptr inbounds double, double* %96, i64 %1427
%1442 = bitcast double* %1441 to <2 x double>*
store <2 x double> %1440, <2 x double>* %1442
%1443 = or i64 %1427, 2
%1444 = getelementptr inbounds double, double* %1284, i64 %1443
%1445 = bitcast double* %1444 to <2 x double>*
%1446 = load <2 x double>, <2 x double>* %1445
%1447 = getelementptr inbounds double, double* %1305, i64 %1443
%1448 = bitcast double* %1447 to <2 x double>*
%1449 = load <2 x double>, <2 x double>* %1448
%1450 = fmul <2 x double> %1446, %1449
%1451 = getelementptr inbounds double, double* %50, i64 %1443
%1452 = bitcast double* %1451 to <2 x double>*
%1453 = load <2 x double>, <2 x double>* %1452
%1454 = fmul <2 x double> %1453, %1453
%1455 = fdiv <2 x double> %1450, %1454
%1456 = getelementptr inbounds double, double* %96, i64 %1443
%1457 = bitcast double* %1456 to <2 x double>*
store <2 x double> %1455, <2 x double>* %1457
%1458 = add nuw i64 %1427, 4
%1459 = add nuw i64 %1428, 2
%1460 = icmp eq i64 %1459, %1264
br i1 %1460, label %1461, label %1426
1461: ; preds = %1426, %1425
%1462 = phi i64 [ 0, %1425 ], [ %1458, %1426 ]
br i1 %1265, label %1478, label %1463
1463: ; preds = %1461
%1464 = getelementptr inbounds double, double* %1284, i64 %1462
%1465 = bitcast double* %1464 to <2 x double>*
%1466 = load <2 x double>, <2 x double>* %1465
%1467 = getelementptr inbounds double, double* %1305, i64 %1462
%1468 = bitcast double* %1467 to <2 x double>*
%1469 = load <2 x double>, <2 x double>* %1468
%1470 = fmul <2 x double> %1466, %1469
%1471 = getelementptr inbounds double, double* %50, i64 %1462
%1472 = bitcast double* %1471 to <2 x double>*
%1473 = load <2 x double>, <2 x double>* %1472
%1474 = fmul <2 x double> %1473, %1473
%1475 = fdiv <2 x double> %1470, %1474
%1476 = getelementptr inbounds double, double* %96, i64 %1462
%1477 = bitcast double* %1476 to <2 x double>*
store <2 x double> %1475, <2 x double>* %1477
br label %1478
1478: ; preds = %1461, %1463
br i1 %1266, label %1522, label %1479
1479: ; preds = %1417, %1416, %1478
%1480 = phi i64 [ 0, %1417 ], [ 0, %1416 ], [ %1261, %1478 ]
%1481 = xor i64 %1480, -1
br i1 %1268, label %1494, label %1482
1482: ; preds = %1479
%1483 = getelementptr inbounds double, double* %1284, i64 %1480
%1484 = load double, double* %1483
%1485 = getelementptr inbounds double, double* %1305, i64 %1480
%1486 = load double, double* %1485
%1487 = fmul double %1484, %1486
%1488 = getelementptr inbounds double, double* %50, i64 %1480
%1489 = load double, double* %1488
%1490 = fmul double %1489, %1489
%1491 = fdiv double %1487, %1490
%1492 = getelementptr inbounds double, double* %96, i64 %1480
store double %1491, double* %1492
%1493 = or i64 %1480, 1
br label %1494
1494: ; preds = %1482, %1479
%1495 = phi i64 [ %1480, %1479 ], [ %1493, %1482 ]
%1496 = icmp eq i64 %1481, %1269
br i1 %1496, label %1522, label %1497
1497: ; preds = %1494, %1497
%1498 = phi i64 [ %1520, %1497 ], [ %1495, %1494 ]
%1499 = getelementptr inbounds double, double* %1284, i64 %1498
%1500 = load double, double* %1499
%1501 = getelementptr inbounds double, double* %1305, i64 %1498
%1502 = load double, double* %1501
%1503 = fmul double %1500, %1502
%1504 = getelementptr inbounds double, double* %50, i64 %1498
%1505 = load double, double* %1504
%1506 = fmul double %1505, %1505
%1507 = fdiv double %1503, %1506
%1508 = getelementptr inbounds double, double* %96, i64 %1498
store double %1507, double* %1508
%1509 = add nuw nsw i64 %1498, 1
%1510 = getelementptr inbounds double, double* %1284, i64 %1509
%1511 = load double, double* %1510
%1512 = getelementptr inbounds double, double* %1305, i64 %1509
%1513 = load double, double* %1512
%1514 = fmul double %1511, %1513
%1515 = getelementptr inbounds double, double* %50, i64 %1509
%1516 = load double, double* %1515
%1517 = fmul double %1516, %1516
%1518 = fdiv double %1514, %1517
%1519 = getelementptr inbounds double, double* %96, i64 %1509
store double %1518, double* %1519
%1520 = add nuw nsw i64 %1498, 2
%1521 = icmp eq i64 %1520, %1231
br i1 %1521, label %1522, label %1497
1522: ; preds = %1494, %1497, %1478, %1387, %1414
%1523 = phi i32 [ %1388, %1387 ], [ %1415, %1414 ], [ %1415, %1478 ], [ %1415, %1497 ], [ %1415, %1494 ]
%1524 = sitofp i32 %1523 to double
%1525 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %96)
%1526 = sitofp i32 %1525 to double
%1527 = fsub double %1524, %1526
%1528 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %1277, i64 %1298, i64 %1271
%1529 = load i32, i32* %1528
%1530 = sext i32 %1529 to i64
%1531 = getelementptr inbounds double, double* %19, i64 %1530
store double %1527, double* %1531
%1532 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %1530
%1533 = load double, double* %1532
%1534 = load i32, i32* %1299
%1535 = sext i32 %1534 to i64
%1536 = getelementptr inbounds double, double* %3, i64 %1535
%1537 = load double, double* %1536
%1538 = call double @llvm.fmuladd.f64(double %1537, double %1527, double %1533)
%1539 = fsub double %1538, %1226
%1540 = getelementptr inbounds double, double* %18, i64 %1530
store double %1539, double* %1540
%1541 = add nuw nsw i64 %1298, 1
%1542 = load i32, i32* %1272
%1543 = sext i32 %1542 to i64
%1544 = icmp slt i64 %1541, %1543
br i1 %1544, label %1297, label %1545
1545: ; preds = %1522, %1275
%1546 = phi i32 [ %1276, %1275 ], [ %1542, %1522 ]
%1547 = sext i32 %1546 to i64
%1548 = add nuw nsw i64 %1277, 1
%1549 = icmp slt i64 %1548, %1547
br i1 %1549, label %1275, label %1550
1550: ; preds = %1545, %1270
%1551 = add nuw nsw i64 %1271, 1
%1552 = icmp eq i64 %1551, %1229
br i1 %1552, label %1553, label %1270
1553: ; preds = %1550
%1554 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %96)
%1555 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.12, i64 0, i64 0))
br i1 %1073, label %1675, label %1556
1556: ; preds = %1553
%1557 = add i32 %1074, 1
%1558 = zext i32 %1557 to i64
br label %1563
1559: ; preds = %1595
br i1 %1073, label %1675, label %1560
1560: ; preds = %1559
%1561 = add i32 %1074, 1
%1562 = zext i32 %1561 to i64
br label %1602
1563: ; preds = %1556, %1595
%1564 = phi i64 [ 0, %1556 ], [ %1596, %1595 ]
%1565 = call i32 @putchar(i32 10)
%1566 = trunc i64 %1564 to i32
%1567 = call i32 (i32, ...) bitcast (i32 (...)* @spd_Name to i32 (i32, ...)*)(i32 %1566)
%1568 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i32 %1567)
%1569 = getelementptr inbounds i32, i32* %8, i64 %1564
%1570 = load i32, i32* %1569
%1571 = icmp sgt i32 %1570, 0
br i1 %1571, label %1572, label %1595
1572: ; preds = %1563, %1588
%1573 = phi i32 [ %1592, %1588 ], [ %1570, %1563 ]
%1574 = phi i64 [ %1591, %1588 ], [ 0, %1563 ]
%1575 = icmp sgt i32 %1573, 0
br i1 %1575, label %1576, label %1588
1576: ; preds = %1572, %1576
%1577 = phi i64 [ %1584, %1576 ], [ 0, %1572 ]
%1578 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %1574, i64 %1577, i64 %1564
%1579 = load i32, i32* %1578
%1580 = sext i32 %1579 to i64
%1581 = getelementptr inbounds [250 x double], [250 x double]* %33, i64 0, i64 %1580
%1582 = load double, double* %1581
%1583 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %1582)
%1584 = add nuw nsw i64 %1577, 1
%1585 = load i32, i32* %1569
%1586 = sext i32 %1585 to i64
%1587 = icmp slt i64 %1584, %1586
br i1 %1587, label %1576, label %1588
1588: ; preds = %1576, %1572
%1589 = call i32 @putchar(i32 10)
%1590 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
%1591 = add nuw nsw i64 %1574, 1
%1592 = load i32, i32* %1569
%1593 = sext i32 %1592 to i64
%1594 = icmp slt i64 %1591, %1593
br i1 %1594, label %1572, label %1595
1595: ; preds = %1588, %1563
%1596 = add nuw nsw i64 %1564, 1
%1597 = icmp eq i64 %1596, %1558
br i1 %1597, label %1559, label %1563
1598: ; preds = %1634
br i1 %1073, label %1675, label %1599
1599: ; preds = %1598
%1600 = add i32 %1074, 1
%1601 = zext i32 %1600 to i64
br label %1637
1602: ; preds = %1560, %1634
%1603 = phi i64 [ 0, %1560 ], [ %1635, %1634 ]
%1604 = call i32 @putchar(i32 10)
%1605 = trunc i64 %1603 to i32
%1606 = call i32 (i32, ...) bitcast (i32 (...)* @spd_Name to i32 (i32, ...)*)(i32 %1605)
%1607 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i32 %1606)
%1608 = getelementptr inbounds i32, i32* %8, i64 %1603
%1609 = load i32, i32* %1608
%1610 = icmp sgt i32 %1609, 0
br i1 %1610, label %1611, label %1634
1611: ; preds = %1602, %1627
%1612 = phi i32 [ %1631, %1627 ], [ %1609, %1602 ]
%1613 = phi i64 [ %1630, %1627 ], [ 0, %1602 ]
%1614 = icmp sgt i32 %1612, 0
br i1 %1614, label %1615, label %1627
1615: ; preds = %1611, %1615
%1616 = phi i64 [ %1623, %1615 ], [ 0, %1611 ]
%1617 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %1613, i64 %1616, i64 %1603
%1618 = load i32, i32* %1617
%1619 = sext i32 %1618 to i64
%1620 = getelementptr inbounds double, double* %18, i64 %1619
%1621 = load double, double* %1620
%1622 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %1621)
%1623 = add nuw nsw i64 %1616, 1
%1624 = load i32, i32* %1608
%1625 = sext i32 %1624 to i64
%1626 = icmp slt i64 %1623, %1625
br i1 %1626, label %1615, label %1627
1627: ; preds = %1615, %1611
%1628 = call i32 @putchar(i32 10)
%1629 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
%1630 = add nuw nsw i64 %1613, 1
%1631 = load i32, i32* %1608
%1632 = sext i32 %1631 to i64
%1633 = icmp slt i64 %1630, %1632
br i1 %1633, label %1611, label %1634
1634: ; preds = %1627, %1602
%1635 = add nuw nsw i64 %1603, 1
%1636 = icmp eq i64 %1635, %1562
br i1 %1636, label %1598, label %1602
1637: ; preds = %1599, %1669
%1638 = phi i64 [ 0, %1599 ], [ %1670, %1669 ]
%1639 = call i32 @putchar(i32 10)
%1640 = trunc i64 %1638 to i32
%1641 = call i32 (i32, ...) bitcast (i32 (...)* @spd_Name to i32 (i32, ...)*)(i32 %1640)
%1642 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.9, i64 0, i64 0), i32 %1641)
%1643 = getelementptr inbounds i32, i32* %8, i64 %1638
%1644 = load i32, i32* %1643
%1645 = icmp sgt i32 %1644, 0
br i1 %1645, label %1646, label %1669
1646: ; preds = %1637, %1662
%1647 = phi i32 [ %1666, %1662 ], [ %1644, %1637 ]
%1648 = phi i64 [ %1665, %1662 ], [ 0, %1637 ]
%1649 = icmp sgt i32 %1647, 0
br i1 %1649, label %1650, label %1662
1650: ; preds = %1646, %1650
%1651 = phi i64 [ %1658, %1650 ], [ 0, %1646 ]
%1652 = getelementptr inbounds [4 x [10 x i32]], [4 x [10 x i32]]* %10, i64 %1648, i64 %1651, i64 %1638
%1653 = load i32, i32* %1652
%1654 = sext i32 %1653 to i64
%1655 = getelementptr inbounds double, double* %19, i64 %1654
%1656 = load double, double* %1655
%1657 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %1656)
%1658 = add nuw nsw i64 %1651, 1
%1659 = load i32, i32* %1643
%1660 = sext i32 %1659 to i64
%1661 = icmp slt i64 %1658, %1660
br i1 %1661, label %1650, label %1662
1662: ; preds = %1650, %1646
%1663 = call i32 @putchar(i32 10)
%1664 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0))
%1665 = add nuw nsw i64 %1648, 1
%1666 = load i32, i32* %1643
%1667 = sext i32 %1666 to i64
%1668 = icmp slt i64 %1665, %1667
br i1 %1668, label %1646, label %1669
1669: ; preds = %1662, %1637
%1670 = add nuw nsw i64 %1638, 1
%1671 = icmp eq i64 %1670, %1601
br i1 %1671, label %1675, label %1637
1672: ; preds = %1224
%1673 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %96)
%1674 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.12, i64 0, i64 0))
br label %1675
1675: ; preds = %1669, %1672, %1553, %1559, %1598
%1676 = call i32 (...) @alloc_LogGrid()
%1677 = sext i32 %1676 to i64
%1678 = inttoptr i64 %1677 to double*
%1679 = inttoptr i64 %1677 to i8*
%1680 = call i32 (...) @alloc_LogGrid()
%1681 = sext i32 %1680 to i64
%1682 = inttoptr i64 %1681 to double*
%1683 = inttoptr i64 %1681 to i8*
%1684 = call i32 (...) @alloc_LogGrid()
%1685 = sext i32 %1684 to i64
%1686 = inttoptr i64 %1685 to double*
%1687 = inttoptr i64 %1685 to i8*
%1688 = call i32 (double*, double, double*, ...) bitcast (i32 (...)* @R_Hartree_DFT to i32 (double*, double, double*, ...)*)(double* %1077, double %61, double* %1678)
%1689 = sitofp i32 %1688 to double
%1690 = fmul double %1689, 5.000000e-01
%1691 = call i32 (double*, double*, double*, double*, ...) bitcast (i32 (...)* @R_Exchange_DFT to i32 (double*, double*, double*, double*, ...)*)(double* %1077, double* %1682, double* %31, double* %29)
%1692 = call i32 (double*, double*, double*, double*, ...) bitcast (i32 (...)* @R_Correlation_DFT to i32 (double*, double*, double*, double*, ...)*)(double* %1077, double* %1686, double* %32, double* %30)
br i1 %62, label %1696, label %1693
1693: ; preds = %1675
%1694 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %14)
%1695 = sitofp i32 %1694 to double
store double %1695, double* %29
br label %1985
1696: ; preds = %1675
%1697 = zext i32 %52 to i64
%1698 = icmp ult i32 %52, 4
br i1 %1698, label %1787, label %1699
1699: ; preds = %1696
%1700 = getelementptr double, double* %14, i64 %1697
%1701 = bitcast double* %1700 to i8*
%1702 = getelementptr double, double* %1077, i64 %1697
%1703 = getelementptr double, double* %1682, i64 %1697
%1704 = icmp ugt double* %1702, %14
%1705 = icmp ult i8* %1078, %1701
%1706 = and i1 %1704, %1705
%1707 = icmp ugt double* %1703, %14
%1708 = icmp ult i8* %1683, %1701
%1709 = and i1 %1707, %1708
%1710 = or i1 %1706, %1709
br i1 %1710, label %1787, label %1711
1711: ; preds = %1699
%1712 = and i64 %1697, 4294967292
%1713 = add nsw i64 %1712, -4
%1714 = lshr exact i64 %1713, 2
%1715 = add nuw nsw i64 %1714, 1
%1716 = and i64 %1715, 1
%1717 = icmp eq i64 %1713, 0
br i1 %1717, label %1763, label %1718
1718: ; preds = %1711
%1719 = and i64 %1715, 9223372036854775806
br label %1720
1720: ; preds = %1720, %1718
%1721 = phi i64 [ 0, %1718 ], [ %1760, %1720 ]
%1722 = phi i64 [ 0, %1718 ], [ %1761, %1720 ]
%1723 = getelementptr inbounds double, double* %1077, i64 %1721
%1724 = bitcast double* %1723 to <2 x double>*
%1725 = load <2 x double>, <2 x double>* %1724
%1726 = getelementptr inbounds double, double* %1723, i64 2
%1727 = bitcast double* %1726 to <2 x double>*
%1728 = load <2 x double>, <2 x double>* %1727
%1729 = getelementptr inbounds double, double* %1682, i64 %1721
%1730 = bitcast double* %1729 to <2 x double>*
%1731 = load <2 x double>, <2 x double>* %1730
%1732 = getelementptr inbounds double, double* %1729, i64 2
%1733 = bitcast double* %1732 to <2 x double>*
%1734 = load <2 x double>, <2 x double>* %1733
%1735 = fmul <2 x double> %1725, %1731
%1736 = fmul <2 x double> %1728, %1734
%1737 = getelementptr inbounds double, double* %14, i64 %1721
%1738 = bitcast double* %1737 to <2 x double>*
store <2 x double> %1735, <2 x double>* %1738
%1739 = getelementptr inbounds double, double* %1737, i64 2
%1740 = bitcast double* %1739 to <2 x double>*
store <2 x double> %1736, <2 x double>* %1740
%1741 = or i64 %1721, 4
%1742 = getelementptr inbounds double, double* %1077, i64 %1741
%1743 = bitcast double* %1742 to <2 x double>*
%1744 = load <2 x double>, <2 x double>* %1743
%1745 = getelementptr inbounds double, double* %1742, i64 2
%1746 = bitcast double* %1745 to <2 x double>*
%1747 = load <2 x double>, <2 x double>* %1746
%1748 = getelementptr inbounds double, double* %1682, i64 %1741
%1749 = bitcast double* %1748 to <2 x double>*
%1750 = load <2 x double>, <2 x double>* %1749
%1751 = getelementptr inbounds double, double* %1748, i64 2
%1752 = bitcast double* %1751 to <2 x double>*
%1753 = load <2 x double>, <2 x double>* %1752
%1754 = fmul <2 x double> %1744, %1750
%1755 = fmul <2 x double> %1747, %1753
%1756 = getelementptr inbounds double, double* %14, i64 %1741
%1757 = bitcast double* %1756 to <2 x double>*
store <2 x double> %1754, <2 x double>* %1757
%1758 = getelementptr inbounds double, double* %1756, i64 2
%1759 = bitcast double* %1758 to <2 x double>*
store <2 x double> %1755, <2 x double>* %1759
%1760 = add nuw i64 %1721, 8
%1761 = add i64 %1722, 2
%1762 = icmp eq i64 %1761, %1719
br i1 %1762, label %1763, label %1720
1763: ; preds = %1720, %1711
%1764 = phi i64 [ 0, %1711 ], [ %1760, %1720 ]
%1765 = icmp eq i64 %1716, 0
br i1 %1765, label %1785, label %1766
1766: ; preds = %1763
%1767 = getelementptr inbounds double, double* %1077, i64 %1764
%1768 = bitcast double* %1767 to <2 x double>*
%1769 = load <2 x double>, <2 x double>* %1768
%1770 = getelementptr inbounds double, double* %1767, i64 2
%1771 = bitcast double* %1770 to <2 x double>*
%1772 = load <2 x double>, <2 x double>* %1771
%1773 = getelementptr inbounds double, double* %1682, i64 %1764
%1774 = bitcast double* %1773 to <2 x double>*
%1775 = load <2 x double>, <2 x double>* %1774
%1776 = getelementptr inbounds double, double* %1773, i64 2
%1777 = bitcast double* %1776 to <2 x double>*
%1778 = load <2 x double>, <2 x double>* %1777
%1779 = fmul <2 x double> %1769, %1775
%1780 = fmul <2 x double> %1772, %1778
%1781 = getelementptr inbounds double, double* %14, i64 %1764
%1782 = bitcast double* %1781 to <2 x double>*
store <2 x double> %1779, <2 x double>* %1782
%1783 = getelementptr inbounds double, double* %1781, i64 2
%1784 = bitcast double* %1783 to <2 x double>*
store <2 x double> %1780, <2 x double>* %1784
br label %1785
1785: ; preds = %1763, %1766
%1786 = icmp eq i64 %1712, %1697
br i1 %1786, label %1839, label %1787
1787: ; preds = %1699, %1696, %1785
%1788 = phi i64 [ 0, %1699 ], [ 0, %1696 ], [ %1712, %1785 ]
%1789 = xor i64 %1788, -1
%1790 = add nsw i64 %1789, %1697
%1791 = and i64 %1697, 3
%1792 = icmp eq i64 %1791, 0
br i1 %1792, label %1805, label %1793
1793: ; preds = %1787, %1793
%1794 = phi i64 [ %1802, %1793 ], [ %1788, %1787 ]
%1795 = phi i64 [ %1803, %1793 ], [ 0, %1787 ]
%1796 = getelementptr inbounds double, double* %1077, i64 %1794
%1797 = load double, double* %1796
%1798 = getelementptr inbounds double, double* %1682, i64 %1794
%1799 = load double, double* %1798
%1800 = fmul double %1797, %1799
%1801 = getelementptr inbounds double, double* %14, i64 %1794
store double %1800, double* %1801
%1802 = add nuw nsw i64 %1794, 1
%1803 = add i64 %1795, 1
%1804 = icmp eq i64 %1803, %1791
br i1 %1804, label %1805, label %1793
1805: ; preds = %1793, %1787
%1806 = phi i64 [ %1788, %1787 ], [ %1802, %1793 ]
%1807 = icmp ult i64 %1790, 3
br i1 %1807, label %1839, label %1808
1808: ; preds = %1805, %1808
%1809 = phi i64 [ %1837, %1808 ], [ %1806, %1805 ]
%1810 = getelementptr inbounds double, double* %1077, i64 %1809
%1811 = load double, double* %1810
%1812 = getelementptr inbounds double, double* %1682, i64 %1809
%1813 = load double, double* %1812
%1814 = fmul double %1811, %1813
%1815 = getelementptr inbounds double, double* %14, i64 %1809
store double %1814, double* %1815
%1816 = add nuw nsw i64 %1809, 1
%1817 = getelementptr inbounds double, double* %1077, i64 %1816
%1818 = load double, double* %1817
%1819 = getelementptr inbounds double, double* %1682, i64 %1816
%1820 = load double, double* %1819
%1821 = fmul double %1818, %1820
%1822 = getelementptr inbounds double, double* %14, i64 %1816
store double %1821, double* %1822
%1823 = add nuw nsw i64 %1809, 2
%1824 = getelementptr inbounds double, double* %1077, i64 %1823
%1825 = load double, double* %1824
%1826 = getelementptr inbounds double, double* %1682, i64 %1823
%1827 = load double, double* %1826
%1828 = fmul double %1825, %1827
%1829 = getelementptr inbounds double, double* %14, i64 %1823
store double %1828, double* %1829
%1830 = add nuw nsw i64 %1809, 3
%1831 = getelementptr inbounds double, double* %1077, i64 %1830
%1832 = load double, double* %1831
%1833 = getelementptr inbounds double, double* %1682, i64 %1830
%1834 = load double, double* %1833
%1835 = fmul double %1832, %1834
%1836 = getelementptr inbounds double, double* %14, i64 %1830
store double %1835, double* %1836
%1837 = add nuw nsw i64 %1809, 4
%1838 = icmp eq i64 %1837, %1697
br i1 %1838, label %1839, label %1808
1839: ; preds = %1805, %1808, %1785
%1840 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %14)
%1841 = sitofp i32 %1840 to double
store double %1841, double* %29
br i1 %62, label %1842, label %1985
1842: ; preds = %1839
%1843 = zext i32 %52 to i64
%1844 = icmp ult i32 %52, 4
br i1 %1844, label %1933, label %1845
1845: ; preds = %1842
%1846 = getelementptr double, double* %14, i64 %1697
%1847 = bitcast double* %1846 to i8*
%1848 = getelementptr double, double* %1077, i64 %1697
%1849 = getelementptr double, double* %1686, i64 %1697
%1850 = icmp ugt double* %1848, %14
%1851 = icmp ult i8* %1078, %1847
%1852 = and i1 %1850, %1851
%1853 = icmp ugt double* %1849, %14
%1854 = icmp ult i8* %1687, %1847
%1855 = and i1 %1853, %1854
%1856 = or i1 %1852, %1855
br i1 %1856, label %1933, label %1857
1857: ; preds = %1845
%1858 = and i64 %1697, 4294967292
%1859 = add nsw i64 %1858, -4
%1860 = lshr exact i64 %1859, 2
%1861 = add nuw nsw i64 %1860, 1
%1862 = and i64 %1861, 1
%1863 = icmp eq i64 %1859, 0
br i1 %1863, label %1909, label %1864
1864: ; preds = %1857
%1865 = and i64 %1861, 9223372036854775806
br label %1866
1866: ; preds = %1866, %1864
%1867 = phi i64 [ 0, %1864 ], [ %1906, %1866 ]
%1868 = phi i64 [ 0, %1864 ], [ %1907, %1866 ]
%1869 = getelementptr inbounds double, double* %1077, i64 %1867
%1870 = bitcast double* %1869 to <2 x double>*
%1871 = load <2 x double>, <2 x double>* %1870
%1872 = getelementptr inbounds double, double* %1869, i64 2
%1873 = bitcast double* %1872 to <2 x double>*
%1874 = load <2 x double>, <2 x double>* %1873
%1875 = getelementptr inbounds double, double* %1686, i64 %1867
%1876 = bitcast double* %1875 to <2 x double>*
%1877 = load <2 x double>, <2 x double>* %1876
%1878 = getelementptr inbounds double, double* %1875, i64 2
%1879 = bitcast double* %1878 to <2 x double>*
%1880 = load <2 x double>, <2 x double>* %1879
%1881 = fmul <2 x double> %1871, %1877
%1882 = fmul <2 x double> %1874, %1880
%1883 = getelementptr inbounds double, double* %14, i64 %1867
%1884 = bitcast double* %1883 to <2 x double>*
store <2 x double> %1881, <2 x double>* %1884
%1885 = getelementptr inbounds double, double* %1883, i64 2
%1886 = bitcast double* %1885 to <2 x double>*
store <2 x double> %1882, <2 x double>* %1886
%1887 = or i64 %1867, 4
%1888 = getelementptr inbounds double, double* %1077, i64 %1887
%1889 = bitcast double* %1888 to <2 x double>*
%1890 = load <2 x double>, <2 x double>* %1889
%1891 = getelementptr inbounds double, double* %1888, i64 2
%1892 = bitcast double* %1891 to <2 x double>*
%1893 = load <2 x double>, <2 x double>* %1892
%1894 = getelementptr inbounds double, double* %1686, i64 %1887
%1895 = bitcast double* %1894 to <2 x double>*
%1896 = load <2 x double>, <2 x double>* %1895
%1897 = getelementptr inbounds double, double* %1894, i64 2
%1898 = bitcast double* %1897 to <2 x double>*
%1899 = load <2 x double>, <2 x double>* %1898
%1900 = fmul <2 x double> %1890, %1896
%1901 = fmul <2 x double> %1893, %1899
%1902 = getelementptr inbounds double, double* %14, i64 %1887
%1903 = bitcast double* %1902 to <2 x double>*
store <2 x double> %1900, <2 x double>* %1903
%1904 = getelementptr inbounds double, double* %1902, i64 2
%1905 = bitcast double* %1904 to <2 x double>*
store <2 x double> %1901, <2 x double>* %1905
%1906 = add nuw i64 %1867, 8
%1907 = add i64 %1868, 2
%1908 = icmp eq i64 %1907, %1865
br i1 %1908, label %1909, label %1866
1909: ; preds = %1866, %1857
%1910 = phi i64 [ 0, %1857 ], [ %1906, %1866 ]
%1911 = icmp eq i64 %1862, 0
br i1 %1911, label %1931, label %1912
1912: ; preds = %1909
%1913 = getelementptr inbounds double, double* %1077, i64 %1910
%1914 = bitcast double* %1913 to <2 x double>*
%1915 = load <2 x double>, <2 x double>* %1914
%1916 = getelementptr inbounds double, double* %1913, i64 2
%1917 = bitcast double* %1916 to <2 x double>*
%1918 = load <2 x double>, <2 x double>* %1917
%1919 = getelementptr inbounds double, double* %1686, i64 %1910
%1920 = bitcast double* %1919 to <2 x double>*
%1921 = load <2 x double>, <2 x double>* %1920
%1922 = getelementptr inbounds double, double* %1919, i64 2
%1923 = bitcast double* %1922 to <2 x double>*
%1924 = load <2 x double>, <2 x double>* %1923
%1925 = fmul <2 x double> %1915, %1921
%1926 = fmul <2 x double> %1918, %1924
%1927 = getelementptr inbounds double, double* %14, i64 %1910
%1928 = bitcast double* %1927 to <2 x double>*
store <2 x double> %1925, <2 x double>* %1928
%1929 = getelementptr inbounds double, double* %1927, i64 2
%1930 = bitcast double* %1929 to <2 x double>*
store <2 x double> %1926, <2 x double>* %1930
br label %1931
1931: ; preds = %1909, %1912
%1932 = icmp eq i64 %1858, %1697
br i1 %1932, label %1985, label %1933
1933: ; preds = %1845, %1842, %1931
%1934 = phi i64 [ 0, %1845 ], [ 0, %1842 ], [ %1858, %1931 ]
%1935 = xor i64 %1934, -1
%1936 = add nsw i64 %1935, %1697
%1937 = and i64 %1697, 3
%1938 = icmp eq i64 %1937, 0
br i1 %1938, label %1951, label %1939
1939: ; preds = %1933, %1939
%1940 = phi i64 [ %1948, %1939 ], [ %1934, %1933 ]
%1941 = phi i64 [ %1949, %1939 ], [ 0, %1933 ]
%1942 = getelementptr inbounds double, double* %1077, i64 %1940
%1943 = load double, double* %1942
%1944 = getelementptr inbounds double, double* %1686, i64 %1940
%1945 = load double, double* %1944
%1946 = fmul double %1943, %1945
%1947 = getelementptr inbounds double, double* %14, i64 %1940
store double %1946, double* %1947
%1948 = add nuw nsw i64 %1940, 1
%1949 = add i64 %1941, 1
%1950 = icmp eq i64 %1949, %1937
br i1 %1950, label %1951, label %1939
1951: ; preds = %1939, %1933
%1952 = phi i64 [ %1934, %1933 ], [ %1948, %1939 ]
%1953 = icmp ult i64 %1936, 3
br i1 %1953, label %1985, label %1954
1954: ; preds = %1951, %1954
%1955 = phi i64 [ %1983, %1954 ], [ %1952, %1951 ]
%1956 = getelementptr inbounds double, double* %1077, i64 %1955
%1957 = load double, double* %1956
%1958 = getelementptr inbounds double, double* %1686, i64 %1955
%1959 = load double, double* %1958
%1960 = fmul double %1957, %1959
%1961 = getelementptr inbounds double, double* %14, i64 %1955
store double %1960, double* %1961
%1962 = add nuw nsw i64 %1955, 1
%1963 = getelementptr inbounds double, double* %1077, i64 %1962
%1964 = load double, double* %1963
%1965 = getelementptr inbounds double, double* %1686, i64 %1962
%1966 = load double, double* %1965
%1967 = fmul double %1964, %1966
%1968 = getelementptr inbounds double, double* %14, i64 %1962
store double %1967, double* %1968
%1969 = add nuw nsw i64 %1955, 2
%1970 = getelementptr inbounds double, double* %1077, i64 %1969
%1971 = load double, double* %1970
%1972 = getelementptr inbounds double, double* %1686, i64 %1969
%1973 = load double, double* %1972
%1974 = fmul double %1971, %1973
%1975 = getelementptr inbounds double, double* %14, i64 %1969
store double %1974, double* %1975
%1976 = add nuw nsw i64 %1955, 3
%1977 = getelementptr inbounds double, double* %1077, i64 %1976
%1978 = load double, double* %1977
%1979 = getelementptr inbounds double, double* %1686, i64 %1976
%1980 = load double, double* %1979
%1981 = fmul double %1978, %1980
%1982 = getelementptr inbounds double, double* %14, i64 %1976
store double %1981, double* %1982
%1983 = add nuw nsw i64 %1955, 4
%1984 = icmp eq i64 %1983, %1843
br i1 %1984, label %1985, label %1954
1985: ; preds = %1951, %1954, %1931, %1693, %1839
%1986 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %14)
%1987 = sitofp i32 %1986 to double
store double %1987, double* %30
br i1 %59, label %1988, label %2000
1988: ; preds = %1985, %1988
%1989 = phi i32 [ %1996, %1988 ], [ %56, %1985 ]
%1990 = phi double [ %1995, %1988 ], [ 0.000000e+00, %1985 ]
%1991 = call i32 (i32, ...) bitcast (i32 (...)* @fill_Atom to i32 (i32, ...)*)(i32 %1989)
%1992 = call i32 (i32, ...) bitcast (i32 (...)* @eigenvalue_Atom to i32 (i32, ...)*)(i32 %1989)
%1993 = mul nsw i32 %1992, %1991
%1994 = sitofp i32 %1993 to double
%1995 = fadd double %1990, %1994
%1996 = add nsw i32 %1989, 1
%1997 = icmp slt i32 %1996, %58
br i1 %1997, label %1988, label %1998
1998: ; preds = %1988
%1999 = load double, double* %30
br label %2000
2000: ; preds = %1998, %1985
%2001 = phi double [ %1987, %1985 ], [ %1999, %1998 ]
%2002 = phi double [ 0.000000e+00, %1985 ], [ %1995, %1998 ]
%2003 = fadd double %1690, %2002
%2004 = load double, double* %31
%2005 = fadd double %2003, %2004
%2006 = load double, double* %32
%2007 = fadd double %2005, %2006
%2008 = fsub double %2007, %1689
%2009 = load double, double* %29
%2010 = fsub double %2008, %2009
%2011 = fsub double %2010, %2001
store double %2011, double* %20
store double %1690, double* %21
store double %1689, double* %22
store double %2004, double* %23
store double %2009, double* %24
store double %2006, double* %25
store double %2001, double* %26
br i1 %62, label %2012, label %2248
2012: ; preds = %2000
%2013 = zext i32 %52 to i64
%2014 = icmp ult i32 %52, 4
br i1 %2014, label %2072, label %2015
2015: ; preds = %2012
%2016 = getelementptr double, double* %17, i64 %2013
%2017 = bitcast double* %2016 to i8*
%2018 = getelementptr double, double* %1678, i64 %2013
%2019 = getelementptr double, double* %1682, i64 %2013
%2020 = getelementptr double, double* %1686, i64 %2013
%2021 = icmp ugt double* %2018, %17
%2022 = icmp ult i8* %1679, %2017
%2023 = and i1 %2021, %2022
%2024 = icmp ugt double* %2019, %17
%2025 = icmp ult i8* %1683, %2017
%2026 = and i1 %2024, %2025
%2027 = or i1 %2023, %2026
%2028 = icmp ugt double* %2020, %17
%2029 = icmp ult i8* %1687, %2017
%2030 = and i1 %2028, %2029
%2031 = or i1 %2027, %2030
br i1 %2031, label %2072, label %2032
2032: ; preds = %2015
%2033 = and i64 %2013, 4294967292
br label %2034
2034: ; preds = %2034, %2032
%2035 = phi i64 [ 0, %2032 ], [ %2068, %2034 ]
%2036 = getelementptr inbounds double, double* %17, i64 %2035
%2037 = bitcast double* %2036 to <2 x double>*
%2038 = load <2 x double>, <2 x double>* %2037
%2039 = getelementptr inbounds double, double* %2036, i64 2
%2040 = bitcast double* %2039 to <2 x double>*
%2041 = load <2 x double>, <2 x double>* %2040
%2042 = getelementptr inbounds double, double* %1678, i64 %2035
%2043 = bitcast double* %2042 to <2 x double>*
%2044 = load <2 x double>, <2 x double>* %2043
%2045 = getelementptr inbounds double, double* %2042, i64 2
%2046 = bitcast double* %2045 to <2 x double>*
%2047 = load <2 x double>, <2 x double>* %2046
%2048 = fsub <2 x double> %2038, %2044
%2049 = fsub <2 x double> %2041, %2047
%2050 = getelementptr inbounds double, double* %1682, i64 %2035
%2051 = bitcast double* %2050 to <2 x double>*
%2052 = load <2 x double>, <2 x double>* %2051
%2053 = getelementptr inbounds double, double* %2050, i64 2
%2054 = bitcast double* %2053 to <2 x double>*
%2055 = load <2 x double>, <2 x double>* %2054
%2056 = fsub <2 x double> %2048, %2052
%2057 = fsub <2 x double> %2049, %2055
%2058 = getelementptr inbounds double, double* %1686, i64 %2035
%2059 = bitcast double* %2058 to <2 x double>*
%2060 = load <2 x double>, <2 x double>* %2059
%2061 = getelementptr inbounds double, double* %2058, i64 2
%2062 = bitcast double* %2061 to <2 x double>*
%2063 = load <2 x double>, <2 x double>* %2062
%2064 = fsub <2 x double> %2056, %2060
%2065 = fsub <2 x double> %2057, %2063
%2066 = bitcast double* %2036 to <2 x double>*
store <2 x double> %2064, <2 x double>* %2066
%2067 = bitcast double* %2039 to <2 x double>*
store <2 x double> %2065, <2 x double>* %2067
%2068 = add nuw i64 %2035, 4
%2069 = icmp eq i64 %2068, %2033
br i1 %2069, label %2070, label %2034
2070: ; preds = %2034
%2071 = icmp eq i64 %2033, %2013
br i1 %2071, label %2094, label %2072
2072: ; preds = %2015, %2012, %2070
%2073 = phi i64 [ 0, %2015 ], [ 0, %2012 ], [ %2033, %2070 ]
%2074 = xor i64 %2073, -1
%2075 = and i64 %2013, 1
%2076 = icmp eq i64 %2075, 0
br i1 %2076, label %2090, label %2077
2077: ; preds = %2072
%2078 = getelementptr inbounds double, double* %17, i64 %2073
%2079 = load double, double* %2078
%2080 = getelementptr inbounds double, double* %1678, i64 %2073
%2081 = load double, double* %2080
%2082 = fsub double %2079, %2081
%2083 = getelementptr inbounds double, double* %1682, i64 %2073
%2084 = load double, double* %2083
%2085 = fsub double %2082, %2084
%2086 = getelementptr inbounds double, double* %1686, i64 %2073
%2087 = load double, double* %2086
%2088 = fsub double %2085, %2087
store double %2088, double* %2078
%2089 = or i64 %2073, 1
br label %2090
2090: ; preds = %2077, %2072
%2091 = phi i64 [ %2073, %2072 ], [ %2089, %2077 ]
%2092 = sub nsw i64 0, %2013
%2093 = icmp eq i64 %2074, %2092
br i1 %2093, label %2094, label %2202
2094: ; preds = %2090, %2202, %2070
br i1 %62, label %2095, label %2248
2095: ; preds = %2094
%2096 = zext i32 %52 to i64
%2097 = icmp ult i32 %52, 4
br i1 %2097, label %2184, label %2098
2098: ; preds = %2095
%2099 = getelementptr double, double* %14, i64 %2013
%2100 = bitcast double* %2099 to i8*
%2101 = getelementptr double, double* %1077, i64 %2013
%2102 = icmp ugt double* %2101, %14
%2103 = icmp ult i8* %1078, %2100
%2104 = and i1 %2102, %2103
br i1 %2104, label %2184, label %2105
2105: ; preds = %2098
%2106 = and i64 %2013, 4294967292
%2107 = add nsw i64 %2106, -4
%2108 = lshr exact i64 %2107, 2
%2109 = add nuw nsw i64 %2108, 1
%2110 = and i64 %2109, 3
%2111 = icmp ult i64 %2107, 12
br i1 %2111, label %2163, label %2112
2112: ; preds = %2105
%2113 = and i64 %2109, 9223372036854775804
br label %2114
2114: ; preds = %2114, %2112
%2115 = phi i64 [ 0, %2112 ], [ %2160, %2114 ]
%2116 = phi i64 [ 0, %2112 ], [ %2161, %2114 ]
%2117 = getelementptr inbounds double, double* %1077, i64 %2115
%2118 = bitcast double* %2117 to <2 x double>*
%2119 = load <2 x double>, <2 x double>* %2118
%2120 = getelementptr inbounds double, double* %2117, i64 2
%2121 = bitcast double* %2120 to <2 x double>*
%2122 = load <2 x double>, <2 x double>* %2121
%2123 = getelementptr inbounds double, double* %14, i64 %2115
%2124 = bitcast double* %2123 to <2 x double>*
store <2 x double> %2119, <2 x double>* %2124
%2125 = getelementptr inbounds double, double* %2123, i64 2
%2126 = bitcast double* %2125 to <2 x double>*
store <2 x double> %2122, <2 x double>* %2126
%2127 = or i64 %2115, 4
%2128 = getelementptr inbounds double, double* %1077, i64 %2127
%2129 = bitcast double* %2128 to <2 x double>*
%2130 = load <2 x double>, <2 x double>* %2129
%2131 = getelementptr inbounds double, double* %2128, i64 2
%2132 = bitcast double* %2131 to <2 x double>*
%2133 = load <2 x double>, <2 x double>* %2132
%2134 = getelementptr inbounds double, double* %14, i64 %2127
%2135 = bitcast double* %2134 to <2 x double>*
store <2 x double> %2130, <2 x double>* %2135
%2136 = getelementptr inbounds double, double* %2134, i64 2
%2137 = bitcast double* %2136 to <2 x double>*
store <2 x double> %2133, <2 x double>* %2137
%2138 = or i64 %2115, 8
%2139 = getelementptr inbounds double, double* %1077, i64 %2138
%2140 = bitcast double* %2139 to <2 x double>*
%2141 = load <2 x double>, <2 x double>* %2140
%2142 = getelementptr inbounds double, double* %2139, i64 2
%2143 = bitcast double* %2142 to <2 x double>*
%2144 = load <2 x double>, <2 x double>* %2143
%2145 = getelementptr inbounds double, double* %14, i64 %2138
%2146 = bitcast double* %2145 to <2 x double>*
store <2 x double> %2141, <2 x double>* %2146
%2147 = getelementptr inbounds double, double* %2145, i64 2
%2148 = bitcast double* %2147 to <2 x double>*
store <2 x double> %2144, <2 x double>* %2148
%2149 = or i64 %2115, 12
%2150 = getelementptr inbounds double, double* %1077, i64 %2149
%2151 = bitcast double* %2150 to <2 x double>*
%2152 = load <2 x double>, <2 x double>* %2151
%2153 = getelementptr inbounds double, double* %2150, i64 2
%2154 = bitcast double* %2153 to <2 x double>*
%2155 = load <2 x double>, <2 x double>* %2154
%2156 = getelementptr inbounds double, double* %14, i64 %2149
%2157 = bitcast double* %2156 to <2 x double>*
store <2 x double> %2152, <2 x double>* %2157
%2158 = getelementptr inbounds double, double* %2156, i64 2
%2159 = bitcast double* %2158 to <2 x double>*
store <2 x double> %2155, <2 x double>* %2159
%2160 = add nuw i64 %2115, 16
%2161 = add nuw i64 %2116, 4
%2162 = icmp eq i64 %2161, %2113
br i1 %2162, label %2163, label %2114
2163: ; preds = %2114, %2105
%2164 = phi i64 [ 0, %2105 ], [ %2160, %2114 ]
%2165 = icmp eq i64 %2110, 0
br i1 %2165, label %2182, label %2166
2166: ; preds = %2163, %2166
%2167 = phi i64 [ %2179, %2166 ], [ %2164, %2163 ]
%2168 = phi i64 [ %2180, %2166 ], [ 0, %2163 ]
%2169 = getelementptr inbounds double, double* %1077, i64 %2167
%2170 = bitcast double* %2169 to <2 x double>*
%2171 = load <2 x double>, <2 x double>* %2170
%2172 = getelementptr inbounds double, double* %2169, i64 2
%2173 = bitcast double* %2172 to <2 x double>*
%2174 = load <2 x double>, <2 x double>* %2173
%2175 = getelementptr inbounds double, double* %14, i64 %2167
%2176 = bitcast double* %2175 to <2 x double>*
store <2 x double> %2171, <2 x double>* %2176
%2177 = getelementptr inbounds double, double* %2175, i64 2
%2178 = bitcast double* %2177 to <2 x double>*
store <2 x double> %2174, <2 x double>* %2178
%2179 = add nuw i64 %2167, 4
%2180 = add i64 %2168, 1
%2181 = icmp eq i64 %2180, %2110
br i1 %2181, label %2182, label %2166
2182: ; preds = %2166, %2163
%2183 = icmp eq i64 %2106, %2013
br i1 %2183, label %2248, label %2184
2184: ; preds = %2098, %2095, %2182
%2185 = phi i64 [ 0, %2098 ], [ 0, %2095 ], [ %2106, %2182 ]
%2186 = xor i64 %2185, -1
%2187 = add nsw i64 %2186, %2013
%2188 = and i64 %2013, 3
%2189 = icmp eq i64 %2188, 0
br i1 %2189, label %2199, label %2190
2190: ; preds = %2184, %2190
%2191 = phi i64 [ %2196, %2190 ], [ %2185, %2184 ]
%2192 = phi i64 [ %2197, %2190 ], [ 0, %2184 ]
%2193 = getelementptr inbounds double, double* %1077, i64 %2191
%2194 = load double, double* %2193
%2195 = getelementptr inbounds double, double* %14, i64 %2191
store double %2194, double* %2195
%2196 = add nuw nsw i64 %2191, 1
%2197 = add i64 %2192, 1
%2198 = icmp eq i64 %2197, %2188
br i1 %2198, label %2199, label %2190
2199: ; preds = %2190, %2184
%2200 = phi i64 [ %2185, %2184 ], [ %2196, %2190 ]
%2201 = icmp ult i64 %2187, 3
br i1 %2201, label %2248, label %2229
2202: ; preds = %2090, %2202
%2203 = phi i64 [ %2227, %2202 ], [ %2091, %2090 ]
%2204 = getelementptr inbounds double, double* %17, i64 %2203
%2205 = load double, double* %2204
%2206 = getelementptr inbounds double, double* %1678, i64 %2203
%2207 = load double, double* %2206
%2208 = fsub double %2205, %2207
%2209 = getelementptr inbounds double, double* %1682, i64 %2203
%2210 = load double, double* %2209
%2211 = fsub double %2208, %2210
%2212 = getelementptr inbounds double, double* %1686, i64 %2203
%2213 = load double, double* %2212
%2214 = fsub double %2211, %2213
store double %2214, double* %2204
%2215 = add nuw nsw i64 %2203, 1
%2216 = getelementptr inbounds double, double* %17, i64 %2215
%2217 = load double, double* %2216
%2218 = getelementptr inbounds double, double* %1678, i64 %2215
%2219 = load double, double* %2218
%2220 = fsub double %2217, %2219
%2221 = getelementptr inbounds double, double* %1682, i64 %2215
%2222 = load double, double* %2221
%2223 = fsub double %2220, %2222
%2224 = getelementptr inbounds double, double* %1686, i64 %2215
%2225 = load double, double* %2224
%2226 = fsub double %2223, %2225
store double %2226, double* %2216
%2227 = add nuw nsw i64 %2203, 2
%2228 = icmp eq i64 %2227, %2013
br i1 %2228, label %2094, label %2202
2229: ; preds = %2199, %2229
%2230 = phi i64 [ %2246, %2229 ], [ %2200, %2199 ]
%2231 = getelementptr inbounds double, double* %1077, i64 %2230
%2232 = load double, double* %2231
%2233 = getelementptr inbounds double, double* %14, i64 %2230
store double %2232, double* %2233
%2234 = add nuw nsw i64 %2230, 1
%2235 = getelementptr inbounds double, double* %1077, i64 %2234
%2236 = load double, double* %2235
%2237 = getelementptr inbounds double, double* %14, i64 %2234
store double %2236, double* %2237
%2238 = add nuw nsw i64 %2230, 2
%2239 = getelementptr inbounds double, double* %1077, i64 %2238
%2240 = load double, double* %2239
%2241 = getelementptr inbounds double, double* %14, i64 %2238
store double %2240, double* %2241
%2242 = add nuw nsw i64 %2230, 3
%2243 = getelementptr inbounds double, double* %1077, i64 %2242
%2244 = load double, double* %2243
%2245 = getelementptr inbounds double, double* %14, i64 %2242
store double %2244, double* %2245
%2246 = add nuw nsw i64 %2230, 4
%2247 = icmp eq i64 %2246, %2096
br i1 %2247, label %2248, label %2229
2248: ; preds = %2199, %2229, %2182, %2000, %2094
%2249 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1678)
%2250 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1682)
%2251 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %1686)
ret void
}