void R_revPBE_Correlation(rho, Vc_out, Ec_out, Pc_out) double rho[], Vc_out[],
    *Ec_out, *Pc_out;
{
  int i;
  double BOG;
  double onethird;
  double onesixth;
  double sevensixth;
  double pi, rs_scale;
  double rs, rss, n;
  double lap, agr, delgr;
  double t, t2, t4, t6;
  double Q0, Q1, Q2, Q3, Q4, Q5, Q8, Q9;
  double uu, vv;
  double ks, kf;
  double H, Hrs, Hrst, Ht, Htt, H_B, H_Bt, B_ec, B;
  double FACT0;
  double FACT1;
  double FACT2;
  double FACT3;
  double ec, ec_rs;
  double uc, duc;
  int Ngrid;
  double *rgrid;
  double *ec_functional;
  double *tmp;
  double *drho;
  double *ddrho;
  double *dadrho;
  pi = 4.0 * atan(1.0);
  BOG = 0.066724550603149 / 0.031090690869655;
  onethird = 1.0 / 3.0;
  onesixth = 1.0 / 6.0;
  sevensixth = 7.0 / 6.0;
  pi = 4.0 * atan(1.0);
  rs_scale = pow((0.75 / pi), (onethird));
  Ngrid = N_LogGrid();
  rgrid = r_LogGrid();
  ec_functional = alloc_LogGrid();
  tmp = alloc_LogGrid();
  drho = alloc_LogGrid();
  ddrho = alloc_LogGrid();
  dadrho = alloc_LogGrid();
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = rho[i] / (4.0 * pi);
  Derivative_LogGrid(tmp, drho);
  Derivative_LogGrid(drho, ddrho);
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = fabs(drho[i]);
  Derivative_LogGrid(tmp, dadrho);
  for (i = 0; i < Ngrid; ++i) {
    n = rho[i] / (4.0 * pi) + 1.0e-80;
    if (n > 1.0e-12) {
      agr = fabs(drho[i]);
      delgr = drho[i] * dadrho[i];
      lap = ddrho[i] + (2.0 / rgrid[i]) * drho[i];
      rs = rs_scale / pow(n, onethird);
      rss = sqrt(rs);
      kf = pow((3.0 * pi * pi * n), onethird);
      ks = sqrt(4.0 * kf / pi);
      t = agr / (2.0 * ks * n);
      uu = delgr / (8 * ks * ks * ks * n * n);
      vv = lap / (4 * ks * ks * n);
      Q0 = -2 * 0.0310907 * (1.0 + 0.213700 * rs);
      Q1 = 2 * 0.0310907 * rss *
           (7.595700 + rss * (3.587600 + rss * (1.638200 + 0.492940 * rss)));
      Q2 = log(1.0 + 1.0 / Q1);
      Q3 = 0.0310907 * (7.595700 / rss + 2.0 * 3.587600 +
                        rss * (3.0 * 1.638200 + 4.0 * 0.492940 * rss));
      ec = Q0 * Q2;
      ec_rs = -2.0 * 0.0310907 * 0.213700 * Q2 - Q0 * Q3 / (Q1 * (1 + Q1));
      uc = ec - rs * ec_rs / 3.0;
      t2 = t * t;
      t4 = t2 * t2;
      B = -ec / 0.031090690869655;
      B = BOG / (exp(B) - 1.0);
      Q4 = 1.0 + B * t2;
      Q5 = 1.0 + B * t2 + B * B * t4;
      H = 0.031090690869655 * log(1.0 + BOG * Q4 * t2 / Q5);
      t6 = t4 * t2;
      B_ec = (B / 0.066724550603149) * (BOG + B);
      Q8 = Q5 * Q5 + BOG * Q4 * Q5 * t2;
      H_B = -0.066724550603149 * B * t6 * (2.0 + B * t2) / Q8;
      Hrs = -(rs / 3.0) * H_B * B_ec * ec_rs;
      Q9 = 1.0 + 2 * B * t2;
      FACT0 = 2.0 * BOG - 6.0 * B;
      FACT1 = Q5 * Q9 + Q4 * Q9 * Q9;
      FACT2 = Q4 * Q5 + B * t2 * (Q4 * Q9 + Q5);
      FACT3 = 2.0 * B * Q5 * Q9 + BOG * FACT2;
      H_Bt = 2.0 * 0.066724550603149 * t4 *
             ((Q4 * Q5 * FACT0 - BOG * FACT1) / Q8) / Q8;
      Hrst = (rs / 3.0) * t2 * H_Bt * B_ec * ec_rs;
      Ht = 2.0 * 0.066724550603149 * Q9 / Q8;
      Htt =
          3.0 * 0.066724550603149 * t * (2.0 * B / Q8 - (Q9 * FACT3 / Q8) / Q8);
      duc = H + Hrs + Hrst + t2 * Ht / 6.0 + 7.0 * t2 * t * Htt / 6.0 -
            uu * Htt - vv * Ht;
      ec_functional[i] = ec + H;
      Vc_out[i] = uc + duc;
    } else {
      ec_functional[i] = 0.0;
      Vc_out[i] = 0.0;
    }
  }
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = (rho[i]) * ec_functional[i];
  *Ec_out = Integrate_LogGrid(tmp);
  for (i = 0; i < Ngrid; ++i)
    tmp[i] = (rho[i]) * Vc_out[i];
  *Pc_out = Integrate_LogGrid(tmp);
  dealloc_LogGrid(ec_functional);
  dealloc_LogGrid(tmp);
  dealloc_LogGrid(drho);
  dealloc_LogGrid(ddrho);
  dealloc_LogGrid(dadrho);
}


x86 assembly (clang, -O0):
<R_revPBE_Correlation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  0xe3d(%rip),%xmm0
call   1040 <atan@plt>
movaps %xmm0,%xmm1
movsd  0xe25(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xe3c(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xe27(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe12(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xdfd(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xde8(%rip),%xmm0
call   1040 <atan@plt>
movaps %xmm0,%xmm1
movsd  0xdd0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xdb7(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x58(%rbp)
mov    $0x0,%al
call   10d0 <N_LogGrid@plt>
mov    %eax,-0x194(%rbp)
mov    $0x0,%al
call   1050 <r_LogGrid@plt>
cltq
mov    %rax,-0x1a0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x1a8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x1b0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x1b8(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x1c0(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x1c8(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x194(%rbp),%eax
jge    131c <R_revPBE_Correlation+0x16c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd13(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x1b0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d1 <R_revPBE_Correlation+0x121>
mov    -0x1b0(%rbp),%rdi
mov    -0x1b8(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
mov    -0x1b8(%rbp),%rdi
mov    -0x1c0(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x194(%rbp),%eax
jge    1395 <R_revPBE_Correlation+0x1e5>
mov    -0x1b8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd8d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x1b0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    134d <R_revPBE_Correlation+0x19d>
mov    -0x1b0(%rbp),%rdi
mov    -0x1c8(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x194(%rbp),%eax
jge    1d73 <R_revPBE_Correlation+0xbc3>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc33(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0xc5a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0xc3c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d3d <R_revPBE_Correlation+0xb8d>
mov    -0x1b8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xce3(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x1b8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1c8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x1c0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1a0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  0xbe7(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x1b8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x1d8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  0xb96(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0xb05(%rip),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
divsd  -0x50(%rbp),%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  0xb2e(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0xb9d(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  0xa7a(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  0xb2c(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xa48(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0xb0c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xaf0(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  0xac4(%rip),%xmm4
mulsd  %xmm4,%xmm3
movsd  0xac0(%rip),%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xaa0(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xa88(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0x9c8(%rip),%xmm1
divsd  -0xb8(%rbp),%xmm1
ff
movsd  0x9b8(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1080 <log@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xa47(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  0xa32(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
movsd  0xa0c(%rip),%xmm3
mulsd  %xmm3,%xmm2
movsd  0xa08(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x9e4(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  0x910(%rip),%xmm3
addsd  -0xb8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x961(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x180(%rbp),%xmm1
ff
movsd  0x914(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x8c5(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
call   1070 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x1d0(%rbp),%xmm0
ff
movsd  0x814(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x7e8(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
movsd  0x7c0(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x150(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
divsd  -0xd8(%rbp),%xmm1
ff
movsd  0x76f(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1080 <log@plt>
movaps %xmm0,%xmm1
movsd  0x7d3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
movsd  0x797(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
addsd  -0x150(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x72d(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  0x6e1(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  0x6d4(%rip),%xmm1
divsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
mulsd  -0x148(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x679(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x615(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  0x634(%rip),%xmm1
mulsd  -0x150(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x150(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm3
ff
movsd  -0xe8(%rbp),%xmm5
ff
movsd  -0xd8(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  0x581(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm1
mulsd  -0x168(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  0x554(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x158(%rbp),%xmm3
ff
movsd  -0x30(%rbp),%xmm2
mulsd  -0x160(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  0x4e7(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x140(%rbp),%xmm0
ff
mulsd  -0x148(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  0x4ab(%rip),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0x483(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  0x46b(%rip),%xmm1
mulsd  -0x150(%rbp),%xmm1
ff
divsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
mulsd  -0x170(%rbp),%xmm2
ff
divsd  -0xe0(%rbp),%xmm2
ff
divsd  -0xe0(%rbp),%xmm2
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x118(%rbp),%xmm0
ff
addsd  -0x120(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
movsd  0x3eb(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  0x3e3(%rip),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movsd  0x3bb(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
mov    -0x1a8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x188(%rbp),%xmm0
ff
addsd  -0x190(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d60 <R_revPBE_Correlation+0xbb0>
mov    -0x1a8(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d65 <R_revPBE_Correlation+0xbb5>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13b1 <R_revPBE_Correlation+0x201>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x194(%rbp),%eax
jge    1dc4 <R_revPBE_Correlation+0xc14>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1a8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x1b0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1d7a <R_revPBE_Correlation+0xbca>
mov    -0x1b0(%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    -0x194(%rbp),%eax
jge    1e2c <R_revPBE_Correlation+0xc7c>
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    -0x1b0(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1de5 <R_revPBE_Correlation+0xc35>
mov    -0x1b0(%rbp),%rdi
mov    $0x0,%al
call   1060 <Integrate_LogGrid@plt>
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x1a8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0x1b0(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0x1b8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0x1c0(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0x1c8(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R_revPBE_Correlation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %rcx,0x10(%rsp)
mov    %rdx,0x88(%rsp)
mov    %rsi,0x48(%rsp)
mov    %rdi,%r13
movsd  0x1e22(%rip),%xmm0
call   1040 <atan@plt>
movsd  0x1e15(%rip),%xmm0
call   1040 <atan@plt>
xor    %eax,%eax
call   10d0 <N_LogGrid@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1050 <r_LogGrid@plt>
mov    %eax,0x70(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r15
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%rbx
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r12
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%rbp
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,0x18(%rsp)
test   %r14d,%r14d
mov    %rbp,0x50(%rsp)
jle    12ef <R_revPBE_Correlation+0x13f>
mov    %r14d,%ebp
cmp    $0x1,%r14d
mov    %r14d,0xc(%rsp)
je     1278 <R_revPBE_Correlation+0xc8>
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
cmp    %rax,%rbx
jae    1313 <R_revPBE_Correlation+0x163>
lea    (%rbx,%rbp,8),%rax
cmp    %r13,%rax
jbe    1313 <R_revPBE_Correlation+0x163>
xor    %eax,%eax
mov    0x10(%rsp),%r14
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
je     12a3 <R_revPBE_Correlation+0xf3>
movsd  0x0(%r13,%rax,8),%xmm0
divsd  0x1d6e(%rip),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %rbp,%rcx
je     1396 <R_revPBE_Correlation+0x1e6>
movsd  0x1d54(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    12c0 <R_revPBE_Correlation+0x110>
jmp    1396 <R_revPBE_Correlation+0x1e6>
mov    %rbx,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    %r12,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0x10(%rsp),%r14
jmp    1480 <R_revPBE_Correlation+0x2d0>
mov    %ebp,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     136d <R_revPBE_Correlation+0x1bd>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
movapd 0x1dc4(%rip),%xmm0
nopl   0x0(%rax)
movupd 0x0(%r13,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rdx,8)
movupd 0x10(%r13,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rbx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1340 <R_revPBE_Correlation+0x190>
jmp    136f <R_revPBE_Correlation+0x1bf>
xor    %edx,%edx
test   $0x1,%cl
mov    0x10(%rsp),%r14
je     138d <R_revPBE_Correlation+0x1dd>
movupd 0x0(%r13,%rdx,8),%xmm0
divpd  0x1d78(%rip),%xmm0
movupd %xmm0,(%rbx,%rdx,8)
cmp    %rbp,%rax
jne    127f <R_revPBE_Correlation+0xcf>
mov    %rbx,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    %r12,%rdi
mov    0x50(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1480 <R_revPBE_Correlation+0x2d0>
cmp    $0x4,%eax
jb     13dd <R_revPBE_Correlation+0x22d>
lea    (%r12,%rbp,8),%rax
cmp    %rax,%rbx
jae    1509 <R_revPBE_Correlation+0x359>
lea    (%rbx,%rbp,8),%rax
cmp    %rax,%r12
jae    1509 <R_revPBE_Correlation+0x359>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1419 <R_revPBE_Correlation+0x269>
movapd 0x1d17(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1400 <R_revPBE_Correlation+0x250>
cmp    $0x3,%rcx
jb     15c2 <R_revPBE_Correlation+0x412>
movapd 0x1ce5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rbx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%rbx,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x10(%rbx,%rax,8)
movsd  0x18(%r12,%rax,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1430 <R_revPBE_Correlation+0x280>
jmp    15c2 <R_revPBE_Correlation+0x412>
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14)
mov    %r15,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    0x50(%rsp),%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    0x18(%rsp),%rdi
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10b0 <dealloc_LogGrid@plt>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d6a <R_revPBE_Correlation+0xbba>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movapd 0x1bd9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rcx,8),%xmm1
movupd 0x10(%r12,%rcx,8),%xmm2
andpd  %xmm0,%xmm1
andpd  %xmm0,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
movupd 0x20(%r12,%rcx,8),%xmm1
movupd 0x30(%r12,%rcx,8),%xmm2
andpd  %xmm0,%xmm1
andpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rbx,%rcx,8)
movupd %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1540 <R_revPBE_Correlation+0x390>
test   $0x1,%dl
je     15b9 <R_revPBE_Correlation+0x409>
movupd (%r12,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm1
movapd 0x1b6a(%rip),%xmm2
andpd  %xmm2,%xmm0
andpd  %xmm2,%xmm1
movupd %xmm0,(%rbx,%rcx,8)
movupd %xmm1,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
jne    13df <R_revPBE_Correlation+0x22f>
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
cmpl   $0x0,0xc(%rsp)
mov    0x48(%rsp),%rax
jle    148f <R_revPBE_Correlation+0x2df>
movslq 0x70(%rsp),%rcx
mov    %rcx,0xa0(%rsp)
xor    %r14d,%r14d
movsd  0x1a0f(%rip),%xmm1
movsd  0x1a0f(%rip),%xmm3
movsd  0x1a0f(%rip),%xmm4
movsd  0x1a0e(%rip),%xmm9
jmp    1b62 <R_revPBE_Correlation+0x9b2>
nopw   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
movapd 0x20(%rsp),%xmm4
movsd  0x30(%rsp),%xmm3
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movapd 0x70(%rsp),%xmm2
divsd  %xmm1,%xmm2
movapd %xmm2,0x70(%rsp)
movapd %xmm0,%xmm1
mulsd  0x19f7(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,0xb0(%rsp)
movapd %xmm0,%xmm1
mulsd  0x19da(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movsd  0x58(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x58(%rsp)
movapd 0x60(%rsp),%xmm1
mulsd  0x19bc(%rip),%xmm1
movsd  0x1954(%rip),%xmm3
addsd  %xmm3,%xmm1
mulsd  0x19b0(%rip),%xmm1
movapd %xmm1,%xmm5
movapd %xmm1,0x30(%rsp)
movsd  0x19be(%rip),%xmm2
movapd %xmm2,%xmm0
divsd  %xmm4,%xmm0
addsd  0x19b6(%rip),%xmm0
movapd %xmm4,%xmm1
mulsd  0x19b2(%rip),%xmm1
addsd  0x19b2(%rip),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
mulsd  0x196e(%rip),%xmm0
addsd  0x196e(%rip),%xmm0
mulsd  %xmm4,%xmm0
addsd  0x196a(%rip),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
unpcklpd %xmm4,%xmm1
mulpd  0x19f6(%rip),%xmm1
movapd %xmm5,%xmm2
xorpd  0x19fa(%rip),%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x20(%rsp)
unpckhpd %xmm2,%xmm2
movapd %xmm2,0x90(%rsp)
movapd %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
call   1080 <log@plt>
movapd 0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
movapd 0x90(%rsp),%xmm3
movapd %xmm3,%xmm2
addsd  0x1879(%rip),%xmm2
mulsd  %xmm3,%xmm2
movapd 0x20(%rsp),%xmm3
divsd  %xmm2,%xmm3
mulsd  0x190b(%rip),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0xa8(%rsp)
movapd 0x60(%rsp),%xmm3
mulsd  %xmm0,%xmm3
divsd  0x18f4(%rip),%xmm3
movapd %xmm1,%xmm2
subsd  %xmm3,%xmm2
movapd %xmm2,0x110(%rsp)
movapd 0x70(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm0,0x90(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm2,0x20(%rsp)
movapd %xmm1,%xmm0
divsd  0x18be(%rip),%xmm0
call   1070 <exp@plt>
addsd  0x18b9(%rip),%xmm0
shufpd $0x2,0x1930(%rip),%xmm0
movsd  0x18b0(%rip),%xmm1
movapd %xmm1,%xmm2
movapd %xmm1,%xmm5
unpcklpd 0x60(%rsp),%xmm2
divpd  %xmm0,%xmm2
movapd %xmm2,0xf0(%rsp)
movapd %xmm2,%xmm0
movapd 0x90(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm0,0x60(%rsp)
movsd  0x17ae(%rip),%xmm3
addsd  %xmm3,%xmm0
movapd %xmm0,0x100(%rsp)
mulsd  %xmm2,%xmm2
mulsd  0x20(%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0xd0(%rsp)
movapd %xmm0,%xmm4
mulsd  %xmm5,%xmm4
movapd %xmm4,0xe0(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm4,%xmm0
divsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
call   1080 <log@plt>
movapd 0xd0(%rsp),%xmm6
movapd 0xe0(%rsp),%xmm1
mulsd  %xmm6,%xmm1
movapd 0x1895(%rip),%xmm8
unpcklpd %xmm1,%xmm8
movapd 0x90(%rsp),%xmm13
movapd %xmm13,%xmm1
movapd 0x20(%rsp),%xmm14
mulsd  %xmm14,%xmm1
movapd 0xf0(%rsp),%xmm3
movapd %xmm3,%xmm2
movsd  0x17e7(%rip),%xmm10
mulsd  %xmm10,%xmm2
mulsd  %xmm1,%xmm2
movapd 0x60(%rsp),%xmm12
movsd  0x1716(%rip),%xmm9
addsd  %xmm9,%xmm12
mulsd  %xmm2,%xmm12
movapd %xmm3,%xmm9
movapd %xmm3,%xmm1
movsd  0x17ba(%rip),%xmm11
mulsd  %xmm11,%xmm1
movsd  0x17b5(%rip),%xmm7
subsd  %xmm1,%xmm7
movapd %xmm3,%xmm15
addsd  %xmm3,%xmm15
movapd %xmm15,%xmm1
mulsd  %xmm13,%xmm1
addsd  0x16ad(%rip),%xmm1
movapd 0x100(%rsp),%xmm11
movapd %xmm11,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm1,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
unpcklpd %xmm13,%xmm3
mulpd  %xmm8,%xmm3
movapd %xmm6,%xmm2
mulsd  %xmm6,%xmm11
movapd %xmm11,%xmm6
unpcklpd %xmm2,%xmm6
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm3,%xmm7
movapd %xmm7,%xmm8
unpckhpd %xmm7,%xmm8
divsd  %xmm8,%xmm12
movapd %xmm9,%xmm3
unpckhpd %xmm9,%xmm3
mulsd  %xmm12,%xmm3
movsd  0x1727(%rip),%xmm12
mulsd  %xmm12,%xmm14
movapd %xmm7,%xmm6
divsd  %xmm8,%xmm6
mulsd  %xmm14,%xmm6
movapd %xmm9,%xmm5
unpcklpd %xmm6,%xmm5
movsd  %xmm10,%xmm7
divpd  %xmm7,%xmm5
movsd  0x16d1(%rip),%xmm10
movapd %xmm10,%xmm6
unpcklpd %xmm13,%xmm6
mulpd  %xmm9,%xmm6
addpd  %xmm10,%xmm9
movsd  %xmm9,%xmm6
mulpd  %xmm5,%xmm6
addsd  %xmm2,%xmm4
mulsd  0x60(%rsp),%xmm4
addsd  %xmm11,%xmm4
mulsd  %xmm15,%xmm2
mulsd  %xmm10,%xmm4
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm6,%xmm3
movapd %xmm6,%xmm4
unpckhpd %xmm6,%xmm4
mulsd  %xmm6,%xmm4
movsd  0x15d2(%rip),%xmm9
movsd  0xa8(%rsp),%xmm5
mulsd  %xmm5,%xmm3
mulsd  %xmm5,%xmm4
mulsd  %xmm1,%xmm2
divsd  %xmm8,%xmm2
unpcklpd %xmm2,%xmm15
movapd %xmm1,%xmm2
mulsd  %xmm12,%xmm2
divsd  %xmm8,%xmm2
divpd  %xmm8,%xmm15
movapd %xmm15,%xmm5
unpckhpd %xmm15,%xmm5
subpd  %xmm5,%xmm15
mulsd  0x1639(%rip),%xmm0
addsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm13,%xmm5
movapd %xmm13,%xmm4
mulsd  %xmm2,%xmm4
movsd  0x162b(%rip),%xmm6
divsd  %xmm6,%xmm4
addsd  %xmm3,%xmm4
movapd 0x70(%rsp),%xmm3
unpcklpd %xmm3,%xmm5
unpcklpd %xmm15,%xmm3
mulpd  0x168c(%rip),%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
mulsd  %xmm1,%xmm3
divsd  %xmm6,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm3,%xmm4
movsd  0xb8(%rsp),%xmm3
mulsd  0xc0(%rsp),%xmm3
divsd  0xb0(%rsp),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm4
mulsd  0x58(%rsp),%xmm2
addsd  %xmm4,%xmm2
addsd  0x110(%rsp),%xmm2
addsd  0x30(%rsp),%xmm0
mov    0x48(%rsp),%rax
movsd  0x14cf(%rip),%xmm1
movsd  0x14cf(%rip),%xmm3
movsd  0x14cf(%rip),%xmm4
movsd  %xmm0,(%r15,%r14,8)
movsd  %xmm2,(%rax,%r14,8)
add    $0x1,%r14
cmp    %r14,%rbp
je     1c79 <R_revPBE_Correlation+0xac9>
movsd  0x0(%r13,%r14,8),%xmm5
divsd  %xmm1,%xmm5
addsd  %xmm3,%xmm5
ucomisd %xmm4,%xmm5
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
jbe    1b49 <R_revPBE_Correlation+0x999>
movsd  (%r12,%r14,8),%xmm1
mov    0xa0(%rsp),%rax
divsd  (%rax,%r14,8),%xmm9
mov    0x18(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,0xb8(%rsp)
movapd %xmm1,0xc0(%rsp)
mulsd  %xmm1,%xmm9
mov    0x50(%rsp),%rax
addsd  (%rax,%r14,8),%xmm9
movsd  %xmm9,0x58(%rsp)
movsd  %xmm5,0x30(%rsp)
movapd %xmm5,%xmm0
movsd  0x144f(%rip),%xmm1
call   1090 <pow@plt>
movsd  0x144a(%rip),%xmm1
divsd  %xmm0,%xmm1
ucomisd 0x1506(%rip),%xmm1
movapd %xmm1,0x60(%rsp)
jb     1c10 <R_revPBE_Correlation+0xa60>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1c19 <R_revPBE_Correlation+0xa69>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm0
call   10a0 <sqrt@plt>
movapd %xmm0,0x20(%rsp)
movsd  0x30(%rsp),%xmm1
movaps 0xc0(%rsp),%xmm0
andps  0x14dc(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movapd %xmm1,%xmm0
mulsd  0x13f3(%rip),%xmm0
movsd  0x13db(%rip),%xmm1
call   1090 <pow@plt>
mulsd  0x13e6(%rip),%xmm0
divsd  0x13e6(%rip),%xmm0
ucomisd 0x148e(%rip),%xmm0
jb     1620 <R_revPBE_Correlation+0x470>
sqrtsd %xmm0,%xmm0
jmp    1625 <R_revPBE_Correlation+0x475>
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%r14
jle    148f <R_revPBE_Correlation+0x2df>
cmp    $0x4,%eax
jae    1c96 <R_revPBE_Correlation+0xae6>
xor    %eax,%eax
jmp    1db8 <R_revPBE_Correlation+0xc08>
lea    (%rbx,%rbp,8),%rax
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
lea    (%r15,%rbp,8),%rdx
cmp    %rcx,%rbx
setb   %sil
cmp    %r13,%rax
seta   %dil
cmp    %rdx,%rbx
setb   %cl
cmp    %rax,%r15
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    1db8 <R_revPBE_Correlation+0xc08>
and    %dl,%cl
jne    1db8 <R_revPBE_Correlation+0xc08>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d7a <R_revPBE_Correlation+0xbca>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd 0x0(%r13,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
movupd 0x20(%r13,%rcx,8),%xmm0
movupd 0x30(%r13,%rcx,8),%xmm1
movupd 0x20(%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm0,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1d00 <R_revPBE_Correlation+0xb50>
jmp    1d7c <R_revPBE_Correlation+0xbcc>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1591 <R_revPBE_Correlation+0x3e1>
jmp    15b9 <R_revPBE_Correlation+0x409>
xor    %ecx,%ecx
test   $0x1,%dl
je     1daf <R_revPBE_Correlation+0xbff>
movupd 0x0(%r13,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
je     1e57 <R_revPBE_Correlation+0xca7>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1dec <R_revPBE_Correlation+0xc3c>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1dd0 <R_revPBE_Correlation+0xc20>
cmp    $0x3,%rcx
jb     1e57 <R_revPBE_Correlation+0xca7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm0
mulsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r13,%rax,8),%xmm0
mulsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1e00 <R_revPBE_Correlation+0xc50>
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <Integrate_LogGrid@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x48(%rsp),%rdi
jle    14ac <R_revPBE_Correlation+0x2fc>
cmp    $0x4,%eax
jae    1f38 <R_revPBE_Correlation+0xd88>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1ecb <R_revPBE_Correlation+0xd1b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1eb0 <R_revPBE_Correlation+0xd00>
cmp    $0x3,%rcx
jb     14ac <R_revPBE_Correlation+0x2fc>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm0
mulsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r13,%rax,8),%xmm0
mulsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1ee0 <R_revPBE_Correlation+0xd30>
jmp    14ac <R_revPBE_Correlation+0x2fc>
lea    (%rbx,%rbp,8),%rax
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rbx
setb   %r8b
cmp    %r13,%rax
seta   %dl
lea    (%rdi,%rbp,8),%rcx
cmp    %rcx,%rbx
setb   %cl
cmp    %rdi,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%r8b
jne    1e90 <R_revPBE_Correlation+0xce0>
and    %sil,%cl
jne    1e90 <R_revPBE_Correlation+0xce0>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2006 <R_revPBE_Correlation+0xe56>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
movupd 0x20(%r13,%rcx,8),%xmm0
movupd 0x30(%r13,%rcx,8),%xmm1
movupd 0x20(%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rcx,8)
movupd %xmm0,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1fa0 <R_revPBE_Correlation+0xdf0>
jmp    2008 <R_revPBE_Correlation+0xe58>
xor    %ecx,%ecx
test   $0x1,%dl
je     2039 <R_revPBE_Correlation+0xe89>
movupd 0x0(%r13,%rcx,8),%xmm0
movupd 0x10(%r13,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
je     14ac <R_revPBE_Correlation+0x2fc>
jmp    1e90 <R_revPBE_Correlation+0xce0>

LLVM IR (-O0):
define void @R_revPBE_Correlation(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 double
%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
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca i32
%56 = alloca double*
%57 = alloca double*
%58 = alloca double*
%59 = alloca double*
%60 = alloca double*
%61 = alloca double*
store double* %0, double** %5
store double* %1, double** %6
store double* %2, double** %7
store double* %3, double** %8
%62 = call double @atan(double 1.000000e+00)
%63 = fmul double 4.000000e+00, %62
store double %63, double* %14
store double 0x40012B444959F39A, double* %10
store double 0x3FD5555555555555, double* %11
store double 0x3FC5555555555555, double* %12
store double 0x3FF2AAAAAAAAAAAB, double* %13
%64 = call double @atan(double 1.000000e+00)
%65 = fmul double 4.000000e+00, %64
store double %65, double* %14
%66 = load double, double* %14
%67 = fdiv double 7.500000e-01, %66
%68 = load double, double* %11
%69 = call double @pow(double %67, double %68)
store double %69, double* %15
%70 = call i32 (...) @N_LogGrid()
store i32 %70, i32* %55
%71 = call i32 (...) @r_LogGrid()
%72 = sext i32 %71 to i64
%73 = inttoptr i64 %72 to double*
store double* %73, double** %56
%74 = call i32 (...) @alloc_LogGrid()
%75 = sext i32 %74 to i64
%76 = inttoptr i64 %75 to double*
store double* %76, double** %57
%77 = call i32 (...) @alloc_LogGrid()
%78 = sext i32 %77 to i64
%79 = inttoptr i64 %78 to double*
store double* %79, double** %58
%80 = call i32 (...) @alloc_LogGrid()
%81 = sext i32 %80 to i64
%82 = inttoptr i64 %81 to double*
store double* %82, double** %59
%83 = call i32 (...) @alloc_LogGrid()
%84 = sext i32 %83 to i64
%85 = inttoptr i64 %84 to double*
store double* %85, double** %60
%86 = call i32 (...) @alloc_LogGrid()
%87 = sext i32 %86 to i64
%88 = inttoptr i64 %87 to double*
store double* %88, double** %61
store i32 0, i32* %9
br label %89
89: ; preds = %106, %4
%90 = load i32, i32* %9
%91 = load i32, i32* %55
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %109
93: ; preds = %89
%94 = load double*, double** %5
%95 = load i32, i32* %9
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
%98 = load double, double* %97
%99 = load double, double* %14
%100 = fmul double 4.000000e+00, %99
%101 = fdiv double %98, %100
%102 = load double*, double** %58
%103 = load i32, i32* %9
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
store double %101, double* %105
br label %106
106: ; preds = %93
%107 = load i32, i32* %9
%108 = add nsw i32 %107, 1
store i32 %108, i32* %9
br label %89
109: ; preds = %89
%110 = load double*, double** %58
%111 = load double*, double** %59
%112 = call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %110, double* %111)
%113 = load double*, double** %59
%114 = load double*, double** %60
%115 = call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %113, double* %114)
store i32 0, i32* %9
br label %116
116: ; preds = %131, %109
%117 = load i32, i32* %9
%118 = load i32, i32* %55
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %134
120: ; preds = %116
%121 = load double*, double** %59
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = call double @llvm.fabs.f64(double %125)
%127 = load double*, double** %58
%128 = load i32, i32* %9
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
store double %126, double* %130
br label %131
131: ; preds = %120
%132 = load i32, i32* %9
%133 = add nsw i32 %132, 1
store i32 %133, i32* %9
br label %116
134: ; preds = %116
%135 = load double*, double** %58
%136 = load double*, double** %61
%137 = call i32 (double*, double*, ...) bitcast (i32 (...)* @Derivative_LogGrid to i32 (double*, double*, ...)*)(double* %135, double* %136)
store i32 0, i32* %9
br label %138
138: ; preds = %484, %134
%139 = load i32, i32* %9
%140 = load i32, i32* %55
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %487
142: ; preds = %138
%143 = load double*, double** %5
%144 = load i32, i32* %9
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds double, double* %143, i64 %145
%147 = load double, double* %146
%148 = load double, double* %14
%149 = fmul double 4.000000e+00, %148
%150 = fdiv double %147, %149
%151 = fadd double %150, 0x2F52F8AC174D6123
store double %151, double* %18
%152 = load double, double* %18
%153 = fcmp ogt double %152, 0x3D719799812DEA11
br i1 %153, label %154, label %474
154: ; preds = %142
%155 = load double*, double** %59
%156 = load i32, i32* %9
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %155, i64 %157
%159 = load double, double* %158
%160 = call double @llvm.fabs.f64(double %159)
store double %160, double* %20
%161 = load double*, double** %59
%162 = load i32, i32* %9
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %161, i64 %163
%165 = load double, double* %164
%166 = load double*, double** %61
%167 = load i32, i32* %9
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %166, i64 %168
%170 = load double, double* %169
%171 = fmul double %165, %170
store double %171, double* %21
%172 = load double*, double** %60
%173 = load i32, i32* %9
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
%177 = load double*, double** %56
%178 = load i32, i32* %9
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = fdiv double 2.000000e+00, %181
%183 = load double*, double** %59
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
%187 = load double, double* %186
%188 = call double @llvm.fmuladd.f64(double %182, double %187, double %176)
store double %188, double* %19
%189 = load double, double* %15
%190 = load double, double* %18
%191 = load double, double* %11
%192 = call double @pow(double %190, double %191)
%193 = fdiv double %189, %192
store double %193, double* %16
%194 = load double, double* %16
%195 = call double @sqrt(double %194)
store double %195, double* %17
%196 = load double, double* %14
%197 = fmul double 3.000000e+00, %196
%198 = load double, double* %14
%199 = fmul double %197, %198
%200 = load double, double* %18
%201 = fmul double %199, %200
%202 = load double, double* %11
%203 = call double @pow(double %201, double %202)
store double %203, double* %37
%204 = load double, double* %37
%205 = fmul double 4.000000e+00, %204
%206 = load double, double* %14
%207 = fdiv double %205, %206
%208 = call double @sqrt(double %207)
store double %208, double* %36
%209 = load double, double* %20
%210 = load double, double* %36
%211 = fmul double 2.000000e+00, %210
%212 = load double, double* %18
%213 = fmul double %211, %212
%214 = fdiv double %209, %213
store double %214, double* %22
%215 = load double, double* %21
%216 = load double, double* %36
%217 = fmul double 8.000000e+00, %216
%218 = load double, double* %36
%219 = fmul double %217, %218
%220 = load double, double* %36
%221 = fmul double %219, %220
%222 = load double, double* %18
%223 = fmul double %221, %222
%224 = load double, double* %18
%225 = fmul double %223, %224
%226 = fdiv double %215, %225
store double %226, double* %34
%227 = load double, double* %19
%228 = load double, double* %36
%229 = fmul double 4.000000e+00, %228
%230 = load double, double* %36
%231 = fmul double %229, %230
%232 = load double, double* %18
%233 = fmul double %231, %232
%234 = fdiv double %227, %233
store double %234, double* %35
%235 = load double, double* %16
%236 = call double @llvm.fmuladd.f64(double 2.137000e-01, double %235, double 1.000000e+00)
%237 = fmul double -6.218140e-02, %236
store double %237, double* %26
%238 = load double, double* %17
%239 = fmul double 6.218140e-02, %238
%240 = load double, double* %17
%241 = load double, double* %17
%242 = load double, double* %17
%243 = call double @llvm.fmuladd.f64(double 4.929400e-01, double %242, double 1.638200e+00)
%244 = call double @llvm.fmuladd.f64(double %241, double %243, double 3.587600e+00)
%245 = call double @llvm.fmuladd.f64(double %240, double %244, double 0x401E61FF2E48E8A7)
%246 = fmul double %239, %245
store double %246, double* %27
%247 = load double, double* %27
%248 = fdiv double 1.000000e+00, %247
%249 = fadd double 1.000000e+00, %248
%250 = call double @log(double %249)
store double %250, double* %28
%251 = load double, double* %17
%252 = fdiv double 0x401E61FF2E48E8A7, %251
%253 = fadd double %252, 7.175200e+00
%254 = load double, double* %17
%255 = load double, double* %17
%256 = call double @llvm.fmuladd.f64(double 1.971760e+00, double %255, double 4.914600e+00)
%257 = call double @llvm.fmuladd.f64(double %254, double %256, double %253)
%258 = fmul double 3.109070e-02, %257
store double %258, double* %29
%259 = load double, double* %26
%260 = load double, double* %28
%261 = fmul double %259, %260
store double %261, double* %51
%262 = load double, double* %28
%263 = load double, double* %26
%264 = load double, double* %29
%265 = fmul double %263, %264
%266 = load double, double* %27
%267 = load double, double* %27
%268 = fadd double 1.000000e+00, %267
%269 = fmul double %266, %268
%270 = fdiv double %265, %269
%271 = fneg double %270
%272 = call double @llvm.fmuladd.f64(double 0xBF8B36D356F9BECD, double %262, double %271)
store double %272, double* %52
%273 = load double, double* %51
%274 = load double, double* %16
%275 = load double, double* %52
%276 = fmul double %274, %275
%277 = fdiv double %276, 3.000000e+00
%278 = fsub double %273, %277
store double %278, double* %53
%279 = load double, double* %22
%280 = load double, double* %22
%281 = fmul double %279, %280
store double %281, double* %23
%282 = load double, double* %23
%283 = load double, double* %23
%284 = fmul double %282, %283
store double %284, double* %24
%285 = load double, double* %51
%286 = fneg double %285
%287 = fdiv double %286, 0x3F9FD63CF1FB1963
store double %287, double* %46
%288 = load double, double* %10
%289 = load double, double* %46
%290 = call double @exp(double %289)
%291 = fsub double %290, 1.000000e+00
%292 = fdiv double %288, %291
store double %292, double* %46
%293 = load double, double* %46
%294 = load double, double* %23
%295 = call double @llvm.fmuladd.f64(double %293, double %294, double 1.000000e+00)
store double %295, double* %30
%296 = load double, double* %46
%297 = load double, double* %23
%298 = call double @llvm.fmuladd.f64(double %296, double %297, double 1.000000e+00)
%299 = load double, double* %46
%300 = load double, double* %46
%301 = fmul double %299, %300
%302 = load double, double* %24
%303 = call double @llvm.fmuladd.f64(double %301, double %302, double %298)
store double %303, double* %31
%304 = load double, double* %10
%305 = load double, double* %30
%306 = fmul double %304, %305
%307 = load double, double* %23
%308 = fmul double %306, %307
%309 = load double, double* %31
%310 = fdiv double %308, %309
%311 = fadd double 1.000000e+00, %310
%312 = call double @log(double %311)
%313 = fmul double 0x3F9FD63CF1FB1963, %312
store double %313, double* %38
%314 = load double, double* %24
%315 = load double, double* %23
%316 = fmul double %314, %315
store double %316, double* %25
%317 = load double, double* %46
%318 = fdiv double %317, 0x3FB114DC32AE4A5A
%319 = load double, double* %10
%320 = load double, double* %46
%321 = fadd double %319, %320
%322 = fmul double %318, %321
store double %322, double* %45
%323 = load double, double* %31
%324 = load double, double* %31
%325 = load double, double* %10
%326 = load double, double* %30
%327 = fmul double %325, %326
%328 = load double, double* %31
%329 = fmul double %327, %328
%330 = load double, double* %23
%331 = fmul double %329, %330
%332 = call double @llvm.fmuladd.f64(double %323, double %324, double %331)
store double %332, double* %32
%333 = load double, double* %46
%334 = fmul double 0xBFB114DC32AE4A5A, %333
%335 = load double, double* %25
%336 = fmul double %334, %335
%337 = load double, double* %46
%338 = load double, double* %23
%339 = call double @llvm.fmuladd.f64(double %337, double %338, double 2.000000e+00)
%340 = fmul double %336, %339
%341 = load double, double* %32
%342 = fdiv double %340, %341
store double %342, double* %43
%343 = load double, double* %16
%344 = fdiv double %343, 3.000000e+00
%345 = fneg double %344
%346 = load double, double* %43
%347 = fmul double %345, %346
%348 = load double, double* %45
%349 = fmul double %347, %348
%350 = load double, double* %52
%351 = fmul double %349, %350
store double %351, double* %39
%352 = load double, double* %46
%353 = fmul double 2.000000e+00, %352
%354 = load double, double* %23
%355 = call double @llvm.fmuladd.f64(double %353, double %354, double 1.000000e+00)
store double %355, double* %33
%356 = load double, double* %10
%357 = load double, double* %46
%358 = fmul double 6.000000e+00, %357
%359 = fneg double %358
%360 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %356, double %359)
store double %360, double* %47
%361 = load double, double* %31
%362 = load double, double* %33
%363 = load double, double* %30
%364 = load double, double* %33
%365 = fmul double %363, %364
%366 = load double, double* %33
%367 = fmul double %365, %366
%368 = call double @llvm.fmuladd.f64(double %361, double %362, double %367)
store double %368, double* %48
%369 = load double, double* %30
%370 = load double, double* %31
%371 = load double, double* %46
%372 = load double, double* %23
%373 = fmul double %371, %372
%374 = load double, double* %30
%375 = load double, double* %33
%376 = load double, double* %31
%377 = call double @llvm.fmuladd.f64(double %374, double %375, double %376)
%378 = fmul double %373, %377
%379 = call double @llvm.fmuladd.f64(double %369, double %370, double %378)
store double %379, double* %49
%380 = load double, double* %46
%381 = fmul double 2.000000e+00, %380
%382 = load double, double* %31
%383 = fmul double %381, %382
%384 = load double, double* %33
%385 = load double, double* %10
%386 = load double, double* %49
%387 = fmul double %385, %386
%388 = call double @llvm.fmuladd.f64(double %383, double %384, double %387)
store double %388, double* %50
%389 = load double, double* %24
%390 = fmul double 0x3FC114DC32AE4A5A, %389
%391 = load double, double* %30
%392 = load double, double* %31
%393 = fmul double %391, %392
%394 = load double, double* %47
%395 = load double, double* %10
%396 = load double, double* %48
%397 = fmul double %395, %396
%398 = fneg double %397
%399 = call double @llvm.fmuladd.f64(double %393, double %394, double %398)
%400 = load double, double* %32
%401 = fdiv double %399, %400
%402 = fmul double %390, %401
%403 = load double, double* %32
%404 = fdiv double %402, %403
store double %404, double* %44
%405 = load double, double* %16
%406 = fdiv double %405, 3.000000e+00
%407 = load double, double* %23
%408 = fmul double %406, %407
%409 = load double, double* %44
%410 = fmul double %408, %409
%411 = load double, double* %45
%412 = fmul double %410, %411
%413 = load double, double* %52
%414 = fmul double %412, %413
store double %414, double* %40
%415 = load double, double* %33
%416 = fmul double 0x3FC114DC32AE4A5A, %415
%417 = load double, double* %32
%418 = fdiv double %416, %417
store double %418, double* %41
%419 = load double, double* %22
%420 = fmul double 0x3FC99F4A4C056F87, %419
%421 = load double, double* %46
%422 = fmul double 2.000000e+00, %421
%423 = load double, double* %32
%424 = fdiv double %422, %423
%425 = load double, double* %33
%426 = load double, double* %50
%427 = fmul double %425, %426
%428 = load double, double* %32
%429 = fdiv double %427, %428
%430 = load double, double* %32
%431 = fdiv double %429, %430
%432 = fsub double %424, %431
%433 = fmul double %420, %432
store double %433, double* %42
%434 = load double, double* %38
%435 = load double, double* %39
%436 = fadd double %434, %435
%437 = load double, double* %40
%438 = fadd double %436, %437
%439 = load double, double* %23
%440 = load double, double* %41
%441 = fmul double %439, %440
%442 = fdiv double %441, 6.000000e+00
%443 = fadd double %438, %442
%444 = load double, double* %23
%445 = fmul double 7.000000e+00, %444
%446 = load double, double* %22
%447 = fmul double %445, %446
%448 = load double, double* %42
%449 = fmul double %447, %448
%450 = fdiv double %449, 6.000000e+00
%451 = fadd double %443, %450
%452 = load double, double* %34
%453 = load double, double* %42
%454 = fneg double %452
%455 = call double @llvm.fmuladd.f64(double %454, double %453, double %451)
%456 = load double, double* %35
%457 = load double, double* %41
%458 = fneg double %456
%459 = call double @llvm.fmuladd.f64(double %458, double %457, double %455)
store double %459, double* %54
%460 = load double, double* %51
%461 = load double, double* %38
%462 = fadd double %460, %461
%463 = load double*, double** %57
%464 = load i32, i32* %9
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %463, i64 %465
store double %462, double* %466
%467 = load double, double* %53
%468 = load double, double* %54
%469 = fadd double %467, %468
%470 = load double*, double** %6
%471 = load i32, i32* %9
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %470, i64 %472
store double %469, double* %473
br label %483
474: ; preds = %142
%475 = load double*, double** %57
%476 = load i32, i32* %9
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %475, i64 %477
store double 0.000000e+00, double* %478
%479 = load double*, double** %6
%480 = load i32, i32* %9
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds double, double* %479, i64 %481
store double 0.000000e+00, double* %482
br label %483
483: ; preds = %474, %154
br label %484
484: ; preds = %483
%485 = load i32, i32* %9
%486 = add nsw i32 %485, 1
store i32 %486, i32* %9
br label %138
487: ; preds = %138
store i32 0, i32* %9
br label %488
488: ; preds = %508, %487
%489 = load i32, i32* %9
%490 = load i32, i32* %55
%491 = icmp slt i32 %489, %490
br i1 %491, label %492, label %511
492: ; preds = %488
%493 = load double*, double** %5
%494 = load i32, i32* %9
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %493, i64 %495
%497 = load double, double* %496
%498 = load double*, double** %57
%499 = load i32, i32* %9
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
%502 = load double, double* %501
%503 = fmul double %497, %502
%504 = load double*, double** %58
%505 = load i32, i32* %9
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %504, i64 %506
store double %503, double* %507
br label %508
508: ; preds = %492
%509 = load i32, i32* %9
%510 = add nsw i32 %509, 1
store i32 %510, i32* %9
br label %488
511: ; preds = %488
%512 = load double*, double** %58
%513 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %512)
%514 = sitofp i32 %513 to double
%515 = load double*, double** %7
store double %514, double* %515
store i32 0, i32* %9
br label %516
516: ; preds = %536, %511
%517 = load i32, i32* %9
%518 = load i32, i32* %55
%519 = icmp slt i32 %517, %518
br i1 %519, label %520, label %539
520: ; preds = %516
%521 = load double*, double** %5
%522 = load i32, i32* %9
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double, double* %521, i64 %523
%525 = load double, double* %524
%526 = load double*, double** %6
%527 = load i32, i32* %9
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %526, i64 %528
%530 = load double, double* %529
%531 = fmul double %525, %530
%532 = load double*, double** %58
%533 = load i32, i32* %9
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %532, i64 %534
store double %531, double* %535
br label %536
536: ; preds = %520
%537 = load i32, i32* %9
%538 = add nsw i32 %537, 1
store i32 %538, i32* %9
br label %516
539: ; preds = %516
%540 = load double*, double** %58
%541 = call i32 (double*, ...) bitcast (i32 (...)* @Integrate_LogGrid to i32 (double*, ...)*)(double* %540)
%542 = sitofp i32 %541 to double
%543 = load double*, double** %8
store double %542, double* %543
%544 = load double*, double** %57
%545 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %544)
%546 = load double*, double** %58
%547 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %546)
%548 = load double*, double** %59
%549 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %548)
%550 = load double*, double** %60
%551 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %550)
%552 = load double*, double** %61
%553 = call i32 (double*, ...) bitcast (i32 (...)* @dealloc_LogGrid to i32 (double*, ...)*)(double* %552)
ret void
}

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