#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 index_2d(int, int const, int const);
size_t index_3d(int, int, int, int const, int const);
size_t prop_index(int, int, int, int, int, int, int, int, int const, int const,
                  int const, int const, int const);
void make_hex_correlator(
    double *C_re, double *C_im, const double *B1_prop_re,
    const double *B1_prop_im, const double *B2_prop_re,
    const double *B2_prop_im, const int *perms, const int *sigs,
    const int *B1_src_color_weights, const int *B1_src_spin_weights,
    const double *B1_src_weights, const int *B2_src_color_weights,
    const int *B2_src_spin_weights, const double *B2_src_weights,
    const double overall_weight, const int *snk_color_weights,
    const int *snk_spin_weights, const double *snk_weights,
    const double *hex_src_psi_re, const double *hex_src_psi_im,
    const double *hex_snk_psi_re, const double *hex_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 NsrcHex, const int NsnkHex, const int Nperms) {
  int x, t, wnum, nperm, b, n, m, y, wnumprime;
  int iC1prime, iS1prime, jC1prime, jS1prime, kC1prime, kS1prime, iC2prime,
      iS2prime, jC2prime, jS2prime, kC2prime, kS2prime;
  int iC1, iS1, jC1, jS1, kC1, kS1, iC2, iS2, jC2, jS2, kC2, kS2;
  int Nb = 2;
  int Nw2 = Nw * Nw;
  double B1_prop_prod_02_re, B1_prop_prod_02_im, B1_prop_prod_re,
      B1_prop_prod_im, B2_prop_prod_02_re, B2_prop_prod_02_im, B2_prop_prod_re,
      B2_prop_prod_im;
  double prop_prod_re, prop_prod_im, new_prop_prod_re, new_prop_prod_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 (wnumprime = 0; wnumprime < Nw2; wnumprime++) {
      iC1prime = snk_color_weights[index_3d(snk_1_b[0], wnumprime, snk_1_nq[0],
                                            Nw2, Nq)];
      iS1prime = snk_spin_weights[index_3d(snk_1_b[0], wnumprime, snk_1_nq[0],
                                           Nw2, Nq)];
      jC1prime = snk_color_weights[index_3d(snk_2_b[0], wnumprime, snk_2_nq[0],
                                            Nw2, Nq)];
      jS1prime = snk_spin_weights[index_3d(snk_2_b[0], wnumprime, snk_2_nq[0],
                                           Nw2, Nq)];
      kC1prime = snk_color_weights[index_3d(snk_3_b[0], wnumprime, snk_3_nq[0],
                                            Nw2, Nq)];
      kS1prime = snk_spin_weights[index_3d(snk_3_b[0], wnumprime, snk_3_nq[0],
                                           Nw2, Nq)];
      iC2prime = snk_color_weights[index_3d(snk_1_b[1], wnumprime, snk_1_nq[1],
                                            Nw2, Nq)];
      iS2prime = snk_spin_weights[index_3d(snk_1_b[1], wnumprime, snk_1_nq[1],
                                           Nw2, Nq)];
      jC2prime = snk_color_weights[index_3d(snk_2_b[1], wnumprime, snk_2_nq[1],
                                            Nw2, Nq)];
      jS2prime = snk_spin_weights[index_3d(snk_2_b[1], wnumprime, snk_2_nq[1],
                                           Nw2, Nq)];
      kC2prime = snk_color_weights[index_3d(snk_3_b[1], wnumprime, snk_3_nq[1],
                                            Nw2, Nq)];
      kS2prime = snk_spin_weights[index_3d(snk_3_b[1], wnumprime, snk_3_nq[1],
                                           Nw2, Nq)];
      for (t = 0; t < Nt; t++) {
        for (y = 0; y < Vsrc; y++) {
          for (x = 0; x < Vsnk; x++) {
            B1_prop_prod_re = 0;
            B1_prop_prod_im = 0;
            for (wnum = 0; wnum < Nw; wnum++) {
              iC1 = B1_src_color_weights[index_2d(wnum, 0, Nq)];
              iS1 = B1_src_spin_weights[index_2d(wnum, 0, Nq)];
              jC1 = B1_src_color_weights[index_2d(wnum, 1, Nq)];
              jS1 = B1_src_spin_weights[index_2d(wnum, 1, Nq)];
              kC1 = B1_src_color_weights[index_2d(wnum, 2, Nq)];
              kS1 = B1_src_spin_weights[index_2d(wnum, 2, Nq)];
              B1_prop_prod_02_re =
                  B1_src_weights[wnum] *
                  ((B1_prop_re[prop_index(0, t, iC1, iS1, iC1prime, iS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_re[prop_index(2, t, kC1, kS1, kC1prime,
                                              kS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] -
                    B1_prop_im[prop_index(0, t, iC1, iS1, iC1prime, iS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_im[prop_index(2, t, kC1, kS1, kC1prime,
                                              kS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]) -
                   (B1_prop_re[prop_index(0, t, iC1, iS1, kC1prime, kS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_re[prop_index(2, t, kC1, kS1, iC1prime,
                                              iS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] -
                    B1_prop_im[prop_index(0, t, iC1, iS1, kC1prime, kS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_im[prop_index(2, t, kC1, kS1, iC1prime,
                                              iS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]));
              B1_prop_prod_02_im =
                  B1_src_weights[wnum] *
                  ((B1_prop_re[prop_index(0, t, iC1, iS1, iC1prime, iS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_im[prop_index(2, t, kC1, kS1, kC1prime,
                                              kS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] +
                    B1_prop_im[prop_index(0, t, iC1, iS1, iC1prime, iS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_re[prop_index(2, t, kC1, kS1, kC1prime,
                                              kS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]) -
                   (B1_prop_re[prop_index(0, t, iC1, iS1, kC1prime, kS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_im[prop_index(2, t, kC1, kS1, iC1prime,
                                              iS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] +
                    B1_prop_im[prop_index(0, t, iC1, iS1, kC1prime, kS1prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B1_prop_re[prop_index(2, t, kC1, kS1, iC1prime,
                                              iS1prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]));
              B1_prop_prod_re +=
                  B1_prop_prod_02_re *
                      B1_prop_re[prop_index(1, t, jC1, jS1, jC1prime, jS1prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)] -
                  B1_prop_prod_02_im *
                      B1_prop_im[prop_index(1, t, jC1, jS1, jC1prime, jS1prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)];
              B1_prop_prod_im +=
                  B1_prop_prod_02_re *
                      B1_prop_im[prop_index(1, t, jC1, jS1, jC1prime, jS1prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)] +
                  B1_prop_prod_02_im *
                      B1_prop_re[prop_index(1, t, jC1, jS1, jC1prime, jS1prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)];
            }
            B2_prop_prod_re = 0;
            B2_prop_prod_im = 0;
            for (wnum = 0; wnum < Nw; wnum++) {
              iC2 = B2_src_color_weights[index_2d(wnum, 0, Nq)];
              iS2 = B2_src_spin_weights[index_2d(wnum, 0, Nq)];
              jC2 = B2_src_color_weights[index_2d(wnum, 1, Nq)];
              jS2 = B2_src_spin_weights[index_2d(wnum, 1, Nq)];
              kC2 = B2_src_color_weights[index_2d(wnum, 2, Nq)];
              kS2 = B2_src_spin_weights[index_2d(wnum, 2, Nq)];
              B2_prop_prod_02_re =
                  B2_src_weights[wnum] *
                  ((B2_prop_re[prop_index(0, t, iC2, iS2, iC2prime, iS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_re[prop_index(2, t, kC2, kS2, kC2prime,
                                              kS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] -
                    B2_prop_im[prop_index(0, t, iC2, iS2, iC2prime, iS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_im[prop_index(2, t, kC2, kS2, kC2prime,
                                              kS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]) -
                   (B2_prop_re[prop_index(0, t, iC2, iS2, kC2prime, kS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_re[prop_index(2, t, kC2, kS2, iC2prime,
                                              iS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] -
                    B2_prop_im[prop_index(0, t, iC2, iS2, kC2prime, kS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_im[prop_index(2, t, kC2, kS2, iC2prime,
                                              iS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]));
              B2_prop_prod_02_im =
                  B2_src_weights[wnum] *
                  ((B2_prop_re[prop_index(0, t, iC2, iS2, iC2prime, iS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_im[prop_index(2, t, kC2, kS2, kC2prime,
                                              kS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] +
                    B2_prop_im[prop_index(0, t, iC2, iS2, iC2prime, iS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_re[prop_index(2, t, kC2, kS2, kC2prime,
                                              kS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]) -
                   (B2_prop_re[prop_index(0, t, iC2, iS2, kC2prime, kS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_im[prop_index(2, t, kC2, kS2, iC2prime,
                                              iS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)] +
                    B2_prop_im[prop_index(0, t, iC2, iS2, kC2prime, kS2prime, y,
                                          x, Nc, Ns, Vsrc, Vsnk, Nt)] *
                        B2_prop_re[prop_index(2, t, kC2, kS2, iC2prime,
                                              iS2prime, y, x, Nc, Ns, Vsrc,
                                              Vsnk, Nt)]));
              B2_prop_prod_re +=
                  B2_prop_prod_02_re *
                      B2_prop_re[prop_index(1, t, jC2, jS2, jC2prime, jS2prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)] -
                  B2_prop_prod_02_im *
                      B2_prop_im[prop_index(1, t, jC2, jS2, jC2prime, jS2prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)];
              B2_prop_prod_im +=
                  B2_prop_prod_02_re *
                      B2_prop_im[prop_index(1, t, jC2, jS2, jC2prime, jS2prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)] +
                  B2_prop_prod_02_im *
                      B2_prop_re[prop_index(1, t, jC2, jS2, jC2prime, jS2prime,
                                            y, x, Nc, Ns, Vsrc, Vsnk, Nt)];
            }
            prop_prod_re = overall_weight * sigs[nperm] *
                           snk_weights[wnumprime] *
                           (B1_prop_prod_re * B2_prop_prod_re -
                            B1_prop_prod_im * B2_prop_prod_im);
            prop_prod_im = overall_weight * sigs[nperm] *
                           snk_weights[wnumprime] *
                           (B1_prop_prod_re * B2_prop_prod_im +
                            B1_prop_prod_im * B2_prop_prod_re);
            for (m = 0; m < NsrcHex; m++) {
              new_prop_prod_re =
                  hex_src_psi_re[index_2d(y, m, NsrcHex)] * prop_prod_re -
                  hex_src_psi_im[index_2d(y, m, NsrcHex)] * prop_prod_im;
              new_prop_prod_im =
                  hex_src_psi_re[index_2d(y, m, NsrcHex)] * prop_prod_im +
                  hex_src_psi_im[index_2d(y, m, NsrcHex)] * prop_prod_re;
              for (n = 0; n < NsnkHex; n++) {
                C_re[index_3d(m, n, t, NsnkHex, Nt)] +=
                    hex_snk_psi_re[index_2d(x, n, NsnkHex)] * new_prop_prod_re -
                    hex_snk_psi_im[index_2d(x, n, NsnkHex)] * new_prop_prod_im;
                C_im[index_3d(m, n, t, NsnkHex, Nt)] +=
                    hex_snk_psi_re[index_2d(x, n, NsnkHex)] * new_prop_prod_im +
                    hex_snk_psi_im[index_2d(x, n, NsnkHex)] * new_prop_prod_re;
              }
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<make_hex_correlator>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x5f0,%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,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
movsd  %xmm0,-0x58(%rbp)
movl   $0x2,-0xe0(%rbp)
mov    0xb0(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe0(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x150(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1e0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x158(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x160(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x168(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x170(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x178(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x180(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x188(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x190(%rbp)
mov    -0xe0(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x198(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0xd0(%rbp),%eax
jge    3ba5 <make_hex_correlator+0x2a75>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xe0(%rbp),%eax
jge    15ad <make_hex_correlator+0x47d>
mov    0x10(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x68(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0x6c(%rbp),%esi
add    $0x0,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x208(%rbp),%rcx
mov    %rax,%rdx
mov    -0x1b0(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x68(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0x6c(%rbp),%esi
add    $0x1,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x200(%rbp),%rcx
mov    %rax,%rdx
mov    -0x1a8(%rbp),%rax
mov    (%rcx,%rdx,4),%edx
sub    $0x1,%edx
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x68(%rbp),%edi
mov    0xb8(%rbp),%esi
imul   -0x6c(%rbp),%esi
add    $0x2,%esi
mov    0xb8(%rbp),%edx
shl    $0x1,%edx
call   1050 <index_2d@plt>
mov    -0x1f8(%rbp),%rsi
mov    -0x1d8(%rbp),%rcx
mov    -0x1a0(%rbp),%rdx
mov    %rax,%rdi
mov    -0x1b0(%rbp),%rax
mov    (%rsi,%rdi,4),%edi
sub    $0x1,%edi
movslq -0x6c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x1ec(%rbp)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1ec(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1c8(%rbp),%rdx
mov    %eax,%edi
mov    -0x1a8(%rbp),%rax
movslq -0x6c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x1e8(%rbp)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1e8(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1c0(%rbp),%rdx
mov    %eax,%edi
mov    -0x1a0(%rbp),%rax
movslq -0x6c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
mov    %edx,-0x1e4(%rbp)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1e4(%rbp),%eax
sub    %edx,%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1b8(%rbp),%rdx
mov    %eax,%edi
mov    -0x1b0(%rbp),%rax
movslq -0x6c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    %edx,%edi
mov    -0x1e0(%rbp),%rdx
movslq -0x6c(%rbp),%rsi
mov    %edi,(%rdx,%rsi,4)
movslq -0x6c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1a0(%rbp),%rax
mov    %edx,%esi
movslq -0x6c(%rbp),%rdx
mov    %esi,(%rcx,%rdx,4)
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  0xb8(%rbp)
mov    -0x1d0(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    138b <make_hex_correlator+0x25b>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    3b92 <make_hex_correlator+0x2a62>
mov    -0x1e0(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
mov    0x50(%rbp),%rdx
mov    %rdx,-0x268(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x268(%rbp),%rdx
mov    -0x1c8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1e0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x80(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x260(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x260(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d8(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x84(%rbp)
mov    0x50(%rbp),%rdx
mov    %rdx,-0x258(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x258(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d8(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x88(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x250(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x250(%rbp),%rdx
mov    -0x1b8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x8c(%rbp)
mov    0x50(%rbp),%rdx
mov    %rdx,-0x248(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x248(%rbp),%rdx
mov    -0x1b8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x90(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x240(%rbp)
mov    (%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    (%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x240(%rbp),%rdx
mov    -0x1c8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1e0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x94(%rbp)
mov    0x50(%rbp),%rdx
mov    %rdx,-0x238(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x238(%rbp),%rdx
mov    -0x1c8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1e0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x98(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x230(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x230(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d8(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0x9c(%rbp)
mov    0x50(%rbp),%rdx
mov    %rdx,-0x228(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x228(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d8(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0xa0(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x220(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x220(%rbp),%rdx
mov    -0x1b8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0xa4(%rbp)
mov    0x50(%rbp),%rdx
mov    %rdx,-0x218(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    -0x218(%rbp),%rdx
mov    -0x1b8(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1d0(%rbp),%rax
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0xa8(%rbp)
mov    0x58(%rbp),%rdx
mov    %rdx,-0x210(%rbp)
mov    0x4(%rcx),%edi
mov    -0x7c(%rbp),%esi
mov    0x4(%rax),%edx
mov    -0xe4(%rbp),%ecx
mov    0xb8(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x210(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0xa8(%rbp),%eax
jge    3b7f <make_hex_correlator+0x2a4f>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x98(%rbp),%eax
jge    3b6c <make_hex_correlator+0x2a3c>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0xa0(%rbp),%eax
jge    3b59 <make_hex_correlator+0x2a29>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0xb0(%rbp),%eax
jge    282b <make_hex_correlator+0x16fb>
mov    0x20(%rbp),%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
xor    %esi,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3e8(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x3e0(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
xor    %esi,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3e0(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x1,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3d8(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x3d0(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x1,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3d0(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x3c8(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x2,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3c8(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc0(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x3c0(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x2,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3c0(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3b8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x398(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3b0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x390(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x3a8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3a8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3a0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x3a0(%rbp),%xmm1
ff
movsd  -0x398(%rbp),%xmm0
ff
movsd  -0x390(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x388(%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,-0x350(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x380(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x360(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x378(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x378(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x370(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x370(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x360(%rbp),%xmm2
ff
movsd  -0x358(%rbp),%xmm4
ff
movsd  -0x350(%rbp),%xmm1
ff
movsd  -0x348(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x340(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x338(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x330(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x330(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x328(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x308(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x320(%rbp),%xmm1
ff
movsd  -0x318(%rbp),%xmm0
ff
movsd  -0x310(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x308(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x300(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2f8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb0(%rbp),%edx
mov    -0xb4(%rbp),%ecx
mov    -0x90(%rbp),%r8d
mov    -0x94(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2f0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0x80(%rbp),%r8d
mov    -0x84(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x2e8(%rbp),%xmm3
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0x2d8(%rbp),%xmm4
ff
movsd  -0x2d0(%rbp),%xmm1
ff
movsd  -0x2c8(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2c0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb8(%rbp),%edx
mov    -0xbc(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x2b8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb8(%rbp),%edx
mov    -0xbc(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x2b0(%rbp),%xmm1
ff
movsd  -0x2a8(%rbp),%xmm0
ff
movsd  -0x2a0(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x298(%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
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x280(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb8(%rbp),%edx
mov    -0xbc(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x290(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x288(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xb8(%rbp),%edx
mov    -0xbc(%rbp),%ecx
mov    -0x88(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x288(%rbp),%xmm1
ff
movsd  -0x280(%rbp),%xmm0
ff
movsd  -0x278(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x270(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1967 <make_hex_correlator+0x837>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0xb0(%rbp),%eax
jge    3724 <make_hex_correlator+0x25f4>
mov    0x38(%rbp),%rax
mov    %rax,-0x568(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
xor    %esi,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x568(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc8(%rbp)
mov    0x40(%rbp),%rax
mov    %rax,-0x560(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
xor    %esi,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x560(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
mov    0x38(%rbp),%rax
mov    %rax,-0x558(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x1,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x558(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd0(%rbp)
mov    0x40(%rbp),%rax
mov    %rax,-0x550(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x1,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x550(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    0x38(%rbp),%rax
mov    %rax,-0x548(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x2,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x548(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    0x40(%rbp),%rax
mov    %rax,-0x540(%rbp)
mov    -0x64(%rbp),%edi
mov    0xb8(%rbp),%edx
mov    $0x2,%esi
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x540(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xdc(%rbp)
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4c8(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x538(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x538(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x518(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x530(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x530(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x510(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x528(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x528(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x520(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x508(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x520(%rbp),%xmm1
ff
movsd  -0x518(%rbp),%xmm0
ff
movsd  -0x510(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x508(%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,-0x4d0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x500(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x500(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4e0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x4f8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4f8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4d8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x4f0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4f0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4e8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x4e8(%rbp),%xmm3
ff
movsd  -0x4e0(%rbp),%xmm2
ff
movsd  -0x4d8(%rbp),%xmm4
ff
movsd  -0x4d0(%rbp),%xmm1
ff
movsd  -0x4c8(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4c0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4b8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x498(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x4b0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4b0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x490(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x4a8(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x4a8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4a0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x488(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x4a0(%rbp),%xmm1
ff
movsd  -0x498(%rbp),%xmm0
ff
movsd  -0x490(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x488(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x480(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x460(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x478(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x478(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x458(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x470(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xc8(%rbp),%edx
mov    -0xcc(%rbp),%ecx
mov    -0xa8(%rbp),%r8d
mov    -0xac(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
xor    %edi,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x470(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x468(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x9c(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x2,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x468(%rbp),%xmm3
ff
movsd  -0x460(%rbp),%xmm2
ff
movsd  -0x458(%rbp),%xmm4
ff
movsd  -0x450(%rbp),%xmm1
ff
movsd  -0x448(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x440(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x428(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd0(%rbp),%edx
mov    -0xd4(%rbp),%ecx
mov    -0xa0(%rbp),%r8d
mov    -0xa4(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x438(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x420(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x430(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x418(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd0(%rbp),%edx
mov    -0xd4(%rbp),%ecx
mov    -0xa0(%rbp),%r8d
mov    -0xa4(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x430(%rbp),%xmm1
ff
movsd  -0x428(%rbp),%xmm0
ff
movsd  -0x420(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x418(%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
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x400(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    %rax,-0x410(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd0(%rbp),%edx
mov    -0xd4(%rbp),%ecx
mov    -0xa0(%rbp),%r8d
mov    -0xa4(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x410(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3f8(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x408(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x60(%rbp),%esi
mov    -0xd0(%rbp),%edx
mov    -0xd4(%rbp),%ecx
mov    -0xa0(%rbp),%r8d
mov    -0xa4(%rbp),%r9d
mov    -0x78(%rbp),%r12d
mov    -0x5c(%rbp),%r15d
mov    0x88(%rbp),%r14d
mov    0x90(%rbp),%ebx
mov    0x98(%rbp),%r11d
mov    0xa0(%rbp),%r10d
mov    0xa8(%rbp),%eax
mov    $0x1,%edi
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1040 <prop_index@plt>
movsd  -0x408(%rbp),%xmm1
ff
movsd  -0x400(%rbp),%xmm0
ff
movsd  -0x3f8(%rbp),%xmm2
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x3f0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2848 <make_hex_correlator+0x1718>
movsd  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm3
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  -0x128(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
mov    0x60(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x128(%rbp),%xmm3
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  -0x120(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0xc0(%rbp),%eax
jge    3b46 <make_hex_correlator+0x2a16>
mov    0x68(%rbp),%rax
mov    %rax,-0x5a8(%rbp)
mov    -0x78(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    0xc0(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x5a8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x5a0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x598(%rbp)
ff
mov    0x70(%rbp),%rax
mov    %rax,-0x590(%rbp)
mov    -0x78(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    0xc0(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x5a0(%rbp),%xmm0
ff
movsd  -0x598(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x590(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x138(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x68(%rbp),%rax
mov    %rax,-0x588(%rbp)
mov    -0x78(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    0xc0(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x588(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x580(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x578(%rbp)
ff
mov    0x70(%rbp),%rax
mov    %rax,-0x570(%rbp)
mov    -0x78(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    0xc0(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x580(%rbp),%xmm0
ff
movsd  -0x578(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x570(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0xc8(%rbp),%eax
jge    3b33 <make_hex_correlator+0x2a03>
mov    0x78(%rbp),%rax
mov    %rax,-0x608(%rbp)
mov    -0x5c(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    0xc8(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x608(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x600(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x5f8(%rbp)
ff
mov    0x80(%rbp),%rax
mov    %rax,-0x5f0(%rbp)
mov    -0x5c(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    0xc8(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x600(%rbp),%xmm0
ff
movsd  -0x5f8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x5f0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x148(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x5e8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    %rax,-0x5e0(%rbp)
mov    -0x74(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    0xc8(%rbp),%ecx
mov    0xa8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x5e8(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x5e0(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x78(%rbp),%rax
mov    %rax,-0x5d8(%rbp)
mov    -0x5c(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    0xc8(%rbp),%edx
call   1050 <index_2d@plt>
mov    %rax,%rcx
mov    -0x5d8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x5d0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x5c8(%rbp)
ff
mov    0x80(%rbp),%rax
mov    %rax,-0x5c0(%rbp)
mov    -0x5c(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    0xc8(%rbp),%edx
call   1050 <index_2d@plt>
movsd  -0x5d0(%rbp),%xmm0
ff
movsd  -0x5c8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x5c0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x5b8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    %rax,-0x5b0(%rbp)
mov    -0x74(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    0xc8(%rbp),%ecx
mov    0xa8(%rbp),%r8d
call   1030 <index_3d@plt>
movsd  -0x5b8(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x5b0(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    3949 <make_hex_correlator+0x2819>
jmp    3b38 <make_hex_correlator+0x2a08>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    37f0 <make_hex_correlator+0x26c0>
jmp    3b4b <make_hex_correlator+0x2a1b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    193b <make_hex_correlator+0x80b>
jmp    3b5e <make_hex_correlator+0x2a2e>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1925 <make_hex_correlator+0x7f5>
jmp    3b71 <make_hex_correlator+0x2a41>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    190f <make_hex_correlator+0x7df>
jmp    3b84 <make_hex_correlator+0x2a54>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    15b4 <make_hex_correlator+0x484>
jmp    3b97 <make_hex_correlator+0x2a67>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1375 <make_hex_correlator+0x245>
mov    -0x150(%rbp),%rax
mov    %rax,%rsp
lea    -0x20(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_hex_correlator>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
movsd  %xmm0,0x1c8(%rsp)
mov    %r9,0x138(%rsp)
mov    %rcx,0x118(%rsp)
mov    %rdx,0xd8(%rsp)
mov    %rsi,0x1e0(%rsp)
mov    0x2e0(%rsp),%eax
test   %eax,%eax
jle    2e24 <make_hex_correlator+0x1cf4>
mov    %r8,%rbp
mov    0x2c8(%rsp),%r8d
mov    0x2c0(%rsp),%ecx
mov    0x2b0(%rsp),%r14d
mov    %ecx,%edx
imul   %ecx,%edx
mov    %eax,%eax
mov    %rax,0x1b8(%rsp)
lea    (%r8,%r8,1),%eax
mov    %eax,0x158(%rsp)
lea    0x1(%r8),%eax
mov    %eax,0x154(%rsp)
lea    0x2(%r8),%eax
mov    %eax,0x150(%rsp)
mov    %edx,0x124(%rsp)
mov    %edx,%eax
mov    %rax,0x1c0(%rsp)
mov    %ecx,%eax
mov    %rax,0x198(%rsp)
xor    %r12d,%r12d
mov    %rdi,0x1d8(%rsp)
mov    %rbp,0xd0(%rsp)
jmp    121a <make_hex_correlator+0xea>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x188(%rsp),%r12
add    $0x1,%r12
cmp    0x1b8(%rsp),%r12
je     2e24 <make_hex_correlator+0x1cf4>
mov    %r12d,%edi
xor    %esi,%esi
mov    0x158(%rsp),%r13d
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x220(%rsp),%r15
mov    (%r15,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %r12d,%edi
mov    $0x1,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%ebp
add    $0xffffffff,%ebp
mov    %r12d,%edi
mov    $0x2,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%ecx
mov    %ebx,%eax
cltd
mov    0x2c8(%rsp),%esi
idiv   %esi
mov    %edx,0x184(%rsp)
mov    %eax,0x128(%rsp)
mov    %ebp,%eax
cltd
mov    0x2c8(%rsp),%esi
idiv   %esi
mov    %eax,0x180(%rsp)
mov    %edx,0x17c(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
mov    0x2c8(%rsp),%ecx
idiv   %ecx
mov    %edx,0x178(%rsp)
mov    %eax,0x174(%rsp)
mov    %r12d,%edi
mov    0x2c8(%rsp),%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%ebx
add    $0xffffffff,%ebx
mov    %r12d,%edi
mov    0x154(%rsp),%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%ebp
add    $0xffffffff,%ebp
mov    %r12,0x188(%rsp)
mov    %r12d,%edi
mov    0x150(%rsp),%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%ecx
mov    0x2c8(%rsp),%eax
mov    %rax,%rsi
mov    %ebx,%eax
mov    0x2b8(%rsp),%ebx
cltd
idiv   %esi
mov    %edx,0x170(%rsp)
mov    %eax,0x16c(%rsp)
mov    %ebp,%eax
cltd
idiv   %esi
mov    %eax,0x168(%rsp)
mov    %edx,0x164(%rsp)
add    $0xffffffff,%ecx
mov    %ecx,%eax
cltd
idiv   %esi
mov    %edx,0x160(%rsp)
mov    %eax,0x15c(%rsp)
cmpl   $0x0,0x124(%rsp)
je     1200 <make_hex_correlator+0xd0>
xor    %ebp,%ebp
jmp    138a <make_hex_correlator+0x25a>
nopl   0x0(%rax)
mov    0x190(%rsp),%rbp
add    $0x1,%rbp
cmp    0x1c0(%rsp),%rbp
je     1200 <make_hex_correlator+0xd0>
mov    0x128(%rsp),%edi
mov    %ebp,%esi
mov    0x184(%rsp),%r15d
mov    %r15d,%edx
mov    0x124(%rsp),%r13d
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%r12
mov    (%r12,%rax,4),%eax
mov    %eax,0x4c(%rsp)
mov    0x128(%rsp),%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x268(%rsp),%r15
mov    (%r15,%rax,4),%eax
mov    %eax,0x1c(%rsp)
mov    0x180(%rsp),%r12d
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x17c(%rsp),%r15d
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0xcc(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x268(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x134(%rsp)
mov    0x174(%rsp),%r12d
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x178(%rsp),%r15d
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x48(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x268(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x44(%rsp)
mov    0x16c(%rsp),%r12d
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x170(%rsp),%r15d
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x18(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x268(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x14(%rsp)
mov    0x168(%rsp),%r15d
mov    %r15d,%edi
mov    %ebp,%esi
mov    0x164(%rsp),%r12d
mov    %r12d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x130(%rsp)
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x268(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x12c(%rsp)
mov    0x15c(%rsp),%r12d
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x160(%rsp),%r15d
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x2c8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x260(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x40(%rsp)
mov    %r12d,%edi
mov    %rbp,0x190(%rsp)
mov    %ebp,%esi
mov    %r15d,%edx
mov    0x2c8(%rsp),%r8d
mov    %r13d,%ecx
call   1030 <index_3d@plt>
test   %ebx,%ebx
mov    0x2d8(%rsp),%r12d
mov    0x2d0(%rsp),%r15d
jle    1370 <make_hex_correlator+0x240>
mov    0x268(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0x3c(%rsp)
xor    %eax,%eax
jmp    160f <make_hex_correlator+0x4df>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
add    $0x1,%eax
cmp    %ebx,%eax
je     1370 <make_hex_correlator+0x240>
mov    %eax,0xc(%rsp)
mov    0x2a8(%rsp),%eax
test   %eax,%eax
jle    1600 <make_hex_correlator+0x4d0>
xor    %edx,%edx
jmp    163e <make_hex_correlator+0x50e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%edx
mov    0x2a8(%rsp),%eax
cmp    %eax,%edx
je     1600 <make_hex_correlator+0x4d0>
test   %r14d,%r14d
jle    1630 <make_hex_correlator+0x500>
xor    %ecx,%ecx
mov    %rdx,0x70(%rsp)
jmp    166c <make_hex_correlator+0x53c>
nopl   0x0(%rax)
mov    0x78(%rsp),%rcx
add    $0x1,%ecx
mov    0x2b0(%rsp),%r14d
cmp    %r14d,%ecx
mov    0x2b8(%rsp),%ebx
je     1630 <make_hex_correlator+0x500>
cmpl   $0x0,0x2c0(%rsp)
mov    %rcx,0x78(%rsp)
jle    2b30 <make_hex_correlator+0x1a00>
xorps  %xmm1,%xmm1
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rsi,(%rsp)
movaps %xmm1,0x140(%rsp)
mov    (%rsp),%rdi
xor    %esi,%esi
mov    0x2c8(%rsp),%r14d
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    0x230(%rsp),%r15
mov    (%r15,%rax,4),%ebx
mov    %ebx,0x20(%rsp)
mov    (%rsp),%rdi
xor    %esi,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    0x238(%rsp),%r12
mov    (%r12,%rax,4),%ebp
mov    %ebp,0x90(%rsp)
mov    (%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%eax
mov    %eax,0x6c(%rsp)
mov    (%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    (%r12,%rax,4),%eax
mov    %eax,0x10(%rsp)
mov    (%rsp),%rdi
mov    $0x2,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%r15d
mov    %r15d,0xb0(%rsp)
mov    (%rsp),%rdi
mov    $0x2,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
mov    (%r12,%rax,4),%eax
mov    %eax,0x50(%rsp)
mov    (%rsp),%rax
mov    0x240(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r12d
mov    %r12d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x54(%rsp),%r8d
mov    0x24(%rsp),%r9d
mov    0x2c0(%rsp),%r13d
push   %r13
mov    0x2c0(%rsp),%r14d
push   %r14
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0xa8(%rsp),%r13
push   %r13
mov    0xa8(%rsp),%r14
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
mov    %rcx,%rbp
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r12d,%esi
mov    %r15d,%edx
mov    0x58(%rsp),%ebx
mov    %ebx,%ecx
mov    0x50(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r15d
push   %r15
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r13
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movaps %xmm0,0x100(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r12d,%esi
mov    %r12d,%ebp
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    0x54(%rsp),%r8d
mov    0x24(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
push   %r15
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    %r13,%r12
push   %r13
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x118(%rsp),%r13
movsd  0x0(%r13,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebp,%esi
mov    0xb8(%rsp),%edx
mov    %ebx,%ecx
mov    0x50(%rsp),%r15d
mov    %r15d,%r8d
mov    0x4c(%rsp),%ebx
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r12
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movaps %xmm0,0xe0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%ebp
mov    %ebp,%esi
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%r13d
mov    %r13d,%ecx
mov    %r15d,%r8d
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r12
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rbx
movaps 0xa0(%rsp),%xmm0
movhps (%rbx,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebp,%esi
mov    0xb8(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x54(%rsp),%r15d
mov    %r15d,%r8d
mov    0x24(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r12
push   %r14
mov    %r14,%rbp
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0x100(%rsp),%xmm0
movhpd (%rbx,%rax,8),%xmm0
mulpd  0xa0(%rsp),%xmm0
movapd %xmm0,0x100(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r14d
mov    %r14d,%esi
mov    0x28(%rsp),%edx
mov    %r13d,%ecx
mov    0x50(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    %r12,%rbx
push   %r12
mov    %rbp,%r12
push   %rbp
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x118(%rsp),%rbp
movaps 0x80(%rsp),%xmm0
movhps 0x0(%rbp,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r14d,%esi
mov    0xb8(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    %r15d,%r8d
mov    %r15d,%r13d
mov    0x24(%rsp),%r14d
mov    %r14d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0xe0(%rsp),%xmm0
movhpd 0x0(%rbp,%rax,8),%xmm0
mulpd  0x80(%rsp),%xmm0
movapd 0x100(%rsp),%xmm1
subpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
subsd  %xmm0,%xmm1
mulsd  0xf0(%rsp),%xmm1
movapd %xmm1,0x100(%rsp)
mov    (%rsp),%rax
mov    0x240(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x1a0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r15d
mov    %r15d,%esi
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    %r13d,%r8d
mov    %r14d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%ebp
push   %rbp
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
mov    %r12,%r14
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movaps %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r15d,%esi
mov    0xb8(%rsp),%r13d
mov    %r13d,%edx
mov    0x58(%rsp),%ecx
mov    0x50(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbp
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
mov    %rbx,%r12
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x118(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movaps %xmm0,0xe0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%ebx
mov    %r15d,%esi
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    0x54(%rsp),%r8d
mov    0x24(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r12
mov    %r12,%r15
mov    %r14,%r12
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebx,%esi
mov    %ebx,%r14d
mov    %r13d,%edx
mov    0x58(%rsp),%ecx
mov    0x50(%rsp),%ebp
mov    %ebp,%r8d
mov    0x4c(%rsp),%ebx
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r15
push   %r12
mov    %r12,%r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r14d,%esi
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    %ebp,%r8d
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r14d
push   %r14
mov    0x2c0(%rsp),%eax
push   %rax
mov    %r15,%rbp
push   %r15
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0xf0(%rsp),%xmm0
movhps (%r12,%rax,8),%xmm0
movaps %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x14(%rsp),%r15d
mov    %r15d,%esi
mov    0xb8(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x54(%rsp),%r8d
mov    0x24(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbp
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x118(%rsp),%r14
movapd 0xe0(%rsp),%xmm0
movhpd (%r14,%rax,8),%xmm0
mulpd  0xf0(%rsp),%xmm0
movapd %xmm0,0xe0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%esi
mov    0x28(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    0x50(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    0x2c0(%rsp),%r12d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0xa8(%rsp),%rbx
push   %rbx
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0xa0(%rsp),%xmm0
movhps (%r14,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r15d,%esi
mov    0xb8(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x54(%rsp),%r8d
mov    0x24(%rsp),%r9d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0x80(%rsp),%xmm1
mov    0xd8(%rsp),%r12
movhpd (%r12,%rax,8),%xmm1
mulpd  0xa0(%rsp),%xmm1
addpd  0xe0(%rsp),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
subsd  %xmm0,%xmm1
mulsd  0x1a0(%rsp),%xmm1
movapd %xmm1,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r15d,%esi
mov    0x74(%rsp),%ebx
mov    %ebx,%edx
mov    0x18(%rsp),%ebp
mov    %ebp,%ecx
mov    0xd4(%rsp),%r14d
mov    %r14d,%r8d
mov    0x13c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0xa8(%rsp),%r13
push   %r13
push   0xa8(%rsp)
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%r12,%rax,8),%xmm0
movaps %xmm0,0x20(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r15d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    %r14d,%r8d
mov    0x13c(%rsp),%r15d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%r12d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r13
mov    0xa8(%rsp),%rbx
push   %rbx
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0x80(%rsp),%xmm0
xorps  0x104f(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
mov    0x118(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
movaps %xmm0,0x50(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x14(%rsp),%r12d
mov    %r12d,%esi
mov    0x74(%rsp),%ebp
mov    %ebp,%edx
mov    0x18(%rsp),%ecx
mov    0xd4(%rsp),%r8d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r13
push   %rbx
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0x20(%rsp),%xmm0
movhps (%r14,%rax,8),%xmm0
movaps %xmm0,0x20(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    0x18(%rsp),%ecx
mov    0xd4(%rsp),%r8d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r13
push   %rbx
call   1040 <prop_index@plt>
mov    0x40(%rsp),%rsi
movapd 0x180(%rsp),%xmm1
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movapd 0x90(%rsp),%xmm0
movhpd (%rcx,%rax,8),%xmm0
movapd 0x50(%rsp),%xmm2
unpcklpd 0x80(%rsp),%xmm2
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm2
movapd 0x100(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  0x20(%rsp),%xmm0
addpd  %xmm2,%xmm0
addpd  %xmm0,%xmm1
add    $0x1,%rsi
cmp    %rsi,0x198(%rsp)
jne    1690 <make_hex_correlator+0x560>
cmpl   $0x0,0x2c0(%rsp)
jle    2b50 <make_hex_correlator+0x1a20>
movapd %xmm1,0x140(%rsp)
xorps  %xmm5,%xmm5
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %rdx,(%rsp)
movaps %xmm5,0x1a0(%rsp)
mov    (%rsp),%rdi
xor    %esi,%esi
mov    0x2c8(%rsp),%r13d
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x248(%rsp),%r15
mov    (%r15,%rax,4),%ebx
mov    %ebx,0x100(%rsp)
mov    (%rsp),%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    0x250(%rsp),%r14
mov    (%r14,%rax,4),%ebp
mov    %ebp,0x90(%rsp)
mov    (%rsp),%rdi
mov    $0x1,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%eax
mov    %eax,0x6c(%rsp)
mov    (%rsp),%rdi
mov    $0x1,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r14,%rax,4),%eax
mov    %eax,0x10(%rsp)
mov    (%rsp),%rdi
mov    $0x2,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r15,%rax,4),%eax
mov    %eax,0x20(%rsp)
mov    (%rsp),%rdi
mov    $0x2,%esi
mov    %r13d,%edx
call   1050 <index_2d@plt>
mov    (%r14,%rax,4),%r12d
mov    %r12d,0x50(%rsp)
mov    (%rsp),%rax
mov    0x258(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r14d
mov    %r14d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r13d
push   %r13
mov    0x2c0(%rsp),%ebp
push   %rbp
mov    %rbp,%r13
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0xa8(%rsp),%r15
push   %r15
mov    0xa8(%rsp),%rbp
push   %rbp
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd0(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r14d,%esi
mov    0x28(%rsp),%edx
mov    %r12d,%ecx
mov    0x48(%rsp),%r8d
mov    0x44(%rsp),%r9d
mov    0x2c0(%rsp),%r12d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
push   %r13
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r15
push   %rbp
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%rbx,%rax,8),%xmm0
movaps %xmm0,0xb0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r14d,%ebx
mov    %r14d,%esi
mov    0x108(%rsp),%r13d
mov    %r13d,%edx
mov    0x98(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r15
push   %rbp
mov    %rbp,%r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x138(%rsp),%r12
movsd  (%r12,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebx,%esi
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x48(%rsp),%ebp
mov    %ebp,%r8d
mov    0x44(%rsp),%ebx
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r15
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%r12,%rax,8),%xmm0
movaps %xmm0,0xe0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r15d
mov    %r15d,%esi
mov    %r13d,%edx
mov    0x98(%rsp),%ecx
mov    %ebp,%r8d
mov    %ebx,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r13d
push   %r13
mov    0xa8(%rsp),%rbx
push   %rbx
mov    %r14,%r12
push   %r14
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd0(%rsp),%rbp
movaps 0xa0(%rsp),%xmm0
movhps 0x0(%rbp,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r15d,%esi
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r14d
push   %r14
push   %r13
push   %rbx
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0xb0(%rsp),%xmm0
movhpd 0x0(%rbp,%rax,8),%xmm0
mulpd  0xa0(%rsp),%xmm0
movapd %xmm0,0xb0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%ebp
mov    %r15d,%esi
mov    0x108(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    0x44(%rsp),%r9d
mov    0x2c0(%rsp),%r15d
push   %r15
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
push   %r13
push   %rbx
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0x80(%rsp),%xmm0
mov    0x138(%rsp),%r14
movhps (%r14,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebp,%esi
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x20(%rsp),%r13d
mov    %r13d,%r8d
mov    0x1c(%rsp),%ebp
mov    %ebp,%r9d
push   %r15
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0xe0(%rsp),%xmm0
movhpd (%r14,%rax,8),%xmm0
mulpd  0x80(%rsp),%xmm0
movapd 0xb0(%rsp),%xmm1
subpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
subsd  %xmm0,%xmm1
mulsd  0xf0(%rsp),%xmm1
movapd %xmm1,0xb0(%rsp)
mov    (%rsp),%rax
mov    0x258(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x1d0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x14(%rsp),%r12d
mov    %r12d,%esi
mov    0x108(%rsp),%r15d
mov    %r15d,%edx
mov    0x98(%rsp),%ecx
mov    %r13d,%r8d
mov    %ebp,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
mov    0xa8(%rsp),%r13
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movaps %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r12d,%esi
mov    %r12d,%ebp
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    0x44(%rsp),%r9d
mov    0x2c0(%rsp),%eax
mov    %rax,%r12
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbx
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%r14,%rax,8),%xmm0
movaps %xmm0,0xe0(%rsp)
mov    %r14,%rbx
sub    $0x8,%rsp
xor    %edi,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    0x98(%rsp),%r14d
mov    %r14d,%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
push   %r12
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0xa8(%rsp),%r12
push   %r12
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%rbx,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebp,%esi
mov    %ebp,%r15d
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x48(%rsp),%ebx
mov    %ebx,%r8d
mov    0x44(%rsp),%ebp
mov    %ebp,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r12
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0xd0(%rsp),%r13
movsd  0x0(%r13,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%esi
mov    0x108(%rsp),%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
mov    %ebp,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%ebp
push   %rbp
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r14d
push   %r14
mov    %r12,%rbx
push   %r12
mov    0xa8(%rsp),%r12
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0xf0(%rsp),%xmm0
movhps 0x0(%r13,%rax,8),%xmm0
movaps %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r15d,%r13d
mov    %r15d,%esi
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbp
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
mov    %r14,%rbp
push   %rbx
push   %r12
mov    %r12,%r15
call   1040 <prop_index@plt>
add    $0x40,%rsp
mov    0x138(%rsp),%r12
movapd 0xe0(%rsp),%xmm0
movhpd (%r12,%rax,8),%xmm0
mulpd  0xf0(%rsp),%xmm0
movapd %xmm0,0xe0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r13d,%esi
mov    0x108(%rsp),%edx
mov    0x98(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    0x44(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r14d
push   %r14
mov    0x2c0(%rsp),%eax
push   %rax
push   %rbp
push   %rbx
push   %r15
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0xa0(%rsp),%xmm0
movhps (%r12,%rax,8),%xmm0
movaps %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r13d,%esi
mov    0x28(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0x20(%rsp),%r8d
mov    0x1c(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%r14d
push   %r14
push   %rbx
push   %r15
mov    %r15,%r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movapd 0x80(%rsp),%xmm1
mov    0xd0(%rsp),%r15
movhpd (%r15,%rax,8),%xmm1
mulpd  0xa0(%rsp),%xmm1
addpd  0xe0(%rsp),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
subsd  %xmm0,%xmm1
mulsd  0x1d0(%rsp),%xmm1
movapd %xmm1,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r13d,%esi
mov    0x74(%rsp),%ebx
mov    %ebx,%edx
mov    0x18(%rsp),%ebp
mov    %ebp,%ecx
mov    0x138(%rsp),%r8d
mov    0x134(%rsp),%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
mov    0xa8(%rsp),%r14
push   %r14
push   %r12
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%r15,%rax,8),%xmm0
movaps %xmm0,0x20(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r13d,%r12d
mov    %r13d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x138(%rsp),%ebp
mov    %ebp,%r8d
mov    0x134(%rsp),%r15d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
mov    0xa8(%rsp),%r13
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movaps 0x80(%rsp),%xmm0
movaps %xmm0,%xmm1
xorps  0x5f7(%rip),%xmm1
movaps %xmm1,0x50(%rsp)
mov    0x138(%rsp),%rbx
movhps (%rbx,%rax,8),%xmm0
movaps %xmm0,0x80(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r12d,%esi
mov    0x74(%rsp),%r12d
mov    %r12d,%edx
mov    0x18(%rsp),%ecx
mov    %ebp,%r8d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
push   %r13
call   1040 <prop_index@plt>
add    $0x40,%rsp
movsd  (%rbx,%rax,8),%xmm0
unpcklpd 0x20(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x14(%rsp),%esi
mov    %r12d,%edx
mov    0x18(%rsp),%ecx
mov    %ebp,%r8d
mov    %r15d,%r9d
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
mov    0x2c0(%rsp),%eax
push   %rax
push   %r14
push   %r13
call   1040 <prop_index@plt>
mov    0x40(%rsp),%rdx
movapd 0x1e0(%rsp),%xmm5
add    $0x40,%rsp
mov    0xd0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
unpcklpd 0x50(%rsp),%xmm0
mulpd  0x80(%rsp),%xmm0
movapd 0xb0(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  0x20(%rsp),%xmm1
addpd  %xmm0,%xmm1
addpd  %xmm1,%xmm5
add    $0x1,%rdx
cmp    %rdx,0x198(%rsp)
jne    2110 <make_hex_correlator+0xfe0>
jmp    2b5d <make_hex_correlator+0x1a2d>
nopl   (%rax)
xorpd  %xmm5,%xmm5
xorpd  %xmm0,%xmm0
movapd %xmm0,0x140(%rsp)
test   %r15d,%r15d
jg     2b7b <make_hex_correlator+0x1a4b>
jmp    1650 <make_hex_correlator+0x520>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,0x140(%rsp)
xorpd  %xmm5,%xmm5
mov    0x2d8(%rsp),%r12d
mov    0x2d0(%rsp),%r15d
mov    0x70(%rsp),%rdx
test   %r15d,%r15d
jle    1650 <make_hex_correlator+0x520>
mov    0x228(%rsp),%rax
mov    0x188(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rcx,4),%xmm0
mulsd  0x1c8(%rsp),%xmm0
mov    0x270(%rsp),%rax
mov    0x190(%rsp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movapd 0x140(%rsp),%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
unpckhpd %xmm5,%xmm3
movapd %xmm4,%xmm6
mulsd  %xmm3,%xmm6
subsd  %xmm2,%xmm6
mulsd  %xmm0,%xmm6
movapd %xmm6,0xb0(%rsp)
mulsd  %xmm1,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm4,0x140(%rsp)
xor    %ebp,%ebp
jmp    2c33 <make_hex_correlator+0x1b03>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%ebp
add    $0x1,%ebp
mov    0x2d0(%rsp),%r15d
cmp    %r15d,%ebp
mov    %r14d,%r12d
mov    0x70(%rsp),%rdx
je     1650 <make_hex_correlator+0x520>
mov    %ebp,0x90(%rsp)
mov    %rdx,%rbx
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   1050 <index_2d@plt>
mov    0x278(%rsp),%r14
movsd  (%r14,%rax,8),%xmm0
mulsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   1050 <index_2d@plt>
mov    0x280(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x140(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   1050 <index_2d@plt>
movsd  (%r14,%rax,8),%xmm0
mulsd  0x140(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   1050 <index_2d@plt>
test   %r12d,%r12d
mov    %r12d,%r14d
mov    0x290(%rsp),%rbx
mov    0x288(%rsp),%r15
mov    0x78(%rsp),%r12
jle    2c10 <make_hex_correlator+0x1ae0>
movsd  0x20(%rsp),%xmm0
subsd  (%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    0x280(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0xb0(%rsp),%xmm0
movsd  0x50(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  (%r15,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  (%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    %r15,%r13
mov    0x90(%rsp),%r15d
mov    %r15d,%edi
mov    %ebp,%esi
mov    0xc(%rsp),%edx
mov    %r14d,%ecx
mov    0x2b8(%rsp),%r8d
call   1030 <index_3d@plt>
mov    0x1d8(%rsp),%rcx
movsd  (%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <index_2d@plt>
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r15d,%edi
mov    0x2b8(%rsp),%r8d
mov    %r13,%r15
mov    0xc(%rsp),%edx
mov    %ebp,%esi
mov    %r14d,%ecx
call   1030 <index_3d@plt>
mov    0x1e0(%rsp),%rsi
movsd  (%rsp),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%ebp
cmp    %ebp,%r14d
jne    2d20 <make_hex_correlator+0x1bf0>
jmp    2c10 <make_hex_correlator+0x1ae0>
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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