#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
size_t Blocal_index(int, int, int, int, int, int, int, int, int, int const,
                    int const, int const, int const);
size_t index_2d(int, int const, int const);
size_t index_3d(int, int, int, int const, int const);
void make_hex_dibaryon_correlator(
    double *C_re, double *C_im, const double *B1_Blocal_re,
    const double *B1_Blocal_im, const double *B2_Blocal_re,
    const double *B2_Blocal_im, const int *perms, const int *sigs,
    const double overall_weight, const int *src_color_weights,
    const int *src_spin_weights, const double *src_weights,
    const double *hex_src_psi_re, const double *hex_src_psi_im, const int Nc,
    const int Ns, const int Vsrc, const int Vsnk, const int Nt, const int Nw,
    const int Nq, const int NsrcHex, const int Nsnk, const int Nperms) {
  int iC1, iS1, jC1, jS1, kC1, kS1, iC2, iS2, jC2, jS2, kC2, kS2, x, t, wnum,
      nperm, b, n, m, y;
  int Nb = 2;
  int Nw2 = Nw * Nw;
  double term_re, term_im;
  int src_1_nq[Nb];
  int src_2_nq[Nb];
  int src_3_nq[Nb];
  int src_1_b[Nb];
  int src_2_b[Nb];
  int src_3_b[Nb];
  int src_1[Nb];
  int src_2[Nb];
  int src_3[Nb];
  for (nperm = 0; nperm < Nperms; nperm++) {
    for (b = 0; b < Nb; b++) {
      src_1[b] = perms[index_2d(nperm, Nq * b + 0, 2 * Nq)] - 1;
      src_2[b] = perms[index_2d(nperm, Nq * b + 1, 2 * Nq)] - 1;
      src_3[b] = perms[index_2d(nperm, Nq * b + 2, 2 * Nq)] - 1;
      src_1_b[b] = (src_1[b] - src_1[b] % Nq) / Nq;
      src_2_b[b] = (src_2[b] - src_2[b] % Nq) / Nq;
      src_3_b[b] = (src_3[b] - src_3[b] % Nq) / Nq;
      src_1_nq[b] = src_1[b] % Nq;
      src_2_nq[b] = src_2[b] % Nq;
      src_3_nq[b] = src_3[b] % Nq;
    }
    for (wnum = 0; wnum < Nw2; wnum++) {
      iC1 = src_color_weights[index_3d(src_1_b[0], wnum, src_1_nq[0], Nw2, Nq)];
      iS1 = src_spin_weights[index_3d(src_1_b[0], wnum, src_1_nq[0], Nw2, Nq)];
      jC1 = src_color_weights[index_3d(src_2_b[0], wnum, src_2_nq[0], Nw2, Nq)];
      jS1 = src_spin_weights[index_3d(src_2_b[0], wnum, src_2_nq[0], Nw2, Nq)];
      kC1 = src_color_weights[index_3d(src_3_b[0], wnum, src_3_nq[0], Nw2, Nq)];
      kS1 = src_spin_weights[index_3d(src_3_b[0], wnum, src_3_nq[0], Nw2, Nq)];
      iC2 = src_color_weights[index_3d(src_1_b[1], wnum, src_1_nq[1], Nw2, Nq)];
      iS2 = src_spin_weights[index_3d(src_1_b[1], wnum, src_1_nq[1], Nw2, Nq)];
      jC2 = src_color_weights[index_3d(src_2_b[1], wnum, src_2_nq[1], Nw2, Nq)];
      jS2 = src_spin_weights[index_3d(src_2_b[1], wnum, src_2_nq[1], Nw2, Nq)];
      kC2 = src_color_weights[index_3d(src_3_b[1], wnum, src_3_nq[1], Nw2, Nq)];
      kS2 = src_spin_weights[index_3d(src_3_b[1], wnum, src_3_nq[1], Nw2, Nq)];
      for (t = 0; t < Nt; t++) {
        for (y = 0; y < Vsrc; y++) {
          for (n = 0; n < Nsnk; n++) {
            term_re =
                sigs[nperm] * overall_weight * src_weights[wnum] *
                (B1_Blocal_re[Blocal_index(t, iC1, iS1, kC1, kS1, y, jC1, jS1,
                                           n, Nc, Ns, Vsrc, Nsnk)] *
                     B2_Blocal_re[Blocal_index(t, iC2, iS2, kC2, kS2, y, jC2,
                                               jS2, n, Nc, Ns, Vsrc, Nsnk)] -
                 B1_Blocal_im[Blocal_index(t, iC1, iS1, kC1, kS1, y, jC1, jS1,
                                           n, Nc, Ns, Vsrc, Nsnk)] *
                     B2_Blocal_im[Blocal_index(t, iC2, iS2, kC2, kS2, y, jC2,
                                               jS2, n, Nc, Ns, Vsrc, Nsnk)]);
            term_im =
                sigs[nperm] * overall_weight * src_weights[wnum] *
                (B1_Blocal_re[Blocal_index(t, iC1, iS1, kC1, kS1, y, jC1, jS1,
                                           n, Nc, Ns, Vsrc, Nsnk)] *
                     B2_Blocal_im[Blocal_index(t, iC2, iS2, kC2, kS2, y, jC2,
                                               jS2, n, Nc, Ns, Vsrc, Nsnk)] +
                 B1_Blocal_im[Blocal_index(t, iC1, iS1, kC1, kS1, y, jC1, jS1,
                                           n, Nc, Ns, Vsrc, Nsnk)] *
                     B2_Blocal_re[Blocal_index(t, iC2, iS2, kC2, kS2, y, jC2,
                                               jS2, n, Nc, Ns, Vsrc, Nsnk)]);
            for (m = 0; m < NsrcHex; m++) {
              C_re[index_3d(m, n, t, Nsnk, Nt)] +=
                  hex_src_psi_re[index_2d(y, m, NsrcHex)] * term_re -
                  hex_src_psi_im[index_2d(y, m, NsrcHex)] * term_im;
              C_im[index_3d(m, n, t, Nsnk, Nt)] +=
                  hex_src_psi_re[index_2d(y, m, NsrcHex)] * term_im +
                  hex_src_psi_im[index_2d(y, m, NsrcHex)] * term_re;
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<make_hex_dibaryon_correlator>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x2a0,%rsp
mov    0x90(%rbp),%eax
mov    0x88(%rbp),%eax
mov    0x80(%rbp),%eax
mov    0x78(%rbp),%eax
mov    0x70(%rbp),%eax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
movsd  %xmm0,-0x58(%rbp)
movl   $0x2,-0xac(%rbp)
mov    0x70(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0xc8(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x158(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd0(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x150(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd8(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x148(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe0(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x140(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x138(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf0(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x130(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x128(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x100(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x108(%rbp)
mov    -0xac(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x110(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0x90(%rbp),%eax
jge    20f4 <make_hex_dibaryon_correlator+0xfc4>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xac(%rbp),%eax
jge    159f <make_hex_dibaryon_correlator+0x46f>
mov    0x10(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x98(%rbp),%edi
mov    0x78(%rbp),%esi
imul   -0x9c(%rbp),%esi
add    $0x0,%esi
mov    0x78(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x180(%rbp),%rcx
mov    %rax,%rdx
mov    -0x128(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x98(%rbp),%edi
mov    0x78(%rbp),%esi
imul   -0x9c(%rbp),%esi
add    $0x1,%esi
mov    0x78(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x178(%rbp),%rcx
mov    %rax,%rdx
mov    -0x120(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x98(%rbp),%edi
mov    0x78(%rbp),%esi
imul   -0x9c(%rbp),%esi
add    $0x2,%esi
mov    0x78(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x170(%rbp),%rsi
mov    -0x150(%rbp),%rcx
mov    -0x118(%rbp),%rdx
mov    %rax,%rdi
mov    -0x128(%rbp),%rax
mov    (%rsi,%rdi,4),%edi
sub    $0x1,%edi
movslq -0x9c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x164(%rbp)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x164(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0x78(%rbp)
mov    -0x140(%rbp),%rdx
mov    %eax,%edi
mov    -0x120(%rbp),%rax
movslq -0x9c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x160(%rbp)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x160(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0x78(%rbp)
mov    -0x138(%rbp),%rdx
mov    %eax,%edi
mov    -0x118(%rbp),%rax
movslq -0x9c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x15c(%rbp)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x15c(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0x78(%rbp)
mov    -0x130(%rbp),%rdx
mov    %eax,%edi
mov    -0x128(%rbp),%rax
movslq -0x9c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x120(%rbp),%rax
mov    %edx,%edi
mov    -0x158(%rbp),%rdx
movslq -0x9c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x9c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x118(%rbp),%rax
mov    %edx,%esi
movslq -0x9c(%rbp),%rdx
mov    %esi,(%rcx,%rdx,4)
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  0x78(%rbp)
mov    -0x148(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1359 <make_hex_dibaryon_correlator+0x229>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    20db <make_hex_dibaryon_correlator+0xfab>
mov    -0x158(%rbp),%rax
mov    -0x140(%rbp),%rcx
mov    0x20(%rbp),%rdx
mov    %rdx,-0x1e0(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1e0(%rbp),%rdx
mov    -0x140(%rbp),%rcx
mov    %rax,%rsi
mov    -0x158(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x5c(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x1d8(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1d8(%rbp),%rdx
mov    -0x138(%rbp),%rcx
mov    %rax,%rsi
mov    -0x150(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x60(%rbp)
mov    0x20(%rbp),%rdx
mov    %rdx,-0x1d0(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1d0(%rbp),%rdx
mov    -0x138(%rbp),%rcx
mov    %rax,%rsi
mov    -0x150(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x64(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x1c8(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1c8(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    %rax,%rsi
mov    -0x148(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x68(%rbp)
mov    0x20(%rbp),%rdx
mov    %rdx,-0x1c0(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1c0(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    %rax,%rsi
mov    -0x148(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x6c(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x1b8(%rbp)
mov    (%rcx),%edi
mov    -0x94(%rbp),%esi
mov    (%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1b8(%rbp),%rdx
mov    -0x140(%rbp),%rcx
mov    %rax,%rsi
mov    -0x158(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x70(%rbp)
mov    0x20(%rbp),%rdx
mov    %rdx,-0x1b0(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1b0(%rbp),%rdx
mov    -0x140(%rbp),%rcx
mov    %rax,%rsi
mov    -0x158(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x74(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x1a8(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1a8(%rbp),%rdx
mov    -0x138(%rbp),%rcx
mov    %rax,%rsi
mov    -0x150(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x78(%rbp)
mov    0x20(%rbp),%rdx
mov    %rdx,-0x1a0(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1a0(%rbp),%rdx
mov    -0x138(%rbp),%rcx
mov    %rax,%rsi
mov    -0x150(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x7c(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x198(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x198(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    %rax,%rsi
mov    -0x148(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x80(%rbp)
mov    0x20(%rbp),%rdx
mov    %rdx,-0x190(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x190(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    %rax,%rsi
mov    -0x148(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x84(%rbp)
mov    0x28(%rbp),%rdx
mov    %rdx,-0x188(%rbp)
mov    0x4(%rcx),%edi
mov    -0x94(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb0(%rbp),%ecx
mov    0x78(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x188(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    0x68(%rbp),%eax
jge    20c2 <make_hex_dibaryon_correlator+0xf92>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    20a9 <make_hex_dibaryon_correlator+0xf79>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    0x88(%rbp),%eax
jge    2090 <make_hex_dibaryon_correlator+0xf60>
mov    0x18(%rbp),%rax
movslq -0x98(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x64(%rbp),%r12d
mov    -0x68(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x260(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x258(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x64(%rbp),%r12d
mov    -0x68(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x250(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x248(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
movsd  -0x248(%rbp),%xmm2
ff
movsd  -0x240(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm3
ff
movsd  -0x230(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x228(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x98(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  -0x58(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x64(%rbp),%r12d
mov    -0x68(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x220(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x218(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x64(%rbp),%r12d
mov    -0x68(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x210(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x90(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    -0x78(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0xa8(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0xa0(%rbp),%r14d
mov    0x48(%rbp),%ebx
mov    0x50(%rbp),%r11d
mov    0x58(%rbp),%r10d
mov    0x88(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <Blocal_index@plt>
movsd  -0x208(%rbp),%xmm2
ff
movsd  -0x200(%rbp),%xmm1
ff
movsd  -0x1f8(%rbp),%xmm3
ff
movsd  -0x1f0(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x1e8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x80(%rbp),%eax
jge    2077 <make_hex_dibaryon_correlator+0xf47>
mov    0x38(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0xa8(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x80(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x2c0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    0x40(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
mov    -0xa8(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x80(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x2b8(%rbp),%xmm0
ff
movsd  -0x2b0(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x2a8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0xa4(%rbp),%edi
mov    -0xa0(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    0x88(%rbp),%ecx
mov    0x68(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x2a0(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x298(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0xa8(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x80(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x290(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x280(%rbp)
ff
mov    0x40(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0xa8(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x80(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x288(%rbp),%xmm0
ff
movsd  -0x280(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x278(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xb8(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0xa4(%rbp),%edi
mov    -0xa0(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    0x88(%rbp),%ecx
mov    0x68(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x270(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x268(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1e66 <make_hex_dibaryon_correlator+0xd36>
jmp    207c <make_hex_dibaryon_correlator+0xf4c>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1921 <make_hex_dibaryon_correlator+0x7f1>
jmp    2095 <make_hex_dibaryon_correlator+0xf65>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1908 <make_hex_dibaryon_correlator+0x7d8>
jmp    20ae <make_hex_dibaryon_correlator+0xf7e>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    18ef <make_hex_dibaryon_correlator+0x7bf>
jmp    20c7 <make_hex_dibaryon_correlator+0xf97>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    15a9 <make_hex_dibaryon_correlator+0x479>
jmp    20e0 <make_hex_dibaryon_correlator+0xfb0>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    133d <make_hex_dibaryon_correlator+0x20d>
mov    -0xc8(%rbp),%rax
mov    %rax,%rsp
lea    -0x20(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_hex_dibaryon_correlator>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movsd  %xmm0,0xf8(%rsp)
mov    %r9,0xf0(%rsp)
mov    %r8,0xd8(%rsp)
mov    %rcx,0xe8(%rsp)
mov    %rdx,0xe0(%rsp)
mov    %rsi,0x120(%rsp)
mov    %rdi,0x118(%rsp)
mov    0x1e0(%rsp),%eax
test   %eax,%eax
jle    1b44 <make_hex_dibaryon_correlator+0xa14>
mov    0x1c8(%rsp),%ecx
mov    0x1b8(%rsp),%r12d
mov    0x1c0(%rsp),%edx
imul   %edx,%edx
mov    %eax,%eax
mov    %rax,0x100(%rsp)
lea    (%rcx,%rcx,1),%eax
mov    %eax,0xa4(%rsp)
lea    0x1(%rcx),%eax
mov    %eax,0xa0(%rsp)
lea    0x2(%rcx),%eax
mov    %eax,0x9c(%rsp)
mov    %edx,0x3c(%rsp)
mov    %edx,%eax
mov    %rax,0x108(%rsp)
xor    %ebp,%ebp
jmp    11f7 <make_hex_dibaryon_correlator+0xc7>
nopl   0x0(%rax)
mov    0x68(%rsp),%rbp
add    $0x1,%rbp
cmp    0x100(%rsp),%rbp
je     1b44 <make_hex_dibaryon_correlator+0xa14>
mov    %ebp,%edi
xor    %esi,%esi
mov    0xa4(%rsp),%r13d
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x160(%rsp),%r14
mov    (%r14,%rax,4),%r15d
add    $0xffffffff,%r15d
mov    %ebp,%edi
mov    $0x1,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r14,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %ebp,%edi
mov    $0x2,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r14,%rax,4),%ecx
mov    %r15d,%eax
cltd
mov    0x1c8(%rsp),%r15d
idiv   %r15d
mov    %edx,0xd4(%rsp)
mov    %eax,0xd0(%rsp)
mov    %ebx,%eax
cltd
idiv   %r15d
mov    %eax,0xcc(%rsp)
mov    %edx,0xc8(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
idiv   %r15d
mov    %edx,0xc4(%rsp)
mov    %eax,0xc0(%rsp)
mov    %rbp,%rbx
mov    %ebx,%edi
mov    %r15d,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r14,%rax,4),%ebp
add    $0xffffffff,%ebp
mov    %ebx,%edi
mov    %rbx,%r14
mov    0xa0(%rsp),%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x160(%rsp),%rcx
mov    (%rcx,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %r14,0x68(%rsp)
mov    %r14d,%edi
mov    0x9c(%rsp),%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x160(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    %ebp,%eax
cltd
idiv   %r15d
mov    %edx,0xbc(%rsp)
mov    %eax,0xb8(%rsp)
mov    %ebx,%eax
cltd
idiv   %r15d
mov    %eax,0xb4(%rsp)
mov    %edx,0xb0(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
idiv   %r15d
mov    %edx,0xac(%rsp)
mov    %eax,0xa8(%rsp)
cmpl   $0x0,0x3c(%rsp)
je     11e0 <make_hex_dibaryon_correlator+0xb0>
xor    %esi,%esi
jmp    1357 <make_hex_dibaryon_correlator+0x227>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x70(%rsp),%rsi
add    $0x1,%rsi
cmp    0x108(%rsp),%rsi
je     11e0 <make_hex_dibaryon_correlator+0xb0>
mov    0xd0(%rsp),%r13d
mov    %r13d,%edi
mov    0xd4(%rsp),%ebp
mov    %ebp,%edx
mov    0x3c(%rsp),%r15d
mov    %r15d,%ecx
mov    0x1c8(%rsp),%ebx
mov    %rbx,%r8
mov    %rsi,%rbx
call   1030 <index_3d@plt>
mov    0x170(%rsp),%r14
mov    (%r14,%rax,4),%eax
mov    %eax,0x2c(%rsp)
mov    %r13d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
mov    0x1c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x178(%rsp),%rbp
mov    0x0(%rbp,%rax,4),%eax
mov    %eax,0x28(%rsp)
mov    0xcc(%rsp),%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    0xc8(%rsp),%ebp
mov    %ebp,%edx
mov    %r15d,%ecx
mov    0x1c8(%rsp),%r13d
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x170(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x78(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x178(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x50(%rsp)
mov    0xc0(%rsp),%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    0xc4(%rsp),%ebp
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x170(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x24(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x178(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x20(%rsp)
mov    0xb8(%rsp),%ebp
mov    %ebp,%edi
mov    %ebx,%esi
mov    0xbc(%rsp),%r14d
mov    %r14d,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x170(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x1c(%rsp)
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x178(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x38(%rsp)
mov    0xb4(%rsp),%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    0xb0(%rsp),%ebp
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x170(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x48(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x178(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x40(%rsp)
mov    0xa8(%rsp),%ebp
mov    %ebp,%edi
mov    %ebx,%esi
mov    0xac(%rsp),%r14d
mov    %r14d,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
mov    0x170(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x34(%rsp)
mov    %ebp,%edi
mov    %rbx,0x70(%rsp)
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <index_3d@plt>
test   %r12d,%r12d
mov    0x1d8(%rsp),%r13d
jle    1340 <make_hex_dibaryon_correlator+0x210>
mov    0x178(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x18(%rsp)
xor    %eax,%eax
jmp    1598 <make_hex_dibaryon_correlator+0x468>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%eax
add    $0x1,%eax
mov    0x1b8(%rsp),%r12d
cmp    %r12d,%eax
je     1340 <make_hex_dibaryon_correlator+0x210>
mov    %eax,0x30(%rsp)
mov    0x1a8(%rsp),%eax
test   %eax,%eax
jle    1580 <make_hex_dibaryon_correlator+0x450>
xor    %ecx,%ecx
jmp    15c2 <make_hex_dibaryon_correlator+0x492>
nopl   0x0(%rax,%rax,1)
mov    0x14(%rsp),%ecx
add    $0x1,%ecx
mov    0x1a8(%rsp),%eax
cmp    %eax,%ecx
je     1580 <make_hex_dibaryon_correlator+0x450>
mov    %ecx,0x14(%rsp)
test   %r13d,%r13d
jle    15b0 <make_hex_dibaryon_correlator+0x480>
xor    %ebx,%ebx
jmp    15e8 <make_hex_dibaryon_correlator+0x4b8>
nop
mov    0x90(%rsp),%rbx
add    $0x1,%ebx
mov    0x1d8(%rsp),%r13d
cmp    %r13d,%ebx
je     15b0 <make_hex_dibaryon_correlator+0x480>
mov    0x168(%rsp),%rax
mov    0x68(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  0xf8(%rsp),%xmm0
mov    0x180(%rsp),%r14
mov    0x70(%rsp),%rax
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x60(%rsp)
sub    $0x8,%rsp
mov    0x38(%rsp),%edi
mov    %edi,%r14d
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    0x28(%rsp),%r8d
mov    0x1c(%rsp),%r9d
push   %r13
mov    0x1b8(%rsp),%ebp
push   %rbp
mov    0x1b8(%rsp),%r15d
push   %r15
mov    0x1b8(%rsp),%r12d
push   %r12
push   %rbx
mov    0x80(%rsp),%r12
push   %r12
mov    0xb0(%rsp),%r15
push   %r15
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
sub    $0x8,%rsp
mov    %r14d,%r15d
mov    %r14d,%edi
mov    0x24(%rsp),%esi
mov    0x40(%rsp),%edx
mov    0x3c(%rsp),%r14d
mov    %r14d,%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%ebp
mov    %ebp,%r9d
push   %r13
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%r12d
push   %r12
push   %rbx
mov    0x70(%rsp),%rax
push   %rax
mov    0x80(%rsp),%rax
push   %rax
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movsd  0x8(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
sub    $0x8,%rsp
mov    %r15d,%edi
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    0x28(%rsp),%r8d
mov    %ebp,%r9d
push   %r13
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
push   %r12
push   %rbx
mov    %rbx,0xc0(%rsp)
push   0x80(%rsp)
mov    0xb0(%rsp),%r13
push   %r13
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xe8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x88(%rsp)
sub    $0x8,%rsp
mov    %r15d,%edi
mov    0x24(%rsp),%esi
mov    0x40(%rsp),%r12d
mov    %r12d,%edx
mov    %r14d,%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r15d
mov    %r15d,%r9d
mov    0x1e0(%rsp),%ebp
push   %rbp
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
push   %rbx
push   0x70(%rsp)
push   0x80(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xf0(%rsp),%rcx
movsd  0x88(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x88(%rsp)
mov    0x168(%rsp),%rax
mov    0x68(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  0xf8(%rsp),%xmm0
mov    0x180(%rsp),%rax
mov    0x70(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x58(%rsp)
sub    $0x8,%rsp
mov    0x38(%rsp),%ebx
mov    %ebx,%edi
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    0x28(%rsp),%r8d
mov    %r15d,%r9d
push   %rbp
mov    0x1b8(%rsp),%r14d
push   %r14
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
mov    0xb8(%rsp),%r15
push   %r15
push   0x80(%rsp)
push   %r13
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    0x24(%rsp),%esi
mov    %r12d,%edx
mov    0x3c(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r12d
mov    %r12d,%r9d
mov    0x1e0(%rsp),%r13d
push   %r13
push   %r14
mov    0x1b8(%rsp),%ebp
push   %rbp
mov    0x1b8(%rsp),%r14d
push   %r14
push   %r15
push   0x70(%rsp)
push   0x80(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xf0(%rsp),%rcx
movsd  0x80(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    0x34(%rsp),%esi
mov    0x30(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    0x28(%rsp),%r8d
mov    %r12d,%r9d
push   %r13
mov    0x1b8(%rsp),%eax
push   %rax
push   %rbp
push   %r14
push   %r15
push   0x80(%rsp)
push   0xb0(%rsp)
mov    %r15,%rbp
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0xe8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x110(%rsp)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    0x24(%rsp),%esi
mov    %r12d,%r15d
mov    0x40(%rsp),%edx
mov    0x3c(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    %r12d,%r9d
push   %r13
mov    0x1b8(%rsp),%eax
push   %rax
mov    0x1b8(%rsp),%eax
push   %rax
push   %r14
push   %rbp
push   0x70(%rsp)
push   0x80(%rsp)
call   1040 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x1d0(%rsp),%r14d
test   %r14d,%r14d
mov    0x190(%rsp),%r12
mov    0x188(%rsp),%rbp
jle    15d0 <make_hex_dibaryon_correlator+0x4a0>
movsd  0x8(%rsp),%xmm1
subsd  0x88(%rsp),%xmm1
mov    0xd8(%rsp),%rcx
movsd  0x110(%rsp),%xmm2
mulsd  (%rcx,%rax,8),%xmm2
movsd  0x60(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x80(%rsp),%xmm1
addsd  %xmm2,%xmm1
movsd  0x58(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x58(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  (%r12,%rax,8),%xmm0
mulsd  0x58(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mov    %ebx,%edi
mov    0x90(%rsp),%r12
mov    %r12d,%esi
mov    %r15d,%ebp
mov    0x30(%rsp),%r15d
mov    %r15d,%edx
mov    0x1d8(%rsp),%r13d
mov    %r13d,%ecx
mov    0x1b8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x118(%rsp),%rcx
movsd  0x8(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    0x188(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    0x190(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x60(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    0x190(%rsp),%r12
mov    0x1b8(%rsp),%r8d
mov    %ebp,%r15d
mov    %r13d,%ecx
mov    0x188(%rsp),%rbp
call   1030 <index_3d@plt>
mov    0x120(%rsp),%rdx
movsd  0x8(%rsp),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%ebx
cmp    %ebx,%r14d
jne    1a10 <make_hex_dibaryon_correlator+0x8e0>
jmp    15d0 <make_hex_dibaryon_correlator+0x4a0>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @make_hex_dibaryon_correlator(double* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, i32* nocapture %6, i32* nocapture %7, double %8, i32* nocapture %9, i32* nocapture %10, double* nocapture %11, double* nocapture %12, double* nocapture %13, i32 %14, i32 %15, i32 %16, i32 %17, i32 %18, i32 %19, i32 %20, i32 %21, i32 %22, i32 %23) {
%25 = mul i32 %19, %19
%26 = icmp sgt i32 %23, 0
br i1 %26, label %27, label %211
27: ; preds = %24
%28 = shl nsw i32 %20, 1
%29 = icmp eq i32 %25, 0
%30 = icmp sgt i32 %18, 0
%31 = icmp sgt i32 %16, 0
%32 = icmp sgt i32 %22, 0
%33 = icmp sgt i32 %21, 0
%34 = zext i32 %23 to i64
%35 = add nsw i32 %20, 1
%36 = add nsw i32 %20, 2
%37 = zext i32 %25 to i64
br label %38
38: ; preds = %27, %208
%39 = phi i64 [ 0, %27 ], [ %209, %208 ]
%40 = trunc i64 %39 to i32
%41 = tail call i64 @index_2d(i32 %40, i32 0, i32 %28)
%42 = getelementptr inbounds i32, i32* %6, i64 %41
%43 = load i32, i32* %42
%44 = add nsw i32 %43, -1
%45 = tail call i64 @index_2d(i32 %40, i32 1, i32 %28)
%46 = getelementptr inbounds i32, i32* %6, i64 %45
%47 = load i32, i32* %46
%48 = add nsw i32 %47, -1
%49 = tail call i64 @index_2d(i32 %40, i32 2, i32 %28)
%50 = getelementptr inbounds i32, i32* %6, i64 %49
%51 = load i32, i32* %50
%52 = add nsw i32 %51, -1
%53 = sdiv i32 %44, %20
%54 = sdiv i32 %48, %20
%55 = sdiv i32 %52, %20
%56 = srem i32 %44, %20
%57 = srem i32 %48, %20
%58 = srem i32 %52, %20
%59 = tail call i64 @index_2d(i32 %40, i32 %20, i32 %28)
%60 = getelementptr inbounds i32, i32* %6, i64 %59
%61 = load i32, i32* %60
%62 = add nsw i32 %61, -1
%63 = tail call i64 @index_2d(i32 %40, i32 %35, i32 %28)
%64 = getelementptr inbounds i32, i32* %6, i64 %63
%65 = load i32, i32* %64
%66 = add nsw i32 %65, -1
%67 = tail call i64 @index_2d(i32 %40, i32 %36, i32 %28)
%68 = getelementptr inbounds i32, i32* %6, i64 %67
%69 = load i32, i32* %68
%70 = add nsw i32 %69, -1
%71 = sdiv i32 %62, %20
%72 = sdiv i32 %66, %20
%73 = sdiv i32 %70, %20
%74 = srem i32 %62, %20
%75 = srem i32 %66, %20
%76 = srem i32 %70, %20
br i1 %29, label %208, label %77
77: ; preds = %38
%78 = getelementptr inbounds i32, i32* %7, i64 %39
br label %79
79: ; preds = %77, %205
%80 = phi i64 [ 0, %77 ], [ %206, %205 ]
%81 = trunc i64 %80 to i32
%82 = tail call i64 @index_3d(i32 %53, i32 %81, i32 %56, i32 %25, i32 %20)
%83 = getelementptr inbounds i32, i32* %9, i64 %82
%84 = load i32, i32* %83
%85 = tail call i64 @index_3d(i32 %53, i32 %81, i32 %56, i32 %25, i32 %20)
%86 = getelementptr inbounds i32, i32* %10, i64 %85
%87 = load i32, i32* %86
%88 = tail call i64 @index_3d(i32 %54, i32 %81, i32 %57, i32 %25, i32 %20)
%89 = getelementptr inbounds i32, i32* %9, i64 %88
%90 = load i32, i32* %89
%91 = tail call i64 @index_3d(i32 %54, i32 %81, i32 %57, i32 %25, i32 %20)
%92 = getelementptr inbounds i32, i32* %10, i64 %91
%93 = load i32, i32* %92
%94 = tail call i64 @index_3d(i32 %55, i32 %81, i32 %58, i32 %25, i32 %20)
%95 = getelementptr inbounds i32, i32* %9, i64 %94
%96 = load i32, i32* %95
%97 = tail call i64 @index_3d(i32 %55, i32 %81, i32 %58, i32 %25, i32 %20)
%98 = getelementptr inbounds i32, i32* %10, i64 %97
%99 = load i32, i32* %98
%100 = tail call i64 @index_3d(i32 %71, i32 %81, i32 %74, i32 %25, i32 %20)
%101 = getelementptr inbounds i32, i32* %9, i64 %100
%102 = load i32, i32* %101
%103 = tail call i64 @index_3d(i32 %71, i32 %81, i32 %74, i32 %25, i32 %20)
%104 = getelementptr inbounds i32, i32* %10, i64 %103
%105 = load i32, i32* %104
%106 = tail call i64 @index_3d(i32 %72, i32 %81, i32 %75, i32 %25, i32 %20)
%107 = getelementptr inbounds i32, i32* %9, i64 %106
%108 = load i32, i32* %107
%109 = tail call i64 @index_3d(i32 %72, i32 %81, i32 %75, i32 %25, i32 %20)
%110 = getelementptr inbounds i32, i32* %10, i64 %109
%111 = load i32, i32* %110
%112 = tail call i64 @index_3d(i32 %73, i32 %81, i32 %76, i32 %25, i32 %20)
%113 = getelementptr inbounds i32, i32* %9, i64 %112
%114 = load i32, i32* %113
%115 = tail call i64 @index_3d(i32 %73, i32 %81, i32 %76, i32 %25, i32 %20)
%116 = getelementptr inbounds i32, i32* %10, i64 %115
%117 = load i32, i32* %116
br i1 %30, label %118, label %205
118: ; preds = %79
%119 = getelementptr inbounds double, double* %11, i64 %80
br label %120
120: ; preds = %118, %202
%121 = phi i32 [ 0, %118 ], [ %203, %202 ]
br i1 %31, label %122, label %202
122: ; preds = %120, %199
%123 = phi i32 [ %200, %199 ], [ 0, %120 ]
br i1 %32, label %124, label %199
124: ; preds = %122, %196
%125 = phi i32 [ %197, %196 ], [ 0, %122 ]
%126 = load i32, i32* %78
%127 = sitofp i32 %126 to double
%128 = fmul double %127, %8
%129 = load double, double* %119
%130 = fmul double %129, %128
%131 = tail call i64 @Blocal_index(i32 %121, i32 %84, i32 %87, i32 %96, i32 %99, i32 %123, i32 %90, i32 %93, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%132 = getelementptr inbounds double, double* %2, i64 %131
%133 = load double, double* %132
%134 = tail call i64 @Blocal_index(i32 %121, i32 %102, i32 %105, i32 %114, i32 %117, i32 %123, i32 %108, i32 %111, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%135 = getelementptr inbounds double, double* %4, i64 %134
%136 = load double, double* %135
%137 = tail call i64 @Blocal_index(i32 %121, i32 %84, i32 %87, i32 %96, i32 %99, i32 %123, i32 %90, i32 %93, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%138 = getelementptr inbounds double, double* %3, i64 %137
%139 = load double, double* %138
%140 = tail call i64 @Blocal_index(i32 %121, i32 %102, i32 %105, i32 %114, i32 %117, i32 %123, i32 %108, i32 %111, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%141 = getelementptr inbounds double, double* %5, i64 %140
%142 = load double, double* %141
%143 = fneg double %139
%144 = fmul double %142, %143
%145 = tail call double @llvm.fmuladd.f64(double %133, double %136, double %144)
%146 = fmul double %130, %145
%147 = load i32, i32* %78
%148 = sitofp i32 %147 to double
%149 = fmul double %148, %8
%150 = load double, double* %119
%151 = fmul double %150, %149
%152 = tail call i64 @Blocal_index(i32 %121, i32 %84, i32 %87, i32 %96, i32 %99, i32 %123, i32 %90, i32 %93, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%153 = getelementptr inbounds double, double* %2, i64 %152
%154 = load double, double* %153
%155 = tail call i64 @Blocal_index(i32 %121, i32 %102, i32 %105, i32 %114, i32 %117, i32 %123, i32 %108, i32 %111, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%156 = getelementptr inbounds double, double* %5, i64 %155
%157 = load double, double* %156
%158 = tail call i64 @Blocal_index(i32 %121, i32 %84, i32 %87, i32 %96, i32 %99, i32 %123, i32 %90, i32 %93, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%159 = getelementptr inbounds double, double* %3, i64 %158
%160 = load double, double* %159
%161 = tail call i64 @Blocal_index(i32 %121, i32 %102, i32 %105, i32 %114, i32 %117, i32 %123, i32 %108, i32 %111, i32 %125, i32 %14, i32 %15, i32 %16, i32 %22)
%162 = getelementptr inbounds double, double* %4, i64 %161
%163 = load double, double* %162
%164 = fmul double %160, %163
%165 = tail call double @llvm.fmuladd.f64(double %154, double %157, double %164)
%166 = fmul double %151, %165
br i1 %33, label %167, label %196
167: ; preds = %124, %167
%168 = phi i32 [ %194, %167 ], [ 0, %124 ]
%169 = tail call i64 @index_2d(i32 %123, i32 %168, i32 %21)
%170 = getelementptr inbounds double, double* %12, i64 %169
%171 = load double, double* %170
%172 = tail call i64 @index_2d(i32 %123, i32 %168, i32 %21)
%173 = getelementptr inbounds double, double* %13, i64 %172
%174 = load double, double* %173
%175 = fneg double %174
%176 = fmul double %166, %175
%177 = tail call double @llvm.fmuladd.f64(double %171, double %146, double %176)
%178 = tail call i64 @index_3d(i32 %168, i32 %125, i32 %121, i32 %22, i32 %18)
%179 = getelementptr inbounds double, double* %0, i64 %178
%180 = load double, double* %179
%181 = fadd double %180, %177
store double %181, double* %179
%182 = tail call i64 @index_2d(i32 %123, i32 %168, i32 %21)
%183 = getelementptr inbounds double, double* %12, i64 %182
%184 = load double, double* %183
%185 = tail call i64 @index_2d(i32 %123, i32 %168, i32 %21)
%186 = getelementptr inbounds double, double* %13, i64 %185
%187 = load double, double* %186
%188 = fmul double %146, %187
%189 = tail call double @llvm.fmuladd.f64(double %184, double %166, double %188)
%190 = tail call i64 @index_3d(i32 %168, i32 %125, i32 %121, i32 %22, i32 %18)
%191 = getelementptr inbounds double, double* %1, i64 %190
%192 = load double, double* %191
%193 = fadd double %192, %189
store double %193, double* %191
%194 = add nuw nsw i32 %168, 1
%195 = icmp eq i32 %194, %21
br i1 %195, label %196, label %167
196: ; preds = %167, %124
%197 = add nuw nsw i32 %125, 1
%198 = icmp eq i32 %197, %22
br i1 %198, label %199, label %124
199: ; preds = %196, %122
%200 = add nuw nsw i32 %123, 1
%201 = icmp eq i32 %200, %16
br i1 %201, label %202, label %122
202: ; preds = %199, %120
%203 = add nuw nsw i32 %121, 1
%204 = icmp eq i32 %203, %18
br i1 %204, label %205, label %120
205: ; preds = %202, %79
%206 = add nuw nsw i64 %80, 1
%207 = icmp eq i64 %206, %37
br i1 %207, label %208, label %79
208: ; preds = %205, %38
%209 = add nuw nsw i64 %39, 1
%210 = icmp eq i64 %209, %34
br i1 %210, label %211, label %38
211: ; preds = %208, %24
ret void
}