void hessian_boys(const int Norbs, double *x_symm, double *y_symm,
                  double *z_symm, double *vector_in, double *vector_out) {
  int rowindex, p, q, r, s;
  const int num_vars = (Norbs * (Norbs - 1)) / 2;
#pragma omp parallel for schedule(static)
  for (rowindex = 0; rowindex < num_vars; rowindex++) {
    s = num_vars - 1 - rowindex;
    r = 2;
    while ((r * (r - 1)) / 2 <= s) {
      r++;
    }
    p = Norbs - r;
    q = rowindex - p * Norbs + ((p + 1) * (p + 2)) / 2;
    double value = 0.0;
    for (s = p + 1; s < Norbs; s++) {
      const int arg_pq = p + Norbs * q;
      const int arg_ps = p + Norbs * s;
      const int arg_qs = q + Norbs * s;
      const int arg_pp = p + Norbs * p;
      const int arg_qq = q + Norbs * q;
      const int arg_ss = s + Norbs * s;
      const double prefactor =
          (2 * x_symm[arg_pq] * x_symm[arg_ps] +
           x_symm[arg_qs] *
               (x_symm[arg_pp] - 0.5 * x_symm[arg_qq] - 0.5 * x_symm[arg_ss])) +
          (2 * y_symm[arg_pq] * y_symm[arg_ps] +
           y_symm[arg_qs] *
               (y_symm[arg_pp] - 0.5 * y_symm[arg_qq] - 0.5 * y_symm[arg_ss])) +
          (2 * z_symm[arg_pq] * z_symm[arg_ps] +
           z_symm[arg_qs] *
               (z_symm[arg_pp] - 0.5 * z_symm[arg_qq] - 0.5 * z_symm[arg_ss]));
      const int colindex = rowindex + s - q;
      value += prefactor * vector_in[colindex];
    }
    for (r = 0; r < q; r++) {
      const int arg_pq = p + Norbs * q;
      const int arg_rq = r + Norbs * q;
      const int arg_pr = p + Norbs * r;
      const int arg_qq = q + Norbs * q;
      const int arg_pp = p + Norbs * p;
      const int arg_rr = r + Norbs * r;
      const double prefactor =
          (2 * x_symm[arg_pq] * x_symm[arg_rq] +
           x_symm[arg_pr] *
               (x_symm[arg_qq] - 0.5 * x_symm[arg_pp] - 0.5 * x_symm[arg_rr])) +
          (2 * y_symm[arg_pq] * y_symm[arg_rq] +
           y_symm[arg_pr] *
               (y_symm[arg_qq] - 0.5 * y_symm[arg_pp] - 0.5 * y_symm[arg_rr])) +
          (2 * z_symm[arg_pq] * z_symm[arg_rq] +
           z_symm[arg_pr] *
               (z_symm[arg_qq] - 0.5 * z_symm[arg_pp] - 0.5 * z_symm[arg_rr]));
      const int colindex = q + r * Norbs - ((r + 1) * (r + 2)) / 2;
      value += prefactor * vector_in[colindex];
    }
    for (s = q + 1; s < Norbs; s++) {
      const int arg_pq = p + Norbs * q;
      const int arg_qs = q + Norbs * s;
      const int arg_ps = p + Norbs * s;
      const int arg_qq = q + Norbs * q;
      const int arg_pp = p + Norbs * p;
      const int arg_ss = s + Norbs * s;
      const double prefactor =
          (2 * x_symm[arg_pq] * x_symm[arg_qs] +
           x_symm[arg_ps] *
               (x_symm[arg_qq] - 0.5 * x_symm[arg_pp] - 0.5 * x_symm[arg_ss])) +
          (2 * y_symm[arg_pq] * y_symm[arg_qs] +
           y_symm[arg_ps] *
               (y_symm[arg_qq] - 0.5 * y_symm[arg_pp] - 0.5 * y_symm[arg_ss])) +
          (2 * z_symm[arg_pq] * z_symm[arg_qs] +
           z_symm[arg_ps] *
               (z_symm[arg_qq] - 0.5 * z_symm[arg_pp] - 0.5 * z_symm[arg_ss]));
      const int colindex = s + q * Norbs - ((q + 1) * (q + 2)) / 2;
      value -= prefactor * vector_in[colindex];
    }
    for (r = 0; r < p; r++) {
      const int arg_pq = p + Norbs * q;
      const int arg_rp = r + Norbs * p;
      const int arg_qr = q + Norbs * r;
      const int arg_pp = p + Norbs * p;
      const int arg_qq = q + Norbs * q;
      const int arg_rr = r + Norbs * r;
      const double prefactor =
          (2 * x_symm[arg_pq] * x_symm[arg_rp] +
           x_symm[arg_qr] *
               (x_symm[arg_pp] - 0.5 * x_symm[arg_qq] - 0.5 * x_symm[arg_rr])) +
          (2 * y_symm[arg_pq] * y_symm[arg_rp] +
           y_symm[arg_qr] *
               (y_symm[arg_pp] - 0.5 * y_symm[arg_qq] - 0.5 * y_symm[arg_rr])) +
          (2 * z_symm[arg_pq] * z_symm[arg_rp] +
           z_symm[arg_qr] *
               (z_symm[arg_pp] - 0.5 * z_symm[arg_qq] - 0.5 * z_symm[arg_rr]));
      const int colindex = p + r * Norbs - ((r + 1) * (r + 2)) / 2;
      value -= prefactor * vector_in[colindex];
    }
    vector_out[rowindex] = -Norbs * value;
  }
}


x86 assembly (clang, -O0):
<hessian_boys>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1c7a <hessian_boys+0xb7a>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    -0x44(%rbp),%eax
jg     118a <hessian_boys+0x8a>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    115f <hessian_boys+0x5f>
mov    -0x4(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf0(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1411 <hessian_boys+0x311>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xdb8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xd6f(%rip),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0xd52(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xd36(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0xced(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xcd0(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xcb0(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0xc67(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xc4a(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11da <hessian_boys+0xda>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    16a9 <hessian_boys+0x5a9>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0xb71(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xb22(%rip),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0xb02(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0xae6(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0xa97(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0xa77(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0xa57(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0xa08(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x9e8(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x9c(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1418 <hessian_boys+0x318>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    197e <hessian_boys+0x87e>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0x8cb(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x876(%rip),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0x856(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0x837(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x18(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0x7e2(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x7c2(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  0x79f(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x20(%rbp),%rax
movslq -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0x74a(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x20(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x72a(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xf8(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc4(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16b2 <hessian_boys+0x5b2>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1c51 <hessian_boys+0xb51>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd8(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0x5f8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x5a3(%rip),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mov    -0x10(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0x583(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0x564(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x18(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0x50f(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x18(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x4ef(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0x4cc(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x20(%rbp),%rax
movslq -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xd4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x20(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
movsd  0x477(%rip),%xmm6
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
mov    -0x20(%rbp),%rax
movslq -0xdc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x457(%rip),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xfc(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1985 <hessian_boys+0x885>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1140 <hessian_boys+0x40>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hessian_boys>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %r9,0x18(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rdx,-0x48(%rsp)
mov    %rsi,-0x50(%rsp)
lea    -0x1(%rdi),%eax
mov    %eax,-0x2c(%rsp)
mov    %rdi,-0x20(%rsp)
imul   %edi,%eax
mov    %rax,-0x28(%rsp)
cmp    $0x2,%eax
jl     1840 <hessian_boys+0x740>
mov    -0x28(%rsp),%rdi
mov    %edi,%ebp
shr    $0x1f,%ebp
add    %edi,%ebp
sar    %ebp
mov    -0x20(%rsp),%rdx
mov    %edx,%eax
neg    %eax
cvtsi2sd %eax,%xmm8
movslq %edx,%rcx
mov    %ebp,-0x30(%rsp)
mov    %ebp,%eax
mov    %rax,0x8(%rsp)
lea    -0x1(%rdi),%eax
mov    %eax,-0x34(%rsp)
mov    %edx,%eax
not    %eax
mov    %rax,(%rsp)
mov    %edx,%eax
imul   %edx,%eax
add    $0xfffffffe,%eax
mov    %eax,-0x38(%rsp)
movl   $0x1,-0x64(%rsp)
xor    %edx,%edx
movapd 0xe69(%rip),%xmm9
movsd  0xe70(%rip),%xmm10
mov    %r8,-0x40(%rsp)
mov    %rcx,-0x58(%rsp)
jmp    11d8 <hessian_boys+0xd8>
nopl   0x0(%rax)
mulsd  %xmm8,%xmm3
mov    0x18(%rsp),%rax
mov    -0x8(%rsp),%rdx
movsd  %xmm3,(%rax,%rdx,8)
add    $0x1,%rdx
addl   $0x1,-0x64(%rsp)
cmp    0x8(%rsp),%rdx
je     1840 <hessian_boys+0x740>
mov    %rdx,-0x8(%rsp)
mov    %edx,%r8d
not    %r8d
add    -0x30(%rsp),%r8d
mov    $0x2,%r14d
mov    $0x1,%ebp
mov    -0x2c(%rsp),%eax
mov    %eax,%r15d
mov    -0x38(%rsp),%r12d
mov    -0x28(%rsp),%rax
mov    %eax,%esi
mov    -0x34(%rsp),%edi
mov    -0x20(%rsp),%r10
mov    (%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14d,%ebx
mov    %edi,%r13d
mov    %r12d,%r11d
mov    %r15d,%edx
mov    %ebp,%r9d
lea    -0x1(%rbx),%edi
imul   %r14d,%edi
mov    %edi,%eax
shr    $0x1f,%eax
add    %edi,%eax
sar    %eax
lea    0x1(%rbx),%r14d
lea    (%rcx,%r13,1),%edi
sub    %r10d,%esi
lea    (%r11,%rcx,1),%r12d
lea    -0x1(%rdx),%r15d
lea    0x1(%r9),%ebp
cmp    %r8d,%eax
jle    1220 <hessian_boys+0x120>
mov    %esi,-0x5c(%rsp)
mov    %r15,-0x10(%rsp)
mov    %r10d,%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
imul   %r10d,%eax
mov    -0x8(%rsp),%rdi
mov    %rax,-0x78(%rsp)
sub    %eax,%edi
lea    0x1(%rcx),%esi
mov    %rcx,-0x80(%rsp)
lea    0x2(%rcx),%eax
imul   %esi,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
mov    %ecx,-0x60(%rsp)
add    %ecx,%edi
xorpd  %xmm3,%xmm3
mov    %rdi,-0x70(%rsp)
movslq %edi,%r15
cmp    %r10d,%esi
mov    -0x40(%rsp),%r8
mov    %r10,%r12
mov    0x10(%rsp),%r10
mov    -0x48(%rsp),%rdi
mov    -0x50(%rsp),%rcx
jge    13ec <hessian_boys+0x2ec>
mov    -0x70(%rsp),%r14
mov    %r14d,%eax
imul   %r12d,%eax
mov    -0x80(%rsp),%rbx
lea    (%rax,%rbx,1),%r8d
mov    -0x78(%rsp),%rbp
add    %ebp,%ebx
add    %r14d,%eax
movslq %r8d,%rbp
movslq %ebx,%r8
cltq
movsd  (%rcx,%rbp,8),%xmm4
movhpd (%rdi,%rbp,8),%xmm4
addpd  %xmm4,%xmm4
movsd  (%rcx,%rax,8),%xmm5
movhpd (%rdi,%rax,8),%xmm5
movsd  (%rcx,%r8,8),%xmm0
movhpd (%rdi,%r8,8),%xmm0
mulpd  %xmm9,%xmm5
addpd  %xmm0,%xmm5
movsd  (%r10,%rbp,8),%xmm6
addsd  %xmm6,%xmm6
movsd  (%r10,%rax,8),%xmm7
mulsd  %xmm10,%xmm7
addsd  (%r10,%r8,8),%xmm7
mov    -0x40(%rsp),%r8
movslq %esi,%r14
sub    -0x60(%rsp),%r13d
movslq %edx,%rbx
imul   -0x58(%rsp),%rbx
xorpd  %xmm3,%xmm3
nopl   (%rax)
movslq %ebx,%rax
add    %r14,%rax
lea    (%rbx,%r15,1),%rbp
movsd  (%rcx,%rax,8),%xmm0
movhpd (%rdi,%rax,8),%xmm0
movslq %r11d,%r11
mulpd  %xmm9,%xmm0
addpd  %xmm5,%xmm0
movsd  (%rcx,%rbp,8),%xmm1
movhpd (%rdi,%rbp,8),%xmm1
mulpd  %xmm0,%xmm1
movsd  (%rcx,%r11,8),%xmm0
movhpd (%rdi,%r11,8),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm7,%xmm0
mulsd  (%r10,%rbp,8),%xmm0
movsd  (%r10,%r11,8),%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movslq %r13d,%r13
mulsd  (%r8,%r13,8),%xmm2
addsd  %xmm2,%xmm3
add    $0x1,%r14
add    $0x1,%r13d
add    -0x58(%rsp),%rbx
add    %r12d,%r11d
add    $0xffffffff,%r9d
jne    1350 <hessian_boys+0x250>
mov    %r15,-0x18(%rsp)
mov    -0x70(%rsp),%rsi
test   %esi,%esi
jle    1550 <hessian_boys+0x450>
mov    %esi,%eax
imul   %r12d,%eax
mov    -0x80(%rsp),%rdx
lea    (%rax,%rdx,1),%edi
lea    (%rax,%rsi,1),%ebp
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rdx,1),%ebx
movslq %edi,%rdi
movslq %ebp,%rbp
movslq %ebx,%rbx
mov    -0x50(%rsp),%r13
movsd  0x0(%r13,%rdi,8),%xmm4
mov    -0x48(%rsp),%rdx
movhpd (%rdx,%rdi,8),%xmm4
addpd  %xmm4,%xmm4
movsd  0x0(%r13,%rbx,8),%xmm5
movhpd (%rdx,%rbx,8),%xmm5
movsd  0x0(%r13,%rbp,8),%xmm0
movhpd (%rdx,%rbp,8),%xmm0
mulpd  %xmm9,%xmm5
addpd  %xmm0,%xmm5
movsd  (%r10,%rdi,8),%xmm6
addsd  %xmm6,%xmm6
movsd  (%r10,%rbx,8),%xmm7
mulsd  %xmm10,%xmm7
addsd  (%r10,%rbp,8),%xmm7
movslq %eax,%r11
mov    %esi,%r14d
xor    %ebx,%ebx
mov    $0x2,%r15d
xor    %ebp,%ebp
mov    -0x10(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbx
lea    (%rbx,%rbp,1),%rdi
lea    (%r11,%rbp,1),%r9
lea    (%rcx,%rbx,1),%eax
cltq
movsd  0x0(%r13,%rdi,8),%xmm0
movhpd (%rdx,%rdi,8),%xmm0
mulpd  %xmm9,%xmm0
addpd  %xmm5,%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
movhpd (%rdx,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movsd  0x0(%r13,%r9,8),%xmm0
movhpd (%rdx,%r9,8),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm7,%xmm0
mulsd  (%r10,%rax,8),%xmm0
movsd  (%r10,%r9,8),%xmm2
mov    -0x70(%rsp),%rsi
mulsd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
add    $0x1,%rbp
mov    %ebp,%eax
imul   %r15d,%eax
shr    %eax
lea    (%rbx,%rsi,1),%edi
sub    %eax,%edi
movslq %edi,%rax
mulsd  (%r8,%rax,8),%xmm2
addsd  %xmm2,%xmm3
add    %r12d,%ebx
add    $0x1,%r15d
cmp    %r14,%rbp
jb     1490 <hessian_boys+0x390>
jmp    155a <hessian_boys+0x45a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x48(%rsp),%rdx
mov    -0x50(%rsp),%r13
lea    0x1(%rsi),%ebp
cmp    %r12d,%ebp
jge    16c0 <hessian_boys+0x5c0>
mov    %esi,%r14d
imul   %r12d,%r14d
mov    -0x80(%rsp),%r15
lea    (%r14,%r15,1),%eax
lea    (%r14,%rsi,1),%r9d
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r15,1),%r11d
movslq %eax,%rbx
movslq %r9d,%rax
movslq %r11d,%rdi
movsd  0x0(%r13,%rbx,8),%xmm4
movhpd (%rdx,%rbx,8),%xmm4
addpd  %xmm4,%xmm4
movsd  0x0(%r13,%rdi,8),%xmm5
movhpd (%rdx,%rdi,8),%xmm5
movsd  0x0(%r13,%rax,8),%xmm0
movhpd (%rdx,%rax,8),%xmm0
mulpd  %xmm9,%xmm5
addpd  %xmm0,%xmm5
movsd  (%r10,%rbx,8),%xmm6
addsd  %xmm6,%xmm6
movsd  (%r10,%rdi,8),%xmm7
mulsd  %xmm10,%xmm7
addsd  (%r10,%rax,8),%xmm7
lea    0x2(%rsi),%edi
imul   %edi,%ebp
mov    %ebp,%edi
shr    $0x1f,%edi
add    %ebp,%edi
sar    %edi
sub    %edi,%r14d
mov    -0x60(%rsp),%eax
add    -0x64(%rsp),%eax
sub    %ecx,%eax
movslq %eax,%rbx
mov    -0x58(%rsp),%rcx
mov    -0x18(%rsp),%r11
mov    -0x5c(%rsp),%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rbp
imul   %rcx,%rbp
mov    %ebx,%edi
imul   %r12d,%edi
movslq %edi,%rax
add    %r11,%rbp
add    %r15d,%edi
add    %rbx,%rax
movslq %edi,%rdi
movsd  0x0(%r13,%rax,8),%xmm0
movhpd (%rdx,%rax,8),%xmm0
movsd  0x0(%r13,%rdi,8),%xmm1
mulpd  %xmm9,%xmm0
movhpd (%rdx,%rdi,8),%xmm1
movsd  0x0(%r13,%rbp,8),%xmm2
addpd  %xmm5,%xmm0
movhpd (%rdx,%rbp,8),%xmm2
mulpd  %xmm4,%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm1,%xmm2
movapd %xmm2,%xmm0
movsd  (%r10,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
unpckhpd %xmm2,%xmm0
addsd  %xmm7,%xmm1
mulsd  (%r10,%rdi,8),%xmm1
addsd  %xmm2,%xmm0
movsd  (%r10,%rbp,8),%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
lea    (%r14,%rbx,1),%eax
cltq
mulsd  (%r8,%rax,8),%xmm2
subsd  %xmm2,%xmm3
add    $0x1,%rbx
cmp    %rcx,%rbx
jl     1610 <hessian_boys+0x510>
test   %r15d,%r15d
jg     16d7 <hessian_boys+0x5d7>
jmp    11b0 <hessian_boys+0xb0>
nop
mov    -0x18(%rsp),%r11
mov    -0x80(%rsp),%r15
mov    -0x5c(%rsp),%esi
test   %r15d,%r15d
jle    11b0 <hessian_boys+0xb0>
mov    -0x70(%rsp),%rbp
mov    %ebp,%eax
imul   %r12d,%eax
lea    (%rax,%r15,1),%edi
mov    -0x78(%rsp),%rcx
add    %r15d,%ecx
add    %ebp,%eax
movslq %edi,%rdi
movslq %ecx,%rbp
cltq
movsd  0x0(%r13,%rdi,8),%xmm4
movhpd (%rdx,%rdi,8),%xmm4
addpd  %xmm4,%xmm4
movsd  0x0(%r13,%rax,8),%xmm5
movhpd (%rdx,%rax,8),%xmm5
movsd  0x0(%r13,%rbp,8),%xmm0
movhpd (%rdx,%rbp,8),%xmm0
mulpd  %xmm9,%xmm5
addpd  %xmm0,%xmm5
movsd  (%r10,%rdi,8),%xmm6
addsd  %xmm6,%xmm6
movsd  (%r10,%rax,8),%xmm7
mulsd  %xmm10,%xmm7
addsd  (%r10,%rbp,8),%xmm7
movslq %esi,%rax
lea    0x0(%r13,%rax,8),%rcx
mov    %rcx,-0x70(%rsp)
lea    (%rdx,%rax,8),%rcx
mov    %rcx,-0x78(%rsp)
lea    (%r10,%rax,8),%rax
mov    %rax,-0x80(%rsp)
mov    -0x10(%rsp),%r8
mov    %r8d,%r15d
mov    %r13,%r14
mov    $0x4,%r13d
mov    $0x2,%ebx
xor    %eax,%eax
xor    %ebp,%ebp
mov    %r10,%r12
movslq %eax,%r9
mov    %ebx,%edi
shr    %edi
mov    %r8d,%r10d
sub    %edi,%r10d
lea    (%r9,%rbp,1),%rdi
movsd  (%r14,%rdi,8),%xmm0
movhpd (%rdx,%rdi,8),%xmm0
movsd  (%r12,%rdi,8),%xmm1
lea    (%rax,%r11,1),%rdi
movsd  (%r14,%rdi,8),%xmm2
movhpd (%rdx,%rdi,8),%xmm2
mulsd  %xmm10,%xmm1
addsd  %xmm7,%xmm1
mulsd  (%r12,%rdi,8),%xmm1
add    %r10d,%r9d
mulpd  %xmm9,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm0,%xmm2
mov    -0x70(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
mov    -0x78(%rsp),%rcx
movhpd (%rcx,%rbp,8),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  %xmm0,%xmm2
mov    -0x80(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movslq %r9d,%rdi
mov    -0x58(%rsp),%rcx
mov    -0x40(%rsp),%rsi
mulsd  (%rsi,%rdi,8),%xmm0
add    $0x1,%rbp
subsd  %xmm0,%xmm3
add    %rcx,%rax
add    %r13d,%ebx
add    $0x2,%r13d
cmp    %rbp,%r15
jne    1780 <hessian_boys+0x680>
jmp    11b0 <hessian_boys+0xb0>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @hessian_boys(i32 %0, double* %1, double* %2, double* %3, double* nocapture %4, double* nocapture writeonly %5) {
%7 = add nsw i32 %0, -1
%8 = mul nsw i32 %7, %0
%9 = sdiv i32 %8, 2
%10 = icmp sgt i32 %8, 1
br i1 %10, label %11, label %437
11: ; preds = %6
%12 = sub nsw i32 0, %0
%13 = sitofp i32 %12 to double
%14 = sext i32 %0 to i64
%15 = zext i32 %9 to i64
br label %16
16: ; preds = %11, %430
%17 = phi i64 [ 0, %11 ], [ %434, %430 ]
%18 = phi i32 [ 1, %11 ], [ %435, %430 ]
%19 = trunc i64 %17 to i32
%20 = xor i32 %19, -1
%21 = add nsw i32 %9, %20
br label %22
22: ; preds = %22, %16
%23 = phi i32 [ 2, %16 ], [ %28, %22 ]
%24 = add nsw i32 %23, -1
%25 = mul nsw i32 %24, %23
%26 = sdiv i32 %25, 2
%27 = icmp sgt i32 %26, %21
%28 = add nuw nsw i32 %23, 1
br i1 %27, label %29, label %22
29: ; preds = %22
%30 = sub i32 %0, %23
%31 = mul i32 %30, %0
%32 = sub nsw i32 %19, %31
%33 = add i32 %30, 1
%34 = add nsw i32 %30, 2
%35 = mul nsw i32 %33, %34
%36 = sdiv i32 %35, 2
%37 = add nsw i32 %36, %32
%38 = icmp slt i32 %33, %0
br i1 %38, label %39, label %78
39: ; preds = %29
%40 = mul nsw i32 %37, %0
%41 = add nsw i32 %40, %30
%42 = add nsw i32 %31, %30
%43 = add nsw i32 %40, %37
%44 = sext i32 %41 to i64
%45 = getelementptr inbounds double, double* %1, i64 %44
%46 = load double, double* %45
%47 = sext i32 %42 to i64
%48 = getelementptr inbounds double, double* %1, i64 %47
%49 = load double, double* %48
%50 = sext i32 %43 to i64
%51 = getelementptr inbounds double, double* %1, i64 %50
%52 = load double, double* %51
%53 = getelementptr inbounds double, double* %2, i64 %44
%54 = load double, double* %53
%55 = insertelement <2 x double> poison, double %46, i64 0
%56 = insertelement <2 x double> %55, double %54, i64 1
%57 = fmul <2 x double> %56, <double 2.000000e+00, double 2.000000e+00>
%58 = getelementptr inbounds double, double* %2, i64 %47
%59 = load double, double* %58
%60 = getelementptr inbounds double, double* %2, i64 %50
%61 = load double, double* %60
%62 = insertelement <2 x double> poison, double %52, i64 0
%63 = insertelement <2 x double> %62, double %61, i64 1
%64 = insertelement <2 x double> poison, double %49, i64 0
%65 = insertelement <2 x double> %64, double %59, i64 1
%66 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %63, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %65)
%67 = getelementptr inbounds double, double* %3, i64 %44
%68 = load double, double* %67
%69 = fmul double %68, 2.000000e+00
%70 = getelementptr inbounds double, double* %3, i64 %47
%71 = load double, double* %70
%72 = getelementptr inbounds double, double* %3, i64 %50
%73 = load double, double* %72
%74 = tail call double @llvm.fmuladd.f64(double %73, double -5.000000e-01, double %71)
%75 = sub i32 %19, %37
%76 = sext i32 %33 to i64
%77 = sext i32 %37 to i64
br label %119
78: ; preds = %119, %29
%79 = phi double [ 0.000000e+00, %29 ], [ %168, %119 ]
%80 = icmp sgt i32 %37, 0
br i1 %80, label %81, label %230
81: ; preds = %78
%82 = mul nsw i32 %37, %0
%83 = add nsw i32 %82, %30
%84 = add nsw i32 %82, %37
%85 = add nsw i32 %31, %30
%86 = sext i32 %83 to i64
%87 = getelementptr inbounds double, double* %1, i64 %86
%88 = load double, double* %87
%89 = sext i32 %84 to i64
%90 = getelementptr inbounds double, double* %1, i64 %89
%91 = load double, double* %90
%92 = sext i32 %85 to i64
%93 = getelementptr inbounds double, double* %1, i64 %92
%94 = load double, double* %93
%95 = getelementptr inbounds double, double* %2, i64 %86
%96 = load double, double* %95
%97 = insertelement <2 x double> poison, double %88, i64 0
%98 = insertelement <2 x double> %97, double %96, i64 1
%99 = fmul <2 x double> %98, <double 2.000000e+00, double 2.000000e+00>
%100 = getelementptr inbounds double, double* %2, i64 %89
%101 = load double, double* %100
%102 = getelementptr inbounds double, double* %2, i64 %92
%103 = load double, double* %102
%104 = insertelement <2 x double> poison, double %94, i64 0
%105 = insertelement <2 x double> %104, double %103, i64 1
%106 = insertelement <2 x double> poison, double %91, i64 0
%107 = insertelement <2 x double> %106, double %101, i64 1
%108 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %105, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %107)
%109 = getelementptr inbounds double, double* %3, i64 %86
%110 = load double, double* %109
%111 = fmul double %110, 2.000000e+00
%112 = getelementptr inbounds double, double* %3, i64 %89
%113 = load double, double* %112
%114 = getelementptr inbounds double, double* %3, i64 %92
%115 = load double, double* %114
%116 = tail call double @llvm.fmuladd.f64(double %115, double -5.000000e-01, double %113)
%117 = sext i32 %82 to i64
%118 = zext i32 %37 to i64
br label %172
119: ; preds = %39, %119
%120 = phi i64 [ %76, %39 ], [ %169, %119 ]
%121 = phi double [ 0.000000e+00, %39 ], [ %168, %119 ]
%122 = trunc i64 %120 to i32
%123 = mul nsw i64 %120, %14
%124 = mul nsw i32 %122, %0
%125 = add nsw i32 %124, %30
%126 = add nsw i64 %123, %77
%127 = sext i32 %124 to i64
%128 = add nsw i64 %120, %127
%129 = sext i32 %125 to i64
%130 = getelementptr inbounds double, double* %1, i64 %129
%131 = load double, double* %130
%132 = getelementptr inbounds double, double* %1, i64 %126
%133 = load double, double* %132
%134 = getelementptr inbounds double, double* %1, i64 %128
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %2, i64 %129
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %2, i64 %126
%139 = load double, double* %138
%140 = getelementptr inbounds double, double* %2, i64 %128
%141 = load double, double* %140
%142 = insertelement <2 x double> poison, double %135, i64 0
%143 = insertelement <2 x double> %142, double %141, i64 1
%144 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %143, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %66)
%145 = insertelement <2 x double> poison, double %133, i64 0
%146 = insertelement <2 x double> %145, double %139, i64 1
%147 = fmul <2 x double> %146, %144
%148 = insertelement <2 x double> poison, double %131, i64 0
%149 = insertelement <2 x double> %148, double %137, i64 1
%150 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %57, <2 x double> %149, <2 x double> %147)
%151 = shufflevector <2 x double> %150, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%152 = fadd <2 x double> %150, %151
%153 = extractelement <2 x double> %152, i64 0
%154 = getelementptr inbounds double, double* %3, i64 %129
%155 = load double, double* %154
%156 = getelementptr inbounds double, double* %3, i64 %126
%157 = load double, double* %156
%158 = getelementptr inbounds double, double* %3, i64 %128
%159 = load double, double* %158
%160 = tail call double @llvm.fmuladd.f64(double %159, double -5.000000e-01, double %74)
%161 = fmul double %157, %160
%162 = tail call double @llvm.fmuladd.f64(double %69, double %155, double %161)
%163 = fadd double %153, %162
%164 = add i32 %75, %122
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %4, i64 %165
%167 = load double, double* %166
%168 = tail call double @llvm.fmuladd.f64(double %163, double %167, double %121)
%169 = add nsw i64 %120, 1
%170 = trunc i64 %169 to i32
%171 = icmp eq i32 %170, %0
br i1 %171, label %78, label %119
172: ; preds = %81, %172
%173 = phi i64 [ 0, %81 ], [ %216, %172 ]
%174 = phi double [ %79, %81 ], [ %228, %172 ]
%175 = trunc i64 %173 to i32
%176 = add nsw i64 %173, %117
%177 = mul nsw i32 %175, %0
%178 = add nsw i32 %177, %30
%179 = sext i32 %177 to i64
%180 = add nsw i64 %173, %179
%181 = getelementptr inbounds double, double* %1, i64 %176
%182 = load double, double* %181
%183 = sext i32 %178 to i64
%184 = getelementptr inbounds double, double* %1, i64 %183
%185 = load double, double* %184
%186 = getelementptr inbounds double, double* %1, i64 %180
%187 = load double, double* %186
%188 = getelementptr inbounds double, double* %2, i64 %176
%189 = load double, double* %188
%190 = getelementptr inbounds double, double* %2, i64 %183
%191 = load double, double* %190
%192 = getelementptr inbounds double, double* %2, i64 %180
%193 = load double, double* %192
%194 = insertelement <2 x double> poison, double %187, i64 0
%195 = insertelement <2 x double> %194, double %193, i64 1
%196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %195, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %108)
%197 = insertelement <2 x double> poison, double %185, i64 0
%198 = insertelement <2 x double> %197, double %191, i64 1
%199 = fmul <2 x double> %198, %196
%200 = insertelement <2 x double> poison, double %182, i64 0
%201 = insertelement <2 x double> %200, double %189, i64 1
%202 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %201, <2 x double> %199)
%203 = shufflevector <2 x double> %202, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%204 = fadd <2 x double> %202, %203
%205 = extractelement <2 x double> %204, i64 0
%206 = getelementptr inbounds double, double* %3, i64 %176
%207 = load double, double* %206
%208 = getelementptr inbounds double, double* %3, i64 %183
%209 = load double, double* %208
%210 = getelementptr inbounds double, double* %3, i64 %180
%211 = load double, double* %210
%212 = tail call double @llvm.fmuladd.f64(double %211, double -5.000000e-01, double %116)
%213 = fmul double %209, %212
%214 = tail call double @llvm.fmuladd.f64(double %111, double %207, double %213)
%215 = fadd double %205, %214
%216 = add nuw nsw i64 %173, 1
%217 = add nuw nsw i32 %175, 2
%218 = trunc i64 %216 to i32
%219 = mul nsw i32 %217, %218
%220 = lshr i32 %219, 1
%221 = trunc i64 %173 to i32
%222 = mul i32 %221, %0
%223 = add i32 %222, %37
%224 = sub i32 %223, %220
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %4, i64 %225
%227 = load double, double* %226
%228 = tail call double @llvm.fmuladd.f64(double %215, double %227, double %174)
%229 = icmp ult i64 %216, %118
br i1 %229, label %172, label %230
230: ; preds = %172, %78
%231 = phi double [ %79, %78 ], [ %228, %172 ]
%232 = add nsw i32 %37, 1
%233 = icmp slt i32 %232, %0
br i1 %233, label %234, label %278
234: ; preds = %230
%235 = mul nsw i32 %37, %0
%236 = add nsw i32 %235, %30
%237 = add nsw i32 %235, %37
%238 = add nsw i32 %31, %30
%239 = sext i32 %236 to i64
%240 = getelementptr inbounds double, double* %1, i64 %239
%241 = load double, double* %240
%242 = sext i32 %237 to i64
%243 = getelementptr inbounds double, double* %1, i64 %242
%244 = load double, double* %243
%245 = sext i32 %238 to i64
%246 = getelementptr inbounds double, double* %1, i64 %245
%247 = load double, double* %246
%248 = getelementptr inbounds double, double* %2, i64 %239
%249 = load double, double* %248
%250 = insertelement <2 x double> poison, double %241, i64 0
%251 = insertelement <2 x double> %250, double %249, i64 1
%252 = fmul <2 x double> %251, <double 2.000000e+00, double 2.000000e+00>
%253 = getelementptr inbounds double, double* %2, i64 %242
%254 = load double, double* %253
%255 = getelementptr inbounds double, double* %2, i64 %245
%256 = load double, double* %255
%257 = insertelement <2 x double> poison, double %247, i64 0
%258 = insertelement <2 x double> %257, double %256, i64 1
%259 = insertelement <2 x double> poison, double %244, i64 0
%260 = insertelement <2 x double> %259, double %254, i64 1
%261 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %258, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %260)
%262 = getelementptr inbounds double, double* %3, i64 %239
%263 = load double, double* %262
%264 = fmul double %263, 2.000000e+00
%265 = getelementptr inbounds double, double* %3, i64 %242
%266 = load double, double* %265
%267 = getelementptr inbounds double, double* %3, i64 %245
%268 = load double, double* %267
%269 = tail call double @llvm.fmuladd.f64(double %268, double -5.000000e-01, double %266)
%270 = add nsw i32 %37, 2
%271 = mul nsw i32 %232, %270
%272 = sdiv i32 %271, -2
%273 = add i32 %272, %235
%274 = add i32 %36, %18
%275 = sub i32 %274, %31
%276 = sext i32 %275 to i64
%277 = sext i32 %37 to i64
br label %320
278: ; preds = %320, %230
%279 = phi double [ %231, %230 ], [ %370, %320 ]
%280 = icmp sgt i32 %30, 0
br i1 %280, label %281, label %430
281: ; preds = %278
%282 = mul nsw i32 %37, %0
%283 = add nsw i32 %282, %30
%284 = add nsw i32 %31, %30
%285 = add nsw i32 %282, %37
%286 = sext i32 %283 to i64
%287 = getelementptr inbounds double, double* %1, i64 %286
%288 = load double, double* %287
%289 = sext i32 %284 to i64
%290 = getelementptr inbounds double, double* %1, i64 %289
%291 = load double, double* %290
%292 = sext i32 %285 to i64
%293 = getelementptr inbounds double, double* %1, i64 %292
%294 = load double, double* %293
%295 = getelementptr inbounds double, double* %2, i64 %286
%296 = load double, double* %295
%297 = insertelement <2 x double> poison, double %288, i64 0
%298 = insertelement <2 x double> %297, double %296, i64 1
%299 = fmul <2 x double> %298, <double 2.000000e+00, double 2.000000e+00>
%300 = getelementptr inbounds double, double* %2, i64 %289
%301 = load double, double* %300
%302 = getelementptr inbounds double, double* %2, i64 %292
%303 = load double, double* %302
%304 = insertelement <2 x double> poison, double %294, i64 0
%305 = insertelement <2 x double> %304, double %303, i64 1
%306 = insertelement <2 x double> poison, double %291, i64 0
%307 = insertelement <2 x double> %306, double %301, i64 1
%308 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %305, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %307)
%309 = getelementptr inbounds double, double* %3, i64 %286
%310 = load double, double* %309
%311 = fmul double %310, 2.000000e+00
%312 = getelementptr inbounds double, double* %3, i64 %289
%313 = load double, double* %312
%314 = getelementptr inbounds double, double* %3, i64 %292
%315 = load double, double* %314
%316 = tail call double @llvm.fmuladd.f64(double %315, double -5.000000e-01, double %313)
%317 = sext i32 %31 to i64
%318 = sext i32 %37 to i64
%319 = zext i32 %30 to i64
br label %373
320: ; preds = %234, %320
%321 = phi i64 [ %276, %234 ], [ %371, %320 ]
%322 = phi double [ %231, %234 ], [ %370, %320 ]
%323 = trunc i64 %321 to i32
%324 = mul nsw i64 %321, %14
%325 = mul nsw i32 %323, %0
%326 = add nsw i64 %324, %277
%327 = add nsw i32 %325, %30
%328 = sext i32 %325 to i64
%329 = add nsw i64 %321, %328
%330 = getelementptr inbounds double, double* %1, i64 %326
%331 = load double, double* %330
%332 = sext i32 %327 to i64
%333 = getelementptr inbounds double, double* %1, i64 %332
%334 = load double, double* %333
%335 = getelementptr inbounds double, double* %1, i64 %329
%336 = load double, double* %335
%337 = getelementptr inbounds double, double* %2, i64 %326
%338 = load double, double* %337
%339 = getelementptr inbounds double, double* %2, i64 %332
%340 = load double, double* %339
%341 = getelementptr inbounds double, double* %2, i64 %329
%342 = load double, double* %341
%343 = insertelement <2 x double> poison, double %336, i64 0
%344 = insertelement <2 x double> %343, double %342, i64 1
%345 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %261)
%346 = insertelement <2 x double> poison, double %334, i64 0
%347 = insertelement <2 x double> %346, double %340, i64 1
%348 = fmul <2 x double> %347, %345
%349 = insertelement <2 x double> poison, double %331, i64 0
%350 = insertelement <2 x double> %349, double %338, i64 1
%351 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %252, <2 x double> %350, <2 x double> %348)
%352 = shufflevector <2 x double> %351, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%353 = fadd <2 x double> %351, %352
%354 = extractelement <2 x double> %353, i64 0
%355 = getelementptr inbounds double, double* %3, i64 %326
%356 = load double, double* %355
%357 = getelementptr inbounds double, double* %3, i64 %332
%358 = load double, double* %357
%359 = getelementptr inbounds double, double* %3, i64 %329
%360 = load double, double* %359
%361 = tail call double @llvm.fmuladd.f64(double %360, double -5.000000e-01, double %269)
%362 = fmul double %358, %361
%363 = tail call double @llvm.fmuladd.f64(double %264, double %356, double %362)
%364 = fadd double %354, %363
%365 = add i32 %273, %323
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %4, i64 %366
%368 = load double, double* %367
%369 = fneg double %364
%370 = tail call double @llvm.fmuladd.f64(double %369, double %368, double %322)
%371 = add nsw i64 %321, 1
%372 = icmp slt i64 %371, %14
br i1 %372, label %320, label %278
373: ; preds = %281, %373
%374 = phi i64 [ 0, %281 ], [ %418, %373 ]
%375 = phi double [ %279, %281 ], [ %428, %373 ]
%376 = trunc i64 %374 to i32
%377 = add nsw i64 %374, %317
%378 = mul nsw i64 %374, %14
%379 = mul nsw i32 %376, %0
%380 = add nsw i64 %378, %318
%381 = sext i32 %379 to i64
%382 = add nsw i64 %374, %381
%383 = getelementptr inbounds double, double* %1, i64 %377
%384 = load double, double* %383
%385 = getelementptr inbounds double, double* %1, i64 %380
%386 = load double, double* %385
%387 = getelementptr inbounds double, double* %1, i64 %382
%388 = load double, double* %387
%389 = getelementptr inbounds double, double* %2, i64 %377
%390 = load double, double* %389
%391 = getelementptr inbounds double, double* %2, i64 %380
%392 = load double, double* %391
%393 = getelementptr inbounds double, double* %2, i64 %382
%394 = load double, double* %393
%395 = insertelement <2 x double> poison, double %388, i64 0
%396 = insertelement <2 x double> %395, double %394, i64 1
%397 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %396, <2 x double> <double -5.000000e-01, double -5.000000e-01>, <2 x double> %308)
%398 = insertelement <2 x double> poison, double %386, i64 0
%399 = insertelement <2 x double> %398, double %392, i64 1
%400 = fmul <2 x double> %399, %397
%401 = insertelement <2 x double> poison, double %384, i64 0
%402 = insertelement <2 x double> %401, double %390, i64 1
%403 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %299, <2 x double> %402, <2 x double> %400)
%404 = shufflevector <2 x double> %403, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%405 = fadd <2 x double> %403, %404
%406 = extractelement <2 x double> %405, i64 0
%407 = getelementptr inbounds double, double* %3, i64 %377
%408 = load double, double* %407
%409 = getelementptr inbounds double, double* %3, i64 %380
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %3, i64 %382
%412 = load double, double* %411
%413 = tail call double @llvm.fmuladd.f64(double %412, double -5.000000e-01, double %316)
%414 = fmul double %410, %413
%415 = tail call double @llvm.fmuladd.f64(double %311, double %408, double %414)
%416 = fadd double %406, %415
%417 = add nsw i32 %379, %30
%418 = add nuw nsw i64 %374, 1
%419 = add nuw nsw i32 %376, 2
%420 = trunc i64 %418 to i32
%421 = mul nsw i32 %419, %420
%422 = lshr i32 %421, 1
%423 = sub i32 %417, %422
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds double, double* %4, i64 %424
%426 = load double, double* %425
%427 = fneg double %416
%428 = tail call double @llvm.fmuladd.f64(double %427, double %426, double %375)
%429 = icmp eq i64 %418, %319
br i1 %429, label %430, label %373
430: ; preds = %373, %278
%431 = phi double [ %279, %278 ], [ %428, %373 ]
%432 = fmul double %431, %13
%433 = getelementptr inbounds double, double* %5, i64 %17
store double %432, double* %433
%434 = add nuw nsw i64 %17, 1
%435 = add nuw nsw i32 %18, 1
%436 = icmp eq i64 %434, %15
br i1 %436, label %437, label %16
437: ; preds = %430, %6
ret void
}