void R_Becke_Exchange(rho, Vx, Ex, Px) double rho[], Vx[], *Ex, *Px;
{
  int i;
  double lda_c;
  double beta;
  double pi;
  double X1, X2, X3, ex;
  double fdn_lda;
  double ux;
  double c;
  double norm;
  double lap, damp, ddamp;
  double z5, z4, z3, z2, z1;
  double rho_fourthirds, rho_onethird, two_onethird;
  int Ngrid;
  double *rhoNRM;
  double *drho;
  double *ddrho;
  double *ex_density;
  double *tmp;
  double *rgrid;
  double *agr;
  double *chi;
  double *chidn;
  double *chiddn;
  double *H;
  double *F;
  double *Fdchi;
  double *G;
  double *G2;
  double *Gdr;
  double *G2dr;
  double *fdn;
  double *fddn;
  pi = 4.0 * atan(1.0);
  c = pow(2.0, 1.0 / 3.0);
  beta = 0.0042;
  lda_c = (3.0 / 2.0) * pow(3.0 / (4.0 * pi), 1.0 / 3.0);
  Ngrid = N_LogGrid();
  rgrid = r_LogGrid();
  ex_density = alloc_LogGrid();
  tmp = alloc_LogGrid();
  drho = alloc_LogGrid();
  ddrho = alloc_LogGrid();
  rhoNRM = alloc_LogGrid();
  agr = alloc_LogGrid();
  chi = alloc_LogGrid();
  chidn = alloc_LogGrid();
  chiddn = alloc_LogGrid();
  H = alloc_LogGrid();
  F = alloc_LogGrid();
  Fdchi = alloc_LogGrid();
  G = alloc_LogGrid();
  G2 = alloc_LogGrid();
  Gdr = alloc_LogGrid();
  G2dr = alloc_LogGrid();
  fdn = alloc_LogGrid();
  fddn = alloc_LogGrid();
  for (i = 0; i < Ngrid; ++i)
    rhoNRM[i] = rho[i] / (4.0 * pi) + 1.0e-10;
  Derivative_LogGrid(rhoNRM, drho);
  for (i = 0; i < Ngrid; ++i)
    agr[i] = fabs(drho[i]);
  Derivative_LogGrid(drho, ddrho);
  for (i = 0; i < Ngrid; ++i) {
    rho_fourthirds = pow(rhoNRM[i], 4.0 / 3.0);
    chi[i] = agr[i] / rho_fourthirds;
    chidn[i] = (-4.0 / 3.0) * chi[i] / rhoNRM[i];
    chiddn[i] = 1.0 / rho_fourthirds;
  }
  for (i = 0; i < Ngrid; ++i) {
    rho_fourthirds = pow(rhoNRM[i], 4.0 / 3.0);
    H[i] = 1.0 * beta * pow(2.0, 1.0 / 3.0) * rho_fourthirds;
  }
  for (i = 0; i < Ngrid; ++i) {
    if ((rhoNRM[i] > 2.0e-8) && (agr[i] > 1.0e-10)) {
      F[i] = chi[i] * chi[i] /
             (1.0 + 6.0 * beta * c * chi[i] *
                        log(c * chi[i] + sqrt(1.0 + c * c * chi[i] * chi[i])));
      Fdchi[i] =
          2 * F[i] / chi[i] -
          (F[i] * F[i] / (chi[i] * chi[i])) *
              (6.0 * beta * c *
                   log(c * chi[i] + sqrt(1.0 + c * c * chi[i] * chi[i])) +
               6.0 * beta * c * c * chi[i] /
                   sqrt(1.0 + c * c * chi[i] * chi[i]));
    }
  }
  for (i = 0; i < Ngrid; ++i) {
    rho_onethird = pow(rhoNRM[i], 1.0 / 3.0);
    fdn_lda = -lda_c / c * (4.0 / 3.0) * rho_onethird;
    fdn[i] = fdn_lda - (4.0 / 3.0) * H[i] * F[i] / rhoNRM[i] -
             H[i] * Fdchi[i] * chidn[i];
    fddn[i] = -1.0 * H[i] * Fdchi[i] * chiddn[i];
  }
  for (i = 0; i < Ngrid; ++i)
    if (agr[i] > 1.0e-10)
      G[i] = fddn[i] / agr[i];
    else
      G[i] = 0.0;
  Derivative_LogGrid(G, Gdr);
  for (i = 0; i < Ngrid; ++i) {
    lap = ddrho[i] + (2.0 / rgrid[i]) * drho[i];
    ux = fdn[i] - (Gdr[i] * drho[i] + G[i] * lap);
    rho_onethird = pow(rhoNRM[i], 1.0 / 3.0);
    X1 = -1.0 * (lda_c / c) * rho_onethird;
    X2 = c * beta * rho_onethird * chi[i] * chi[i];
    X3 = 1.0 + 6.0 * beta * c * chi[i] *
                   log(c * chi[i] + sqrt(1.0 + c * c * chi[i] * chi[i]));
    ex = X1 - X2 / X3;
    Vx[i] = ux;
    ex_density[i] = ex;
    if ((fdn[i] - ex) > 0.0) {
      rho_onethird = pow(rhoNRM[i], 1.0 / 3.0);
      ex_density[i] = -1.0 * (lda_c / c) * rho_onethird;
      Vx[i] = -lda_c / c * (4.0 / 3.0) * rho_onethird;
    }
  }
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = rho[i] * ex_density[i];
  *Ex = Integrate_LogGrid(tmp);
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = rho[i] * Vx[i];
  *Px = Integrate_LogGrid(tmp);
  dealloc_LogGrid(ex_density);
  dealloc_LogGrid(tmp);
  dealloc_LogGrid(drho);
  dealloc_LogGrid(rhoNRM);
  dealloc_LogGrid(agr);
  dealloc_LogGrid(chi);
  dealloc_LogGrid(chidn);
  dealloc_LogGrid(chiddn);
  dealloc_LogGrid(H);
  dealloc_LogGrid(F);
  dealloc_LogGrid(Fdchi);
  dealloc_LogGrid(G);
  dealloc_LogGrid(Gdr);
  dealloc_LogGrid(fdn);
  dealloc_LogGrid(fddn);
}


x86 assembly (clang, -O0):
<R_Becke_Exchange>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  0x1e6d(%rip),%xmm0
call   1040 <atan@plt>
movaps %xmm0,%xmm1
movsd  0x1e45(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x1e44(%rip),%xmm0
movsd  0x1e1c(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  0x1e22(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0x1e0d(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0x1df8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  0x1de4(%rip),%xmm1
call   1080 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x1dcc(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    $0x0,%al
call   10c0 <N_LogGrid@plt>
mov    %eax,-0xdc(%rbp)
mov    $0x0,%al
call   1050 <r_LogGrid@plt>
cltq
mov    %rax,-0x110(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x108(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xf0(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xf8(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x118(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x120(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x128(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x130(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x138(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x140(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x148(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x150(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x158(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x160(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x168(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x170(%rbp)
mov    $0x0,%al
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x178(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    13d8 <R_Becke_Exchange+0x238>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1c73(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0x1c9a(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1381 <R_Becke_Exchange+0x1e1>
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    143c <R_Becke_Exchange+0x29c>
mov    -0xf0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1c56(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f4 <R_Becke_Exchange+0x254>
mov    -0xf0(%rbp),%rdi
mov    -0xf8(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    151a <R_Becke_Exchange+0x37a>
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1bc9(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x118(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x1b99(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x128(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1b3c(%rip),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1458 <R_Becke_Exchange+0x2b8>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    15b4 <R_Becke_Exchange+0x414>
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1b00(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x1ad3(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  0x1ab6(%rip),%xmm0
movsd  0x1a8e(%rip),%xmm1
call   1080 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0x138(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1521 <R_Becke_Exchange+0x381>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1924 <R_Becke_Exchange+0x784>
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1a76(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1911 <R_Becke_Exchange+0x771>
mov    -0x118(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1a4c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1911 <R_Becke_Exchange+0x771>
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  0x19fa(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1975(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  -0x1d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x1d0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <log@plt>
movsd  -0x1c8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
movsd  0x192d(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x140(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x140(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x18fa(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x140(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  0x1899(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1824(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  -0x1b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x1b0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <log@plt>
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0x17f3(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x178e(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  -0x1a8(%rbp),%xmm3
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x198(%rbp),%xmm4
ff
movsd  -0x190(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x188(%rbp),%xmm0
ff
divsd  %xmm5,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1916 <R_Becke_Exchange+0x776>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15bb <R_Becke_Exchange+0x41b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1a8f <R_Becke_Exchange+0x8ef>
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x16b6(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  0x16c0(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x138(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x1697(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
subsd  %xmm0,%xmm1
mov    -0x138(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x148(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x128(%rbp),%rax
movslq -0x24(%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    -0x170(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x138(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x15f4(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x148(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x130(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x178(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    192b <R_Becke_Exchange+0x78b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1b22 <R_Becke_Exchange+0x982>
mov    -0x118(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1593(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1afc <R_Becke_Exchange+0x95c>
mov    -0x178(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x150(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b0f <R_Becke_Exchange+0x96f>
mov    -0x150(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b14 <R_Becke_Exchange+0x974>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a96 <R_Becke_Exchange+0x8f6>
mov    -0x150(%rbp),%rdi
mov    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1e44 <R_Becke_Exchange+0xca4>
mov    -0xf8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0x14b8(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x170(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x150(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1402(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
divsd  -0x78(%rbp),%xmm1
movsd  0x141b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x13c3(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x133e(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  -0x1f0(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <log@plt>
movaps %xmm0,%xmm1
movsd  -0x1e0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x12fe(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x170(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1e31 <R_Becke_Exchange+0xc91>
mov    -0xe8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1254(%rip),%xmm1
call   1080 <pow@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
divsd  -0x78(%rbp),%xmm1
movsd  0x126d(%rip),%xmm0
mulsd  %xmm1,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    -0x100(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  0x1230(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e36 <R_Becke_Exchange+0xc96>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1b3e <R_Becke_Exchange+0x99e>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1e95 <R_Becke_Exchange+0xcf5>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1e4b <R_Becke_Exchange+0xcab>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   1060 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xdc(%rbp),%eax
jge    1efd <R_Becke_Exchange+0xd5d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1eb6 <R_Becke_Exchange+0xd16>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   1060 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x100(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x108(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0xf0(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0xe8(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x118(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x120(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x128(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x130(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x138(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x140(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x148(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x150(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x160(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x170(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
mov    -0x178(%rbp),%rdi
mov    $0x0,%al
call   10a0 <dealloc_LogGrid@plt>
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_Becke_Exchange>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rcx,%r15
mov    %rdx,0xc0(%rsp)
mov    %rsi,0x98(%rsp)
mov    %rdi,0x30(%rsp)
movsd  0x1e2f(%rip),%xmm0
call   1040 <atan@plt>
xor    %eax,%eax
call   10c0 <N_LogGrid@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1050 <r_LogGrid@plt>
mov    %eax,0x10(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x40(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x90(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
movslq %eax,%rbp
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
movslq %eax,%r14
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x28(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0xb8(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x68(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x50(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
movslq %eax,%r12
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0xa8(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x38(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x58(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x48(%rsp)
xor    %eax,%eax
call   10b0 <alloc_LogGrid@plt>
movslq %eax,%r8
test   %ebx,%ebx
mov    %r15,0xf0(%rsp)
mov    %r12,0xb0(%rsp)
mov    %r8,0x60(%rsp)
jle    1300 <R_Becke_Exchange+0x160>
mov    %ebx,%edi
mov    %ebx,0xc(%rsp)
cmp    $0x1,%ebx
jne    1312 <R_Becke_Exchange+0x172>
xor    %eax,%eax
mov    0x30(%rsp),%rbx
jmp    13c7 <R_Becke_Exchange+0x227>
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
jmp    1475 <R_Becke_Exchange+0x2d5>
mov    0x30(%rsp),%rbx
lea    (%rbx,%rdi,8),%rax
cmp    %rax,%r14
jae    1330 <R_Becke_Exchange+0x190>
lea    (%r14,%rdi,8),%rax
cmp    %rbx,%rax
jbe    1330 <R_Becke_Exchange+0x190>
xor    %eax,%eax
jmp    13c7 <R_Becke_Exchange+0x227>
mov    %edi,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1c9b <R_Becke_Exchange+0xafb>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
movapd 0x1d23(%rip),%xmm0
movapd 0x1d2b(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rbx,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%r14,%rdx,8)
movupd 0x10(%rbx,%rdx,8),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r14,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1370 <R_Becke_Exchange+0x1d0>
test   $0x1,%cl
je     13c2 <R_Becke_Exchange+0x222>
movupd (%rbx,%rdx,8),%xmm0
divpd  0x1ccc(%rip),%xmm0
addpd  0x1cd4(%rip),%xmm0
movupd %xmm0,(%r14,%rdx,8)
cmp    %rdi,%rax
je     1441 <R_Becke_Exchange+0x2a1>
mov    %rax,%rcx
not    %rcx
test   $0x1,%dil
je     13f2 <R_Becke_Exchange+0x252>
movsd  (%rbx,%rax,8),%xmm0
divsd  0x1c28(%rip),%xmm0
addsd  0x1c28(%rip),%xmm0
movsd  %xmm0,(%r14,%rax,8)
or     $0x1,%rax
add    %rdi,%rcx
je     1441 <R_Becke_Exchange+0x2a1>
movsd  0x1c09(%rip),%xmm0
movsd  0x1c09(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r14,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1410 <R_Becke_Exchange+0x270>
mov    %rdi,0x18(%rsp)
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1475 <R_Becke_Exchange+0x2d5>
cmp    $0x4,%eax
mov    0x38(%rsp),%rbx
jae    15aa <R_Becke_Exchange+0x40a>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
jmp    1696 <R_Becke_Exchange+0x4f6>
mov    %rbp,%rdi
mov    0xa0(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0x38(%rsp),%rbx
mov    %rbx,%rdi
mov    0x58(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0x68(%rsp),%r12
mov    0x90(%rsp),%rdi
mov    %rbx,%r15
xor    %eax,%eax
mov    %rdi,%rbx
call   1060 <Integrate_LogGrid@plt>
mov    %rbx,%rdi
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax)
xor    %eax,%eax
mov    %rdi,%rbx
call   1060 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xf0(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x40(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %r13,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0x28(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0xb8(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0x50(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0xb0(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0xa8(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0x58(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0x48(%rsp),%rdi
xor    %eax,%eax
call   10a0 <dealloc_LogGrid@plt>
mov    0x60(%rsp),%rdi
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10a0 <dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
lea    0x0(,%rdi,8),%rax
add    %rbp,%rax
cmp    %rax,%r13
jae    15d6 <R_Becke_Exchange+0x436>
lea    0x0(,%rdi,8),%rax
add    %r13,%rax
cmp    %rax,%rbp
jae    15d6 <R_Becke_Exchange+0x436>
xor    %eax,%eax
jmp    1696 <R_Becke_Exchange+0x4f6>
mov    %edi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1cab <R_Becke_Exchange+0xb0b>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movapd 0x1a9c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
andpd  %xmm0,%xmm1
andpd  %xmm0,%xmm2
movupd %xmm1,0x0(%r13,%rcx,8)
movupd %xmm2,0x10(%r13,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm1
movupd 0x30(%rbp,%rcx,8),%xmm2
andpd  %xmm0,%xmm1
andpd  %xmm0,%xmm2
movupd %xmm1,0x20(%r13,%rcx,8)
movupd %xmm2,0x30(%r13,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1610 <R_Becke_Exchange+0x470>
test   $0x1,%dl
je     168d <R_Becke_Exchange+0x4ed>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movapd 0x1a29(%rip),%xmm2
andpd  %xmm2,%xmm0
andpd  %xmm2,%xmm1
movupd %xmm0,0x0(%r13,%rcx,8)
movupd %xmm1,0x10(%r13,%rcx,8)
cmp    %rdi,%rax
je     172d <R_Becke_Exchange+0x58d>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     16cb <R_Becke_Exchange+0x52b>
movapd 0x19f0(%rip),%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    16b0 <R_Becke_Exchange+0x510>
cmp    $0x3,%rcx
jb     172d <R_Becke_Exchange+0x58d>
movapd 0x19c7(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%r13,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x10(%r13,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    16e0 <R_Becke_Exchange+0x540>
mov    %rbp,%rdi
mov    0xa0(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
cmpl   $0x0,0xc(%rsp)
jle    148c <R_Becke_Exchange+0x2ec>
mov    %rbp,0x70(%rsp)
movslq 0x10(%rsp),%rax
mov    %rax,0xe0(%rsp)
xor    %ebp,%ebp
mov    0xb8(%rsp),%r12
mov    0x68(%rsp),%r15
mov    0x28(%rsp),%rbx
movsd  (%r14,%rbp,8),%xmm0
movsd  0x189a(%rip),%xmm1
call   1080 <pow@plt>
movsd  0x1895(%rip),%xmm2
mov    0x18(%rsp),%rax
movsd  0x0(%r13,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mulsd  %xmm2,%xmm1
divsd  (%r14,%rbp,8),%xmm1
movsd  %xmm1,(%r12,%rbp,8)
movsd  0x1848(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1770 <R_Becke_Exchange+0x5d0>
cmpl   $0x0,0xc(%rsp)
mov    0x70(%rsp),%rbp
mov    0x38(%rsp),%rbx
jle    148c <R_Becke_Exchange+0x2ec>
lea    -0x1(%rax),%rcx
mov    %eax,%r15d
and    $0x3,%r15d
cmp    $0x3,%rcx
mov    %rcx,0x78(%rsp)
mov    %r13,0xc8(%rsp)
jae    1806 <R_Becke_Exchange+0x666>
xor    %r12d,%r12d
jmp    18bc <R_Becke_Exchange+0x71c>
mov    %eax,%ebx
and    $0xfffffffc,%ebx
xor    %r12d,%r12d
mov    0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%r12,8),%xmm0
movsd  0x17ea(%rip),%xmm1
call   1080 <pow@plt>
movsd  0x17ed(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%r12,8)
movsd  0x8(%r14,%r12,8),%xmm0
movsd  0x17c3(%rip),%xmm1
call   1080 <pow@plt>
mulsd  0x17c6(%rip),%xmm0
movsd  %xmm0,0x8(%rbp,%r12,8)
movsd  0x10(%r14,%r12,8),%xmm0
movsd  0x17a0(%rip),%xmm1
call   1080 <pow@plt>
mulsd  0x17a3(%rip),%xmm0
movsd  %xmm0,0x10(%rbp,%r12,8)
movsd  0x18(%r14,%r12,8),%xmm0
movsd  0x177d(%rip),%xmm1
call   1080 <pow@plt>
mulsd  0x1780(%rip),%xmm0
movsd  %xmm0,0x18(%rbp,%r12,8)
add    $0x4,%r12
cmp    %r12,%rbx
jne    1820 <R_Becke_Exchange+0x680>
test   %r15,%r15
je     1909 <R_Becke_Exchange+0x769>
mov    %r15,%r13
mov    0x50(%rsp),%rax
lea    (%rax,%r12,8),%r15
lea    (%r14,%r12,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rbp,8),%xmm0
movsd  0x172b(%rip),%xmm1
call   1080 <pow@plt>
mulsd  0x172e(%rip),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    18e0 <R_Becke_Exchange+0x740>
cmpl   $0x0,0xc(%rsp)
mov    0x70(%rsp),%rbp
mov    0xb0(%rsp),%r12
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%rcx
mov    0xc8(%rsp),%r13
jle    148c <R_Becke_Exchange+0x2ec>
xor    %r15d,%r15d
movsd  0x16f2(%rip),%xmm3
movsd  0x16ca(%rip),%xmm2
movsd  0x16b2(%rip),%xmm1
jmp    19f0 <R_Becke_Exchange+0x850>
movsd  %xmm6,0x88(%rsp)
movsd  %xmm7,0x80(%rsp)
call   1090 <sqrt@plt>
movsd  0x80(%rsp),%xmm7
movsd  0x88(%rsp),%xmm6
movsd  0x167c(%rip),%xmm1
mov    0x18(%rsp),%rcx
movsd  0x167f(%rip),%xmm2
movsd  0x1697(%rip),%xmm3
divsd  %xmm0,%xmm7
movsd  0x10(%rsp),%xmm4
movapd %xmm4,%xmm0
addsd  %xmm4,%xmm0
movsd  0x20(%rsp),%xmm5
divsd  %xmm5,%xmm0
mulsd  %xmm5,%xmm5
mulsd  0x1677(%rip),%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm4,%xmm4
divsd  %xmm5,%xmm4
mulsd  %xmm6,%xmm4
subsd  %xmm4,%xmm0
mov    0xa8(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
add    $0x1,%r15
cmp    %r15,%rcx
je     1b4d <R_Becke_Exchange+0x9ad>
movsd  (%r14,%r15,8),%xmm0
ucomisd %xmm3,%xmm0
jbe    19e3 <R_Becke_Exchange+0x843>
movsd  0x0(%r13,%r15,8),%xmm0
ucomisd %xmm2,%xmm0
jbe    19e3 <R_Becke_Exchange+0x843>
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,8),%xmm2
movapd %xmm2,%xmm0
mulsd  0x1618(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
movapd %xmm2,%xmm0
mulsd  0x160e(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x1636(%rip),%xmm0
jb     1a4a <R_Becke_Exchange+0x8aa>
sqrtsd %xmm0,%xmm0
jmp    1a5b <R_Becke_Exchange+0x8bb>
movsd  %xmm2,0x10(%rsp)
call   1090 <sqrt@plt>
movsd  0x10(%rsp),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rsp)
mulsd  0x15d7(%rip),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
call   1070 <log@plt>
movsd  0x20(%rsp),%xmm2
mulsd  %xmm0,%xmm2
movsd  0x1570(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  0x10(%rsp),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  %xmm0,(%r12,%r15,8)
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,8),%xmm2
movapd %xmm2,%xmm0
mulsd  0x157f(%rip),%xmm0
movsd  %xmm2,0x20(%rsp)
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x15a1(%rip),%xmm0
jb     1adf <R_Becke_Exchange+0x93f>
sqrtsd %xmm0,%xmm0
jmp    1ae4 <R_Becke_Exchange+0x944>
call   1090 <sqrt@plt>
movsd  0x20(%rsp),%xmm1
mulsd  0x1556(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1070 <log@plt>
movapd %xmm0,%xmm6
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
movapd %xmm1,%xmm0
mulsd  0x1526(%rip),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,%xmm7
mulsd  0x1526(%rip),%xmm7
movsd  0x14ce(%rip),%xmm1
addsd  %xmm1,%xmm0
ucomisd 0x153a(%rip),%xmm0
jb     1953 <R_Becke_Exchange+0x7b3>
sqrtsd %xmm0,%xmm0
jmp    1984 <R_Becke_Exchange+0x7e4>
cmpl   $0x0,0xc(%rsp)
jle    148c <R_Becke_Exchange+0x2ec>
xor    %ebp,%ebp
mov    0xa8(%rsp),%rbx
mov    0x50(%rsp),%r15
mov    0x48(%rsp),%r12
nopl   0x0(%rax)
movsd  (%r14,%rbp,8),%xmm0
movsd  0x14da(%rip),%xmm1
call   1080 <pow@plt>
movsd  0x14d5(%rip),%xmm3
mov    0x18(%rsp),%rsi
movsd  (%r15,%rbp,8),%xmm1
movapd %xmm1,%xmm2
mulsd  0x147e(%rip),%xmm2
mov    0xb0(%rsp),%rax
mulsd  (%rax,%rbp,8),%xmm2
mulsd  %xmm3,%xmm0
divsd  (%r14,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
mulsd  (%rbx,%rbp,8),%xmm1
mov    0xb8(%rsp),%rax
mulsd  (%rax,%rbp,8),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm0
xorpd  0x14c9(%rip),%xmm0
mulsd  (%rbx,%rbp,8),%xmm0
mov    0x68(%rsp),%rax
mulsd  (%rax,%rbp,8),%xmm0
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1b70 <R_Becke_Exchange+0x9d0>
mov    0xc(%rsp),%r15d
test   %r15d,%r15d
mov    0x70(%rsp),%rbp
mov    0x38(%rsp),%rbx
movsd  0x13e9(%rip),%xmm3
jle    148c <R_Becke_Exchange+0x2ec>
cmpq   $0x0,0x78(%rsp)
je     1cbb <R_Becke_Exchange+0xb1b>
mov    %esi,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x60(%rsp),%rdx
jmp    1c5f <R_Becke_Exchange+0xabf>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
je     1cc2 <R_Becke_Exchange+0xb22>
movsd  0x0(%r13,%rax,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm1
xorpd  %xmm2,%xmm2
jbe    1c7d <R_Becke_Exchange+0xadd>
movsd  (%rdx,%rax,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
ucomisd %xmm3,%xmm1
jbe    1c50 <R_Becke_Exchange+0xab0>
movsd  0x8(%rdx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
jmp    1c50 <R_Becke_Exchange+0xab0>
xor    %edx,%edx
test   $0x1,%cl
jne    13a7 <R_Becke_Exchange+0x207>
jmp    13c2 <R_Becke_Exchange+0x222>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1663 <R_Becke_Exchange+0x4c3>
jmp    168d <R_Becke_Exchange+0x4ed>
xor    %eax,%eax
mov    0x60(%rsp),%rdx
test   $0x1,%sil
mov    0x68(%rsp),%r12
je     1cf0 <R_Becke_Exchange+0xb50>
movsd  0x0(%r13,%rax,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd 0x1330(%rip),%xmm1
jbe    1ceb <R_Becke_Exchange+0xb4b>
movsd  (%rdx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mov    %rbx,%rdi
mov    0x58(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
test   %r15d,%r15d
mov    0x90(%rsp),%rdi
jle    14a8 <R_Becke_Exchange+0x308>
mov    0x18(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xd8(%rsp)
xor    %r15d,%r15d
mov    0x48(%rsp),%rax
jmp    1d42 <R_Becke_Exchange+0xba2>
nop
add    $0x8,%r15
cmp    %r15,0xd8(%rsp)
je     1f31 <R_Becke_Exchange+0xd91>
movsd  0x131e(%rip),%xmm0
mov    0xe0(%rsp),%rcx
divsd  (%rcx,%r15,1),%xmm0
movsd  0x0(%rbp,%r15,1),%xmm1
mulsd  %xmm1,%xmm0
mov    0xa0(%rsp),%rcx
addsd  (%rcx,%r15,1),%xmm0
mulsd  (%rbx,%r15,1),%xmm0
movsd  %xmm0,0x80(%rsp)
movsd  (%rax,%r15,1),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x58(%rsp),%rax
mulsd  (%rax,%r15,1),%xmm1
movsd  %xmm1,0x78(%rsp)
movsd  (%r14,%r15,1),%xmm0
movsd  0x12ad(%rip),%xmm1
call   1080 <pow@plt>
movapd %xmm0,%xmm1
mulsd  0x12b4(%rip),%xmm1
movsd  %xmm1,0x88(%rsp)
mulsd  0x125b(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,1),%xmm2
movapd %xmm2,%xmm0
mulsd  0x124e(%rip),%xmm0
movsd  %xmm0,0xe8(%rsp)
movapd %xmm2,%xmm0
mulsd  0x1241(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x11f5(%rip),%xmm0
ucomisd 0x1265(%rip),%xmm0
jb     1e20 <R_Becke_Exchange+0xc80>
sqrtsd %xmm0,%xmm0
jmp    1e37 <R_Becke_Exchange+0xc97>
nopl   0x0(%rax,%rax,1)
movsd  %xmm2,0xd0(%rsp)
call   1090 <sqrt@plt>
movsd  0xd0(%rsp),%xmm2
movsd  0x78(%rsp),%xmm1
addsd  0x80(%rsp),%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x10(%rsp)
movsd  0x20(%rsp),%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%rsp)
mulsd  0x11d6(%rip),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
call   1070 <log@plt>
movsd  0xe8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x116c(%rip),%xmm1
movsd  0x20(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  0x88(%rsp),%xmm1
subsd  %xmm0,%xmm1
mov    0x98(%rsp),%rax
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rax,%r15,1)
mov    0x40(%rsp),%rax
movsd  %xmm1,(%rax,%r15,1)
mov    0x48(%rsp),%rax
movsd  (%rax,%r15,1),%xmm0
subsd  %xmm1,%xmm0
ucomisd 0x1197(%rip),%xmm0
jbe    1d30 <R_Becke_Exchange+0xb90>
movsd  (%r14,%r15,1),%xmm0
movsd  0x1163(%rip),%xmm1
call   1080 <pow@plt>
mov    0x48(%rsp),%rax
movapd %xmm0,%xmm1
mulsd  0x1165(%rip),%xmm1
mov    0x40(%rsp),%rcx
movsd  %xmm1,(%rcx,%r15,1)
mulsd  0x1142(%rip),%xmm0
mov    0x98(%rsp),%rcx
movsd  %xmm0,(%rcx,%r15,1)
jmp    1d30 <R_Becke_Exchange+0xb90>
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x90(%rsp),%rdi
jle    14a8 <R_Becke_Exchange+0x308>
mov    %rbx,%r15
cmp    $0x4,%eax
jae    1f63 <R_Becke_Exchange+0xdc3>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%rbx
mov    0x18(%rsp),%r9
jmp    2069 <R_Becke_Exchange+0xec9>
mov    0x18(%rsp),%r9
lea    (%rdi,%r9,8),%rax
mov    0x30(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0x40(%rsp),%rbx
lea    (%rbx,%r9,8),%rdx
cmp    %rcx,%rdi
setb   %r10b
cmp    %rsi,%rax
seta   %r8b
cmp    %rdx,%rdi
setb   %cl
cmp    %rax,%rbx
setb   %dl
xor    %eax,%eax
test   %r8b,%r10b
jne    2069 <R_Becke_Exchange+0xec9>
and    %dl,%cl
jne    2069 <R_Becke_Exchange+0xec9>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     202f <R_Becke_Exchange+0xe8f>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
movupd 0x20(%rsi,%rcx,8),%xmm0
movupd 0x30(%rsi,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rdi,%rcx,8)
movupd %xmm0,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1fce <R_Becke_Exchange+0xe2e>
jmp    2031 <R_Becke_Exchange+0xe91>
xor    %ecx,%ecx
test   $0x1,%r8b
je     2060 <R_Becke_Exchange+0xec0>
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
cmp    %r9,%rax
je     20ee <R_Becke_Exchange+0xf4e>
mov    %rax,%rcx
not    %rcx
add    %r9,%rcx
mov    %r9,%rdx
and    $0x3,%rdx
je     2099 <R_Becke_Exchange+0xef9>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2080 <R_Becke_Exchange+0xee0>
cmp    $0x3,%rcx
jb     20ee <R_Becke_Exchange+0xf4e>
nop
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
mulsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
mulsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r9
jne    20a0 <R_Becke_Exchange+0xf00>
xor    %eax,%eax
mov    %rdi,%rbx
call   1060 <Integrate_LogGrid@plt>
mov    %rbx,%rdi
mov    0x18(%rsp),%r10
mov    0x30(%rsp),%r9
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x98(%rsp),%rbx
jle    14cb <R_Becke_Exchange+0x32b>
cmp    $0x4,%eax
jae    21c4 <R_Becke_Exchange+0x1024>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r10,%rcx
mov    %r10,%rdx
and    $0x3,%rdx
je     2163 <R_Becke_Exchange+0xfc3>
movsd  (%r9,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2149 <R_Becke_Exchange+0xfa9>
cmp    $0x3,%rcx
jb     14cb <R_Becke_Exchange+0x32b>
movsd  (%r9,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm0
mulsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  0x10(%r9,%rax,8),%xmm0
mulsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movsd  0x18(%r9,%rax,8),%xmm0
mulsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    216d <R_Becke_Exchange+0xfcd>
jmp    14cb <R_Becke_Exchange+0x32b>
lea    (%rdi,%r10,8),%rax
lea    (%r9,%r10,8),%rcx
cmp    %rcx,%rdi
setb   %r8b
cmp    %r9,%rax
seta   %dl
lea    (%rbx,%r10,8),%rcx
cmp    %rcx,%rdi
setb   %cl
cmp    %rbx,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%r8b
jne    2137 <R_Becke_Exchange+0xf97>
and    %sil,%cl
jne    2137 <R_Becke_Exchange+0xf97>
mov    %r10d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2286 <R_Becke_Exchange+0x10e6>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
movupd 0x20(%r9,%rcx,8),%xmm0
movupd 0x30(%r9,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rdi,%rcx,8)
movupd %xmm0,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2221 <R_Becke_Exchange+0x1081>
jmp    2288 <R_Becke_Exchange+0x10e8>
xor    %ecx,%ecx
test   $0x1,%dl
je     22b8 <R_Becke_Exchange+0x1118>
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%rcx,8),%xmm1
movupd (%rbx,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
cmp    %r10,%rax
je     14cb <R_Becke_Exchange+0x32b>
jmp    2137 <R_Becke_Exchange+0xf97>

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

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