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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
size_t Bdouble_index(int, int, int, int, int, int, int, int, int, int,
                     int const, int const, int const, int const);
size_t Q_index(int, int, int, int, int, int, int, int, int, int const,
               int const, int const, int const);
int /*<<< orphan*/ free(double *);
size_t index_2d(int, int, int const);
double *malloc(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_double_block(double *Bdouble_re, double *Bdouble_im,
                       const double *prop_re, const double *prop_im,
                       const int *color_weights, const int *spin_weights,
                       const double *weights, const double *psi_re,
                       const double *psi_im, const int Nc, const int Ns,
                       const int Vsrc, const int Vsnk, const int Nt,
                       const int Nw, const int Nq, const int Nsrc) {
  int iCprime, iSprime, jCprime, jSprime, kCprime, kSprime, iC, iS, jC, jS, kC,
      kS, x, x1, x2, t, y, wnum, n;
  double prop_prod_re;
  double prop_prod_im;
  double *Q12_re =
      malloc(Nt * Nc * Ns * Nc * Ns * Vsnk * Nc * Ns * Vsrc * sizeof(double));
  double *Q12_im =
      malloc(Nt * Nc * Ns * Nc * Ns * Vsnk * Nc * Ns * Vsrc * sizeof(double));
  double *Q01_re =
      malloc(Nt * Nc * Ns * Nc * Ns * Vsnk * Nc * Ns * Vsrc * sizeof(double));
  double *Q01_im =
      malloc(Nt * Nc * Ns * Nc * Ns * Vsnk * Nc * Ns * Vsrc * sizeof(double));
  for (t = 0; t < Nt; t++) {
    for (iCprime = 0; iCprime < Nc; iCprime++) {
      for (iSprime = 0; iSprime < Ns; iSprime++) {
        for (kCprime = 0; kCprime < Nc; kCprime++) {
          for (kSprime = 0; kSprime < Ns; kSprime++) {
            for (x1 = 0; x1 < Vsnk; x1++) {
              for (n = 0; n < Nsrc; n++) {
                for (jCprime = 0; jCprime < Nc; jCprime++) {
                  for (jSprime = 0; jSprime < Ns; jSprime++) {
                    for (x2 = 0; x2 < Vsnk; x2++) {
                      Bdouble_re[Bdouble_index(
                          t, iCprime, iSprime, kCprime, kSprime, x1, jCprime,
                          jSprime, x2, n, Nc, Ns, Vsnk, Nsrc)] = 0.0;
                      Bdouble_im[Bdouble_index(
                          t, iCprime, iSprime, kCprime, kSprime, x1, jCprime,
                          jSprime, x2, n, Nc, Ns, Vsnk, Nsrc)] = 0.0;
                    }
                  }
                }
              }
              for (jC = 0; jC < Nc; jC++) {
                for (jS = 0; jS < Ns; jS++) {
                  for (y = 0; y < Vsrc; y++) {
                    Q12_re[Q_index(t, iCprime, iSprime, kCprime, kSprime, x1,
                                   jC, jS, y, Nc, Ns, Vsrc, Vsnk)] = 0.0;
                    Q12_im[Q_index(t, iCprime, iSprime, kCprime, kSprime, x1,
                                   jC, jS, y, Nc, Ns, Vsrc, Vsnk)] = 0.0;
                    Q01_re[Q_index(t, iCprime, iSprime, kCprime, kSprime, x1,
                                   jC, jS, y, Nc, Ns, Vsrc, Vsnk)] = 0.0;
                    Q01_im[Q_index(t, iCprime, iSprime, kCprime, kSprime, x1,
                                   jC, jS, y, Nc, Ns, Vsrc, Vsnk)] = 0.0;
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  for (wnum = 0; wnum < Nw; wnum++) {
    iC = color_weights[index_2d(wnum, 0, Nq)];
    iS = spin_weights[index_2d(wnum, 0, Nq)];
    jC = color_weights[index_2d(wnum, 1, Nq)];
    jS = spin_weights[index_2d(wnum, 1, Nq)];
    kC = color_weights[index_2d(wnum, 2, Nq)];
    kS = spin_weights[index_2d(wnum, 2, Nq)];
    for (t = 0; t < Nt; t++) {
      for (jCprime = 0; jCprime < Nc; jCprime++) {
        for (jSprime = 0; jSprime < Ns; jSprime++) {
          for (kCprime = 0; kCprime < Nc; kCprime++) {
            for (kSprime = 0; kSprime < Ns; kSprime++) {
              for (y = 0; y < Vsrc; y++) {
                for (x = 0; x < Vsnk; x++) {
                  Q12_re[Q_index(t, jCprime, jSprime, kCprime, kSprime, x, iC,
                                 iS, y, Nc, Ns, Vsrc, Vsnk)] +=
                      weights[wnum] *
                      (prop_re[prop_index(1, t, jC, jS, jCprime, jSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_re[prop_index(2, t, kC, kS, kCprime, kSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)] -
                       prop_im[prop_index(1, t, jC, jS, jCprime, jSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_im[prop_index(2, t, kC, kS, kCprime, kSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)]);
                  Q12_im[Q_index(t, jCprime, jSprime, kCprime, kSprime, x, iC,
                                 iS, y, Nc, Ns, Vsrc, Vsnk)] +=
                      weights[wnum] *
                      (prop_re[prop_index(1, t, jC, jS, jCprime, jSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_im[prop_index(2, t, kC, kS, kCprime, kSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)] +
                       prop_im[prop_index(1, t, jC, jS, jCprime, jSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_re[prop_index(2, t, kC, kS, kCprime, kSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)]);
                  Q01_re[Q_index(t, jCprime, jSprime, kCprime, kSprime, x, kC,
                                 kS, y, Nc, Ns, Vsrc, Vsnk)] +=
                      weights[wnum] *
                      (prop_re[prop_index(0, t, iC, iS, kCprime, kSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_re[prop_index(1, t, jC, jS, jCprime, jSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)] -
                       prop_im[prop_index(0, t, iC, iS, kCprime, kSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_im[prop_index(1, t, jC, jS, jCprime, jSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)]);
                  Q01_im[Q_index(t, jCprime, jSprime, kCprime, kSprime, x, kC,
                                 kS, y, Nc, Ns, Vsrc, Vsnk)] +=
                      weights[wnum] *
                      (prop_re[prop_index(0, t, iC, iS, kCprime, kSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_im[prop_index(1, t, jC, jS, jCprime, jSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)] +
                       prop_im[prop_index(0, t, iC, iS, kCprime, kSprime, y, x,
                                          Nc, Ns, Vsrc, Vsnk, Nt)] *
                           prop_re[prop_index(1, t, jC, jS, jCprime, jSprime, y,
                                              x, Nc, Ns, Vsrc, Vsnk, Nt)]);
                }
              }
            }
          }
        }
      }
    }
  }
  for (t = 0; t < Nt; t++) {
    for (jCprime = 0; jCprime < Nc; jCprime++) {
      for (jSprime = 0; jSprime < Ns; jSprime++) {
        for (kCprime = 0; kCprime < Nc; kCprime++) {
          for (kSprime = 0; kSprime < Ns; kSprime++) {
            for (x1 = 0; x1 < Vsnk; x1++) {
              for (iC = 0; iC < Nc; iC++) {
                for (iS = 0; iS < Ns; iS++) {
                  for (iCprime = 0; iCprime < Nc; iCprime++) {
                    for (iSprime = 0; iSprime < Ns; iSprime++) {
                      for (y = 0; y < Vsrc; y++) {
                        for (x2 = 0; x2 < Vsnk; x2++) {
                          prop_prod_re =
                              Q12_re[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_re[prop_index(0, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)] -
                              Q12_im[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_im[prop_index(0, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)];
                          prop_prod_im =
                              Q12_re[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_im[prop_index(0, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)] +
                              Q12_im[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_re[prop_index(0, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)];
                          prop_prod_re -=
                              Q01_re[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_re[prop_index(2, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)] -
                              Q01_im[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_im[prop_index(2, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)];
                          prop_prod_im -=
                              Q01_re[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_im[prop_index(2, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)] +
                              Q01_im[Q_index(t, jCprime, jSprime, kCprime,
                                             kSprime, x1, iC, iS, y, Nc, Ns,
                                             Vsrc, Vsnk)] *
                                  prop_re[prop_index(2, t, iC, iS, iCprime,
                                                     iSprime, y, x2, Nc, Ns,
                                                     Vsrc, Vsnk, Nt)];
                          for (n = 0; n < Nsrc; n++) {
                            Bdouble_re[Bdouble_index(
                                t, iCprime, iSprime, kCprime, kSprime, x1,
                                jCprime, jSprime, x2, n, Nc, Ns, Vsnk, Nsrc)] +=
                                psi_re[index_2d(y, n, Nsrc)] * prop_prod_re -
                                psi_im[index_2d(y, n, Nsrc)] * prop_prod_im;
                            Bdouble_im[Bdouble_index(
                                t, iCprime, iSprime, kCprime, kSprime, x1,
                                jCprime, jSprime, x2, n, Nc, Ns, Vsnk, Nsrc)] +=
                                psi_re[index_2d(y, n, Nsrc)] * prop_prod_im +
                                psi_im[index_2d(y, n, Nsrc)] * prop_prod_re;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  free(Q12_re);
  free(Q12_im);
  free(Q01_re);
  free(Q01_im);
}


x86 assembly (clang, -O0):
<make_double_block>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3d8,%rsp
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
mov    0x48(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x40(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xc0(%rbp)
mov    0x48(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x40(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xc8(%rbp)
mov    0x48(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x40(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xd0(%rbp)
mov    0x48(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x40(%rbp),%eax
imul   0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    17a6 <make_double_block+0x646>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    178d <make_double_block+0x62d>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    177a <make_double_block+0x61a>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1767 <make_double_block+0x607>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1754 <make_double_block+0x5f4>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1741 <make_double_block+0x5e1>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x60(%rbp),%eax
jge    14bf <make_double_block+0x35f>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    14a6 <make_double_block+0x346>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1493 <make_double_block+0x333>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1480 <make_double_block+0x320>
mov    -0x30(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x64(%rbp),%r13d
mov    -0x68(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xa4(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x60(%rbp),%eax
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1050 <Bdouble_index@plt>
mov    %rax,%rcx
mov    -0xe8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x64(%rbp),%r13d
mov    -0x68(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xa4(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x60(%rbp),%eax
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1050 <Bdouble_index@plt>
mov    %rax,%rcx
mov    -0xe0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1353 <make_double_block+0x1f3>
jmp    1485 <make_double_block+0x325>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    133d <make_double_block+0x1dd>
jmp    1498 <make_double_block+0x338>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    132a <make_double_block+0x1ca>
jmp    14ab <make_double_block+0x34b>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1314 <make_double_block+0x1b4>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1728 <make_double_block+0x5c8>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1715 <make_double_block+0x5b5>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1702 <make_double_block+0x5a2>
mov    -0xc0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x108(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x100(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0xf8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x7c(%rbp),%r12d
mov    -0x80(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0xf0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    14ef <make_double_block+0x38f>
jmp    1707 <make_double_block+0x5a7>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    14d9 <make_double_block+0x379>
jmp    171a <make_double_block+0x5ba>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    14c6 <make_double_block+0x366>
jmp    172d <make_double_block+0x5cd>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    12fb <make_double_block+0x19b>
jmp    1746 <make_double_block+0x5e6>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12e5 <make_double_block+0x185>
jmp    1759 <make_double_block+0x5f9>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12d2 <make_double_block+0x172>
jmp    176c <make_double_block+0x60c>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12bf <make_double_block+0x15f>
jmp    177f <make_double_block+0x61f>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12ac <make_double_block+0x14c>
jmp    1792 <make_double_block+0x632>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1296 <make_double_block+0x136>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    2593 <make_double_block+0x1433>
mov    -0x50(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
xor    %esi,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x138(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
xor    %esi,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x130(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
mov    $0x1,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x128(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
mov    $0x1,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x120(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
mov    $0x2,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x118(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0xa0(%rbp),%edi
mov    0x58(%rbp),%edx
mov    $0x2,%esi
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x110(%rbp),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    257a <make_double_block+0x141a>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    2561 <make_double_block+0x1401>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    254e <make_double_block+0x13ee>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    253b <make_double_block+0x13db>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    2528 <make_double_block+0x13c8>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    2515 <make_double_block+0x13b5>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    24fc <make_double_block+0x139c>
mov    0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x278(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x270(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x268(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
movsd  -0x260(%rbp),%xmm1
ff
movsd  -0x258(%rbp),%xmm0
ff
movsd  -0x250(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x248(%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,-0x238(%rbp)
ff
mov    -0xc0(%rbp),%rax
mov    %rax,-0x230(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
movsd  -0x240(%rbp),%xmm0
ff
movsd  -0x238(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x230(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x228(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x220(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x218(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
movsd  -0x210(%rbp),%xmm1
ff
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x200(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x1f8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0xc8(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  -0x1e8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x1e0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x1d8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x1d0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x1c8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
movsd  -0x1c0(%rbp),%xmm1
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x1a8(%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,-0x198(%rbp)
ff
mov    -0xd0(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x190(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x188(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x180(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%r8d
mov    -0x70(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x178(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    -0x80(%rbp),%ecx
mov    -0x64(%rbp),%r8d
mov    -0x68(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x8c(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x1,%edi
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   1070 <prop_index@plt>
movsd  -0x170(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x158(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0xd8(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x8c(%rbp),%r9d
mov    -0x84(%rbp),%r12d
mov    -0x88(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x140(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    195b <make_double_block+0x7fb>
jmp    2501 <make_double_block+0x13a1>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1942 <make_double_block+0x7e2>
jmp    251a <make_double_block+0x13ba>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    192c <make_double_block+0x7cc>
jmp    252d <make_double_block+0x13cd>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1919 <make_double_block+0x7b9>
jmp    2540 <make_double_block+0x13e0>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1906 <make_double_block+0x7a6>
jmp    2553 <make_double_block+0x13f3>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18f3 <make_double_block+0x793>
jmp    2566 <make_double_block+0x1406>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    18dd <make_double_block+0x77d>
jmp    257f <make_double_block+0x141f>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    17b0 <make_double_block+0x650>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    32e7 <make_double_block+0x2187>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    32ce <make_double_block+0x216e>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    32bb <make_double_block+0x215b>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    32a8 <make_double_block+0x2148>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    3295 <make_double_block+0x2135>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    3282 <make_double_block+0x2122>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    3269 <make_double_block+0x2109>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    3256 <make_double_block+0x20f6>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    3243 <make_double_block+0x20e3>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    3230 <make_double_block+0x20d0>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    321d <make_double_block+0x20bd>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    3204 <make_double_block+0x20a4>
mov    -0xc0(%rbp),%rax
mov    %rax,-0x358(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x358(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x338(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x350(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
mov    -0xc8(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x348(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x340(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
movsd  -0x340(%rbp),%xmm1
ff
movsd  -0x338(%rbp),%xmm0
ff
movsd  -0x330(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x328(%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,-0xb0(%rbp)
ff
mov    -0xc0(%rbp),%rax
mov    %rax,-0x320(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x320(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x318(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
mov    -0xc8(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x310(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
xor    %edi,%edi
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   1070 <prop_index@plt>
movsd  -0x308(%rbp),%xmm1
ff
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2f8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x2f0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xd0(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x2e8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x2e0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    -0xd8(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x2d8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm1
ff
movsd  -0x2c0(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x2b8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xd0(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x2b0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
mov    %rax,%rcx
mov    -0x2a8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
mov    -0xd8(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x74(%rbp),%r12d
mov    -0x78(%rbp),%r15d
mov    -0x9c(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x38(%rbp),%r10d
mov    0x40(%rbp),%eax
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 <Q_index@plt>
mov    %rax,%rcx
mov    -0x2a0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x98(%rbp),%esi
mov    -0x74(%rbp),%edx
mov    -0x78(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x60(%rbp),%r9d
mov    -0x9c(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    $0x2,%edi
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   1070 <prop_index@plt>
movsd  -0x298(%rbp),%xmm0
ff
movsd  -0x290(%rbp),%xmm1
ff
movsd  -0x288(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x280(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x60(%rbp),%eax
jge    31eb <make_double_block+0x208b>
mov    0x18(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x60(%rbp),%edx
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x3b8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3b0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x3a8(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x60(%rbp),%edx
call   1080 <index_2d@plt>
movsd  -0x3b0(%rbp),%xmm0
ff
movsd  -0x3a8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x3a0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x398(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    %rax,-0x390(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x64(%rbp),%r13d
mov    -0x68(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xa4(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x60(%rbp),%eax
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1050 <Bdouble_index@plt>
movsd  -0x398(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x390(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x60(%rbp),%edx
call   1080 <index_2d@plt>
mov    %rax,%rcx
mov    -0x388(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x380(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x378(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x370(%rbp)
mov    -0x9c(%rbp),%edi
mov    -0xa4(%rbp),%esi
mov    0x60(%rbp),%edx
call   1080 <index_2d@plt>
movsd  -0x380(%rbp),%xmm0
ff
movsd  -0x378(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x370(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0x98(%rbp),%edi
mov    -0x5c(%rbp),%esi
mov    -0x60(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%r8d
mov    -0x90(%rbp),%r9d
mov    -0x64(%rbp),%r13d
mov    -0x68(%rbp),%r12d
mov    -0x94(%rbp),%r15d
mov    -0xa4(%rbp),%r14d
mov    0x28(%rbp),%ebx
mov    0x30(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x60(%rbp),%eax
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
call   1050 <Bdouble_index@plt>
movsd  -0x368(%rbp),%xmm0
ff
mov    %rax,%rcx
mov    -0x360(%rbp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    2f5b <make_double_block+0x1dfb>
jmp    31f0 <make_double_block+0x2090>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    2680 <make_double_block+0x1520>
jmp    3209 <make_double_block+0x20a9>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    2667 <make_double_block+0x1507>
jmp    3222 <make_double_block+0x20c2>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2651 <make_double_block+0x14f1>
jmp    3235 <make_double_block+0x20d5>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    263e <make_double_block+0x14de>
jmp    3248 <make_double_block+0x20e8>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    262b <make_double_block+0x14cb>
jmp    325b <make_double_block+0x20fb>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    2618 <make_double_block+0x14b8>
jmp    326e <make_double_block+0x210e>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    2602 <make_double_block+0x14a2>
jmp    3287 <make_double_block+0x2127>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    25ec <make_double_block+0x148c>
jmp    329a <make_double_block+0x213a>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    25d9 <make_double_block+0x1479>
jmp    32ad <make_double_block+0x214d>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    25c6 <make_double_block+0x1466>
jmp    32c0 <make_double_block+0x2160>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    25b3 <make_double_block+0x1453>
jmp    32d3 <make_double_block+0x2173>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    259d <make_double_block+0x143d>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
add    $0x3d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_double_block>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0xb8(%rsp)
mov    %r8,0xf0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rdx,0xc8(%rsp)
mov    %rsi,0x108(%rsp)
mov    %rdi,0x100(%rsp)
mov    0x1b0(%rsp),%eax
mov    %rax,0xd0(%rsp)
mov    0x1a8(%rsp),%eax
mov    %eax,0xf8(%rsp)
mov    0x198(%rsp),%r14d
mov    0x190(%rsp),%edx
mov    0x188(%rsp),%ebx
mov    0x180(%rsp),%eax
mov    0x178(%rsp),%ecx
mov    %rax,0x10(%rsp)
mov    %rcx,0x18(%rsp)
imul   %ecx,%eax
mov    %eax,%ecx
imul   %ebx,%ecx
imul   %eax,%eax
imul   %ecx,%eax
mov    %rdx,0x38(%rsp)
mov    %edx,%ebp
imul   %r14d,%ebp
imul   %eax,%ebp
mov    0x1a0(%rsp),%eax
mov    %eax,0x70(%rsp)
shl    $0x3,%ebp
mov    0x170(%rsp),%rax
mov    %rax,0x118(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xe8(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0xd8(%rsp)
test   %r14d,%r14d
mov    %r14,0x48(%rsp)
mov    %rbx,%r12
mov    %rbx,0x50(%rsp)
jle    1659 <make_double_block+0x4f9>
xor    %eax,%eax
jmp    12b5 <make_double_block+0x155>
nopl   0x0(%rax)
mov    0x30(%rsp),%eax
add    $0x1,%eax
mov    0x48(%rsp),%r14
cmp    %r14d,%eax
je     1659 <make_double_block+0x4f9>
mov    %eax,0x30(%rsp)
cmpl   $0x0,0x18(%rsp)
jle    12a0 <make_double_block+0x140>
xor    %eax,%eax
jmp    12dd <make_double_block+0x17d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x60(%rsp),%eax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
je     12a0 <make_double_block+0x140>
mov    %eax,0x60(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    12d0 <make_double_block+0x170>
xor    %eax,%eax
jmp    12fd <make_double_block+0x19d>
nopl   0x0(%rax)
mov    0xc(%rsp),%eax
add    $0x1,%eax
cmp    0x10(%rsp),%eax
je     12d0 <make_double_block+0x170>
mov    %eax,0xc(%rsp)
xor    %eax,%eax
jmp    131d <make_double_block+0x1bd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x78(%rsp),%eax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
je     12f0 <make_double_block+0x190>
mov    %eax,0x78(%rsp)
xor    %eax,%eax
jmp    133d <make_double_block+0x1dd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%eax
add    $0x1,%eax
cmp    0x10(%rsp),%eax
je     1310 <make_double_block+0x1b0>
mov    %eax,0x28(%rsp)
cmpl   $0x0,0x38(%rsp)
jle    1330 <make_double_block+0x1d0>
xor    %eax,%eax
jmp    135d <make_double_block+0x1fd>
nopl   0x0(%rax)
mov    0x8(%rsp),%eax
add    $0x1,%eax
cmp    0x38(%rsp),%eax
je     1330 <make_double_block+0x1d0>
mov    %eax,0x8(%rsp)
cmpl   $0x0,0xd0(%rsp)
jle    14a6 <make_double_block+0x346>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,0x58(%rsp)
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %rax,0x40(%rsp)
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %rax,0x20(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%ebx
mov    %ebx,%edi
mov    0x60(%rsp),%r15d
mov    %r15d,%esi
mov    0xc(%rsp),%r12d
mov    %r12d,%edx
mov    0x78(%rsp),%r14d
mov    %r14d,%ecx
mov    0x28(%rsp),%r8d
mov    0x8(%rsp),%r9d
push   0xd0(%rsp)
push   0x40(%rsp)
mov    0x20(%rsp),%r13
push   %r13
push   0x30(%rsp)
push   0x78(%rsp)
push   %rbp
push   0x50(%rsp)
push   0x78(%rsp)
call   1050 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x100(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    %ebx,%edi
mov    %r15d,%esi
mov    %r12d,%edx
mov    %r14d,%ecx
mov    0x28(%rsp),%r8d
mov    0x8(%rsp),%r9d
push   0xd0(%rsp)
mov    0x40(%rsp),%rbx
push   %rbx
push   %r13
push   0x30(%rsp)
push   0x78(%rsp)
push   %rbp
push   0x50(%rsp)
push   0x78(%rsp)
call   1050 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x108(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebp
cmp    %ebp,%ebx
jne    13b0 <make_double_block+0x250>
mov    0x20(%rsp),%rax
add    $0x1,%eax
cmp    0x10(%rsp),%eax
jne    13a0 <make_double_block+0x240>
mov    0x40(%rsp),%rax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
jne    1390 <make_double_block+0x230>
mov    0x58(%rsp),%rax
add    $0x1,%eax
cmp    0xd0(%rsp),%eax
jne    1380 <make_double_block+0x220>
xor    %eax,%eax
mov    0x50(%rsp),%r12
jmp    14c2 <make_double_block+0x362>
nop
mov    0x40(%rsp),%rax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
je     1350 <make_double_block+0x1f0>
mov    %rax,0x40(%rsp)
xor    %eax,%eax
jmp    14d8 <make_double_block+0x378>
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    %r11d,%eax
je     14b0 <make_double_block+0x350>
test   %r12d,%r12d
mov    0x38(%rsp),%r10
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%rbx
mov    0xc(%rsp),%edx
mov    0x8(%rsp),%r13d
mov    0x40(%rsp),%r15
jle    14d0 <make_double_block+0x370>
xor    %r14d,%r14d
mov    %rax,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    0x38(%rsp),%edi
mov    0x68(%rsp),%esi
mov    0x80(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    %r13d,%r9d
push   %r10
mov    %r12,%rbp
push   %r12
push   %r11
push   %rbx
push   %r14
push   %rax
push   %r15
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe8(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    0x38(%rsp),%edi
mov    0x68(%rsp),%esi
mov    0x14(%rsp),%edx
mov    0x80(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    %r13d,%r9d
push   0x40(%rsp)
push   %r12
push   0x28(%rsp)
push   %rbx
push   %r14
push   0x50(%rsp)
push   %r15
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xb0(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    0x38(%rsp),%edi
mov    0x68(%rsp),%esi
mov    0x14(%rsp),%edx
mov    0x80(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    %r13d,%r9d
push   0x40(%rsp)
push   %r12
push   0x28(%rsp)
push   %rbx
push   %r14
push   0x50(%rsp)
push   %r15
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    0x38(%rsp),%edi
mov    0x68(%rsp),%esi
mov    0x14(%rsp),%edx
mov    0x80(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    %r13d,%r9d
push   0x40(%rsp)
push   %r12
push   0x28(%rsp)
push   %rbx
push   %r14
push   0x50(%rsp)
push   %r15
call   1040 <Q_index@plt>
mov    0x78(%rsp),%r10
mov    0x50(%rsp),%r11
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    0xc(%rsp),%edx
mov    0x20(%rsp),%rax
add    $0x1,%r14d
cmp    %r14d,%ebp
jne    1510 <make_double_block+0x3b0>
jmp    14d0 <make_double_block+0x370>
mov    0x70(%rsp),%eax
test   %eax,%eax
jle    2035 <make_double_block+0xed5>
mov    %eax,%eax
mov    %rax,0x120(%rsp)
xor    %ebx,%ebx
jmp    1697 <make_double_block+0x537>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x60(%rsp),%rbx
add    $0x1,%rbx
cmp    0x120(%rsp),%rbx
je     2035 <make_double_block+0xed5>
mov    %ebx,%edi
xor    %esi,%esi
mov    0xf8(%rsp),%ebp
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    0xf0(%rsp),%r14
mov    (%r14,%rax,4),%eax
mov    %rax,0x90(%rsp)
mov    %ebx,%edi
xor    %esi,%esi
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    0xb8(%rsp),%r15
mov    (%r15,%rax,4),%eax
mov    %rax,0xc0(%rsp)
mov    %ebx,%edi
mov    $0x1,%esi
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    (%r14,%rax,4),%eax
mov    %eax,0x58(%rsp)
mov    %ebx,%edi
mov    $0x1,%esi
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    (%r15,%rax,4),%eax
mov    %eax,0xc(%rsp)
mov    %ebx,%edi
mov    $0x2,%esi
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    (%r14,%rax,4),%eax
mov    %rax,0x78(%rsp)
mov    %rbx,0x60(%rsp)
mov    %ebx,%edi
mov    $0x2,%esi
mov    %ebp,%edx
call   1080 <index_2d@plt>
mov    0x48(%rsp),%r14
test   %r14d,%r14d
jle    1680 <make_double_block+0x520>
mov    0xb8(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x70(%rsp)
xor    %eax,%eax
jmp    1775 <make_double_block+0x615>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%eax
add    $0x1,%eax
mov    0x48(%rsp),%r14
cmp    %r14d,%eax
je     1680 <make_double_block+0x520>
mov    %eax,0x28(%rsp)
cmpl   $0x0,0x18(%rsp)
jle    1760 <make_double_block+0x600>
xor    %eax,%eax
jmp    179d <make_double_block+0x63d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%eax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
je     1760 <make_double_block+0x600>
mov    %eax,0x8(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    1790 <make_double_block+0x630>
xor    %eax,%eax
jmp    17bd <make_double_block+0x65d>
nopl   0x0(%rax)
mov    0x40(%rsp),%eax
add    $0x1,%eax
cmp    0x10(%rsp),%eax
je     1790 <make_double_block+0x630>
mov    %eax,0x40(%rsp)
xor    %eax,%eax
jmp    17e0 <make_double_block+0x680>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x80(%rsp),%eax
add    $0x1,%eax
cmp    0x18(%rsp),%eax
je     17b0 <make_double_block+0x650>
mov    %eax,0x80(%rsp)
xor    %eax,%eax
jmp    1800 <make_double_block+0x6a0>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%eax
add    $0x1,%eax
cmp    0x10(%rsp),%eax
je     17d0 <make_double_block+0x670>
mov    %eax,0x88(%rsp)
test   %r12d,%r12d
jle    17f0 <make_double_block+0x690>
xor    %eax,%eax
jmp    181b <make_double_block+0x6bb>
add    $0x1,%eax
cmp    %r10d,%eax
mov    %r10,%r12
je     17f0 <make_double_block+0x690>
mov    %r12,%r10
mov    0x38(%rsp),%rbx
test   %ebx,%ebx
mov    0x48(%rsp),%r11
mov    0x10(%rsp),%rbp
mov    0x18(%rsp),%r15
mov    0x98(%rsp),%r12
mov    0x60(%rsp),%rdi
mov    0x58(%rsp),%edx
mov    0xc(%rsp),%ecx
mov    0x28(%rsp),%esi
mov    0x8(%rsp),%r8d
mov    0x40(%rsp),%r9d
jle    1810 <make_double_block+0x6b0>
xor    %r13d,%r13d
mov    %rax,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,8),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
push   %r11
push   %rbx
push   %r10
push   %rbp
push   %r15
push   %r13
push   %rax
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %rcx,%rbp
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x30(%rsp),%esi
mov    0x80(%rsp),%r14
mov    %r14d,%edx
mov    0x78(%rsp),%r12
mov    %r12d,%ecx
mov    0x88(%rsp),%r8d
mov    %r8d,%ebx
mov    0x90(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x30(%rsp),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%r15
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x30(%rsp),%esi
mov    %r14d,%edx
mov    %r12d,%ecx
mov    %ebx,%r12d
mov    %ebx,%r8d
mov    0x90(%rsp),%r14d
mov    %r14d,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0xa0(%rsp),%xmm1
mulsd  (%r15,%rax,8),%xmm1
movsd  0x30(%rsp),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    0x30(%rsp),%edi
mov    0x10(%rsp),%esi
mov    0x48(%rsp),%edx
mov    %ebx,%ecx
mov    %ebx,%r15d
mov    %r14d,%r8d
mov    %r14d,%r12d
mov    %r13d,%r9d
push   0x40(%rsp)
push   0x60(%rsp)
push   0x28(%rsp)
push   0x38(%rsp)
push   0x48(%rsp)
push   0xf0(%rsp)
push   0xc8(%rsp)
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe8(%rsp),%rcx
movsd  0x30(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %rbp,%rbx
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x30(%rsp),%esi
mov    0x80(%rsp),%r14
mov    %r14d,%edx
mov    0x78(%rsp),%rbp
mov    %ebp,%ecx
mov    %r15d,%r8d
mov    %r12d,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%r15
movsd  0x30(%rsp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x30(%rsp),%esi
mov    %r14d,%edx
mov    %ebp,%ecx
mov    0x88(%rsp),%ebp
mov    %ebp,%r8d
mov    %r12d,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x68(%rsp),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
addsd  0x30(%rsp),%xmm0
mulsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
mov    0x30(%rsp),%edi
mov    0x10(%rsp),%esi
mov    0x48(%rsp),%edx
mov    %ebp,%ecx
mov    %r13,%r14
mov    %ebp,%r13d
mov    %r12d,%r8d
mov    %r12d,%ebp
mov    %r14d,%r9d
push   0x40(%rsp)
push   0x60(%rsp)
push   0x28(%rsp)
push   0x38(%rsp)
push   0x48(%rsp)
mov    0xf0(%rsp),%r12
push   %r12
mov    0xc8(%rsp),%r15
push   %r15
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xb0(%rsp),%rcx
movsd  0x68(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x30(%rsp),%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %r13d,%r8d
mov    %r14,%r13
mov    %ebp,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r14
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r14
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x30(%rsp),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x30(%rsp),%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %r12,%rbx
mov    0x88(%rsp),%r12d
mov    %r12d,%r8d
mov    %ebp,%r9d
mov    %ebp,%r14d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0xa0(%rsp),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x30(%rsp),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    0x30(%rsp),%edi
mov    0x10(%rsp),%esi
mov    0x48(%rsp),%edx
mov    %r12d,%ecx
mov    %r14d,%ebp
mov    %r14d,%r8d
mov    %r13d,%r9d
push   0x40(%rsp)
push   0x60(%rsp)
push   0x28(%rsp)
push   0x38(%rsp)
push   0x48(%rsp)
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movsd  0x30(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x30(%rsp),%esi
mov    0x98(%rsp),%r14
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %r12d,%r8d
mov    %ebp,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%r15
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rbp
movsd  0x30(%rsp),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x30(%rsp),%esi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %r12d,%r8d
mov    0x90(%rsp),%r14d
mov    %r14d,%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    0x30(%rsp),%esi
mov    0x60(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   0x48(%rsp)
push   0x68(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   %r13
push   0x58(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
movsd  0x68(%rsp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
addsd  0x30(%rsp),%xmm0
mulsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
sub    $0x8,%rsp
mov    0x30(%rsp),%edi
mov    0x10(%rsp),%esi
mov    0x48(%rsp),%edx
mov    %r12d,%ecx
mov    %r14d,%r8d
mov    %r13d,%r9d
push   0x40(%rsp)
push   0x60(%rsp)
push   0x28(%rsp)
push   0x38(%rsp)
push   0x48(%rsp)
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1040 <Q_index@plt>
mov    0x4c(%rsp),%ecx
mov    0x98(%rsp),%edx
mov    0xa0(%rsp),%rdi
mov    0xd8(%rsp),%r12
mov    0x118(%rsp),%r14
mov    0x78(%rsp),%rbx
mov    0x50(%rsp),%rbp
mov    0x88(%rsp),%r11
mov    0x90(%rsp),%r10
mov    0x80(%rsp),%r9d
mov    0x48(%rsp),%r8d
mov    0x68(%rsp),%esi
mov    0x58(%rsp),%r15
add    $0x40,%rsp
movsd  0x68(%rsp),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
mov    0x20(%rsp),%rax
add    $0x1,%r13d
cmp    %r13d,%ebx
jne    1870 <make_double_block+0x710>
jmp    1810 <make_double_block+0x6b0>
test   %r14d,%r14d
mov    0xe8(%rsp),%r13
mov    0xb0(%rsp),%rbx
jle    2a6d <make_double_block+0x190d>
movl   $0x0,0x60(%rsp)
jmp    2075 <make_double_block+0xf15>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x60(%rsp)
cmp    0x48(%rsp),%eax
je     2a6d <make_double_block+0x190d>
cmpl   $0x0,0x18(%rsp)
jle    2060 <make_double_block+0xf00>
xor    %eax,%eax
mov    %rax,0x68(%rsp)
jmp    20a3 <make_double_block+0xf43>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x68(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x68(%rsp)
cmp    0x18(%rsp),%eax
je     2060 <make_double_block+0xf00>
cmpl   $0x0,0x10(%rsp)
jle    2090 <make_double_block+0xf30>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    20d3 <make_double_block+0xf73>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
cmp    0x10(%rsp),%eax
je     2090 <make_double_block+0xf30>
movl   $0x0,0x58(%rsp)
jmp    20f1 <make_double_block+0xf91>
nopl   (%rax)
mov    0x58(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x58(%rsp)
cmp    0x18(%rsp),%eax
je     20c0 <make_double_block+0xf60>
movl   $0x0,0xc(%rsp)
jmp    2111 <make_double_block+0xfb1>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
cmp    0x10(%rsp),%eax
je     20e0 <make_double_block+0xf80>
cmpl   $0x0,0x38(%rsp)
jle    2100 <make_double_block+0xfa0>
movl   $0x0,0x30(%rsp)
jmp    2141 <make_double_block+0xfe1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x30(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x30(%rsp)
cmp    0x38(%rsp),%eax
je     2100 <make_double_block+0xfa0>
xor    %eax,%eax
mov    %rax,0x80(%rsp)
jmp    2169 <make_double_block+0x1009>
nopl   (%rax)
mov    0x80(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x80(%rsp)
cmp    0x18(%rsp),%eax
je     2130 <make_double_block+0xfd0>
xor    %eax,%eax
mov    %rax,0x90(%rsp)
jmp    2199 <make_double_block+0x1039>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x90(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x90(%rsp)
cmp    0x10(%rsp),%eax
je     2150 <make_double_block+0xff0>
movl   $0x0,0x8(%rsp)
jmp    21c1 <make_double_block+0x1061>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8(%rsp)
cmp    0x18(%rsp),%eax
je     2180 <make_double_block+0x1020>
movl   $0x0,0x40(%rsp)
jmp    21e1 <make_double_block+0x1081>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x40(%rsp)
cmp    0x10(%rsp),%eax
je     21b0 <make_double_block+0x1050>
test   %r12d,%r12d
jle    21d0 <make_double_block+0x1070>
xor    %eax,%eax
mov    %rax,0x88(%rsp)
jmp    2218 <make_double_block+0x10b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x88(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x88(%rsp)
cmp    %r12d,%eax
je     21d0 <make_double_block+0x1070>
xor    %eax,%eax
mov    %rax,0x70(%rsp)
jmp    2258 <make_double_block+0x10f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x70(%rsp)
cmp    0x38(%rsp),%eax
mov    0x50(%rsp),%r12
mov    0xe8(%rsp),%r13
mov    0xb0(%rsp),%rbx
je     2200 <make_double_block+0x10a0>
sub    $0x8,%rsp
mov    0x68(%rsp),%edi
mov    0x70(%rsp),%rsi
mov    %rsi,0x70(%rsp)
mov    0x28(%rsp),%rdx
mov    %rdx,0x28(%rsp)
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
mov    0x40(%rsp),%rbp
push   %rbp
push   %r12
mov    0x28(%rsp),%rbx
push   %rbx
mov    0x38(%rsp),%rbx
push   %rbx
mov    0xb0(%rsp),%rax
push   %rax
mov    0xc0(%rsp),%rbx
push   %rbx
mov    %rbx,0xc8(%rsp)
mov    0xb8(%rsp),%r14
push   %r14
call   1040 <Q_index@plt>
add    $0x40,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    0x68(%rsp),%r15d
mov    %r15d,%esi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
mov    0x50(%rsp),%rax
push   %rax
push   %rbp
push   %r12
push   0x30(%rsp)
mov    0x40(%rsp),%r13
push   %r13
mov    %r12,%r14
mov    0xa0(%rsp),%r12
push   %r12
mov    0xc0(%rsp),%rbx
push   %rbx
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%rcx
movsd  0x78(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x78(%rsp)
sub    $0x8,%rsp
mov    %r15d,%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
push   %rbp
mov    %rbp,%r12
push   %r14
push   0x28(%rsp)
push   %r13
mov    %r13,%r14
push   %rbx
mov    0xc0(%rsp),%rbx
push   %rbx
mov    0xb8(%rsp),%rbp
push   %rbp
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xb0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x28(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%esi
mov    %ebp,%edx
mov    %ebx,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r12
mov    0x68(%rsp),%rbx
push   %rbx
mov    0x30(%rsp),%r13
push   %r13
push   %r14
push   0xa0(%rsp)
mov    0xc0(%rsp),%rbp
push   %rbp
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rcx
movsd  0x28(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x28(%rsp)
sub    $0x8,%rsp
mov    %r15d,%edi
mov    %r15d,%r14d
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
push   %r12
mov    %r12,%r15
push   %rbx
push   %r13
mov    0x38(%rsp),%r13
push   %r13
mov    %rbp,%r12
push   %rbp
mov    0xc0(%rsp),%rbp
push   %rbp
mov    0xb8(%rsp),%rbx
push   %rbx
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x98(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r14d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r15
mov    0x68(%rsp),%rbx
push   %rbx
mov    0x30(%rsp),%rbp
push   %rbp
push   %r13
push   0xa0(%rsp)
push   %r12
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rcx
movsd  0x98(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x98(%rsp)
sub    $0x8,%rsp
mov    %r14d,%r13d
mov    %r14d,0x68(%rsp)
mov    %r14d,%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
mov    %r15,%r14
push   %r15
push   %rbx
push   %rbp
mov    0x38(%rsp),%r15
push   %r15
push   %r12
mov    0xc0(%rsp),%rbx
push   %rbx
mov    0xb8(%rsp),%rbp
push   %rbp
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xb0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xc0(%rsp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r13d,%esi
mov    %ebp,%edx
mov    %ebx,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r14
mov    0x68(%rsp),%rbx
push   %rbx
mov    0x30(%rsp),%r12
push   %r12
push   %r15
mov    %r15,%r13
push   0xa0(%rsp)
mov    0xc0(%rsp),%rbp
push   %rbp
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%rcx
movsd  0xc0(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xc0(%rsp)
sub    $0x8,%rsp
mov    0x68(%rsp),%r14d
mov    %r14d,%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
mov    0x40(%rsp),%r15
push   %r15
push   %rbx
push   %r12
push   %r13
push   %rbp
mov    0xc0(%rsp),%rbp
push   %rbp
mov    0xb8(%rsp),%rbx
push   %rbx
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r14d,%esi
mov    %r14d,%r13d
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r15
mov    0x68(%rsp),%rbx
push   %rbx
push   %r12
mov    0x40(%rsp),%r14
push   %r14
push   0xa0(%rsp)
mov    0xc0(%rsp),%rbp
push   %rbp
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xc8(%rsp),%rcx
movsd  0xa0(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xa0(%rsp)
sub    $0x8,%rsp
mov    %r13d,%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
push   %r15
push   %rbx
push   %r12
push   %r14
mov    %rbp,%r12
push   %rbp
mov    0xc0(%rsp),%rbp
push   %rbp
mov    0xb8(%rsp),%rbx
push   %rbx
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xb8(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    %rbp,%rbx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r15
mov    %r15,%r13
mov    0x68(%rsp),%r15
push   %r15
mov    0x30(%rsp),%rbp
push   %rbp
push   %r14
push   0xa0(%rsp)
push   %r12
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rcx
movsd  0xb8(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xb8(%rsp)
sub    $0x8,%rsp
mov    0x68(%rsp),%r12d
mov    %r12d,%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
push   %r13
push   %r15
push   %rbp
push   %r14
mov    0xb0(%rsp),%r14
push   %r14
mov    %rbx,%rbp
push   %rbx
mov    0xb8(%rsp),%rbx
push   %rbx
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xe0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %r12d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r13
mov    %r15,%r12
push   %r15
mov    0x30(%rsp),%r15
push   %r15
mov    0x40(%rsp),%rbp
push   %rbp
push   0xa0(%rsp)
mov    %r14,%rbx
push   %r14
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xa8(%rsp),%rcx
movsd  0xf0(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xf0(%rsp)
sub    $0x8,%rsp
mov    0x68(%rsp),%edi
mov    0x70(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0x60(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    0x38(%rsp),%r9d
push   %r13
push   %r12
push   %r15
push   %rbp
push   %r14
mov    0xc0(%rsp),%r14
push   %r14
mov    0xb8(%rsp),%rbx
push   %rbx
call   1040 <Q_index@plt>
add    $0x40,%rsp
mov    0xd8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0xf8(%rsp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    0x68(%rsp),%esi
mov    %ebx,%edx
mov    %r14d,%ecx
mov    0x10(%rsp),%r8d
mov    0x48(%rsp),%r9d
push   0x50(%rsp)
push   %r13
push   %r12
push   %r15
push   %rbp
push   0xa0(%rsp)
push   0xc0(%rsp)
call   1070 <prop_index@plt>
add    $0x40,%rsp
mov    0xd0(%rsp),%r15
test   %r15d,%r15d
jle    2230 <make_double_block+0x10d0>
movsd  0x78(%rsp),%xmm0
subsd  0x28(%rsp),%xmm0
movsd  0x98(%rsp),%xmm1
addsd  0xc0(%rsp),%xmm1
movsd  0xa0(%rsp),%xmm2
subsd  0xb8(%rsp),%xmm2
mov    0xc8(%rsp),%rcx
movsd  0xf8(%rsp),%xmm3
mulsd  (%rcx,%rax,8),%xmm3
subsd  %xmm2,%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0xf0(%rsp),%xmm0
addsd  %xmm3,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x98(%rsp)
xor    %r14d,%r14d
mov    0x88(%rsp),%rbx
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r15d,%edx
call   1080 <index_2d@plt>
mov    0x110(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r15d,%edx
call   1080 <index_2d@plt>
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x98(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
mov    0x60(%rsp),%edi
mov    0x8(%rsp),%esi
mov    0x40(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0xc(%rsp),%r8d
mov    0x30(%rsp),%r9d
push   %r15
mov    0x40(%rsp),%rbp
push   %rbp
push   0x20(%rsp)
push   0x30(%rsp)
push   %r14
mov    0x98(%rsp),%r12
push   %r12
push   0x50(%rsp)
mov    0xa0(%rsp),%r13
push   %r13
call   1050 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x100(%rsp),%rcx
movsd  0x28(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r15d,%edx
call   1080 <index_2d@plt>
mov    0x110(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r15d,%edx
call   1080 <index_2d@plt>
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x78(%rsp),%xmm0
addsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x60(%rsp),%edi
mov    0x8(%rsp),%esi
mov    0x40(%rsp),%edx
mov    0x58(%rsp),%ecx
mov    0xc(%rsp),%r8d
mov    0x30(%rsp),%r9d
push   %r15
push   %rbp
push   0x20(%rsp)
push   0x30(%rsp)
push   %r14
push   %r12
push   0x50(%rsp)
push   %r13
call   1050 <Bdouble_index@plt>
add    $0x40,%rsp
mov    0x108(%rsp),%rcx
movsd  0x28(%rsp),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%r14d
cmp    %r14d,%r15d
jne    28f0 <make_double_block+0x1790>
jmp    2230 <make_double_block+0x10d0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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