#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 Bdouble_index(int, int, int, int, int, int, int, int, int, int,
                     int const, int const, int const, int const);
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);
size_t index_3d(int, int, int, int const, int const);
void make_dibaryon_correlator(
    double *C_re, double *C_im, const double *B1_Blocal_re,
    const double *B1_Blocal_im, const double *B1_Bsingle_re,
    const double *B1_Bsingle_im, const double *B1_Bdouble_re,
    const double *B1_Bdouble_im, const double *B2_Blocal_re,
    const double *B2_Blocal_im, const double *B2_Bsingle_re,
    const double *B2_Bsingle_im, const double *B2_Bdouble_re,
    const double *B2_Bdouble_im, const int *perms, const int *sigs,
    const double overall_weight, const int *snk_color_weights,
    const int *snk_spin_weights, const double *snk_weights,
    const double *snk_psi_re, const double *snk_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 Nsrc, const int Nsnk, const int Nperms) {
  int iC1, iS1, jC1, jS1, kC1, kS1, iC2, iS2, jC2, jS2, kC2, kS2, x1, x2, t,
      wnum, nperm, b, n, m;
  int Nb = 2;
  int Nw2 = Nw * Nw;
  double term_re, term_im, new_term_re, new_term_im;
  int snk_1_nq[Nb];
  int snk_2_nq[Nb];
  int snk_3_nq[Nb];
  int snk_1_b[Nb];
  int snk_2_b[Nb];
  int snk_3_b[Nb];
  int snk_1[Nb];
  int snk_2[Nb];
  int snk_3[Nb];
  for (nperm = 0; nperm < Nperms; nperm++) {
    for (b = 0; b < Nb; b++) {
      snk_1[b] = perms[index_2d(nperm, Nq * b + 0, 2 * Nq)] - 1;
      snk_2[b] = perms[index_2d(nperm, Nq * b + 1, 2 * Nq)] - 1;
      snk_3[b] = perms[index_2d(nperm, Nq * b + 2, 2 * Nq)] - 1;
      snk_1_b[b] = (snk_1[b] - snk_1[b] % Nq) / Nq;
      snk_2_b[b] = (snk_2[b] - snk_2[b] % Nq) / Nq;
      snk_3_b[b] = (snk_3[b] - snk_3[b] % Nq) / Nq;
      snk_1_nq[b] = snk_1[b] % Nq;
      snk_2_nq[b] = snk_2[b] % Nq;
      snk_3_nq[b] = snk_3[b] % Nq;
    }
    for (wnum = 0; wnum < Nw2; wnum++) {
      iC1 = snk_color_weights[index_3d(snk_1_b[0], wnum, snk_1_nq[0], Nw2, Nq)];
      iS1 = snk_spin_weights[index_3d(snk_1_b[0], wnum, snk_1_nq[0], Nw2, Nq)];
      jC1 = snk_color_weights[index_3d(snk_2_b[0], wnum, snk_2_nq[0], Nw2, Nq)];
      jS1 = snk_spin_weights[index_3d(snk_2_b[0], wnum, snk_2_nq[0], Nw2, Nq)];
      kC1 = snk_color_weights[index_3d(snk_3_b[0], wnum, snk_3_nq[0], Nw2, Nq)];
      kS1 = snk_spin_weights[index_3d(snk_3_b[0], wnum, snk_3_nq[0], Nw2, Nq)];
      iC2 = snk_color_weights[index_3d(snk_1_b[1], wnum, snk_1_nq[1], Nw2, Nq)];
      iS2 = snk_spin_weights[index_3d(snk_1_b[1], wnum, snk_1_nq[1], Nw2, Nq)];
      jC2 = snk_color_weights[index_3d(snk_2_b[1], wnum, snk_2_nq[1], Nw2, Nq)];
      jS2 = snk_spin_weights[index_3d(snk_2_b[1], wnum, snk_2_nq[1], Nw2, Nq)];
      kC2 = snk_color_weights[index_3d(snk_3_b[1], wnum, snk_3_nq[1], Nw2, Nq)];
      kS2 = snk_spin_weights[index_3d(snk_3_b[1], wnum, snk_3_nq[1], Nw2, Nq)];
      for (t = 0; t < Nt; t++) {
        for (x1 = 0; x1 < Vsnk; x1++) {
          for (x2 = 0; x2 < Vsnk; x2++) {
            for (m = 0; m < Nsrc; m++) {
              term_re = sigs[nperm] * overall_weight * snk_weights[wnum];
              term_im = 0.0;
              for (b = 0; b < Nb; b++) {
                if ((snk_1_b[b] == 0) && (snk_2_b[b] == 0) &&
                    (snk_3_b[b] == 0)) {
                  new_term_re =
                      term_re * B1_Blocal_re[Blocal_index(t, iC1, iS1, kC1, kS1,
                                                          x1, jC1, jS1, m, Nc,
                                                          Ns, Vsnk, Nsrc)] -
                      term_im * B1_Blocal_im[Blocal_index(t, iC1, iS1, kC1, kS1,
                                                          x1, jC1, jS1, m, Nc,
                                                          Ns, Vsnk, Nsrc)];
                  new_term_im =
                      term_re * B1_Blocal_im[Blocal_index(t, iC1, iS1, kC1, kS1,
                                                          x1, jC1, jS1, m, Nc,
                                                          Ns, Vsnk, Nsrc)] +
                      term_im * B1_Blocal_re[Blocal_index(t, iC1, iS1, kC1, kS1,
                                                          x1, jC1, jS1, m, Nc,
                                                          Ns, Vsnk, Nsrc)];
                } else if ((snk_1_b[b] == 1) && (snk_2_b[b] == 1) &&
                           (snk_3_b[b] == 1)) {
                  new_term_re =
                      term_re * B2_Blocal_re[Blocal_index(t, iC2, iS2, kC2, kS2,
                                                          x2, jC2, jS2, m, Nc,
                                                          Ns, Vsnk, Nsrc)] -
                      term_im * B2_Blocal_im[Blocal_index(t, iC2, iS2, kC2, kS2,
                                                          x2, jC2, jS2, m, Nc,
                                                          Ns, Vsnk, Nsrc)];
                  new_term_im =
                      term_re * B2_Blocal_im[Blocal_index(t, iC2, iS2, kC2, kS2,
                                                          x2, jC2, jS2, m, Nc,
                                                          Ns, Vsnk, Nsrc)] +
                      term_im * B2_Blocal_re[Blocal_index(t, iC2, iS2, kC2, kS2,
                                                          x2, jC2, jS2, m, Nc,
                                                          Ns, Vsnk, Nsrc)];
                } else if ((snk_1_b[b] == 0) && (snk_3_b[b] == 0)) {
                  new_term_re = term_re * B1_Bsingle_re[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)] -
                                term_im * B1_Bsingle_im[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)];
                  new_term_im = term_re * B1_Bsingle_im[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)] +
                                term_im * B1_Bsingle_re[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)];
                } else if ((snk_1_b[b] == 1) && (snk_3_b[b] == 1)) {
                  new_term_re = term_re * B2_Bsingle_re[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)] -
                                term_im * B2_Bsingle_im[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)];
                  new_term_im = term_re * B2_Bsingle_im[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)] +
                                term_im * B2_Bsingle_re[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)];
                } else if (((snk_1_b[b] == 0) && (snk_2_b[b] == 0)) ||
                           ((snk_2_b[b] == 0) && (snk_3_b[b] == 0))) {
                  new_term_re = term_re * B1_Bdouble_re[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)] -
                                term_im * B1_Bdouble_im[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)];
                  new_term_im = term_re * B1_Bdouble_im[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)] +
                                term_im * B1_Bdouble_re[Bdouble_index(
                                              t, iC1, iS1, kC1, kS1, x1, jC1,
                                              jS1, x2, m, Nc, Ns, Vsnk, Nsrc)];
                } else if (((snk_1_b[b] == 1) && (snk_2_b[b] == 1)) ||
                           ((snk_2_b[b] == 1) && (snk_3_b[b] == 1))) {
                  new_term_re = term_re * B2_Bdouble_re[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)] -
                                term_im * B2_Bdouble_im[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)];
                  new_term_im = term_re * B2_Bdouble_im[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)] +
                                term_im * B2_Bdouble_re[Bdouble_index(
                                              t, iC2, iS2, kC2, kS2, x2, jC2,
                                              jS2, x1, m, Nc, Ns, Vsnk, Nsrc)];
                }
                term_re = new_term_re;
                term_im = new_term_im;
              }
              for (n = 0; n < Nsnk; n++) {
                C_re[index_3d(m, n, t, Nsnk, Nt)] +=
                    snk_psi_re[index_3d(x1, x2, n, Vsnk, Nsnk)] * term_re -
                    snk_psi_im[index_3d(x1, x2, n, Vsnk, Nsnk)] * term_im;
                C_im[index_3d(m, n, t, Nsnk, Nt)] +=
                    snk_psi_re[index_3d(x1, x2, n, Vsnk, Nsnk)] * term_im +
                    snk_psi_im[index_3d(x1, x2, n, Vsnk, Nsnk)] * term_re;
              }
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<make_dibaryon_correlator>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x418,%rsp
mov    0xd0(%rbp),%eax
mov    0xc8(%rbp),%eax
mov    0xc0(%rbp),%eax
mov    0xb8(%rbp),%eax
mov    0xb0(%rbp),%eax
mov    0xa8(%rbp),%eax
mov    0xa0(%rbp),%eax
mov    0x98(%rbp),%eax
mov    0x90(%rbp),%eax
mov    0x88(%rbp),%eax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
movsd  %xmm0,-0x60(%rbp)
movl   $0x2,-0xb4(%rbp)
mov    0xb0(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0xe0(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x170(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
mov    -0xb4(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x168(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf0(%rbp)
mov    -0xb4(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x160(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0xb4(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x158(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x100(%rbp)
mov    -0xb4(%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,-0x108(%rbp)
mov    -0xb4(%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,-0x110(%rbp)
mov    -0xb4(%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,-0x118(%rbp)
mov    -0xb4(%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,-0x120(%rbp)
mov    -0xb4(%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,-0x128(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0xd0(%rbp),%eax
jge    31de <make_dibaryon_correlator+0x209e>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1619 <make_dibaryon_correlator+0x4d9>
mov    0x50(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0xa4(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0xa8(%rbp),%esi
add    $0x0,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1060 <index_2d@plt>
mov    -0x198(%rbp),%rcx
mov    %rax,%rdx
mov    -0x140(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0xa8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0xa4(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0xa8(%rbp),%esi
add    $0x1,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1060 <index_2d@plt>
mov    -0x190(%rbp),%rcx
mov    %rax,%rdx
mov    -0x138(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0xa8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0xa4(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0xa8(%rbp),%esi
add    $0x2,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1060 <index_2d@plt>
mov    -0x188(%rbp),%rsi
mov    -0x168(%rbp),%rcx
mov    -0x130(%rbp),%rdx
mov    %rax,%rdi
mov    -0x140(%rbp),%rax
mov    (%rsi,%rdi,4),%edi
sub    $0x1,%edi
movslq -0xa8(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x17c(%rbp)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x17c(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x158(%rbp),%rdx
mov    %eax,%edi
mov    -0x138(%rbp),%rax
movslq -0xa8(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x178(%rbp)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x178(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x150(%rbp),%rdx
mov    %eax,%edi
mov    -0x130(%rbp),%rax
movslq -0xa8(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x174(%rbp)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x174(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x148(%rbp),%rdx
mov    %eax,%edi
mov    -0x140(%rbp),%rax
movslq -0xa8(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x138(%rbp),%rax
mov    %edx,%edi
mov    -0x170(%rbp),%rdx
movslq -0xa8(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0xa8(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x130(%rbp),%rax
mov    %edx,%esi
movslq -0xa8(%rbp),%rdx
mov    %esi,(%rcx,%rdx,4)
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x160(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    13a6 <make_dibaryon_correlator+0x266>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    31c5 <make_dibaryon_correlator+0x2085>
mov    -0x170(%rbp),%rax
mov    -0x158(%rbp),%rcx
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1f8(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1f8(%rbp),%rdx
mov    -0x158(%rbp),%rcx
mov    %rax,%rsi
mov    -0x170(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x64(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1f0(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1f0(%rbp),%rdx
mov    -0x150(%rbp),%rcx
mov    %rax,%rsi
mov    -0x168(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x68(%rbp)
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1e8(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1e8(%rbp),%rdx
mov    -0x150(%rbp),%rcx
mov    %rax,%rsi
mov    -0x168(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x6c(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1e0(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1e0(%rbp),%rdx
mov    -0x148(%rbp),%rcx
mov    %rax,%rsi
mov    -0x160(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x70(%rbp)
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1d8(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1d8(%rbp),%rdx
mov    -0x148(%rbp),%rcx
mov    %rax,%rsi
mov    -0x160(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x74(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1d0(%rbp)
mov    (%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    (%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1d0(%rbp),%rdx
mov    -0x158(%rbp),%rcx
mov    %rax,%rsi
mov    -0x170(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x78(%rbp)
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1c8(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1c8(%rbp),%rdx
mov    -0x158(%rbp),%rcx
mov    %rax,%rsi
mov    -0x170(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x7c(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1c0(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1c0(%rbp),%rdx
mov    -0x150(%rbp),%rcx
mov    %rax,%rsi
mov    -0x168(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x80(%rbp)
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1b8(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1b8(%rbp),%rdx
mov    -0x150(%rbp),%rcx
mov    %rax,%rsi
mov    -0x168(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x84(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1b0(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1b0(%rbp),%rdx
mov    -0x148(%rbp),%rcx
mov    %rax,%rsi
mov    -0x160(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x88(%rbp)
mov    0x60(%rbp),%rdx
mov    %rdx,-0x1a8(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x1a8(%rbp),%rdx
mov    -0x148(%rbp),%rcx
mov    %rax,%rsi
mov    -0x160(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x8c(%rbp)
mov    0x68(%rbp),%rdx
mov    %rdx,-0x1a0(%rbp)
mov    0x4(%rcx),%edi
mov    -0xa0(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xb8(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x1a0(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0xa8(%rbp),%eax
jge    31ac <make_dibaryon_correlator+0x206c>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0xa0(%rbp),%eax
jge    3193 <make_dibaryon_correlator+0x2053>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0xa0(%rbp),%eax
jge    317a <make_dibaryon_correlator+0x203a>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    0xc0(%rbp),%eax
jge    3161 <make_dibaryon_correlator+0x2021>
mov    0x58(%rbp),%rax
movslq -0xa4(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  -0x60(%rbp),%xmm0
mov    0x70(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    2eed <make_dibaryon_correlator+0x1dad>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1d79 <make_dibaryon_correlator+0xc39>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1d79 <make_dibaryon_correlator+0xc39>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1d79 <make_dibaryon_correlator+0xc39>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r12d
mov    -0x70(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x248(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r12d
mov    -0x70(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
movsd  -0x240(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x228(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r12d
mov    -0x70(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x220(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r12d
mov    -0x70(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
movsd  -0x218(%rbp),%xmm1
ff
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x208(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x200(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2eb9 <make_dibaryon_correlator+0x1d79>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    20d5 <make_dibaryon_correlator+0xf95>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    20d5 <make_dibaryon_correlator+0xf95>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    20d5 <make_dibaryon_correlator+0xf95>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x288(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x298(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x290(%rbp)
ff
mov    0x28(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
movsd  -0x290(%rbp),%xmm1
ff
movsd  -0x288(%rbp),%xmm0
ff
movsd  -0x280(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x278(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x260(%rbp)
ff
mov    0x28(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x270(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x258(%rbp)
movsd  -0xc8(%rbp),%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%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   1050 <Blocal_index@plt>
movsd  -0x268(%rbp),%xmm1
ff
movsd  -0x260(%rbp),%xmm0
ff
movsd  -0x258(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x250(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2eb4 <make_dibaryon_correlator+0x1d74>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2419 <make_dibaryon_correlator+0x12d9>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2419 <make_dibaryon_correlator+0x12d9>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2e8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x2e0(%rbp),%xmm1
ff
movsd  -0x2d8(%rbp),%xmm0
ff
movsd  -0x2d0(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2c8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2c0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x2b8(%rbp),%xmm1
ff
movsd  -0x2b0(%rbp),%xmm0
ff
movsd  -0x2a8(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2a0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2eaf <make_dibaryon_correlator+0x1d6f>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    278d <make_dibaryon_correlator+0x164d>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    278d <make_dibaryon_correlator+0x164d>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x328(%rbp)
ff
mov    0x30(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x338(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x330(%rbp)
ff
mov    0x38(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x330(%rbp),%xmm1
ff
movsd  -0x328(%rbp),%xmm0
ff
movsd  -0x320(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x318(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x300(%rbp)
ff
mov    0x38(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x310(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x308(%rbp)
ff
mov    0x30(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x308(%rbp),%xmm1
ff
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2f8(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2f0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2eaa <make_dibaryon_correlator+0x1d6a>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    27bd <make_dibaryon_correlator+0x167d>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     27ed <make_dibaryon_correlator+0x16ad>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2b01 <make_dibaryon_correlator+0x19c1>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2b01 <make_dibaryon_correlator+0x19c1>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x378(%rbp)
ff
mov    0x10(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x388(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x380(%rbp)
ff
mov    0x18(%rbp),%rax
mov    %rax,-0x368(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x380(%rbp),%xmm1
ff
movsd  -0x378(%rbp),%xmm0
ff
movsd  -0x370(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x368(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x350(%rbp)
ff
mov    0x18(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x360(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x358(%rbp)
ff
mov    0x10(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x6c(%rbp),%r13d
mov    -0x70(%rbp),%r12d
mov    -0x98(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x358(%rbp),%xmm1
ff
movsd  -0x350(%rbp),%xmm0
ff
movsd  -0x348(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x340(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2ea5 <make_dibaryon_correlator+0x1d65>
mov    -0x158(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    2b31 <make_dibaryon_correlator+0x19f1>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     2b61 <make_dibaryon_correlator+0x1a21>
mov    -0x150(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    2ea0 <make_dibaryon_correlator+0x1d60>
mov    -0x148(%rbp),%rax
movslq -0xa8(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    2ea0 <make_dibaryon_correlator+0x1d60>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x3c8(%rbp)
ff
mov    0x40(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3d8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3c0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x3d0(%rbp)
ff
mov    0x48(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x3d0(%rbp),%xmm1
ff
movsd  -0x3c8(%rbp),%xmm0
ff
movsd  -0x3c0(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3b8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x3a0(%rbp)
ff
mov    0x48(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3b0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x398(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x3a8(%rbp)
ff
mov    0x40(%rbp),%rax
mov    %rax,-0x390(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x8c(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x84(%rbp),%r13d
mov    -0x88(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xb0(%rbp),%r14d
mov    0x88(%rbp),%ebx
mov    0x90(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xc0(%rbp),%eax
sub    $0x40,%rsp
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1040 <Bdouble_index@plt>
movsd  -0x3a8(%rbp),%xmm1
ff
movsd  -0x3a0(%rbp),%xmm0
ff
movsd  -0x398(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x390(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    2ea5 <make_dibaryon_correlator+0x1d65>
jmp    2eaa <make_dibaryon_correlator+0x1d6a>
jmp    2eaf <make_dibaryon_correlator+0x1d6f>
jmp    2eb4 <make_dibaryon_correlator+0x1d74>
jmp    2eb9 <make_dibaryon_correlator+0x1d79>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1a3b <make_dibaryon_correlator+0x8fb>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    0xc8(%rbp),%eax
jge    3148 <make_dibaryon_correlator+0x2008>
mov    0x78(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x98(%rbp),%esi
mov    -0xac(%rbp),%edx
mov    0xa0(%rbp),%ecx
mov    0xc8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x438(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x430(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x428(%rbp)
ff
mov    0x80(%rbp),%rax
mov    %rax,-0x420(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x98(%rbp),%esi
mov    -0xac(%rbp),%edx
mov    0xa0(%rbp),%ecx
mov    0xc8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x430(%rbp),%xmm0
ff
movsd  -0x428(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x420(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x418(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    %rax,-0x410(%rbp)
mov    -0xb0(%rbp),%edi
mov    -0xac(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    0xc8(%rbp),%ecx
mov    0xa8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x418(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x410(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x78(%rbp),%rax
mov    %rax,-0x408(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x98(%rbp),%esi
mov    -0xac(%rbp),%edx
mov    0xa0(%rbp),%ecx
mov    0xc8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x408(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x400(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x3f8(%rbp)
ff
mov    0x80(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x98(%rbp),%esi
mov    -0xac(%rbp),%edx
mov    0xa0(%rbp),%ecx
mov    0xc8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x400(%rbp),%xmm0
ff
movsd  -0x3f8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x3f0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3e8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x3e0(%rbp)
mov    -0xb0(%rbp),%edi
mov    -0xac(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    0xc8(%rbp),%ecx
mov    0xa8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x3e8(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x3e0(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2ef7 <make_dibaryon_correlator+0x1db7>
jmp    314d <make_dibaryon_correlator+0x200d>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    19e7 <make_dibaryon_correlator+0x8a7>
jmp    3166 <make_dibaryon_correlator+0x2026>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    19cb <make_dibaryon_correlator+0x88b>
jmp    317f <make_dibaryon_correlator+0x203f>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    19af <make_dibaryon_correlator+0x86f>
jmp    3198 <make_dibaryon_correlator+0x2058>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1993 <make_dibaryon_correlator+0x853>
jmp    31b1 <make_dibaryon_correlator+0x2071>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1623 <make_dibaryon_correlator+0x4e3>
jmp    31ca <make_dibaryon_correlator+0x208a>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    138a <make_dibaryon_correlator+0x24a>
mov    -0xe0(%rbp),%rax
mov    %rax,%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_dibaryon_correlator>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
movsd  %xmm0,0x130(%rsp)
mov    %r9,0x140(%rsp)
mov    %r8,0x118(%rsp)
mov    %rcx,0x138(%rsp)
mov    %rdx,0x110(%rsp)
mov    0x250(%rsp),%eax
test   %eax,%eax
jle    253d <make_dibaryon_correlator+0x13fd>
mov    0x238(%rsp),%ecx
mov    0x228(%rsp),%ebp
mov    0x230(%rsp),%edx
imul   %edx,%edx
mov    %eax,%eax
mov    %rax,0x120(%rsp)
lea    (%rcx,%rcx,1),%eax
mov    %eax,0xcc(%rsp)
lea    0x1(%rcx),%eax
mov    %eax,0xc8(%rsp)
lea    0x2(%rcx),%eax
mov    %eax,0xc4(%rsp)
mov    %edx,0xac(%rsp)
mov    %edx,%eax
mov    %rax,0x128(%rsp)
xor    %r12d,%r12d
mov    %rsi,0x150(%rsp)
mov    %rdi,0x148(%rsp)
jmp    120a <make_dibaryon_correlator+0xca>
nop
mov    0x108(%rsp),%r12
add    $0x1,%r12
cmp    0x120(%rsp),%r12
je     253d <make_dibaryon_correlator+0x13fd>
mov    %r12d,%edi
xor    %esi,%esi
mov    0xcc(%rsp),%r14d
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    0x1d0(%rsp),%r13
mov    0x0(%r13,%rax,4),%r15d
add    $0xffffffff,%r15d
mov    %r12d,%edi
mov    $0x1,%esi
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    0x0(%r13,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %r12d,%edi
mov    $0x2,%esi
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    0x0(%r13,%rax,4),%ecx
mov    %r15d,%eax
cltd
mov    0x238(%rsp),%r15d
mov    %r15,%rsi
idiv   %esi
mov    %edx,0xfc(%rsp)
mov    %eax,0xf8(%rsp)
mov    %eax,0x100(%rsp)
mov    %ebx,%eax
cltd
idiv   %esi
mov    %edx,0xf0(%rsp)
add    $0xffffffff,%ecx
mov    %eax,0xf4(%rsp)
mov    %eax,0xb0(%rsp)
mov    %ecx,%eax
cltd
idiv   %esi
mov    %edx,0xec(%rsp)
mov    %eax,0xe8(%rsp)
mov    %eax,0xa0(%rsp)
mov    %r12d,%edi
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    %r13,%r15
mov    0x0(%r13,%rax,4),%r13d
add    $0xffffffff,%r13d
mov    %r12d,%edi
mov    0xc8(%rsp),%esi
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    (%r15,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %r12,0x108(%rsp)
mov    %r12d,%edi
mov    0xc4(%rsp),%esi
mov    %r14d,%edx
call   1060 <index_2d@plt>
mov    (%r15,%rax,4),%ecx
mov    %r13d,%eax
cltd
mov    0x238(%rsp),%edi
idiv   %edi
mov    %edx,0xe4(%rsp)
mov    %eax,%esi
mov    %ebx,%eax
cltd
idiv   %edi
mov    %rdi,%rbx
mov    %eax,%edi
mov    %edx,0xd8(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
idiv   %ebx
mov    %edx,0xd0(%rsp)
mov    %esi,0xe0(%rsp)
mov    %esi,0x104(%rsp)
mov    %edi,0xdc(%rsp)
mov    %edi,0xb4(%rsp)
mov    %eax,0xd4(%rsp)
mov    %eax,0xa4(%rsp)
cmpl   $0x0,0xac(%rsp)
je     11f0 <make_dibaryon_correlator+0xb0>
xor    %ebx,%ebx
mov    0x1e8(%rsp),%r14
jmp    13c2 <make_dibaryon_correlator+0x282>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x10(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  %xmm0,0x10(%rsp)
add    $0x1,%rbx
cmp    0x128(%rsp),%rbx
mov    0x1e8(%rsp),%r14
je     11f0 <make_dibaryon_correlator+0xb0>
mov    %rbx,0x70(%rsp)
mov    0xf8(%rsp),%r12d
mov    %r12d,%edi
mov    %ebx,%esi
mov    0xfc(%rsp),%r15d
mov    %r15d,%edx
mov    0xac(%rsp),%r13d
mov    %r13d,%ecx
mov    0x238(%rsp),%ebx
mov    %ebx,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x40(%rsp)
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    %ebx,%r8d
mov    %rbx,%r15
call   1030 <index_3d@plt>
mov    (%r14,%rax,4),%eax
mov    %eax,0x3c(%rsp)
mov    0xf4(%rsp),%ebx
mov    %ebx,%edi
mov    0x70(%rsp),%rsi
mov    0xf0(%rsp),%r12d
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x88(%rsp)
mov    %ebx,%edi
mov    0x70(%rsp),%rsi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    (%r14,%rax,4),%eax
mov    %rax,0x80(%rsp)
mov    0xe8(%rsp),%r12d
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    0xec(%rsp),%ebx
mov    %ebx,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x44(%rsp)
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    (%r14,%rax,4),%eax
mov    %eax,0x38(%rsp)
mov    0xe0(%rsp),%r12d
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    0xe4(%rsp),%ebx
mov    %ebx,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x6c(%rsp)
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    (%r14,%rax,4),%eax
mov    %eax,0x5c(%rsp)
mov    0xdc(%rsp),%ebx
mov    %ebx,%edi
mov    0x70(%rsp),%rsi
mov    0xd8(%rsp),%r12d
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x98(%rsp)
mov    %ebx,%edi
mov    0x70(%rsp),%rsi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    (%r14,%rax,4),%eax
mov    %rax,0x90(%rsp)
mov    0xd4(%rsp),%ebx
mov    %ebx,%edi
mov    0x70(%rsp),%rsi
mov    0xd0(%rsp),%r12d
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x4c(%rsp)
mov    %ebx,%edi
mov    0x70(%rsp),%rbx
mov    %ebx,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    %r15d,%r8d
call   1030 <index_3d@plt>
test   %ebp,%ebp
jle    1390 <make_dibaryon_correlator+0x250>
mov    (%r14,%rax,4),%eax
mov    %eax,0x48(%rsp)
movl   $0x0,0xc(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
jmp    160a <make_dibaryon_correlator+0x4ca>
nopl   0x0(%rax)
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    0x228(%rsp),%ebp
mov    %eax,0xc(%rsp)
cmp    %ebp,%eax
je     139c <make_dibaryon_correlator+0x25c>
mov    0x220(%rsp),%r13d
test   %r13d,%r13d
jle    15f0 <make_dibaryon_correlator+0x4b0>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
jmp    1638 <make_dibaryon_correlator+0x4f8>
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    0x220(%rsp),%eax
mov    %rcx,0x28(%rsp)
cmp    %eax,%ecx
je     15f0 <make_dibaryon_correlator+0x4b0>
xor    %eax,%eax
jmp    1653 <make_dibaryon_correlator+0x513>
nopl   0x0(%rax)
mov    0x60(%rsp),%rax
add    $0x1,%eax
mov    0x220(%rsp),%ecx
cmp    %ecx,%eax
je     1620 <make_dibaryon_correlator+0x4e0>
mov    %rax,0x60(%rsp)
mov    0x240(%rsp),%eax
test   %eax,%eax
jle    1640 <make_dibaryon_correlator+0x500>
xor    %eax,%eax
jmp    169b <make_dibaryon_correlator+0x55b>
nopw   0x0(%rax,%rax,1)
mov    %r13,0x28(%rsp)
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    0x240(%rsp),%r14d
cmp    %r14d,%eax
mov    0x70(%rsp),%rbx
movsd  0x10(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
je     1640 <make_dibaryon_correlator+0x500>
mov    %rax,0x50(%rsp)
mov    0x1d8(%rsp),%rax
mov    0x108(%rsp),%rcx
xorps  %xmm2,%xmm2
cvtsi2sdl (%rax,%rcx,4),%xmm2
mulsd  0x130(%rsp),%xmm2
mov    0x1f0(%rsp),%rax
mulsd  (%rax,%rbx,8),%xmm2
xorpd  %xmm5,%xmm5
mov    $0x1,%dil
xor    %eax,%eax
jmp    18fb <make_dibaryon_correlator+0x7bb>
nopl   0x0(%rax)
mov    %edi,0x34(%rsp)
mov    0xc(%rsp),%ebp
mov    %ebp,%edi
mov    0x6c(%rsp),%esi
mov    0x5c(%rsp),%edx
mov    0x4c(%rsp),%ecx
mov    0x48(%rsp),%ebx
mov    %ebx,%r8d
mov    0x60(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   0x70(%rsp)
push   0x50(%rsp)
mov    0xc0(%rsp),%r13
push   %r13
mov    0xd0(%rsp),%r14
push   %r14
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1c0(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %ebp,%edi
mov    0x6c(%rsp),%ebp
mov    %ebp,%esi
mov    0x5c(%rsp),%r13d
mov    %r13d,%edx
mov    0x4c(%rsp),%r12d
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    0x60(%rsp),%rbx
mov    %ebx,%r9d
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x70(%rsp),%r15
push   %r15
push   0x50(%rsp)
push   0xc0(%rsp)
push   %r14
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1c8(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r12d,%ecx
mov    0x48(%rsp),%r14d
mov    %r14d,%r8d
mov    %ebx,%r9d
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r15
push   0x50(%rsp)
mov    0xc0(%rsp),%r12
push   %r12
mov    0xd0(%rsp),%rbx
push   %rbx
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1c8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0xc(%rsp),%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x4c(%rsp),%ecx
mov    %r14d,%r8d
mov    0x60(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r15
push   0x50(%rsp)
push   %r12
push   %rbx
call   1040 <Bdouble_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x1c0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,%xmm5
mov    $0x1,%eax
movapd %xmm5,%xmm1
movapd %xmm2,%xmm0
test   $0x1,%dil
mov    $0x0,%edi
je     23c0 <make_dibaryon_correlator+0x1280>
movapd %xmm5,%xmm4
movapd %xmm2,%xmm3
mov    0x100(%rsp,%rax,4),%ecx
test   %ecx,%ecx
je     1b30 <make_dibaryon_correlator+0x9f0>
cmp    $0x1,%ecx
jne    1d50 <make_dibaryon_correlator+0xc10>
mov    0xb0(%rsp,%rax,4),%ecx
mov    0xa0(%rsp,%rax,4),%esi
cmp    $0x1,%ecx
jne    1d5e <make_dibaryon_correlator+0xc1e>
cmp    $0x1,%esi
jne    16e0 <make_dibaryon_correlator+0x5a0>
sub    $0x8,%rsp
mov    %edi,0x3c(%rsp)
mov    0x14(%rsp),%ebx
mov    %ebx,%edi
mov    0x74(%rsp),%esi
mov    0x64(%rsp),%edx
mov    0x54(%rsp),%ebp
mov    %ebp,%ecx
mov    0x50(%rsp),%r8d
mov    0x68(%rsp),%r9
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
push   0x78(%rsp)
mov    0xc0(%rsp),%r13
push   %r13
mov    0xd0(%rsp),%r14
push   %r14
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x1a0(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    0x74(%rsp),%r13d
mov    %r13d,%esi
mov    0x64(%rsp),%ebx
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x50(%rsp),%ebp
mov    %ebp,%r8d
mov    0x68(%rsp),%r15
mov    %r15d,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x78(%rsp),%r12
push   %r12
push   0xc0(%rsp)
push   %r14
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x1a8(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    0x54(%rsp),%r14d
mov    %r14d,%ecx
mov    %ebp,%r8d
mov    %r15d,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%ebp
push   %rbp
mov    0x228(%rsp),%eax
push   %rax
push   %r12
mov    0xc0(%rsp),%r13
push   %r13
mov    0xd0(%rsp),%rbx
push   %rbx
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x1a8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    0x74(%rsp),%esi
mov    0x64(%rsp),%edx
mov    %r14d,%ecx
mov    0x50(%rsp),%r8d
mov    %r15d,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
push   %rbp
mov    0x228(%rsp),%eax
push   %rax
push   %r12
push   %r13
push   %rbx
call   1050 <Blocal_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x1a0(%rsp),%rcx
jmp    18cb <make_dibaryon_correlator+0x78b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xb0(%rsp,%rax,4),%ecx
mov    0xa0(%rsp,%rax,4),%edx
test   %ecx,%ecx
je     1fc5 <make_dibaryon_correlator+0xe85>
test   %edx,%edx
jne    1f80 <make_dibaryon_correlator+0xe40>
mov    %edi,0x34(%rsp)
mov    0xc(%rsp),%edi
mov    0x40(%rsp),%r15d
mov    %r15d,%esi
mov    0x3c(%rsp),%r14d
mov    %r14d,%edx
mov    0x44(%rsp),%ecx
mov    0x38(%rsp),%r8d
mov    0x28(%rsp),%r9
mov    %r9,0x28(%rsp)
mov    0x240(%rsp),%ebx
push   %rbx
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x70(%rsp),%rbp
push   %rbp
push   0x88(%rsp)
mov    0xb0(%rsp),%r13
push   %r13
mov    0xc0(%rsp),%r12
push   %r12
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    %r15d,%esi
mov    %r14d,%edx
mov    0x44(%rsp),%r14d
mov    %r14d,%ecx
mov    0x38(%rsp),%ebx
mov    %ebx,%r8d
mov    0x28(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %rbp
mov    0x88(%rsp),%r13
push   %r13
push   0xb0(%rsp)
push   0xc0(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x140(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    %r15d,%esi
mov    0x3c(%rsp),%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
mov    0x28(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    %rax,%rbx
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x70(%rsp),%r14
push   %r14
push   %r13
mov    0xb0(%rsp),%r12
push   %r12
mov    0xc0(%rsp),%r15
push   %r15
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x240(%rsp),%ebp
mov    0xc(%rsp),%edi
mov    0x40(%rsp),%esi
mov    0x3c(%rsp),%edx
mov    0x44(%rsp),%ecx
mov    0x38(%rsp),%r8d
mov    0x28(%rsp),%r9
push   %rbp
push   %rbx
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r14
push   %r13
push   %r12
push   %r15
call   1040 <Bdouble_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x118(%rsp),%rcx
jmp    18cb <make_dibaryon_correlator+0x78b>
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp,%rax,4),%ecx
xor    %edx,%edx
jmp    1f60 <make_dibaryon_correlator+0xe20>
mov    $0x1,%dl
cmp    $0x1,%esi
jne    1f60 <make_dibaryon_correlator+0xe20>
mov    %edi,0x34(%rsp)
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
mov    0x6c(%rsp),%ebp
mov    %ebp,%esi
mov    0x5c(%rsp),%edx
mov    0x4c(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    0x60(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   0x70(%rsp)
push   0x50(%rsp)
mov    0xc0(%rsp),%r13
push   %r13
mov    0xd0(%rsp),%r14
push   %r14
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1b0(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
mov    0x5c(%rsp),%r13d
mov    %r13d,%edx
mov    0x4c(%rsp),%r12d
mov    %r12d,%ecx
mov    0x48(%rsp),%ebx
mov    %ebx,%r8d
mov    0x60(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x70(%rsp),%r15
push   %r15
push   0x50(%rsp)
push   0xc0(%rsp)
push   %r14
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1b8(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
mov    0x60(%rsp),%r14
mov    %r14d,%r9d
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r15
push   0x50(%rsp)
mov    0xc0(%rsp),%r12
push   %r12
mov    0xd0(%rsp),%rbx
push   %rbx
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x1b8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0xc(%rsp),%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x4c(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    %r14d,%r9d
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r15
push   0x50(%rsp)
push   %r12
push   %rbx
call   1040 <Bdouble_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x1b0(%rsp),%rcx
jmp    18cb <make_dibaryon_correlator+0x78b>
cs nopw 0x0(%rax,%rax,1)
test   %ecx,%ecx
je     1fa0 <make_dibaryon_correlator+0xe60>
test   %dl,%dl
je     1f80 <make_dibaryon_correlator+0xe40>
movapd %xmm0,%xmm2
movapd %xmm1,%xmm5
cmp    $0x1,%ecx
je     16e0 <make_dibaryon_correlator+0x5a0>
jmp    18df <make_dibaryon_correlator+0x79f>
xchg   %ax,%ax
cmp    $0x1,%ecx
jne    1fb8 <make_dibaryon_correlator+0xe78>
cmpl   $0x1,0xa0(%rsp,%rax,4)
01
movapd %xmm0,%xmm2
movapd %xmm1,%xmm5
je     16e0 <make_dibaryon_correlator+0x5a0>
jmp    18df <make_dibaryon_correlator+0x79f>
cmpl   $0x0,0xa0(%rsp,%rax,4)
movapd %xmm0,%xmm2
movapd %xmm1,%xmm5
jne    18df <make_dibaryon_correlator+0x79f>
jmp    1fcd <make_dibaryon_correlator+0xe8d>
movapd %xmm0,%xmm2
movapd %xmm1,%xmm5
jmp    18df <make_dibaryon_correlator+0x79f>
test   %edx,%edx
je     21bf <make_dibaryon_correlator+0x107f>
mov    %edi,0x34(%rsp)
mov    0xc(%rsp),%edi
mov    0x40(%rsp),%esi
mov    0x3c(%rsp),%ebx
mov    %ebx,%edx
mov    0x44(%rsp),%ecx
mov    0x38(%rsp),%r8d
mov    %r8d,%r12d
mov    0x28(%rsp),%r9
mov    0x240(%rsp),%ebp
push   %rbp
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   0x70(%rsp)
push   0x88(%rsp)
mov    0xb0(%rsp),%r15
push   %r15
mov    0xc0(%rsp),%r13
push   %r13
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x190(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    0x40(%rsp),%r15d
mov    %r15d,%esi
mov    %ebx,%edx
mov    0x44(%rsp),%r14d
mov    %r14d,%ecx
mov    %r12d,%ebx
mov    %r12d,%r8d
mov    0x28(%rsp),%r9
push   %rbp
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x70(%rsp),%r13
push   %r13
mov    0x88(%rsp),%r12
push   %r12
push   0xb0(%rsp)
push   0xc0(%rsp)
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x198(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0xc(%rsp),%edi
mov    %r15d,%esi
mov    0x3c(%rsp),%r15d
mov    %r15d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
mov    0x28(%rsp),%r9
mov    0x240(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r13
push   %r12
mov    0xb0(%rsp),%rbx
push   %rbx
mov    0xc0(%rsp),%r14
push   %r14
call   1040 <Bdouble_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x240(%rsp),%ebp
mov    0xc(%rsp),%edi
mov    0x40(%rsp),%esi
mov    %r15d,%edx
mov    0x44(%rsp),%ecx
mov    0x38(%rsp),%r8d
mov    0x28(%rsp),%r9
push   %rbp
mov    0x228(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
mov    0x220(%rsp),%eax
push   %rax
push   %r13
push   %r12
push   %rbx
push   %r14
call   1040 <Bdouble_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x190(%rsp),%rcx
jmp    18cb <make_dibaryon_correlator+0x78b>
sub    $0x8,%rsp
mov    %edi,0x3c(%rsp)
mov    0x14(%rsp),%edi
mov    0x48(%rsp),%ebp
mov    %ebp,%esi
mov    0x44(%rsp),%edx
mov    0x4c(%rsp),%r14d
mov    %r14d,%ecx
mov    0x40(%rsp),%r8d
mov    0x30(%rsp),%r9
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x228(%rsp),%ebx
push   %rbx
mov    0x78(%rsp),%r15
push   %r15
mov    0xb0(%rsp),%r13
push   %r13
mov    0xc0(%rsp),%r12
push   %r12
movsd  %xmm3,0x58(%rsp)
movsd  %xmm4,0x60(%rsp)
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x110(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    %ebp,%esi
mov    0x44(%rsp),%r12d
mov    %r12d,%edx
mov    %r14d,%ecx
mov    0x40(%rsp),%ebx
mov    %ebx,%r8d
mov    0x30(%rsp),%rbp
mov    %ebp,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
push   %r15
push   0xb0(%rsp)
push   0xc0(%rsp)
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
mov    0x138(%rsp),%r15
movsd  (%r15,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    0x48(%rsp),%esi
mov    %r12d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
mov    %ebp,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
mov    0x78(%rsp),%r13
push   %r13
mov    0xb0(%rsp),%r12
push   %r12
mov    0xc0(%rsp),%r14
push   %r14
call   1050 <Blocal_index@plt>
add    $0x40,%rsp
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x208(%rsp),%r15d
sub    $0x8,%rsp
mov    0x14(%rsp),%edi
mov    0x48(%rsp),%esi
mov    0x44(%rsp),%edx
mov    0x4c(%rsp),%ecx
mov    0x40(%rsp),%r8d
mov    %ebp,%r9d
mov    0x248(%rsp),%eax
push   %rax
mov    0x230(%rsp),%eax
push   %rax
mov    0x228(%rsp),%eax
push   %rax
push   %r15
push   %r13
push   %r12
push   %r14
call   1050 <Blocal_index@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
mov    0x74(%rsp),%edi
movsd  0x50(%rsp),%xmm2
add    $0x40,%rsp
mov    0x110(%rsp),%rcx
jmp    18cb <make_dibaryon_correlator+0x78b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x248(%rsp),%ebx
test   %ebx,%ebx
mov    0x220(%rsp),%r14d
mov    0x28(%rsp),%r13
mov    0x200(%rsp),%rbp
movsd  %xmm2,0x10(%rsp)
mov    0x60(%rsp),%r12
movsd  %xmm5,0x20(%rsp)
jle    1670 <make_dibaryon_correlator+0x530>
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
call   1030 <index_3d@plt>
mov    0x1f8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
call   1030 <index_3d@plt>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
mov    0x50(%rsp),%rdi
mov    %r15d,%esi
mov    0xc(%rsp),%ebp
mov    %ebp,%edx
mov    %ebx,%ecx
mov    0x228(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x148(%rsp),%rcx
movsd  0x18(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
call   1030 <index_3d@plt>
mov    0x1f8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
call   1030 <index_3d@plt>
mov    0x200(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x50(%rsp),%rdi
mov    %r15d,%esi
mov    %ebp,%edx
mov    0x200(%rsp),%rbp
mov    %ebx,%ecx
mov    0x228(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x150(%rsp),%rdx
movsd  0x18(%rsp),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%r15d
cmp    %r15d,%ebx
jne    2400 <make_dibaryon_correlator+0x12c0>
jmp    1670 <make_dibaryon_correlator+0x530>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @make_dibaryon_correlator(double* %0, double* %1, double* %2, double* %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, i32* %14, i32* %15, double %16, i32* %17, i32* %18, double* %19, double* %20, double* %21, i32 %22, i32 %23, i32 %24, i32 %25, i32 %26, i32 %27, i32 %28, i32 %29, i32 %30, i32 %31) {
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca double*
%40 = alloca double*
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = alloca i32*
%48 = alloca i32*
%49 = alloca double
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca double*
%53 = alloca double*
%54 = alloca double*
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32
%84 = alloca i32
%85 = alloca i32
%86 = alloca i32
%87 = alloca double
%88 = alloca double
%89 = alloca double
%90 = alloca double
%91 = alloca i8*
%92 = alloca i64
%93 = alloca i64
%94 = alloca i64
%95 = alloca i64
%96 = alloca i64
%97 = alloca i64
%98 = alloca i64
%99 = alloca i64
%100 = alloca i64
store double* %0, double** %33
store double* %1, double** %34
store double* %2, double** %35
store double* %3, double** %36
store double* %4, double** %37
store double* %5, double** %38
store double* %6, double** %39
store double* %7, double** %40
store double* %8, double** %41
store double* %9, double** %42
store double* %10, double** %43
store double* %11, double** %44
store double* %12, double** %45
store double* %13, double** %46
store i32* %14, i32** %47
store i32* %15, i32** %48
store double %16, double* %49
store i32* %17, i32** %50
store i32* %18, i32** %51
store double* %19, double** %52
store double* %20, double** %53
store double* %21, double** %54
store i32 %22, i32* %55
store i32 %23, i32* %56
store i32 %24, i32* %57
store i32 %25, i32* %58
store i32 %26, i32* %59
store i32 %27, i32* %60
store i32 %28, i32* %61
store i32 %29, i32* %62
store i32 %30, i32* %63
store i32 %31, i32* %64
store i32 2, i32* %85
%101 = load i32, i32* %60
%102 = load i32, i32* %60
%103 = mul nsw i32 %101, %102
store i32 %103, i32* %86
%104 = load i32, i32* %85
%105 = zext i32 %104 to i64
%106 = call i8* @llvm.stacksave()
store i8* %106, i8** %91
%107 = alloca i32, i64 %105
store i64 %105, i64* %92
%108 = load i32, i32* %85
%109 = zext i32 %108 to i64
%110 = alloca i32, i64 %109
store i64 %109, i64* %93
%111 = load i32, i32* %85
%112 = zext i32 %111 to i64
%113 = alloca i32, i64 %112
store i64 %112, i64* %94
%114 = load i32, i32* %85
%115 = zext i32 %114 to i64
%116 = alloca i32, i64 %115
store i64 %115, i64* %95
%117 = load i32, i32* %85
%118 = zext i32 %117 to i64
%119 = alloca i32, i64 %118
store i64 %118, i64* %96
%120 = load i32, i32* %85
%121 = zext i32 %120 to i64
%122 = alloca i32, i64 %121
store i64 %121, i64* %97
%123 = load i32, i32* %85
%124 = zext i32 %123 to i64
%125 = alloca i32, i64 %124
store i64 %124, i64* %98
%126 = load i32, i32* %85
%127 = zext i32 %126 to i64
%128 = alloca i32, i64 %127
store i64 %127, i64* %99
%129 = load i32, i32* %85
%130 = zext i32 %129 to i64
%131 = alloca i32, i64 %130
store i64 %130, i64* %100
store i32 0, i32* %81
br label %132
132: ; preds = %1139, %32
%133 = load i32, i32* %81
%134 = load i32, i32* %64
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %1142
136: ; preds = %132
store i32 0, i32* %82
br label %137
137: ; preds = %262, %136
%138 = load i32, i32* %82
%139 = load i32, i32* %85
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %265
141: ; preds = %137
%142 = load i32*, i32** %47
%143 = load i32, i32* %81
%144 = load i32, i32* %61
%145 = load i32, i32* %82
%146 = mul nsw i32 %144, %145
%147 = add nsw i32 %146, 0
%148 = load i32, i32* %61
%149 = mul nsw i32 2, %148
%150 = call i64 @index_2d(i32 %143, i32 %147, i32 %149)
%151 = getelementptr inbounds i32, i32* %142, i64 %150
%152 = load i32, i32* %151
%153 = sub nsw i32 %152, 1
%154 = load i32, i32* %82
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %125, i64 %155
store i32 %153, i32* %156
%157 = load i32*, i32** %47
%158 = load i32, i32* %81
%159 = load i32, i32* %61
%160 = load i32, i32* %82
%161 = mul nsw i32 %159, %160
%162 = add nsw i32 %161, 1
%163 = load i32, i32* %61
%164 = mul nsw i32 2, %163
%165 = call i64 @index_2d(i32 %158, i32 %162, i32 %164)
%166 = getelementptr inbounds i32, i32* %157, i64 %165
%167 = load i32, i32* %166
%168 = sub nsw i32 %167, 1
%169 = load i32, i32* %82
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %128, i64 %170
store i32 %168, i32* %171
%172 = load i32*, i32** %47
%173 = load i32, i32* %81
%174 = load i32, i32* %61
%175 = load i32, i32* %82
%176 = mul nsw i32 %174, %175
%177 = add nsw i32 %176, 2
%178 = load i32, i32* %61
%179 = mul nsw i32 2, %178
%180 = call i64 @index_2d(i32 %173, i32 %177, i32 %179)
%181 = getelementptr inbounds i32, i32* %172, i64 %180
%182 = load i32, i32* %181
%183 = sub nsw i32 %182, 1
%184 = load i32, i32* %82
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %131, i64 %185
store i32 %183, i32* %186
%187 = load i32, i32* %82
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %125, i64 %188
%190 = load i32, i32* %189
%191 = load i32, i32* %82
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %125, i64 %192
%194 = load i32, i32* %193
%195 = load i32, i32* %61
%196 = srem i32 %194, %195
%197 = sub nsw i32 %190, %196
%198 = load i32, i32* %61
%199 = sdiv i32 %197, %198
%200 = load i32, i32* %82
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i32, i32* %116, i64 %201
store i32 %199, i32* %202
%203 = load i32, i32* %82
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %128, i64 %204
%206 = load i32, i32* %205
%207 = load i32, i32* %82
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %128, i64 %208
%210 = load i32, i32* %209
%211 = load i32, i32* %61
%212 = srem i32 %210, %211
%213 = sub nsw i32 %206, %212
%214 = load i32, i32* %61
%215 = sdiv i32 %213, %214
%216 = load i32, i32* %82
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32, i32* %119, i64 %217
store i32 %215, i32* %218
%219 = load i32, i32* %82
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %131, i64 %220
%222 = load i32, i32* %221
%223 = load i32, i32* %82
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %131, i64 %224
%226 = load i32, i32* %225
%227 = load i32, i32* %61
%228 = srem i32 %226, %227
%229 = sub nsw i32 %222, %228
%230 = load i32, i32* %61
%231 = sdiv i32 %229, %230
%232 = load i32, i32* %82
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %122, i64 %233
store i32 %231, i32* %234
%235 = load i32, i32* %82
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32, i32* %125, i64 %236
%238 = load i32, i32* %237
%239 = load i32, i32* %61
%240 = srem i32 %238, %239
%241 = load i32, i32* %82
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i32, i32* %107, i64 %242
store i32 %240, i32* %243
%244 = load i32, i32* %82
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i32, i32* %128, i64 %245
%247 = load i32, i32* %246
%248 = load i32, i32* %61
%249 = srem i32 %247, %248
%250 = load i32, i32* %82
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %110, i64 %251
store i32 %249, i32* %252
%253 = load i32, i32* %82
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %131, i64 %254
%256 = load i32, i32* %255
%257 = load i32, i32* %61
%258 = srem i32 %256, %257
%259 = load i32, i32* %82
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %113, i64 %260
store i32 %258, i32* %261
br label %262
262: ; preds = %141
%263 = load i32, i32* %82
%264 = add nsw i32 %263, 1
store i32 %264, i32* %82
br label %137
265: ; preds = %137
store i32 0, i32* %80
br label %266
266: ; preds = %1135, %265
%267 = load i32, i32* %80
%268 = load i32, i32* %86
%269 = icmp slt i32 %267, %268
br i1 %269, label %270, label %1138
270: ; preds = %266
%271 = load i32*, i32** %50
%272 = getelementptr inbounds i32, i32* %116, i64 0
%273 = load i32, i32* %272
%274 = load i32, i32* %80
%275 = getelementptr inbounds i32, i32* %107, i64 0
%276 = load i32, i32* %275
%277 = load i32, i32* %86
%278 = load i32, i32* %61
%279 = call i64 @index_3d(i32 %273, i32 %274, i32 %276, i32 %277, i32 %278)
%280 = getelementptr inbounds i32, i32* %271, i64 %279
%281 = load i32, i32* %280
store i32 %281, i32* %65
%282 = load i32*, i32** %51
%283 = getelementptr inbounds i32, i32* %116, i64 0
%284 = load i32, i32* %283
%285 = load i32, i32* %80
%286 = getelementptr inbounds i32, i32* %107, i64 0
%287 = load i32, i32* %286
%288 = load i32, i32* %86
%289 = load i32, i32* %61
%290 = call i64 @index_3d(i32 %284, i32 %285, i32 %287, i32 %288, i32 %289)
%291 = getelementptr inbounds i32, i32* %282, i64 %290
%292 = load i32, i32* %291
store i32 %292, i32* %66
%293 = load i32*, i32** %50
%294 = getelementptr inbounds i32, i32* %119, i64 0
%295 = load i32, i32* %294
%296 = load i32, i32* %80
%297 = getelementptr inbounds i32, i32* %110, i64 0
%298 = load i32, i32* %297
%299 = load i32, i32* %86
%300 = load i32, i32* %61
%301 = call i64 @index_3d(i32 %295, i32 %296, i32 %298, i32 %299, i32 %300)
%302 = getelementptr inbounds i32, i32* %293, i64 %301
%303 = load i32, i32* %302
store i32 %303, i32* %67
%304 = load i32*, i32** %51
%305 = getelementptr inbounds i32, i32* %119, i64 0
%306 = load i32, i32* %305
%307 = load i32, i32* %80
%308 = getelementptr inbounds i32, i32* %110, i64 0
%309 = load i32, i32* %308
%310 = load i32, i32* %86
%311 = load i32, i32* %61
%312 = call i64 @index_3d(i32 %306, i32 %307, i32 %309, i32 %310, i32 %311)
%313 = getelementptr inbounds i32, i32* %304, i64 %312
%314 = load i32, i32* %313
store i32 %314, i32* %68
%315 = load i32*, i32** %50
%316 = getelementptr inbounds i32, i32* %122, i64 0
%317 = load i32, i32* %316
%318 = load i32, i32* %80
%319 = getelementptr inbounds i32, i32* %113, i64 0
%320 = load i32, i32* %319
%321 = load i32, i32* %86
%322 = load i32, i32* %61
%323 = call i64 @index_3d(i32 %317, i32 %318, i32 %320, i32 %321, i32 %322)
%324 = getelementptr inbounds i32, i32* %315, i64 %323
%325 = load i32, i32* %324
store i32 %325, i32* %69
%326 = load i32*, i32** %51
%327 = getelementptr inbounds i32, i32* %122, i64 0
%328 = load i32, i32* %327
%329 = load i32, i32* %80
%330 = getelementptr inbounds i32, i32* %113, i64 0
%331 = load i32, i32* %330
%332 = load i32, i32* %86
%333 = load i32, i32* %61
%334 = call i64 @index_3d(i32 %328, i32 %329, i32 %331, i32 %332, i32 %333)
%335 = getelementptr inbounds i32, i32* %326, i64 %334
%336 = load i32, i32* %335
store i32 %336, i32* %70
%337 = load i32*, i32** %50
%338 = getelementptr inbounds i32, i32* %116, i64 1
%339 = load i32, i32* %338
%340 = load i32, i32* %80
%341 = getelementptr inbounds i32, i32* %107, i64 1
%342 = load i32, i32* %341
%343 = load i32, i32* %86
%344 = load i32, i32* %61
%345 = call i64 @index_3d(i32 %339, i32 %340, i32 %342, i32 %343, i32 %344)
%346 = getelementptr inbounds i32, i32* %337, i64 %345
%347 = load i32, i32* %346
store i32 %347, i32* %71
%348 = load i32*, i32** %51
%349 = getelementptr inbounds i32, i32* %116, i64 1
%350 = load i32, i32* %349
%351 = load i32, i32* %80
%352 = getelementptr inbounds i32, i32* %107, i64 1
%353 = load i32, i32* %352
%354 = load i32, i32* %86
%355 = load i32, i32* %61
%356 = call i64 @index_3d(i32 %350, i32 %351, i32 %353, i32 %354, i32 %355)
%357 = getelementptr inbounds i32, i32* %348, i64 %356
%358 = load i32, i32* %357
store i32 %358, i32* %72
%359 = load i32*, i32** %50
%360 = getelementptr inbounds i32, i32* %119, i64 1
%361 = load i32, i32* %360
%362 = load i32, i32* %80
%363 = getelementptr inbounds i32, i32* %110, i64 1
%364 = load i32, i32* %363
%365 = load i32, i32* %86
%366 = load i32, i32* %61
%367 = call i64 @index_3d(i32 %361, i32 %362, i32 %364, i32 %365, i32 %366)
%368 = getelementptr inbounds i32, i32* %359, i64 %367
%369 = load i32, i32* %368
store i32 %369, i32* %73
%370 = load i32*, i32** %51
%371 = getelementptr inbounds i32, i32* %119, i64 1
%372 = load i32, i32* %371
%373 = load i32, i32* %80
%374 = getelementptr inbounds i32, i32* %110, i64 1
%375 = load i32, i32* %374
%376 = load i32, i32* %86
%377 = load i32, i32* %61
%378 = call i64 @index_3d(i32 %372, i32 %373, i32 %375, i32 %376, i32 %377)
%379 = getelementptr inbounds i32, i32* %370, i64 %378
%380 = load i32, i32* %379
store i32 %380, i32* %74
%381 = load i32*, i32** %50
%382 = getelementptr inbounds i32, i32* %122, i64 1
%383 = load i32, i32* %382
%384 = load i32, i32* %80
%385 = getelementptr inbounds i32, i32* %113, i64 1
%386 = load i32, i32* %385
%387 = load i32, i32* %86
%388 = load i32, i32* %61
%389 = call i64 @index_3d(i32 %383, i32 %384, i32 %386, i32 %387, i32 %388)
%390 = getelementptr inbounds i32, i32* %381, i64 %389
%391 = load i32, i32* %390
store i32 %391, i32* %75
%392 = load i32*, i32** %51
%393 = getelementptr inbounds i32, i32* %122, i64 1
%394 = load i32, i32* %393
%395 = load i32, i32* %80
%396 = getelementptr inbounds i32, i32* %113, i64 1
%397 = load i32, i32* %396
%398 = load i32, i32* %86
%399 = load i32, i32* %61
%400 = call i64 @index_3d(i32 %394, i32 %395, i32 %397, i32 %398, i32 %399)
%401 = getelementptr inbounds i32, i32* %392, i64 %400
%402 = load i32, i32* %401
store i32 %402, i32* %76
store i32 0, i32* %79
br label %403
403: ; preds = %1131, %270
%404 = load i32, i32* %79
%405 = load i32, i32* %59
%406 = icmp slt i32 %404, %405
br i1 %406, label %407, label %1134
407: ; preds = %403
store i32 0, i32* %77
br label %408
408: ; preds = %1127, %407
%409 = load i32, i32* %77
%410 = load i32, i32* %58
%411 = icmp slt i32 %409, %410
br i1 %411, label %412, label %1130
412: ; preds = %408
store i32 0, i32* %78
br label %413
413: ; preds = %1123, %412
%414 = load i32, i32* %78
%415 = load i32, i32* %58
%416 = icmp slt i32 %414, %415
br i1 %416, label %417, label %1126
417: ; preds = %413
store i32 0, i32* %84
br label %418
418: ; preds = %1119, %417
%419 = load i32, i32* %84
%420 = load i32, i32* %62
%421 = icmp slt i32 %419, %420
br i1 %421, label %422, label %1122
422: ; preds = %418
%423 = load i32*, i32** %48
%424 = load i32, i32* %81
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds i32, i32* %423, i64 %425
%427 = load i32, i32* %426
%428 = sitofp i32 %427 to double
%429 = load double, double* %49
%430 = fmul double %428, %429
%431 = load double*, double** %52
%432 = load i32, i32* %80
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fmul double %430, %435
store double %436, double* %87
store double 0.000000e+00, double* %88
store i32 0, i32* %82
br label %437
437: ; preds = %1041, %422
%438 = load i32, i32* %82
%439 = load i32, i32* %85
%440 = icmp slt i32 %438, %439
br i1 %440, label %441, label %1044
441: ; preds = %437
%442 = load i32, i32* %82
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds i32, i32* %116, i64 %443
%445 = load i32, i32* %444
%446 = icmp eq i32 %445, 0
br i1 %446, label %447, label %537
447: ; preds = %441
%448 = load i32, i32* %82
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %119, i64 %449
%451 = load i32, i32* %450
%452 = icmp eq i32 %451, 0
br i1 %452, label %453, label %537
453: ; preds = %447
%454 = load i32, i32* %82
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i32, i32* %122, i64 %455
%457 = load i32, i32* %456
%458 = icmp eq i32 %457, 0
br i1 %458, label %459, label %537
459: ; preds = %453
%460 = load double, double* %87
%461 = load double*, double** %35
%462 = load i32, i32* %79
%463 = load i32, i32* %65
%464 = load i32, i32* %66
%465 = load i32, i32* %69
%466 = load i32, i32* %70
%467 = load i32, i32* %77
%468 = load i32, i32* %67
%469 = load i32, i32* %68
%470 = load i32, i32* %84
%471 = load i32, i32* %55
%472 = load i32, i32* %56
%473 = load i32, i32* %58
%474 = load i32, i32* %62
%475 = call i64 @Blocal_index(i32 %462, i32 %463, i32 %464, i32 %465, i32 %466, i32 %467, i32 %468, i32 %469, i32 %470, i32 %471, i32 %472, i32 %473, i32 %474)
%476 = getelementptr inbounds double, double* %461, i64 %475
%477 = load double, double* %476
%478 = load double, double* %88
%479 = load double*, double** %36
%480 = load i32, i32* %79
%481 = load i32, i32* %65
%482 = load i32, i32* %66
%483 = load i32, i32* %69
%484 = load i32, i32* %70
%485 = load i32, i32* %77
%486 = load i32, i32* %67
%487 = load i32, i32* %68
%488 = load i32, i32* %84
%489 = load i32, i32* %55
%490 = load i32, i32* %56
%491 = load i32, i32* %58
%492 = load i32, i32* %62
%493 = call i64 @Blocal_index(i32 %480, i32 %481, i32 %482, i32 %483, i32 %484, i32 %485, i32 %486, i32 %487, i32 %488, i32 %489, i32 %490, i32 %491, i32 %492)
%494 = getelementptr inbounds double, double* %479, i64 %493
%495 = load double, double* %494
%496 = fmul double %478, %495
%497 = fneg double %496
%498 = call double @llvm.fmuladd.f64(double %460, double %477, double %497)
store double %498, double* %89
%499 = load double, double* %87
%500 = load double*, double** %36
%501 = load i32, i32* %79
%502 = load i32, i32* %65
%503 = load i32, i32* %66
%504 = load i32, i32* %69
%505 = load i32, i32* %70
%506 = load i32, i32* %77
%507 = load i32, i32* %67
%508 = load i32, i32* %68
%509 = load i32, i32* %84
%510 = load i32, i32* %55
%511 = load i32, i32* %56
%512 = load i32, i32* %58
%513 = load i32, i32* %62
%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* %88
%518 = load double*, double** %35
%519 = load i32, i32* %79
%520 = load i32, i32* %65
%521 = load i32, i32* %66
%522 = load i32, i32* %69
%523 = load i32, i32* %70
%524 = load i32, i32* %77
%525 = load i32, i32* %67
%526 = load i32, i32* %68
%527 = load i32, i32* %84
%528 = load i32, i32* %55
%529 = load i32, i32* %56
%530 = load i32, i32* %58
%531 = load i32, i32* %62
%532 = call i64 @Blocal_index(i32 %519, i32 %520, i32 %521, i32 %522, i32 %523, i32 %524, i32 %525, i32 %526, i32 %527, i32 %528, i32 %529, i32 %530, i32 %531)
%533 = getelementptr inbounds double, double* %518, i64 %532
%534 = load double, double* %533
%535 = fmul double %517, %534
%536 = call double @llvm.fmuladd.f64(double %499, double %516, double %535)
store double %536, double* %90
br label %1038
537: ; preds = %453, %447, %441
%538 = load i32, i32* %82
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32, i32* %116, i64 %539
%541 = load i32, i32* %540
%542 = icmp eq i32 %541, 1
br i1 %542, label %543, label %633
543: ; preds = %537
%544 = load i32, i32* %82
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds i32, i32* %119, i64 %545
%547 = load i32, i32* %546
%548 = icmp eq i32 %547, 1
br i1 %548, label %549, label %633
549: ; preds = %543
%550 = load i32, i32* %82
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i32, i32* %122, i64 %551
%553 = load i32, i32* %552
%554 = icmp eq i32 %553, 1
br i1 %554, label %555, label %633
555: ; preds = %549
%556 = load double, double* %87
%557 = load double*, double** %41
%558 = load i32, i32* %79
%559 = load i32, i32* %71
%560 = load i32, i32* %72
%561 = load i32, i32* %75
%562 = load i32, i32* %76
%563 = load i32, i32* %78
%564 = load i32, i32* %73
%565 = load i32, i32* %74
%566 = load i32, i32* %84
%567 = load i32, i32* %55
%568 = load i32, i32* %56
%569 = load i32, i32* %58
%570 = load i32, i32* %62
%571 = call i64 @Blocal_index(i32 %558, i32 %559, i32 %560, i32 %561, i32 %562, i32 %563, i32 %564, i32 %565, i32 %566, i32 %567, i32 %568, i32 %569, i32 %570)
%572 = getelementptr inbounds double, double* %557, i64 %571
%573 = load double, double* %572
%574 = load double, double* %88
%575 = load double*, double** %42
%576 = load i32, i32* %79
%577 = load i32, i32* %71
%578 = load i32, i32* %72
%579 = load i32, i32* %75
%580 = load i32, i32* %76
%581 = load i32, i32* %78
%582 = load i32, i32* %73
%583 = load i32, i32* %74
%584 = load i32, i32* %84
%585 = load i32, i32* %55
%586 = load i32, i32* %56
%587 = load i32, i32* %58
%588 = load i32, i32* %62
%589 = call i64 @Blocal_index(i32 %576, i32 %577, i32 %578, i32 %579, i32 %580, i32 %581, i32 %582, i32 %583, i32 %584, i32 %585, i32 %586, i32 %587, i32 %588)
%590 = getelementptr inbounds double, double* %575, i64 %589
%591 = load double, double* %590
%592 = fmul double %574, %591
%593 = fneg double %592
%594 = call double @llvm.fmuladd.f64(double %556, double %573, double %593)
store double %594, double* %89
%595 = load double, double* %87
%596 = load double*, double** %42
%597 = load i32, i32* %79
%598 = load i32, i32* %71
%599 = load i32, i32* %72
%600 = load i32, i32* %75
%601 = load i32, i32* %76
%602 = load i32, i32* %78
%603 = load i32, i32* %73
%604 = load i32, i32* %74
%605 = load i32, i32* %84
%606 = load i32, i32* %55
%607 = load i32, i32* %56
%608 = load i32, i32* %58
%609 = load i32, i32* %62
%610 = call i64 @Blocal_index(i32 %597, i32 %598, i32 %599, i32 %600, i32 %601, i32 %602, i32 %603, i32 %604, i32 %605, i32 %606, i32 %607, i32 %608, i32 %609)
%611 = getelementptr inbounds double, double* %596, i64 %610
%612 = load double, double* %611
%613 = load double, double* %88
%614 = load double*, double** %41
%615 = load i32, i32* %79
%616 = load i32, i32* %71
%617 = load i32, i32* %72
%618 = load i32, i32* %75
%619 = load i32, i32* %76
%620 = load i32, i32* %78
%621 = load i32, i32* %73
%622 = load i32, i32* %74
%623 = load i32, i32* %84
%624 = load i32, i32* %55
%625 = load i32, i32* %56
%626 = load i32, i32* %58
%627 = load i32, i32* %62
%628 = call i64 @Blocal_index(i32 %615, i32 %616, i32 %617, i32 %618, i32 %619, i32 %620, i32 %621, i32 %622, i32 %623, i32 %624, i32 %625, i32 %626, i32 %627)
%629 = getelementptr inbounds double, double* %614, i64 %628
%630 = load double, double* %629
%631 = fmul double %613, %630
%632 = call double @llvm.fmuladd.f64(double %595, double %612, double %631)
store double %632, double* %90
br label %1037
633: ; preds = %549, %543, %537
%634 = load i32, i32* %82
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds i32, i32* %116, i64 %635
%637 = load i32, i32* %636
%638 = icmp eq i32 %637, 0
br i1 %638, label %639, label %727
639: ; preds = %633
%640 = load i32, i32* %82
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds i32, i32* %122, i64 %641
%643 = load i32, i32* %642
%644 = icmp eq i32 %643, 0
br i1 %644, label %645, label %727
645: ; preds = %639
%646 = load double, double* %87
%647 = load double*, double** %37
%648 = load i32, i32* %79
%649 = load i32, i32* %65
%650 = load i32, i32* %66
%651 = load i32, i32* %69
%652 = load i32, i32* %70
%653 = load i32, i32* %77
%654 = load i32, i32* %67
%655 = load i32, i32* %68
%656 = load i32, i32* %78
%657 = load i32, i32* %84
%658 = load i32, i32* %55
%659 = load i32, i32* %56
%660 = load i32, i32* %58
%661 = load i32, i32* %62
%662 = call i64 @Bdouble_index(i32 %648, i32 %649, i32 %650, i32 %651, i32 %652, i32 %653, i32 %654, i32 %655, i32 %656, i32 %657, i32 %658, i32 %659, i32 %660, i32 %661)
%663 = getelementptr inbounds double, double* %647, i64 %662
%664 = load double, double* %663
%665 = load double, double* %88
%666 = load double*, double** %38
%667 = load i32, i32* %79
%668 = load i32, i32* %65
%669 = load i32, i32* %66
%670 = load i32, i32* %69
%671 = load i32, i32* %70
%672 = load i32, i32* %77
%673 = load i32, i32* %67
%674 = load i32, i32* %68
%675 = load i32, i32* %78
%676 = load i32, i32* %84
%677 = load i32, i32* %55
%678 = load i32, i32* %56
%679 = load i32, i32* %58
%680 = load i32, i32* %62
%681 = call i64 @Bdouble_index(i32 %667, i32 %668, i32 %669, i32 %670, i32 %671, i32 %672, i32 %673, i32 %674, i32 %675, i32 %676, i32 %677, i32 %678, i32 %679, i32 %680)
%682 = getelementptr inbounds double, double* %666, i64 %681
%683 = load double, double* %682
%684 = fmul double %665, %683
%685 = fneg double %684
%686 = call double @llvm.fmuladd.f64(double %646, double %664, double %685)
store double %686, double* %89
%687 = load double, double* %87
%688 = load double*, double** %38
%689 = load i32, i32* %79
%690 = load i32, i32* %65
%691 = load i32, i32* %66
%692 = load i32, i32* %69
%693 = load i32, i32* %70
%694 = load i32, i32* %77
%695 = load i32, i32* %67
%696 = load i32, i32* %68
%697 = load i32, i32* %78
%698 = load i32, i32* %84
%699 = load i32, i32* %55
%700 = load i32, i32* %56
%701 = load i32, i32* %58
%702 = load i32, i32* %62
%703 = call i64 @Bdouble_index(i32 %689, i32 %690, i32 %691, i32 %692, i32 %693, i32 %694, i32 %695, i32 %696, i32 %697, i32 %698, i32 %699, i32 %700, i32 %701, i32 %702)
%704 = getelementptr inbounds double, double* %688, i64 %703
%705 = load double, double* %704
%706 = load double, double* %88
%707 = load double*, double** %37
%708 = load i32, i32* %79
%709 = load i32, i32* %65
%710 = load i32, i32* %66
%711 = load i32, i32* %69
%712 = load i32, i32* %70
%713 = load i32, i32* %77
%714 = load i32, i32* %67
%715 = load i32, i32* %68
%716 = load i32, i32* %78
%717 = load i32, i32* %84
%718 = load i32, i32* %55
%719 = load i32, i32* %56
%720 = load i32, i32* %58
%721 = load i32, i32* %62
%722 = call i64 @Bdouble_index(i32 %708, i32 %709, i32 %710, i32 %711, i32 %712, i32 %713, i32 %714, i32 %715, i32 %716, i32 %717, i32 %718, i32 %719, i32 %720, i32 %721)
%723 = getelementptr inbounds double, double* %707, i64 %722
%724 = load double, double* %723
%725 = fmul double %706, %724
%726 = call double @llvm.fmuladd.f64(double %687, double %705, double %725)
store double %726, double* %90
br label %1036
727: ; preds = %639, %633
%728 = load i32, i32* %82
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds i32, i32* %116, i64 %729
%731 = load i32, i32* %730
%732 = icmp eq i32 %731, 1
br i1 %732, label %733, label %821
733: ; preds = %727
%734 = load i32, i32* %82
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds i32, i32* %122, i64 %735
%737 = load i32, i32* %736
%738 = icmp eq i32 %737, 1
br i1 %738, label %739, label %821
739: ; preds = %733
%740 = load double, double* %87
%741 = load double*, double** %43
%742 = load i32, i32* %79
%743 = load i32, i32* %71
%744 = load i32, i32* %72
%745 = load i32, i32* %75
%746 = load i32, i32* %76
%747 = load i32, i32* %78
%748 = load i32, i32* %73
%749 = load i32, i32* %74
%750 = load i32, i32* %77
%751 = load i32, i32* %84
%752 = load i32, i32* %55
%753 = load i32, i32* %56
%754 = load i32, i32* %58
%755 = load i32, i32* %62
%756 = call i64 @Bdouble_index(i32 %742, i32 %743, i32 %744, i32 %745, i32 %746, i32 %747, i32 %748, i32 %749, i32 %750, i32 %751, i32 %752, i32 %753, i32 %754, i32 %755)
%757 = getelementptr inbounds double, double* %741, i64 %756
%758 = load double, double* %757
%759 = load double, double* %88
%760 = load double*, double** %44
%761 = load i32, i32* %79
%762 = load i32, i32* %71
%763 = load i32, i32* %72
%764 = load i32, i32* %75
%765 = load i32, i32* %76
%766 = load i32, i32* %78
%767 = load i32, i32* %73
%768 = load i32, i32* %74
%769 = load i32, i32* %77
%770 = load i32, i32* %84
%771 = load i32, i32* %55
%772 = load i32, i32* %56
%773 = load i32, i32* %58
%774 = load i32, i32* %62
%775 = call i64 @Bdouble_index(i32 %761, i32 %762, i32 %763, i32 %764, i32 %765, i32 %766, i32 %767, i32 %768, i32 %769, i32 %770, i32 %771, i32 %772, i32 %773, i32 %774)
%776 = getelementptr inbounds double, double* %760, i64 %775
%777 = load double, double* %776
%778 = fmul double %759, %777
%779 = fneg double %778
%780 = call double @llvm.fmuladd.f64(double %740, double %758, double %779)
store double %780, double* %89
%781 = load double, double* %87
%782 = load double*, double** %44
%783 = load i32, i32* %79
%784 = load i32, i32* %71
%785 = load i32, i32* %72
%786 = load i32, i32* %75
%787 = load i32, i32* %76
%788 = load i32, i32* %78
%789 = load i32, i32* %73
%790 = load i32, i32* %74
%791 = load i32, i32* %77
%792 = load i32, i32* %84
%793 = load i32, i32* %55
%794 = load i32, i32* %56
%795 = load i32, i32* %58
%796 = load i32, i32* %62
%797 = call i64 @Bdouble_index(i32 %783, i32 %784, i32 %785, i32 %786, i32 %787, i32 %788, i32 %789, i32 %790, i32 %791, i32 %792, i32 %793, i32 %794, i32 %795, i32 %796)
%798 = getelementptr inbounds double, double* %782, i64 %797
%799 = load double, double* %798
%800 = load double, double* %88
%801 = load double*, double** %43
%802 = load i32, i32* %79
%803 = load i32, i32* %71
%804 = load i32, i32* %72
%805 = load i32, i32* %75
%806 = load i32, i32* %76
%807 = load i32, i32* %78
%808 = load i32, i32* %73
%809 = load i32, i32* %74
%810 = load i32, i32* %77
%811 = load i32, i32* %84
%812 = load i32, i32* %55
%813 = load i32, i32* %56
%814 = load i32, i32* %58
%815 = load i32, i32* %62
%816 = call i64 @Bdouble_index(i32 %802, i32 %803, i32 %804, i32 %805, i32 %806, i32 %807, i32 %808, i32 %809, i32 %810, i32 %811, i32 %812, i32 %813, i32 %814, i32 %815)
%817 = getelementptr inbounds double, double* %801, i64 %816
%818 = load double, double* %817
%819 = fmul double %800, %818
%820 = call double @llvm.fmuladd.f64(double %781, double %799, double %819)
store double %820, double* %90
br label %1035
821: ; preds = %733, %727
%822 = load i32, i32* %82
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds i32, i32* %116, i64 %823
%825 = load i32, i32* %824
%826 = icmp eq i32 %825, 0
br i1 %826, label %827, label %833
827: ; preds = %821
%828 = load i32, i32* %82
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds i32, i32* %119, i64 %829
%831 = load i32, i32* %830
%832 = icmp eq i32 %831, 0
br i1 %832, label %845, label %833
833: ; preds = %827, %821
%834 = load i32, i32* %82
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds i32, i32* %119, i64 %835
%837 = load i32, i32* %836
%838 = icmp eq i32 %837, 0
br i1 %838, label %839, label %927
839: ; preds = %833
%840 = load i32, i32* %82
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds i32, i32* %122, i64 %841
%843 = load i32, i32* %842
%844 = icmp eq i32 %843, 0
br i1 %844, label %845, label %927
845: ; preds = %839, %827
%846 = load double, double* %87
%847 = load double*, double** %39
%848 = load i32, i32* %79
%849 = load i32, i32* %65
%850 = load i32, i32* %66
%851 = load i32, i32* %69
%852 = load i32, i32* %70
%853 = load i32, i32* %77
%854 = load i32, i32* %67
%855 = load i32, i32* %68
%856 = load i32, i32* %78
%857 = load i32, i32* %84
%858 = load i32, i32* %55
%859 = load i32, i32* %56
%860 = load i32, i32* %58
%861 = load i32, i32* %62
%862 = call i64 @Bdouble_index(i32 %848, i32 %849, i32 %850, i32 %851, i32 %852, i32 %853, i32 %854, i32 %855, i32 %856, i32 %857, i32 %858, i32 %859, i32 %860, i32 %861)
%863 = getelementptr inbounds double, double* %847, i64 %862
%864 = load double, double* %863
%865 = load double, double* %88
%866 = load double*, double** %40
%867 = load i32, i32* %79
%868 = load i32, i32* %65
%869 = load i32, i32* %66
%870 = load i32, i32* %69
%871 = load i32, i32* %70
%872 = load i32, i32* %77
%873 = load i32, i32* %67
%874 = load i32, i32* %68
%875 = load i32, i32* %78
%876 = load i32, i32* %84
%877 = load i32, i32* %55
%878 = load i32, i32* %56
%879 = load i32, i32* %58
%880 = load i32, i32* %62
%881 = call i64 @Bdouble_index(i32 %867, i32 %868, i32 %869, i32 %870, i32 %871, i32 %872, i32 %873, i32 %874, i32 %875, i32 %876, i32 %877, i32 %878, i32 %879, i32 %880)
%882 = getelementptr inbounds double, double* %866, i64 %881
%883 = load double, double* %882
%884 = fmul double %865, %883
%885 = fneg double %884
%886 = call double @llvm.fmuladd.f64(double %846, double %864, double %885)
store double %886, double* %89
%887 = load double, double* %87
%888 = load double*, double** %40
%889 = load i32, i32* %79
%890 = load i32, i32* %65
%891 = load i32, i32* %66
%892 = load i32, i32* %69
%893 = load i32, i32* %70
%894 = load i32, i32* %77
%895 = load i32, i32* %67
%896 = load i32, i32* %68
%897 = load i32, i32* %78
%898 = load i32, i32* %84
%899 = load i32, i32* %55
%900 = load i32, i32* %56
%901 = load i32, i32* %58
%902 = load i32, i32* %62
%903 = call i64 @Bdouble_index(i32 %889, i32 %890, i32 %891, i32 %892, i32 %893, i32 %894, i32 %895, i32 %896, i32 %897, i32 %898, i32 %899, i32 %900, i32 %901, i32 %902)
%904 = getelementptr inbounds double, double* %888, i64 %903
%905 = load double, double* %904
%906 = load double, double* %88
%907 = load double*, double** %39
%908 = load i32, i32* %79
%909 = load i32, i32* %65
%910 = load i32, i32* %66
%911 = load i32, i32* %69
%912 = load i32, i32* %70
%913 = load i32, i32* %77
%914 = load i32, i32* %67
%915 = load i32, i32* %68
%916 = load i32, i32* %78
%917 = load i32, i32* %84
%918 = load i32, i32* %55
%919 = load i32, i32* %56
%920 = load i32, i32* %58
%921 = load i32, i32* %62
%922 = call i64 @Bdouble_index(i32 %908, i32 %909, i32 %910, i32 %911, i32 %912, i32 %913, i32 %914, i32 %915, i32 %916, i32 %917, i32 %918, i32 %919, i32 %920, i32 %921)
%923 = getelementptr inbounds double, double* %907, i64 %922
%924 = load double, double* %923
%925 = fmul double %906, %924
%926 = call double @llvm.fmuladd.f64(double %887, double %905, double %925)
store double %926, double* %90
br label %1034
927: ; preds = %839, %833
%928 = load i32, i32* %82
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds i32, i32* %116, i64 %929
%931 = load i32, i32* %930
%932 = icmp eq i32 %931, 1
br i1 %932, label %933, label %939
933: ; preds = %927
%934 = load i32, i32* %82
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds i32, i32* %119, i64 %935
%937 = load i32, i32* %936
%938 = icmp eq i32 %937, 1
br i1 %938, label %951, label %939
939: ; preds = %933, %927
%940 = load i32, i32* %82
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds i32, i32* %119, i64 %941
%943 = load i32, i32* %942
%944 = icmp eq i32 %943, 1
br i1 %944, label %945, label %1033
945: ; preds = %939
%946 = load i32, i32* %82
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds i32, i32* %122, i64 %947
%949 = load i32, i32* %948
%950 = icmp eq i32 %949, 1
br i1 %950, label %951, label %1033
951: ; preds = %945, %933
%952 = load double, double* %87
%953 = load double*, double** %45
%954 = load i32, i32* %79
%955 = load i32, i32* %71
%956 = load i32, i32* %72
%957 = load i32, i32* %75
%958 = load i32, i32* %76
%959 = load i32, i32* %78
%960 = load i32, i32* %73
%961 = load i32, i32* %74
%962 = load i32, i32* %77
%963 = load i32, i32* %84
%964 = load i32, i32* %55
%965 = load i32, i32* %56
%966 = load i32, i32* %58
%967 = load i32, i32* %62
%968 = call i64 @Bdouble_index(i32 %954, i32 %955, i32 %956, i32 %957, i32 %958, i32 %959, i32 %960, i32 %961, i32 %962, i32 %963, i32 %964, i32 %965, i32 %966, i32 %967)
%969 = getelementptr inbounds double, double* %953, i64 %968
%970 = load double, double* %969
%971 = load double, double* %88
%972 = load double*, double** %46
%973 = load i32, i32* %79
%974 = load i32, i32* %71
%975 = load i32, i32* %72
%976 = load i32, i32* %75
%977 = load i32, i32* %76
%978 = load i32, i32* %78
%979 = load i32, i32* %73
%980 = load i32, i32* %74
%981 = load i32, i32* %77
%982 = load i32, i32* %84
%983 = load i32, i32* %55
%984 = load i32, i32* %56
%985 = load i32, i32* %58
%986 = load i32, i32* %62
%987 = call i64 @Bdouble_index(i32 %973, i32 %974, i32 %975, i32 %976, i32 %977, i32 %978, i32 %979, i32 %980, i32 %981, i32 %982, i32 %983, i32 %984, i32 %985, i32 %986)
%988 = getelementptr inbounds double, double* %972, i64 %987
%989 = load double, double* %988
%990 = fmul double %971, %989
%991 = fneg double %990
%992 = call double @llvm.fmuladd.f64(double %952, double %970, double %991)
store double %992, double* %89
%993 = load double, double* %87
%994 = load double*, double** %46
%995 = load i32, i32* %79
%996 = load i32, i32* %71
%997 = load i32, i32* %72
%998 = load i32, i32* %75
%999 = load i32, i32* %76
%1000 = load i32, i32* %78
%1001 = load i32, i32* %73
%1002 = load i32, i32* %74
%1003 = load i32, i32* %77
%1004 = load i32, i32* %84
%1005 = load i32, i32* %55
%1006 = load i32, i32* %56
%1007 = load i32, i32* %58
%1008 = load i32, i32* %62
%1009 = call i64 @Bdouble_index(i32 %995, i32 %996, i32 %997, i32 %998, i32 %999, i32 %1000, i32 %1001, i32 %1002, i32 %1003, i32 %1004, i32 %1005, i32 %1006, i32 %1007, i32 %1008)
%1010 = getelementptr inbounds double, double* %994, i64 %1009
%1011 = load double, double* %1010
%1012 = load double, double* %88
%1013 = load double*, double** %45
%1014 = load i32, i32* %79
%1015 = load i32, i32* %71
%1016 = load i32, i32* %72
%1017 = load i32, i32* %75
%1018 = load i32, i32* %76
%1019 = load i32, i32* %78
%1020 = load i32, i32* %73
%1021 = load i32, i32* %74
%1022 = load i32, i32* %77
%1023 = load i32, i32* %84
%1024 = load i32, i32* %55
%1025 = load i32, i32* %56
%1026 = load i32, i32* %58
%1027 = load i32, i32* %62
%1028 = call i64 @Bdouble_index(i32 %1014, i32 %1015, i32 %1016, i32 %1017, i32 %1018, i32 %1019, i32 %1020, i32 %1021, i32 %1022, i32 %1023, i32 %1024, i32 %1025, i32 %1026, i32 %1027)
%1029 = getelementptr inbounds double, double* %1013, i64 %1028
%1030 = load double, double* %1029
%1031 = fmul double %1012, %1030
%1032 = call double @llvm.fmuladd.f64(double %993, double %1011, double %1031)
store double %1032, double* %90
br label %1033
1033: ; preds = %951, %945, %939
br label %1034
1034: ; preds = %1033, %845
br label %1035
1035: ; preds = %1034, %739
br label %1036
1036: ; preds = %1035, %645
br label %1037
1037: ; preds = %1036, %555
br label %1038
1038: ; preds = %1037, %459
%1039 = load double, double* %89
store double %1039, double* %87
%1040 = load double, double* %90
store double %1040, double* %88
br label %1041
1041: ; preds = %1038
%1042 = load i32, i32* %82
%1043 = add nsw i32 %1042, 1
store i32 %1043, i32* %82
br label %437
1044: ; preds = %437
store i32 0, i32* %83
br label %1045
1045: ; preds = %1115, %1044
%1046 = load i32, i32* %83
%1047 = load i32, i32* %63
%1048 = icmp slt i32 %1046, %1047
br i1 %1048, label %1049, label %1118
1049: ; preds = %1045
%1050 = load double*, double** %53
%1051 = load i32, i32* %77
%1052 = load i32, i32* %78
%1053 = load i32, i32* %83
%1054 = load i32, i32* %58
%1055 = load i32, i32* %63
%1056 = call i64 @index_3d(i32 %1051, i32 %1052, i32 %1053, i32 %1054, i32 %1055)
%1057 = getelementptr inbounds double, double* %1050, i64 %1056
%1058 = load double, double* %1057
%1059 = load double, double* %87
%1060 = load double*, double** %54
%1061 = load i32, i32* %77
%1062 = load i32, i32* %78
%1063 = load i32, i32* %83
%1064 = load i32, i32* %58
%1065 = load i32, i32* %63
%1066 = call i64 @index_3d(i32 %1061, i32 %1062, i32 %1063, i32 %1064, i32 %1065)
%1067 = getelementptr inbounds double, double* %1060, i64 %1066
%1068 = load double, double* %1067
%1069 = load double, double* %88
%1070 = fmul double %1068, %1069
%1071 = fneg double %1070
%1072 = call double @llvm.fmuladd.f64(double %1058, double %1059, double %1071)
%1073 = load double*, double** %33
%1074 = load i32, i32* %84
%1075 = load i32, i32* %83
%1076 = load i32, i32* %79
%1077 = load i32, i32* %63
%1078 = load i32, i32* %59
%1079 = call i64 @index_3d(i32 %1074, i32 %1075, i32 %1076, i32 %1077, i32 %1078)
%1080 = getelementptr inbounds double, double* %1073, i64 %1079
%1081 = load double, double* %1080
%1082 = fadd double %1081, %1072
store double %1082, double* %1080
%1083 = load double*, double** %53
%1084 = load i32, i32* %77
%1085 = load i32, i32* %78
%1086 = load i32, i32* %83
%1087 = load i32, i32* %58
%1088 = load i32, i32* %63
%1089 = call i64 @index_3d(i32 %1084, i32 %1085, i32 %1086, i32 %1087, i32 %1088)
%1090 = getelementptr inbounds double, double* %1083, i64 %1089
%1091 = load double, double* %1090
%1092 = load double, double* %88
%1093 = load double*, double** %54
%1094 = load i32, i32* %77
%1095 = load i32, i32* %78
%1096 = load i32, i32* %83
%1097 = load i32, i32* %58
%1098 = load i32, i32* %63
%1099 = call i64 @index_3d(i32 %1094, i32 %1095, i32 %1096, i32 %1097, i32 %1098)
%1100 = getelementptr inbounds double, double* %1093, i64 %1099
%1101 = load double, double* %1100
%1102 = load double, double* %87
%1103 = fmul double %1101, %1102
%1104 = call double @llvm.fmuladd.f64(double %1091, double %1092, double %1103)
%1105 = load double*, double** %34
%1106 = load i32, i32* %84
%1107 = load i32, i32* %83
%1108 = load i32, i32* %79
%1109 = load i32, i32* %63
%1110 = load i32, i32* %59
%1111 = call i64 @index_3d(i32 %1106, i32 %1107, i32 %1108, i32 %1109, i32 %1110)
%1112 = getelementptr inbounds double, double* %1105, i64 %1111
%1113 = load double, double* %1112
%1114 = fadd double %1113, %1104
store double %1114, double* %1112
br label %1115
1115: ; preds = %1049
%1116 = load i32, i32* %83
%1117 = add nsw i32 %1116, 1
store i32 %1117, i32* %83
br label %1045
1118: ; preds = %1045
br label %1119
1119: ; preds = %1118
%1120 = load i32, i32* %84
%1121 = add nsw i32 %1120, 1
store i32 %1121, i32* %84
br label %418
1122: ; preds = %418
br label %1123
1123: ; preds = %1122
%1124 = load i32, i32* %78
%1125 = add nsw i32 %1124, 1
store i32 %1125, i32* %78
br label %413
1126: ; preds = %413
br label %1127
1127: ; preds = %1126
%1128 = load i32, i32* %77
%1129 = add nsw i32 %1128, 1
store i32 %1129, i32* %77
br label %408
1130: ; preds = %408
br label %1131
1131: ; preds = %1130
%1132 = load i32, i32* %79
%1133 = add nsw i32 %1132, 1
store i32 %1133, i32* %79
br label %403
1134: ; preds = %403
br label %1135
1135: ; preds = %1134
%1136 = load i32, i32* %80
%1137 = add nsw i32 %1136, 1
store i32 %1137, i32* %80
br label %266
1138: ; preds = %266
br label %1139
1139: ; preds = %1138
%1140 = load i32, i32* %81
%1141 = add nsw i32 %1140, 1
store i32 %1141, i32* %81
br label %132
1142: ; preds = %132
%1143 = load i8*, i8** %91
ret void
}

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