int erd__2d_pq_integrals(int shellp, int shellq, int ngqexq, double *b00,
                         double *b01, double *b10, double *c00x, double *c00y,
                         double *c00z, double *d00x, double *d00y, double *d00z,
                         int case2d, double *int2dx, double *int2dy,
                         double *int2dz) {
  int i, k, n, n1;
  double b0, b1;
  double weight;
  switch (case2d) {
  case 1:
    goto L1;
  case 2:
    goto L3;
  case 3:
    goto L3;
  case 4:
    goto L2;
  case 5:
    goto L4;
  case 6:
    goto L4;
  case 7:
    goto L2;
  case 8:
    goto L4;
  case 9:
    goto L4;
  }
L1:
  for (n = 0; n < ngqexq; n += (16 / 8)) {

    for (n1 = 0; n1 < (16 / 8); n1++) {
      int2dy[n + n1] = 1.0;
      int2dz[n + n1] = 1.0;
    }
  }
  return 0;
L2:
  for (n = 0; n < ngqexq; n += (16 / 8)) {
    __attribute__((aligned(16))) double int2dx_0[(16 / 8)], int2dx_1[(16 / 8)],
        int2dx_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dy_0[(16 / 8)], int2dy_1[(16 / 8)],
        int2dy_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dz_0[(16 / 8)], int2dz_1[(16 / 8)],
        int2dz_2[(16 / 8)];

    for (n1 = 0; n1 < (16 / 8); n1++) {
      int2dx_2[n1] = int2dx[n + n1];
      int2dy[n + n1] = int2dy_2[n1] = 1.;
      int2dz[n + n1] = int2dz_2[n1] = 1.;
      int2dx[n + n1 + ngqexq] = int2dx_1[n1] = d00x[n + n1] * int2dx[n + n1];
      int2dy[n + n1 + ngqexq] = int2dy_1[n1] = d00y[n + n1];
      int2dz[n + n1 + ngqexq] = int2dz_1[n1] = d00z[n + n1];
    }
    for (k = 2; k <= shellq; ++k) {
      double k1 = k - 1;

      for (n1 = 0; n1 < (16 / 8); n1++) {
        b1 = k1 * b01[n + n1];
        int2dx_0[n1] = b1 * int2dx_2[n1] + d00x[n + n1] * int2dx_1[n1];
        int2dx_2[n1] = int2dx_1[n1];
        int2dx_1[n1] = int2dx_0[n1];
        int2dx[n + n1 + k * ngqexq] = int2dx_0[n1];
        int2dy_0[n1] = b1 * int2dy_2[n1] + d00y[n + n1] * int2dy_1[n1];
        int2dy_2[n1] = int2dy_1[n1];
        int2dy_1[n1] = int2dy_0[n1];
        int2dy[n + n1 + k * ngqexq] = int2dy_0[n1];
        int2dz_0[n1] = b1 * int2dz_2[n1] + d00z[n + n1] * int2dz_1[n1];
        int2dz_2[n1] = int2dz_1[n1];
        int2dz_1[n1] = int2dz_0[n1];
        int2dz[n + n1 + k * ngqexq] = int2dz_0[n1];
      }
    }
  }
  return 0;
L3:
  for (n = 0; n < ngqexq; n += (16 / 8)) {
    __attribute__((aligned(16))) double int2dx_0[(16 / 8)], int2dx_1[(16 / 8)],
        int2dx_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dy_0[(16 / 8)], int2dy_1[(16 / 8)],
        int2dy_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dz_0[(16 / 8)], int2dz_1[(16 / 8)],
        int2dz_2[(16 / 8)];

    for (n1 = 0; n1 < (16 / 8); n1++) {
      int2dx_2[n1] = int2dx[n + n1];
      int2dy[n + n1] = int2dy_2[n1] = 1.;
      int2dz[n + n1] = int2dz_2[n1] = 1.;
      int2dx[n + n1 + ngqexq] = int2dx_1[n1] = c00x[n + n1] * int2dx[n + n1];
      int2dy[n + n1 + ngqexq] = int2dy_1[n1] = c00y[n + n1];
      int2dz[n + n1 + ngqexq] = int2dz_1[n1] = c00z[n + n1];
    }
    for (i = 2; i <= shellp; ++i) {
      double i1 = i - 1;

      for (n1 = 0; n1 < (16 / 8); n1++) {
        b1 = i1 * b10[n + n1];
        int2dx_0[n1] = b1 * int2dx_2[n1] + c00x[n + n1] * int2dx_1[n1];
        int2dx_2[n1] = int2dx_1[n1];
        int2dx_1[n1] = int2dx_0[n1];
        int2dx[n + n1 + i * ngqexq] = int2dx_0[n1];
        int2dy_0[n1] = b1 * int2dy_2[n1] + c00y[n + n1] * int2dy_1[n1];
        int2dy_2[n1] = int2dy_1[n1];
        int2dy_1[n1] = int2dy_0[n1];
        int2dy[n + n1 + i * ngqexq] = int2dy_0[n1];
        int2dz_0[n1] = b1 * int2dz_2[n1] + c00z[n + n1] * int2dz_1[n1];
        int2dz_2[n1] = int2dz_1[n1];
        int2dz_1[n1] = int2dz_0[n1];
        int2dz[n + n1 + i * ngqexq] = int2dz_0[n1];
      }
    }
  }
  return 0;
L4:
  for (n = 0; n < ngqexq; n += (16 / 8)) {
    __attribute__((aligned(16))) double int2dx_0[(16 / 8)], int2dx_i1[(16 / 8)],
        int2dx_k1[(16 / 8)], int2dx_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dy_0[(16 / 8)], int2dy_i1[(16 / 8)],
        int2dy_k1[(16 / 8)], int2dy_2[(16 / 8)];
    __attribute__((aligned(16))) double int2dz_0[(16 / 8)], int2dz_i1[(16 / 8)],
        int2dz_k1[(16 / 8)], int2dz_2[(16 / 8)];

    for (n1 = 0; n1 < (16 / 8); n1++) {
      int2dx_2[n1] = int2dx[n + n1];
      int2dy[n + n1] = int2dy_2[n1] = 1.;
      int2dz[n + n1] = int2dz_2[n1] = 1.;
      int2dx[n + n1 + ngqexq] = int2dx_i1[n1] = c00x[n + n1] * int2dx[n + n1];
      int2dy[n + n1 + ngqexq] = int2dy_i1[n1] = c00y[n + n1];
      int2dz[n + n1 + ngqexq] = int2dz_i1[n1] = c00z[n + n1];
    }
    for (i = 2; i <= shellp; ++i) {
      double i1 = i - 1;

      for (n1 = 0; n1 < (16 / 8); n1++) {
        b1 = i1 * b10[n + n1];
        int2dx_0[n1] = b1 * int2dx_2[n1] + c00x[n + n1] * int2dx_i1[n1];
        int2dx_2[n1] = int2dx_i1[n1];
        int2dx_i1[n1] = int2dx_0[n1];
        int2dx[n + n1 + i * ngqexq] = int2dx_0[n1];
        int2dy_0[n1] = b1 * int2dy_2[n1] + c00y[n + n1] * int2dy_i1[n1];
        int2dy_2[n1] = int2dy_i1[n1];
        int2dy_i1[n1] = int2dy_0[n1];
        int2dy[n + n1 + i * ngqexq] = int2dy_0[n1];
        int2dz_0[n1] = b1 * int2dz_2[n1] + c00z[n + n1] * int2dz_i1[n1];
        int2dz_2[n1] = int2dz_i1[n1];
        int2dz_i1[n1] = int2dz_0[n1];
        int2dz[n + n1 + i * ngqexq] = int2dz_0[n1];
      }
    }

    for (n1 = 0; n1 < (16 / 8); n1++) {
      weight = int2dx[n + n1];
      int2dx_2[n1] = weight;
      int2dy_2[n1] = 1.;
      int2dz_2[n1] = 1.;
      int2dx[n + n1 + (shellp + 1) * ngqexq] = int2dx_k1[n1] =
          d00x[n + n1] * weight;
      int2dy[n + n1 + (shellp + 1) * ngqexq] = int2dy_k1[n1] = d00y[n + n1];
      int2dz[n + n1 + (shellp + 1) * ngqexq] = int2dz_k1[n1] = d00z[n + n1];
    }
    for (k = 2; k <= shellq; ++k) {
      double k1 = k - 1;

      for (n1 = 0; n1 < (16 / 8); n1++) {
        b1 = k1 * b01[n + n1];
        int2dx_0[n1] = b1 * int2dx_2[n1] + d00x[n + n1] * int2dx_k1[n1];
        int2dx_2[n1] = int2dx_k1[n1];
        int2dx_k1[n1] = int2dx_0[n1];
        int2dx[n + n1 + k * (shellp + 1) * ngqexq] = int2dx_0[n1];
        int2dy_0[n1] = b1 * int2dy_2[n1] + d00y[n + n1] * int2dy_k1[n1];
        int2dy_2[n1] = int2dy_k1[n1];
        int2dy_k1[n1] = int2dy_0[n1];
        int2dy[n + n1 + k * (shellp + 1) * ngqexq] = int2dy_0[n1];
        int2dz_0[n1] = b1 * int2dz_2[n1] + d00z[n + n1] * int2dz_k1[n1];
        int2dz_2[n1] = int2dz_k1[n1];
        int2dz_k1[n1] = int2dz_0[n1];
        int2dz[n + n1 + k * (shellp + 1) * ngqexq] = int2dz_0[n1];
      }
    }
  }
  if (shellq <= shellp) {
    for (n = 0; n < ngqexq; n += (16 / 8)) {
      __attribute__((aligned(16))) double int2dx_00[(16 / 8)],
          int2dx_10[(16 / 8)], int2dx_20[(16 / 8)], int2dx_11[(16 / 8)];
      __attribute__((aligned(16))) double int2dy_00[(16 / 8)],
          int2dy_10[(16 / 8)], int2dy_20[(16 / 8)], int2dy_11[(16 / 8)];
      __attribute__((aligned(16))) double int2dz_00[(16 / 8)],
          int2dz_10[(16 / 8)], int2dz_20[(16 / 8)], int2dz_11[(16 / 8)];
      for (k = 1; k <= shellq; ++k) {
        int k1 = k - 1;

        for (n1 = 0; n1 < (16 / 8); n1++) {
          b0 = k * b00[n + n1];
          int2dx_10[n1] =
              b0 * int2dx[n + n1 + k1 * (shellp + 1) * ngqexq] +
              c00x[n + n1] * int2dx[n + n1 + k * (shellp + 1) * ngqexq];
          int2dy_10[n1] =
              b0 * int2dy[n + n1 + k1 * (shellp + 1) * ngqexq] +
              c00y[n + n1] * int2dy[n + n1 + k * (shellp + 1) * ngqexq];
          int2dz_10[n1] =
              b0 * int2dz[n + n1 + k1 * (shellp + 1) * ngqexq] +
              c00z[n + n1] * int2dz[n + n1 + k * (shellp + 1) * ngqexq];
          int2dx_20[n1] = int2dx[n + n1 + (k * (shellp + 1)) * ngqexq];
          int2dy_20[n1] = int2dy[n + n1 + (k * (shellp + 1)) * ngqexq];
          int2dz_20[n1] = int2dz[n + n1 + (k * (shellp + 1)) * ngqexq];
        }

        for (n1 = 0; n1 < (16 / 8); n1++) {
          int2dx[n + n1 + (k * (shellp + 1) + 1) * ngqexq] = int2dx_10[n1];
          int2dy[n + n1 + (k * (shellp + 1) + 1) * ngqexq] = int2dy_10[n1];
          int2dz[n + n1 + (k * (shellp + 1) + 1) * ngqexq] = int2dz_10[n1];
        }
        for (i = 2; i <= shellp; ++i) {
          int i1 = i - 1;

          for (n1 = 0; n1 < (16 / 8); n1++) {
            b0 = k * b00[n + n1];
            b1 = i1 * b10[n + n1];
            int2dx_11[n1] = int2dx[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dx_00[n1] = b0 * int2dx_11[n1] + b1 * int2dx_20[n1] +
                            c00x[n + n1] * int2dx_10[n1];
            int2dx_20[n1] = int2dx_10[n1];
            int2dx_10[n1] = int2dx_00[n1];
            int2dy_11[n1] = int2dy[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dy_00[n1] = b0 * int2dy_11[n1] + b1 * int2dy_20[n1] +
                            c00y[n + n1] * int2dy_10[n1];
            int2dy_20[n1] = int2dy_10[n1];
            int2dy_10[n1] = int2dy_00[n1];
            int2dz_11[n1] = int2dz[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dz_00[n1] = b0 * int2dz_11[n1] + b1 * int2dz_20[n1] +
                            c00z[n + n1] * int2dz_10[n1];
            int2dz_20[n1] = int2dz_10[n1];
            int2dz_10[n1] = int2dz_00[n1];
          }

          for (n1 = 0; n1 < (16 / 8); n1++) {
            int2dx[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dx_00[n1];
            int2dy[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dy_00[n1];
            int2dz[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dz_00[n1];
          }
        }
      }
    }
  } else {
    for (n = 0; n < ngqexq; n += (16 / 8)) {
      __attribute__((aligned(16))) double int2dx_00[(16 / 8)],
          int2dx_01[(16 / 8)], int2dx_02[(16 / 8)], int2dx_11[(16 / 8)];
      __attribute__((aligned(16))) double int2dy_00[(16 / 8)],
          int2dy_01[(16 / 8)], int2dy_02[(16 / 8)], int2dy_11[(16 / 8)];
      __attribute__((aligned(16))) double int2dz_00[(16 / 8)],
          int2dz_01[(16 / 8)], int2dz_02[(16 / 8)], int2dz_11[(16 / 8)];
      for (i = 1; i <= shellp; ++i) {
        int i1 = i - 1;

        for (n1 = 0; n1 < (16 / 8); n1++) {
          b0 = i * b00[n + n1];
          int2dx_01[n1] = b0 * int2dx[n + n1 + i1 * ngqexq] +
                          d00x[n + n1] * int2dx[n + n1 + i * ngqexq];
          int2dy_01[n1] = b0 * int2dy[n + n1 + i1 * ngqexq] +
                          d00y[n + n1] * int2dy[n + n1 + i * ngqexq];
          int2dz_01[n1] = b0 * int2dz[n + n1 + i1 * ngqexq] +
                          d00z[n + n1] * int2dz[n + n1 + i * ngqexq];
          int2dx_02[n1] = int2dx[n + n1 + (i)*ngqexq];
          int2dy_02[n1] = int2dy[n + n1 + (i)*ngqexq];
          int2dz_02[n1] = int2dz[n + n1 + (i)*ngqexq];
        }

        for (n1 = 0; n1 < (16 / 8); n1++) {
          int2dx[n + n1 + (i + (shellp + 1)) * ngqexq] = int2dx_01[n1];
          int2dy[n + n1 + (i + (shellp + 1)) * ngqexq] = int2dy_01[n1];
          int2dz[n + n1 + (i + (shellp + 1)) * ngqexq] = int2dz_01[n1];
        }
        for (k = 2; k <= shellq; ++k) {
          int k1 = k - 1;

          for (n1 = 0; n1 < (16 / 8); n1++) {
            b0 = i * b00[n + n1];
            b1 = k1 * b01[n + n1];
            int2dx_11[n1] = int2dx[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dx_00[n1] = b0 * int2dx_11[n1] + b1 * int2dx_02[n1] +
                            d00x[n + n1] * int2dx_01[n1];
            int2dx_02[n1] = int2dx_01[n1];
            int2dx_01[n1] = int2dx_00[n1];
            int2dy_11[n1] = int2dy[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dy_00[n1] = b0 * int2dy_11[n1] + b1 * int2dy_02[n1] +
                            d00y[n + n1] * int2dy_01[n1];
            int2dy_02[n1] = int2dy_01[n1];
            int2dy_01[n1] = int2dy_00[n1];
            int2dz_11[n1] = int2dz[n + n1 + (i1 + k1 * (shellp + 1)) * ngqexq];
            int2dz_00[n1] = b0 * int2dz_11[n1] + b1 * int2dz_02[n1] +
                            d00z[n + n1] * int2dz_01[n1];
            int2dz_02[n1] = int2dz_01[n1];
            int2dz_01[n1] = int2dz_00[n1];
          }

          for (n1 = 0; n1 < (16 / 8); n1++) {
            int2dx[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dx_00[n1];
            int2dy[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dy_00[n1];
            int2dz[n + n1 + (i + k * (shellp + 1)) * ngqexq] = int2dz_00[n1];
          }
        }
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<erd__2d_pq_integrals>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x400(%rbp)
sub    $0x8,%eax
ja     11a3 <erd__2d_pq_integrals+0xa3>
mov    -0x400(%rbp),%rax
lea    0x1e9b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    11a8 <erd__2d_pq_integrals+0xa8>
jmp    15e7 <erd__2d_pq_integrals+0x4e7>
jmp    15e7 <erd__2d_pq_integrals+0x4e7>
jmp    122d <erd__2d_pq_integrals+0x12d>
jmp    19bf <erd__2d_pq_integrals+0x8bf>
jmp    19bf <erd__2d_pq_integrals+0x8bf>
jmp    122d <erd__2d_pq_integrals+0x12d>
jmp    19bf <erd__2d_pq_integrals+0x8bf>
jmp    19bf <erd__2d_pq_integrals+0x8bf>
jmp    11a8 <erd__2d_pq_integrals+0xa8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1221 <erd__2d_pq_integrals+0x121>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    120e <erd__2d_pq_integrals+0x10e>
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1e1f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1e05(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c2 <erd__2d_pq_integrals+0xc2>
jmp    1213 <erd__2d_pq_integrals+0x113>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    11af <erd__2d_pq_integrals+0xaf>
movl   $0x0,-0x4(%rbp)
jmp    2ef6 <erd__2d_pq_integrals+0x1df6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15db <erd__2d_pq_integrals+0x4db>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1384 <erd__2d_pq_integrals+0x284>
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  0x1d87(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1d69(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  0x1d58(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1d3a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1247 <erd__2d_pq_integrals+0x147>
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     15c8 <erd__2d_pq_integrals+0x4c8>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    15b5 <erd__2d_pq_integrals+0x4b5>
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x70(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm2
ff ff
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm2
ff ff
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xc0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13b0 <erd__2d_pq_integrals+0x2b0>
jmp    15ba <erd__2d_pq_integrals+0x4ba>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    138b <erd__2d_pq_integrals+0x28b>
jmp    15cd <erd__2d_pq_integrals+0x4cd>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1234 <erd__2d_pq_integrals+0x134>
movl   $0x0,-0x4(%rbp)
jmp    2ef6 <erd__2d_pq_integrals+0x1df6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19b3 <erd__2d_pq_integrals+0x8b3>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1744 <erd__2d_pq_integrals+0x644>
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  0x19ca(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x19ac(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  0x199b(%rip),%xmm0
movsd  %xmm0,-0x180(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x197d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1601 <erd__2d_pq_integrals+0x501>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     19a0 <erd__2d_pq_integrals+0x8a0>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    198d <erd__2d_pq_integrals+0x88d>
movsd  -0x188(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm2
ff ff
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x140(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x180(%rbp,%rax,8),%xmm2
ff ff
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x170(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x160(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x180(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1770 <erd__2d_pq_integrals+0x670>
jmp    1992 <erd__2d_pq_integrals+0x892>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    174b <erd__2d_pq_integrals+0x64b>
jmp    19a5 <erd__2d_pq_integrals+0x8a5>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    15ee <erd__2d_pq_integrals+0x4ee>
movl   $0x0,-0x4(%rbp)
jmp    2ef6 <erd__2d_pq_integrals+0x1df6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2130 <erd__2d_pq_integrals+0x1030>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1b1c <erd__2d_pq_integrals+0xa1c>
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  0x15f2(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x15d4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  0x15c3(%rip),%xmm0
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x15a5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19d9 <erd__2d_pq_integrals+0x8d9>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1d78 <erd__2d_pq_integrals+0xc78>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1d65 <erd__2d_pq_integrals+0xc65>
movsd  -0x258(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x1d0(%rbp,%rax,8),%xmm2
ff ff
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x1b0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x210(%rbp,%rax,8),%xmm2
ff ff
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x1f0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1e0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1f0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm2
ff ff
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x230(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x220(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b48 <erd__2d_pq_integrals+0xa48>
jmp    1d6a <erd__2d_pq_integrals+0xc6a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b23 <erd__2d_pq_integrals+0xa23>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1ea6 <erd__2d_pq_integrals+0xda6>
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  0x1242(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  0x122d(%rip),%xmm0
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x50(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1c0(%rbp,%rax,8)
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x200(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d7f <erd__2d_pq_integrals+0xc7f>
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     211d <erd__2d_pq_integrals+0x101d>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    210a <erd__2d_pq_integrals+0x100a>
movsd  -0x260(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x1d0(%rbp,%rax,8),%xmm2
ff ff
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x1c0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1c0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1c0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x210(%rbp,%rax,8),%xmm2
ff ff
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x200(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x1e0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x200(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
movslq -0x38(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x200(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm2
ff ff
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x38(%rbp),%rax
mulsd  -0x240(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x220(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x240(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ed2 <erd__2d_pq_integrals+0xdd2>
jmp    210f <erd__2d_pq_integrals+0x100f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ead <erd__2d_pq_integrals+0xdad>
jmp    2122 <erd__2d_pq_integrals+0x1022>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    19c6 <erd__2d_pq_integrals+0x8c6>
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2844 <erd__2d_pq_integrals+0x1744>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    283f <erd__2d_pq_integrals+0x173f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     282c <erd__2d_pq_integrals+0x172c>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x324(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    23a1 <erd__2d_pq_integrals+0x12a1>
cvtsi2sdl -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x324(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x280(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x324(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2c0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x324(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x300(%rbp,%rax,8)
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x310(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2175 <erd__2d_pq_integrals+0x1075>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    245c <erd__2d_pq_integrals+0x135c>
movslq -0x38(%rbp),%rax
movsd  -0x280(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x2c0(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x300(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    23a8 <erd__2d_pq_integrals+0x12a8>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2819 <erd__2d_pq_integrals+0x1719>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x328(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2745 <erd__2d_pq_integrals+0x1645>
cvtsi2sdl -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
cvtsi2sdl -0x328(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x328(%rbp),%edx
mov    -0x324(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2a0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x2a0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x280(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x270(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x280(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x270(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x280(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x328(%rbp),%edx
mov    -0x324(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2e0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x2e0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x2c0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x2c0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2c0(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x328(%rbp),%edx
mov    -0x324(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x320(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x320(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x310(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x300(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x2f0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x300(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x310(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x2f0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x300(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2482 <erd__2d_pq_integrals+0x1382>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2806 <erd__2d_pq_integrals+0x1706>
movslq -0x38(%rbp),%rax
movsd  -0x270(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x2f0(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    274c <erd__2d_pq_integrals+0x164c>
jmp    280b <erd__2d_pq_integrals+0x170b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2463 <erd__2d_pq_integrals+0x1363>
jmp    281e <erd__2d_pq_integrals+0x171e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2156 <erd__2d_pq_integrals+0x1056>
jmp    2831 <erd__2d_pq_integrals+0x1731>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    2143 <erd__2d_pq_integrals+0x1043>
jmp    2eef <erd__2d_pq_integrals+0x1def>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2eea <erd__2d_pq_integrals+0x1dea>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2ed7 <erd__2d_pq_integrals+0x1dd7>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3f4(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2a58 <erd__2d_pq_integrals+0x1958>
cvtsi2sdl -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x350(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x390(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3d0(%rbp,%rax,8)
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x360(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    287d <erd__2d_pq_integrals+0x177d>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2b07 <erd__2d_pq_integrals+0x1a07>
movslq -0x38(%rbp),%rax
movsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2a5f <erd__2d_pq_integrals+0x195f>
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     2ec4 <erd__2d_pq_integrals+0x1dc4>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3f8(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2df0 <erd__2d_pq_integrals+0x1cf0>
cvtsi2sdl -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
cvtsi2sdl -0x3f8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
mov    -0x3f8(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x370(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x360(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x350(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x340(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x360(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x340(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x350(%rbp,%rax,8)
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
mov    -0x3f8(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3b0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x3b0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x390(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x380(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x380(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x390(%rbp,%rax,8)
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x3f4(%rbp),%edx
mov    -0x3f8(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm1
movslq -0x38(%rbp),%rax
movsd  -0x3f0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x48(%rbp),%xmm0
movslq -0x38(%rbp),%rax
mulsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rax
movsd  -0x3d0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3c0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
movslq -0x38(%rbp),%rax
movsd  -0x3c0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x38(%rbp),%rax
movsd  %xmm0,-0x3d0(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2b2d <erd__2d_pq_integrals+0x1a2d>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    2eb1 <erd__2d_pq_integrals+0x1db1>
movslq -0x38(%rbp),%rax
movsd  -0x340(%rbp,%rax,8),%xmm0
ff ff
mov    0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x380(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x38(%rbp),%rax
movsd  -0x3c0(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x8(%rbp),%edi
add    $0x1,%edi
imul   %edi,%esi
add    %esi,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2df7 <erd__2d_pq_integrals+0x1cf7>
jmp    2eb6 <erd__2d_pq_integrals+0x1db6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2b0e <erd__2d_pq_integrals+0x1a0e>
jmp    2ec9 <erd__2d_pq_integrals+0x1dc9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    285e <erd__2d_pq_integrals+0x175e>
jmp    2edc <erd__2d_pq_integrals+0x1ddc>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    284b <erd__2d_pq_integrals+0x174b>
jmp    2eef <erd__2d_pq_integrals+0x1def>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<erd__2d_pq_integrals>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,-0x58(%rsp)
mov    %rdi,-0x68(%rsp)
mov    0x90(%rsp),%eax
cmp    $0x9,%eax
mov    %rdx,-0x80(%rsp)
ja     2425 <erd__2d_pq_integrals+0x1325>
mov    $0x360,%esi
bt     %eax,%esi
mov    %r9,-0x20(%rsp)
mov    %r8,-0x50(%rsp)
jb     13fa <erd__2d_pq_integrals+0x2fa>
mov    $0xc,%ecx
bt     %eax,%ecx
jb     1d5d <erd__2d_pq_integrals+0xc5d>
mov    $0x90,%ecx
bt     %eax,%ecx
jae    2425 <erd__2d_pq_integrals+0x1325>
test   %edx,%edx
jle    24dc <erd__2d_pq_integrals+0x13dc>
mov    -0x80(%rsp),%esi
mov    -0x58(%rsp),%rax
lea    0x1(%rax),%r12d
mov    %rsi,%rax
shl    $0x4,%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,1),%r15
add    $0x8,%r15
lea    0x0(,%rsi,8),%r8
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,1),%r13
add    $0x8,%r13
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
add    $0x8,%rbx
xor    %edx,%edx
mov    %rsi,-0x80(%rsp)
movabs $0x3ff0000000000000,%r9
jmp    11ee <erd__2d_pq_integrals+0xee>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdx
add    $0x10,%r15
add    $0x10,%r13
add    $0x10,%rbx
mov    -0x80(%rsp),%rsi
cmp    %rsi,%rdx
jae    24dc <erd__2d_pq_integrals+0x13dc>
lea    (%rdx,%rsi,1),%rax
mov    %rdx,%rcx
or     $0x1,%rcx
add    %rcx,%rsi
mov    0x98(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm1
mov    0xa0(%rsp),%r11
mov    %r9,(%r11,%rdx,8)
mov    0xa8(%rsp),%r14
mov    %r9,(%r14,%rdx,8)
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm10
mulsd  (%rdi,%rdx,8),%xmm10
movsd  %xmm10,(%rdi,%rax,8)
mov    0x80(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm11
movsd  %xmm11,(%r11,%rax,8)
mov    0x88(%rsp),%r10
movsd  (%r10,%rdx,8),%xmm9
movsd  %xmm9,(%r14,%rax,8)
movsd  (%rdi,%rcx,8),%xmm4
mov    %r9,(%r11,%rcx,8)
mov    %r9,(%r14,%rcx,8)
mov    0x78(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm8
mulsd  (%rdi,%rcx,8),%xmm8
movsd  %xmm8,(%rdi,%rsi,8)
movsd  0x0(%rbp,%rcx,8),%xmm14
movsd  %xmm14,(%r11,%rsi,8)
mov    %rbp,%r11
movsd  (%r10,%rcx,8),%xmm15
movsd  %xmm15,(%r14,%rsi,8)
cmpl   $0x2,-0x58(%rsp)
mov    -0x50(%rsp),%rbp
jl     11d0 <erd__2d_pq_integrals+0xd0>
mov    %rax,%r14
mov    $0x2,%edi
xor    %esi,%esi
movsd  0x1d3c(%rip),%xmm5
movapd %xmm5,%xmm12
movsd  %xmm5,-0x78(%rsp)
movapd %xmm5,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rdi),%eax
xorps  %xmm6,%xmm6
cvtsi2sd %eax,%xmm6
movsd  0x0(%rbp,%rdx,8),%xmm7
mulsd  %xmm6,%xmm7
movsd  (%r14,%rdx,8),%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm7,%xmm1
movapd %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%r15,%rsi,1)
movsd  (%r11,%rdx,8),%xmm3
mulsd  %xmm11,%xmm3
mulsd  %xmm7,%xmm2
movapd %xmm2,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,-0x8(%r13,%rsi,1)
movsd  (%r10,%rdx,8),%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm12,%xmm7
addsd  %xmm2,%xmm7
movsd  %xmm7,-0x8(%rbx,%rsi,1)
mulsd  0x0(%rbp,%rcx,8),%xmm6
movsd  (%r14,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
mulsd  %xmm6,%xmm4
movapd %xmm4,%xmm13
addsd  %xmm2,%xmm13
movsd  %xmm13,(%r15,%rsi,1)
movsd  (%r11,%rcx,8),%xmm2
mulsd  %xmm14,%xmm2
mulsd  %xmm6,%xmm5
movapd %xmm5,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rsi,1)
movsd  (%r10,%rcx,8),%xmm2
mulsd  %xmm15,%xmm2
mulsd  -0x78(%rsp),%xmm6
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rbx,%rsi,1)
add    $0x1,%rdi
add    %r8,%rsi
movapd %xmm9,%xmm12
movsd  %xmm15,-0x78(%rsp)
movapd %xmm7,%xmm9
movapd %xmm6,%xmm15
movapd %xmm11,%xmm2
movapd %xmm14,%xmm5
movapd %xmm1,%xmm11
movapd %xmm3,%xmm14
movapd %xmm10,%xmm1
movapd %xmm8,%xmm4
movapd %xmm0,%xmm10
movapd %xmm13,%xmm8
cmp    %rdi,%r12
jne    12e0 <erd__2d_pq_integrals+0x1e0>
jmp    11d0 <erd__2d_pq_integrals+0xd0>
test   %edx,%edx
jle    24dc <erd__2d_pq_integrals+0x13dc>
mov    %rcx,0x20(%rsp)
mov    -0x68(%rsp),%rax
lea    0x1(%rax),%r8d
mov    %r8d,%r9d
mov    -0x80(%rsp),%rax
imul   %eax,%r9d
mov    %eax,%r10d
movslq %r9d,%rdx
mov    -0x58(%rsp),%rax
add    $0x1,%eax
mov    %rax,-0x8(%rsp)
mov    %r10,%rax
shl    $0x4,%rax
mov    0x98(%rsp),%r13
lea    (%rax,%r13,1),%rcx
add    $0x8,%rcx
mov    %rcx,-0x18(%rsp)
lea    0x0(,%r10,8),%r15
mov    0xa0(%rsp),%rbx
lea    0x8(%rbx,%rax,1),%rcx
mov    %rcx,-0x38(%rsp)
mov    0xa8(%rsp),%rcx
lea    0x8(%rcx,%rax,1),%rax
mov    %rax,-0x40(%rsp)
mov    %rdx,-0x48(%rsp)
lea    (%rdx,%rdx,1),%eax
mov    %eax,-0x28(%rsp)
xor    %r12d,%r12d
mov    %r8,-0x10(%rsp)
mov    %r10,0x10(%rsp)
mov    %r15,0x18(%rsp)
jmp    14d1 <erd__2d_pq_integrals+0x3d1>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r12
addq   $0x10,-0x18(%rsp)
addq   $0x10,-0x38(%rsp)
addq   $0x10,-0x40(%rsp)
mov    0x10(%rsp),%r10
cmp    %r10,%r12
mov    %r8,%rbx
mov    -0x10(%rsp),%r8
mov    0x18(%rsp),%r15
jae    18df <erd__2d_pq_integrals+0x7df>
lea    (%r12,%r10,1),%rbp
mov    %r12,%rdx
or     $0x1,%rdx
mov    %r10,%rsi
lea    (%rdx,%r10,1),%rsi
movsd  0x0(%r13,%r12,8),%xmm0
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rbx,%r12,8)
mov    %rbx,%rax
mov    0xa8(%rsp),%rdi
mov    %rcx,(%rdi,%r12,8)
mov    0x60(%rsp),%r11
movsd  (%r11,%r12,8),%xmm13
mulsd  0x0(%r13,%r12,8),%xmm13
mov    %rbp,%rcx
movsd  %xmm13,0x0(%r13,%rbp,8)
mov    0x68(%rsp),%r10
movsd  (%r10,%r12,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mov    0x70(%rsp),%r14
movsd  (%r14,%r12,8),%xmm3
movsd  %xmm3,(%rdi,%rbp,8)
movsd  0x0(%r13,%rdx,8),%xmm2
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rbx,%rdx,8)
mov    %rcx,(%rdi,%rdx,8)
movsd  (%r11,%rdx,8),%xmm14
mulsd  0x0(%r13,%rdx,8),%xmm14
movsd  %xmm14,0x0(%r13,%rsi,8)
movsd  (%r10,%rdx,8),%xmm7
movsd  %xmm7,(%rbx,%rsi,8)
movsd  (%r14,%rdx,8),%xmm4
movsd  %xmm4,(%rdi,%rsi,8)
cmpl   $0x2,-0x68(%rsp)
mov    -0x18(%rsp),%r13
mov    -0x38(%rsp),%rbx
mov    -0x40(%rsp),%rbp
mov    -0x20(%rsp),%rcx
jl     16ef <erd__2d_pq_integrals+0x5ef>
mov    $0x2,%esi
xor    %edi,%edi
movsd  0x1a4b(%rip),%xmm9
movapd %xmm9,%xmm5
movapd %xmm9,%xmm6
movapd %xmm9,%xmm15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm3,%xmm8
movsd  %xmm3,-0x60(%rsp)
movsd  %xmm4,-0x78(%rsp)
movapd %xmm1,%xmm11
movapd %xmm7,%xmm12
movapd %xmm13,%xmm10
movapd %xmm14,%xmm7
lea    -0x1(%rsi),%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movsd  (%rcx,%r12,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  (%r11,%r12,8),%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r13,%rdi,1)
movsd  (%r10,%r12,8),%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm3,%xmm6
addsd  %xmm1,%xmm6
movsd  %xmm6,-0x8(%rbx,%rdi,1)
movsd  (%r14,%r12,8),%xmm1
mulsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,-0x8(%rbp,%rdi,1)
mulsd  (%rcx,%rdx,8),%xmm4
movsd  (%r11,%rdx,8),%xmm1
mulsd  %xmm14,%xmm1
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%rdi,1)
movsd  (%r10,%rdx,8),%xmm1
mulsd  %xmm12,%xmm1
mulsd  %xmm4,%xmm5
addsd  %xmm1,%xmm5
movsd  %xmm5,(%rbx,%rdi,1)
movsd  (%r14,%rdx,8),%xmm1
movsd  -0x78(%rsp),%xmm8
mulsd  %xmm8,%xmm1
mulsd  %xmm15,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,0x0(%rbp,%rdi,1)
add    $0x1,%rsi
add    %r15,%rdi
movapd %xmm2,%xmm14
movapd %xmm0,%xmm13
movapd %xmm7,%xmm2
movapd %xmm10,%xmm0
movapd %xmm5,%xmm7
movapd %xmm6,%xmm1
movapd %xmm12,%xmm5
movapd %xmm11,%xmm6
movapd %xmm8,%xmm15
movsd  -0x60(%rsp),%xmm9
cmp    %rsi,%r8
jne    15d0 <erd__2d_pq_integrals+0x4d0>
mov    -0x48(%rsp),%rcx
lea    (%r12,%rcx,1),%rax
lea    (%rdx,%rcx,1),%rsi
mov    0x98(%rsp),%r13
movsd  0x0(%r13,%r12,8),%xmm1
mov    0x78(%rsp),%r15
movsd  (%r15,%r12,8),%xmm8
mulsd  %xmm1,%xmm8
movsd  %xmm8,0x0(%r13,%rax,8)
mov    0x80(%rsp),%r14
movsd  (%r14,%r12,8),%xmm0
mov    0xa0(%rsp),%r8
movsd  %xmm0,(%r8,%rax,8)
mov    0x88(%rsp),%r10
movsd  (%r10,%r12,8),%xmm3
mov    0xa8(%rsp),%rbx
movsd  %xmm3,(%rbx,%rax,8)
movsd  0x0(%r13,%rdx,8),%xmm2
movsd  (%r15,%rdx,8),%xmm12
mulsd  %xmm2,%xmm12
movsd  %xmm12,0x0(%r13,%rsi,8)
movsd  (%r14,%rdx,8),%xmm14
movsd  %xmm14,(%r8,%rsi,8)
movsd  (%r10,%rdx,8),%xmm4
movsd  %xmm4,(%rbx,%rsi,8)
cmpl   $0x2,-0x58(%rsp)
mov    -0x8(%rsp),%rcx
mov    -0x50(%rsp),%rbp
jl     14a0 <erd__2d_pq_integrals+0x3a0>
mov    $0x2,%esi
mov    -0x28(%rsp),%eax
mov    %eax,%edi
movsd  0x184f(%rip),%xmm7
movapd %xmm7,%xmm5
movapd %xmm7,%xmm6
movapd %xmm7,%xmm15
xchg   %ax,%ax
movapd %xmm3,%xmm9
movapd %xmm4,%xmm10
movapd %xmm0,%xmm11
movapd %xmm8,%xmm13
lea    -0x1(%rsi),%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movslq %edi,%rdi
movsd  0x0(%rbp,%r12,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  (%r15,%r12,8),%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
lea    (%r12,%rdi,1),%rax
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%r14,%r12,8),%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm3,%xmm6
addsd  %xmm0,%xmm6
movsd  %xmm6,(%r8,%rax,8)
movsd  (%r10,%r12,8),%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm7,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rbx,%rax,8)
mulsd  0x0(%rbp,%rdx,8),%xmm4
movapd %xmm14,%xmm7
movapd %xmm12,%xmm14
movsd  (%r15,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
lea    (%rdx,%rdi,1),%rax
movsd  %xmm2,0x0(%r13,%rax,8)
movsd  (%r14,%rdx,8),%xmm0
mulsd  %xmm7,%xmm0
mulsd  %xmm4,%xmm5
addsd  %xmm0,%xmm5
movsd  %xmm5,(%r8,%rax,8)
movsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm15,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
add    $0x1,%rsi
add    %r9d,%edi
movapd %xmm2,%xmm12
movapd %xmm1,%xmm8
movapd %xmm14,%xmm2
movapd %xmm13,%xmm1
movapd %xmm5,%xmm14
movapd %xmm6,%xmm0
movapd %xmm7,%xmm5
movapd %xmm11,%xmm6
movapd %xmm10,%xmm15
movapd %xmm9,%xmm7
cmp    %rsi,%rcx
jne    17c0 <erd__2d_pq_integrals+0x6c0>
jmp    14a0 <erd__2d_pq_integrals+0x3a0>
mov    -0x68(%rsp),%rax
cmp    %eax,-0x58(%rsp)
mov    %r9,-0x18(%rsp)
jle    2004 <erd__2d_pq_integrals+0xf04>
cmpl   $0x0,-0x80(%rsp)
jle    24dc <erd__2d_pq_integrals+0x13dc>
movslq -0x10(%rsp),%rax
mov    -0x68(%rsp),%rdx
mov    %edx,%ecx
mov    %rcx,-0x28(%rsp)
lea    (%rdx,%rdx,1),%ecx
add    $0x3,%ecx
imul   -0x80(%rsp),%ecx
mov    %ecx,-0x6c(%rsp)
imul   %r10,%rax
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,8),%rcx
mov    %rcx,0x8(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,(%rsp)
mov    0xa0(%rsp),%rcx
lea    0x8(%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
add    $0x8,%rcx
mov    0x20(%rsp),%r14
xor    %eax,%eax
mov    %rax,-0x30(%rsp)
xor    %r13d,%r13d
jmp    1988 <erd__2d_pq_integrals+0x888>
nopl   (%rax)
add    $0x2,%r13
addl   $0x2,-0x6c(%rsp)
addq   $0x10,-0x30(%rsp)
cmp    %r10,%r13
jae    24dc <erd__2d_pq_integrals+0x13dc>
cmpl   $0x0,-0x68(%rsp)
mov    -0x80(%rsp),%r15
jle    1970 <erd__2d_pq_integrals+0x870>
lea    (%r15,%r13,1),%eax
cltq
mov    %rax,-0x20(%rsp)
mov    %r13,%rax
or     $0x1,%rax
mov    %rax,-0x78(%rsp)
mov    $0x1,%r12d
mov    -0x30(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x6c(%rsp),%eax
mov    %eax,-0x48(%rsp)
xor    %edi,%edi
jmp    1a11 <erd__2d_pq_integrals+0x911>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%r12
add    $0x1,%r12
mov    -0x40(%rsp),%rdi
add    $0x1,%rdi
mov    -0x80(%rsp),%r15
add    %r15d,-0x48(%rsp)
mov    -0x60(%rsp),%rax
add    0x18(%rsp),%rax
mov    %rax,-0x60(%rsp)
cmp    -0x28(%rsp),%rdi
mov    0x10(%rsp),%r10
mov    %r9,%r14
mov    %rsi,%r13
je     1970 <erd__2d_pq_integrals+0x870>
mov    %rdi,-0x40(%rsp)
mov    %rdi,%rax
imul   %r10,%rax
add    -0x20(%rsp),%rax
lea    -0x1(%r12),%r9
imul   %r10,%r9
mov    %r12,%rdi
imul   %r10,%rdi
mov    0x98(%rsp),%r8
movupd (%r8,%rax,8),%xmm7
mov    0xa0(%rsp),%r11
movsd  (%r11,%rax,8),%xmm10
movsd  0x8(%r11,%rax,8),%xmm14
mov    0xa8(%rsp),%r10
movsd  (%r10,%rax,8),%xmm1
movsd  0x8(%r10,%rax,8),%xmm9
lea    (%rdi,%r13,1),%rax
mov    -0x78(%rsp),%rbx
add    %rbx,%rdi
mov    0x88(%rsp),%rbp
movsd  0x0(%rbp,%r13,8),%xmm11
mulsd  (%r10,%rax,8),%xmm11
movupd (%r8,%rax,8),%xmm12
movsd  (%r11,%rdi,8),%xmm13
movhpd (%r11,%rax,8),%xmm13
lea    (%r9,%r13,1),%rax
add    %rbx,%r9
movsd  (%r10,%rax,8),%xmm5
movupd (%r8,%rax,8),%xmm6
movsd  (%r11,%r9,8),%xmm2
movhpd (%r11,%rax,8),%xmm2
cvtsi2sd %r12d,%xmm8
movupd (%r14,%r13,8),%xmm4
unpcklpd %xmm8,%xmm8
mulpd  %xmm8,%xmm4
mulsd  %xmm4,%xmm5
addsd  %xmm11,%xmm5
mov    0x78(%rsp),%rax
movupd (%rax,%r13,8),%xmm3
mulpd  %xmm3,%xmm12
mov    0x80(%rsp),%rsi
movsd  (%rsi,%rbx,8),%xmm3
movhpd (%rsi,%r13,8),%xmm3
mulpd  %xmm3,%xmm13
movapd %xmm4,%xmm3
shufpd $0x1,%xmm4,%xmm3
mulpd  %xmm3,%xmm2
movsd  0x0(%rbp,%rbx,8),%xmm3
mulsd  (%r10,%rdi,8),%xmm3
mov    %r14,%rbx
mov    -0x10(%rsp),%rax
mov    %r12,-0x38(%rsp)
add    %r12d,%eax
imul   %r15d,%eax
mulpd  %xmm4,%xmm6
unpckhpd %xmm4,%xmm4
mulsd  (%r10,%r9,8),%xmm4
lea    (%rax,%r13,1),%edi
addpd  %xmm13,%xmm2
addpd  %xmm12,%xmm6
movslq %edi,%rdi
movlpd %xmm6,(%r8,%rdi,8)
movhpd %xmm2,(%r11,%rdi,8)
movsd  %xmm5,(%r10,%rdi,8)
addsd  %xmm3,%xmm4
lea    0x1(%rax,%r13,1),%eax
cltq
movhpd %xmm6,(%r8,%rax,8)
movlpd %xmm2,(%r11,%rax,8)
movsd  %xmm4,(%r10,%rax,8)
cmpl   $0x2,-0x58(%rsp)
mov    %r13,%rsi
mov    -0x18(%rsp),%r13
mov    %r14,%r9
mov    -0x8(%rsp),%r11
mov    0x8(%rsp),%r12
mov    (%rsp),%r10
jl     19d0 <erd__2d_pq_integrals+0x8d0>
mov    %r8,%r14
shufpd $0x1,%xmm6,%xmm6
shufpd $0x1,%xmm7,%xmm7
unpcklpd %xmm10,%xmm14
mov    $0x2,%r15d
mov    -0x60(%rsp),%rdi
mov    -0x48(%rsp),%eax
mov    %eax,%r8d
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm2,%xmm10
lea    -0x1(%r15),%eax
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
mov    -0x50(%rsp),%rax
movupd (%rax,%rsi,8),%xmm2
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm2
shufpd $0x1,%xmm3,%xmm2
mulpd  %xmm2,%xmm14
mulpd  %xmm7,%xmm2
movapd %xmm6,%xmm11
movapd %xmm5,%xmm12
mulsd  %xmm3,%xmm1
unpckhpd %xmm3,%xmm3
mulsd  %xmm9,%xmm3
movapd %xmm4,%xmm9
movupd (%r9,%rsi,8),%xmm7
mulpd  %xmm8,%xmm7
movapd %xmm7,%xmm4
shufpd $0x1,%xmm7,%xmm4
movsd  -0x8(%rcx,%rdi,1),%xmm6
mulsd  %xmm7,%xmm6
addsd  %xmm1,%xmm6
mov    0x88(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm5
mulsd  %xmm12,%xmm5
addsd  %xmm6,%xmm5
movupd (%r12,%rdi,1),%xmm1
mov    %r10,%rbx
mov    %r11,%r10
mov    %r13,%r11
mov    0x78(%rsp),%rbp
movupd 0x0(%rbp,%rsi,8),%xmm6
movsd  (%rdx,%rdi,1),%xmm0
movhpd -0x8(%rdx,%rdi,1),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm14,%xmm0
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm2,%xmm1
shufpd $0x1,%xmm6,%xmm6
mov    0x80(%rsp),%r13
mov    -0x78(%rsp),%rbp
movsd  0x0(%r13,%rbp,8),%xmm2
movhpd 0x0(%r13,%rsi,8),%xmm2
mulpd  %xmm10,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm11,%xmm6
addpd  %xmm1,%xmm6
unpckhpd %xmm7,%xmm7
mulsd  (%rcx,%rdi,1),%xmm7
addsd  %xmm3,%xmm7
movsd  (%rax,%rbp,8),%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm7,%xmm4
movslq %r8d,%r8
movhpd %xmm6,(%r14,%r8,8)
mov    0xa0(%rsp),%rax
mov    %r9,%rbp
mov    %rax,%r9
movhpd %xmm2,(%rax,%r8,8)
mov    0xa8(%rsp),%rax
movsd  %xmm5,(%rax,%r8,8)
lea    0x1(%r8),%eax
cltq
movlpd %xmm6,(%r14,%rax,8)
movlpd %xmm2,(%r9,%rax,8)
mov    %rbp,%r9
mov    %r11,%r13
mov    %r10,%r11
mov    %rbx,%r10
mov    0xa8(%rsp),%rbx
movsd  %xmm4,(%rbx,%rax,8)
add    $0x1,%r15
add    %r13d,%r8d
add    %r10,%rdi
movapd %xmm12,%xmm1
movapd %xmm11,%xmm7
movapd %xmm10,%xmm14
cmp    %r15,%r11
jne    1bd0 <erd__2d_pq_integrals+0xad0>
jmp    19d0 <erd__2d_pq_integrals+0x8d0>
test   %edx,%edx
jle    24dc <erd__2d_pq_integrals+0x13dc>
mov    -0x80(%rsp),%esi
mov    -0x68(%rsp),%rax
lea    0x1(%rax),%r14d
mov    %rsi,%rax
shl    $0x4,%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,1),%r13
add    $0x8,%r13
lea    0x0(,%rsi,8),%r15
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,1),%r9
add    $0x8,%r9
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
add    $0x8,%rdx
xor    %edi,%edi
mov    %rsi,-0x50(%rsp)
movabs $0x3ff0000000000000,%r10
jmp    1dee <erd__2d_pq_integrals+0xcee>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rdi
add    $0x10,%r13
add    $0x10,%r9
add    $0x10,%rdx
mov    -0x50(%rsp),%rsi
cmp    %rsi,%rdi
jae    24dc <erd__2d_pq_integrals+0x13dc>
lea    (%rdi,%rsi,1),%rax
mov    %rdi,%rbx
or     $0x1,%rbx
add    %rbx,%rsi
mov    0x98(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm7
mov    0xa0(%rsp),%r11
mov    %r10,(%r11,%rdi,8)
mov    0xa8(%rsp),%rcx
mov    %r10,(%rcx,%rdi,8)
mov    0x60(%rsp),%r8
movsd  (%r8,%rdi,8),%xmm13
mulsd  0x0(%rbp,%rdi,8),%xmm13
movsd  %xmm13,0x0(%rbp,%rax,8)
mov    0x68(%rsp),%r12
movsd  (%r12,%rdi,8),%xmm1
movsd  %xmm1,(%r11,%rax,8)
mov    0x70(%rsp),%r11
movsd  (%r11,%rdi,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
movsd  0x0(%rbp,%rbx,8),%xmm2
mov    0xa0(%rsp),%rax
mov    %r10,(%rax,%rbx,8)
mov    %r10,(%rcx,%rbx,8)
movsd  (%r8,%rbx,8),%xmm14
mulsd  0x0(%rbp,%rbx,8),%xmm14
movsd  %xmm14,0x0(%rbp,%rsi,8)
movsd  (%r12,%rbx,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  %xmm0,(%rax,%rsi,8)
movsd  (%r11,%rbx,8),%xmm4
movsd  %xmm4,(%rcx,%rsi,8)
cmpl   $0x2,-0x68(%rsp)
mov    -0x20(%rsp),%rcx
jl     1dd0 <erd__2d_pq_integrals+0xcd0>
mov    $0x2,%esi
xor    %ebp,%ebp
movsd  0x113c(%rip),%xmm9
movapd %xmm9,%xmm5
movapd %xmm9,%xmm6
movapd %xmm9,%xmm15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm3,%xmm8
movsd  %xmm3,-0x80(%rsp)
movsd  %xmm4,-0x78(%rsp)
movapd %xmm1,%xmm11
movapd %xmm0,%xmm12
movapd %xmm13,%xmm10
movapd %xmm14,%xmm0
lea    -0x1(%rsi),%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movsd  (%rcx,%rdi,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  (%r8,%rdi,8),%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm3,%xmm7
addsd  %xmm1,%xmm7
movsd  %xmm7,-0x8(%r13,%rbp,1)
movsd  (%r12,%rdi,8),%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm3,%xmm6
addsd  %xmm1,%xmm6
movsd  %xmm6,-0x8(%r9,%rbp,1)
movsd  (%r11,%rdi,8),%xmm1
mulsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,-0x8(%rdx,%rbp,1)
mulsd  (%rcx,%rbx,8),%xmm4
movsd  (%r8,%rbx,8),%xmm1
mulsd  %xmm14,%xmm1
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%rbp,1)
movsd  (%r12,%rbx,8),%xmm1
mulsd  %xmm12,%xmm1
mulsd  %xmm4,%xmm5
addsd  %xmm1,%xmm5
movsd  %xmm5,(%r9,%rbp,1)
movsd  (%r11,%rbx,8),%xmm1
movsd  -0x78(%rsp),%xmm8
mulsd  %xmm8,%xmm1
mulsd  %xmm15,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rdx,%rbp,1)
add    $0x1,%rsi
add    %r15,%rbp
movapd %xmm2,%xmm14
movapd %xmm7,%xmm13
movapd %xmm0,%xmm2
movapd %xmm10,%xmm7
movapd %xmm5,%xmm0
movapd %xmm6,%xmm1
movapd %xmm12,%xmm5
movapd %xmm11,%xmm6
movapd %xmm8,%xmm15
movsd  -0x80(%rsp),%xmm9
cmp    %rsi,%r14
jne    1ee0 <erd__2d_pq_integrals+0xde0>
jmp    1dd0 <erd__2d_pq_integrals+0xcd0>
cmpl   $0x0,-0x80(%rsp)
jle    24dc <erd__2d_pq_integrals+0x13dc>
movslq -0x10(%rsp),%rdx
mov    -0x58(%rsp),%eax
mov    %rax,0x8(%rsp)
mov    -0x68(%rsp),%rax
add    $0x3,%eax
imul   -0x80(%rsp),%eax
mov    %eax,-0x6c(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%r10,8),%rax
mov    %rax,(%rsp)
imul   %r10,%rdx
shl    $0x3,%rdx
mov    %rdx,-0x28(%rsp)
mov    0xa0(%rsp),%rax
lea    (%rax,%r10,8),%rdi
add    $0x8,%rdi
mov    0xa8(%rsp),%rax
lea    (%rax,%r10,8),%rbx
add    $0x8,%rbx
xor    %eax,%eax
mov    %rax,-0x30(%rsp)
xor    %r15d,%r15d
mov    0x20(%rsp),%r12
jmp    209a <erd__2d_pq_integrals+0xf9a>
nopl   0x0(%rax)
add    $0x2,%r15
addl   $0x2,-0x6c(%rsp)
addq   $0x10,-0x30(%rsp)
cmp    0x10(%rsp),%r15
jae    24dc <erd__2d_pq_integrals+0x13dc>
cmpl   $0x0,-0x58(%rsp)
mov    0xa8(%rsp),%r10
mov    0xa0(%rsp),%r11
jle    2080 <erd__2d_pq_integrals+0xf80>
lea    (%r9,%r15,1),%eax
mov    %eax,-0x8(%rsp)
mov    %r15,%rax
or     $0x1,%rax
mov    %rax,-0x50(%rsp)
mov    $0x1,%r8d
mov    -0x30(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x6c(%rsp),%eax
mov    %eax,-0x48(%rsp)
xor    %ecx,%ecx
jmp    2126 <erd__2d_pq_integrals+0x1026>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%r8
add    $0x1,%r8
mov    -0x40(%rsp),%rcx
add    $0x1,%rcx
mov    -0x18(%rsp),%r9
add    %r9d,-0x48(%rsp)
mov    -0x60(%rsp),%rax
add    -0x28(%rsp),%rax
mov    %rax,-0x60(%rsp)
cmp    0x8(%rsp),%rcx
je     2080 <erd__2d_pq_integrals+0xf80>
mov    %r9d,%eax
mov    %rcx,-0x40(%rsp)
imul   %ecx,%eax
add    -0x8(%rsp),%eax
lea    -0x1(%r8),%esi
imul   %r9d,%esi
mov    %r9d,%ebp
imul   %r8d,%ebp
movslq %esi,%rsi
movslq %ebp,%rbp
cltq
mov    0x98(%rsp),%r14
movupd (%r14,%rax,8),%xmm7
movsd  (%r11,%rax,8),%xmm10
movsd  0x8(%r11,%rax,8),%xmm14
movsd  (%r10,%rax,8),%xmm1
movsd  0x8(%r10,%rax,8),%xmm9
lea    (%r15,%rsi,1),%rax
mov    -0x50(%rsp),%rdx
add    %rdx,%rsi
movsd  (%r10,%rax,8),%xmm4
movupd (%r14,%rax,8),%xmm5
movsd  (%r11,%rsi,8),%xmm3
movhpd (%r11,%rax,8),%xmm3
lea    (%r15,%rbp,1),%rax
mov    0x70(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm11
mulsd  (%r10,%rax,8),%xmm11
add    %rdx,%rbp
movsd  (%r11,%rbp,8),%xmm13
movhpd (%r11,%rax,8),%xmm13
movupd (%r14,%rax,8),%xmm12
cvtsi2sd %r8d,%xmm8
movupd (%r12,%r15,8),%xmm6
unpcklpd %xmm8,%xmm8
mulpd  %xmm8,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm11,%xmm4
mov    0x60(%rsp),%rax
movupd (%rax,%r15,8),%xmm11
mov    0x68(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
movhpd (%rax,%r15,8),%xmm2
mulpd  %xmm11,%xmm12
mulpd  %xmm2,%xmm13
movapd %xmm6,%xmm2
shufpd $0x1,%xmm6,%xmm2
mulpd  %xmm2,%xmm3
movsd  (%rcx,%rdx,8),%xmm2
mulsd  (%r10,%rbp,8),%xmm2
mov    %r8,-0x38(%rsp)
mov    %r8d,%eax
mov    -0x10(%rsp),%r8
imul   %r8d,%eax
add    $0x1,%eax
imul   -0x80(%rsp),%eax
mulpd  %xmm6,%xmm5
unpckhpd %xmm6,%xmm6
mulsd  (%r10,%rsi,8),%xmm6
lea    (%rax,%r15,1),%esi
addpd  %xmm13,%xmm3
addpd  %xmm12,%xmm5
movslq %esi,%rsi
movlpd %xmm5,(%r14,%rsi,8)
movhpd %xmm3,(%r11,%rsi,8)
movsd  %xmm4,(%r10,%rsi,8)
addsd  %xmm2,%xmm6
lea    0x1(%rax,%r15,1),%eax
cltq
movhpd %xmm5,(%r14,%rax,8)
movlpd %xmm3,(%r11,%rax,8)
movsd  %xmm6,(%r10,%rax,8)
cmpl   $0x2,-0x68(%rsp)
mov    0x18(%rsp),%r14
mov    -0x20(%rsp),%rbp
mov    (%rsp),%r9
jl     20f0 <erd__2d_pq_integrals+0xff0>
shufpd $0x1,%xmm5,%xmm5
shufpd $0x1,%xmm7,%xmm7
unpcklpd %xmm10,%xmm14
mov    $0x2,%r13d
mov    -0x60(%rsp),%rdx
mov    -0x48(%rsp),%eax
mov    %eax,%esi
nopl   (%rax)
movapd %xmm3,%xmm10
mov    %r13,-0x78(%rsp)
lea    -0x1(%r13),%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movupd 0x0(%rbp,%r15,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
movapd %xmm2,%xmm3
shufpd $0x1,%xmm2,%xmm3
mulpd  %xmm3,%xmm14
mulpd  %xmm7,%xmm3
movapd %xmm5,%xmm11
movapd %xmm4,%xmm12
mulsd  %xmm2,%xmm1
unpckhpd %xmm2,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm6,%xmm9
movupd (%r12,%r15,8),%xmm7
mulpd  %xmm8,%xmm7
movapd %xmm7,%xmm6
shufpd $0x1,%xmm7,%xmm6
movsd  -0x8(%rbx,%rdx,1),%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm1,%xmm5
movsd  (%rcx,%r15,8),%xmm4
mulsd  %xmm12,%xmm4
addsd  %xmm5,%xmm4
movupd (%r9,%rdx,1),%xmm1
mov    0x60(%rsp),%rax
movupd (%rax,%r15,8),%xmm5
movsd  (%rdi,%rdx,1),%xmm0
movhpd -0x8(%rdi,%rdx,1),%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm14,%xmm0
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm3,%xmm1
shufpd $0x1,%xmm5,%xmm5
mov    0x68(%rsp),%r13
mov    -0x50(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm3
movhpd 0x0(%r13,%r15,8),%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm0,%xmm3
mulpd  %xmm11,%xmm5
addpd  %xmm1,%xmm5
unpckhpd %xmm7,%xmm7
mulsd  (%rbx,%rdx,1),%xmm7
addsd  %xmm2,%xmm7
movsd  (%rcx,%rax,8),%xmm6
mulsd  %xmm9,%xmm6
addsd  %xmm7,%xmm6
movslq %esi,%rsi
mov    0x98(%rsp),%r13
movhpd %xmm5,0x0(%r13,%rsi,8)
movhpd %xmm3,(%r11,%rsi,8)
movsd  %xmm4,(%r10,%rsi,8)
lea    0x1(%rsi),%eax
cltq
movlpd %xmm5,0x0(%r13,%rax,8)
movlpd %xmm3,(%r11,%rax,8)
movsd  %xmm6,(%r10,%rax,8)
mov    -0x78(%rsp),%rax
add    $0x1,%rax
add    -0x80(%rsp),%esi
add    %r14,%rdx
movapd %xmm12,%xmm1
movapd %xmm11,%xmm7
movapd %xmm10,%xmm14
mov    %rax,%r13
cmp    %rax,%r8
jne    22c0 <erd__2d_pq_integrals+0x11c0>
jmp    20f0 <erd__2d_pq_integrals+0xff0>
test   %edx,%edx
jle    24dc <erd__2d_pq_integrals+0x13dc>
mov    -0x80(%rsp),%eax
add    $0xffffffffffffffff,%rax
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
cmp    $0x2,%rax
mov    0xa8(%rsp),%rdi
mov    0xa0(%rsp),%rbp
jae    2459 <erd__2d_pq_integrals+0x1359>
xor    %edx,%edx
jmp    24a1 <erd__2d_pq_integrals+0x13a1>
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
movabs $0x3ff0000000000000,%rsi
nopl   0x0(%rax)
mov    %rsi,0x0(%rbp,%rdx,8)
mov    %rsi,(%rdi,%rdx,8)
mov    %rsi,0x8(%rbp,%rdx,8)
mov    %rsi,0x8(%rdi,%rdx,8)
mov    %rsi,0x10(%rbp,%rdx,8)
mov    %rsi,0x10(%rdi,%rdx,8)
mov    %rsi,0x18(%rbp,%rdx,8)
mov    %rsi,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rax
jne    2470 <erd__2d_pq_integrals+0x1370>
test   $0x1,%cl
je     24dc <erd__2d_pq_integrals+0x13dc>
lea    0x0(,%rdx,8),%rax
movabs $0x3ff0000000000000,%rcx
mov    0xa0(%rsp),%rdi
mov    %rcx,(%rdi,%rdx,8)
mov    0xa8(%rsp),%rsi
mov    %rcx,(%rsi,%rdx,8)
or     $0x8,%rax
mov    %rcx,(%rdi,%rax,1)
mov    %rcx,(%rsi,%rax,1)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @erd__2d_pq_integrals(i32 %0, i32 %1, i32 %2, double* %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, i32 %12, double* %13, double* %14, double* %15) {
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca i32
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca [2 x double]
%42 = alloca [2 x double]
%43 = alloca [2 x double]
%44 = alloca [2 x double]
%45 = alloca [2 x double]
%46 = alloca [2 x double]
%47 = alloca [2 x double]
%48 = alloca [2 x double]
%49 = alloca [2 x double]
%50 = alloca double
%51 = alloca [2 x double]
%52 = alloca [2 x double]
%53 = alloca [2 x double]
%54 = alloca [2 x double]
%55 = alloca [2 x double]
%56 = alloca [2 x double]
%57 = alloca [2 x double]
%58 = alloca [2 x double]
%59 = alloca [2 x double]
%60 = alloca double
%61 = alloca [2 x double]
%62 = alloca [2 x double]
%63 = alloca [2 x double]
%64 = alloca [2 x double]
%65 = alloca [2 x double]
%66 = alloca [2 x double]
%67 = alloca [2 x double]
%68 = alloca [2 x double]
%69 = alloca [2 x double]
%70 = alloca [2 x double]
%71 = alloca [2 x double]
%72 = alloca [2 x double]
%73 = alloca double
%74 = alloca double
%75 = alloca [2 x double]
%76 = alloca [2 x double]
%77 = alloca [2 x double]
%78 = alloca [2 x double]
%79 = alloca [2 x double]
%80 = alloca [2 x double]
%81 = alloca [2 x double]
%82 = alloca [2 x double]
%83 = alloca [2 x double]
%84 = alloca [2 x double]
%85 = alloca [2 x double]
%86 = alloca [2 x double]
%87 = alloca i32
%88 = alloca i32
%89 = alloca [2 x double]
%90 = alloca [2 x double]
%91 = alloca [2 x double]
%92 = alloca [2 x double]
%93 = alloca [2 x double]
%94 = alloca [2 x double]
%95 = alloca [2 x double]
%96 = alloca [2 x double]
%97 = alloca [2 x double]
%98 = alloca [2 x double]
%99 = alloca [2 x double]
%100 = alloca [2 x double]
%101 = alloca i32
%102 = alloca i32
store i32 %0, i32* %18
store i32 %1, i32* %19
store i32 %2, i32* %20
store double* %3, double** %21
store double* %4, double** %22
store double* %5, double** %23
store double* %6, double** %24
store double* %7, double** %25
store double* %8, double** %26
store double* %9, double** %27
store double* %10, double** %28
store double* %11, double** %29
store i32 %12, i32* %30
store double* %13, double** %31
store double* %14, double** %32
store double* %15, double** %33
%103 = load i32, i32* %30
switch i32 %103, label %113 [
i32 1, label %104
i32 2, label %105
i32 3, label %106
i32 4, label %107
i32 5, label %108
i32 6, label %109
i32 7, label %110
i32 8, label %111
i32 9, label %112
]
104: ; preds = %16
br label %114
105: ; preds = %16
br label %428
106: ; preds = %16
br label %428
107: ; preds = %16
br label %144
108: ; preds = %16
br label %712
109: ; preds = %16
br label %712
110: ; preds = %16
br label %144
111: ; preds = %16
br label %712
112: ; preds = %16
br label %712
113: ; preds = %16
br label %114
114: ; preds = %113, %104
store i32 0, i32* %36
br label %115
115: ; preds = %140, %114
%116 = load i32, i32* %36
%117 = load i32, i32* %20
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %143
119: ; preds = %115
store i32 0, i32* %37
br label %120
120: ; preds = %136, %119
%121 = load i32, i32* %37
%122 = icmp slt i32 %121, 2
br i1 %122, label %123, label %139
123: ; preds = %120
%124 = load double*, double** %32
%125 = load i32, i32* %36
%126 = load i32, i32* %37
%127 = add nsw i32 %125, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %124, i64 %128
store double 1.000000e+00, double* %129
%130 = load double*, double** %33
%131 = load i32, i32* %36
%132 = load i32, i32* %37
%133 = add nsw i32 %131, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %130, i64 %134
store double 1.000000e+00, double* %135
br label %136
136: ; preds = %123
%137 = load i32, i32* %37
%138 = add nsw i32 %137, 1
store i32 %138, i32* %37
br label %120
139: ; preds = %120
br label %140
140: ; preds = %139
%141 = load i32, i32* %36
%142 = add nsw i32 %141, 2
store i32 %142, i32* %36
br label %115
143: ; preds = %115
store i32 0, i32* %17
br label %2363
144: ; preds = %110, %107
store i32 0, i32* %36
br label %145
145: ; preds = %424, %144
%146 = load i32, i32* %36
%147 = load i32, i32* %20
%148 = icmp slt i32 %146, %147
br i1 %148, label %149, label %427
149: ; preds = %145
store i32 0, i32* %37
br label %150
150: ; preds = %244, %149
%151 = load i32, i32* %37
%152 = icmp slt i32 %151, 2
br i1 %152, label %153, label %247
153: ; preds = %150
%154 = load double*, double** %31
%155 = load i32, i32* %36
%156 = load i32, i32* %37
%157 = add nsw i32 %155, %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %154, i64 %158
%160 = load double, double* %159
%161 = load i32, i32* %37
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [2 x double], [2 x double]* %43, i64 0, i64 %162
store double %160, double* %163
%164 = load i32, i32* %37
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [2 x double], [2 x double]* %46, i64 0, i64 %165
store double 1.000000e+00, double* %166
%167 = load double*, double** %32
%168 = load i32, i32* %36
%169 = load i32, i32* %37
%170 = add nsw i32 %168, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %167, i64 %171
store double 1.000000e+00, double* %172
%173 = load i32, i32* %37
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [2 x double], [2 x double]* %49, i64 0, i64 %174
store double 1.000000e+00, double* %175
%176 = load double*, double** %33
%177 = load i32, i32* %36
%178 = load i32, i32* %37
%179 = add nsw i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %176, i64 %180
store double 1.000000e+00, double* %181
%182 = load double*, double** %27
%183 = load i32, i32* %36
%184 = load i32, i32* %37
%185 = add nsw i32 %183, %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %182, i64 %186
%188 = load double, double* %187
%189 = load double*, double** %31
%190 = load i32, i32* %36
%191 = load i32, i32* %37
%192 = add nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %189, i64 %193
%195 = load double, double* %194
%196 = fmul double %188, %195
%197 = load i32, i32* %37
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [2 x double], [2 x double]* %42, i64 0, i64 %198
store double %196, double* %199
%200 = load double*, double** %31
%201 = load i32, i32* %36
%202 = load i32, i32* %37
%203 = add nsw i32 %201, %202
%204 = load i32, i32* %20
%205 = add nsw i32 %203, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %200, i64 %206
store double %196, double* %207
%208 = load double*, double** %28
%209 = load i32, i32* %36
%210 = load i32, i32* %37
%211 = add nsw i32 %209, %210
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %208, i64 %212
%214 = load double, double* %213
%215 = load i32, i32* %37
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [2 x double], [2 x double]* %45, i64 0, i64 %216
store double %214, double* %217
%218 = load double*, double** %32
%219 = load i32, i32* %36
%220 = load i32, i32* %37
%221 = add nsw i32 %219, %220
%222 = load i32, i32* %20
%223 = add nsw i32 %221, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %218, i64 %224
store double %214, double* %225
%226 = load double*, double** %29
%227 = load i32, i32* %36
%228 = load i32, i32* %37
%229 = add nsw i32 %227, %228
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %226, i64 %230
%232 = load double, double* %231
%233 = load i32, i32* %37
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 %234
store double %232, double* %235
%236 = load double*, double** %33
%237 = load i32, i32* %36
%238 = load i32, i32* %37
%239 = add nsw i32 %237, %238
%240 = load i32, i32* %20
%241 = add nsw i32 %239, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %236, i64 %242
store double %232, double* %243
br label %244
244: ; preds = %153
%245 = load i32, i32* %37
%246 = add nsw i32 %245, 1
store i32 %246, i32* %37
br label %150
247: ; preds = %150
store i32 2, i32* %35
br label %248
248: ; preds = %420, %247
%249 = load i32, i32* %35
%250 = load i32, i32* %19
%251 = icmp sle i32 %249, %250
br i1 %251, label %252, label %423
252: ; preds = %248
%253 = load i32, i32* %35
%254 = sub nsw i32 %253, 1
%255 = sitofp i32 %254 to double
store double %255, double* %50
store i32 0, i32* %37
br label %256
256: ; preds = %416, %252
%257 = load i32, i32* %37
%258 = icmp slt i32 %257, 2
br i1 %258, label %259, label %419
259: ; preds = %256
%260 = load double, double* %50
%261 = load double*, double** %22
%262 = load i32, i32* %36
%263 = load i32, i32* %37
%264 = add nsw i32 %262, %263
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %261, i64 %265
%267 = load double, double* %266
%268 = fmul double %260, %267
store double %268, double* %39
%269 = load double, double* %39
%270 = load i32, i32* %37
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds [2 x double], [2 x double]* %43, i64 0, i64 %271
%273 = load double, double* %272
%274 = load double*, double** %27
%275 = load i32, i32* %36
%276 = load i32, i32* %37
%277 = add nsw i32 %275, %276
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %274, i64 %278
%280 = load double, double* %279
%281 = load i32, i32* %37
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [2 x double], [2 x double]* %42, i64 0, i64 %282
%284 = load double, double* %283
%285 = fmul double %280, %284
%286 = call double @llvm.fmuladd.f64(double %269, double %273, double %285)
%287 = load i32, i32* %37
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [2 x double], [2 x double]* %41, i64 0, i64 %288
store double %286, double* %289
%290 = load i32, i32* %37
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [2 x double], [2 x double]* %42, i64 0, i64 %291
%293 = load double, double* %292
%294 = load i32, i32* %37
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [2 x double], [2 x double]* %43, i64 0, i64 %295
store double %293, double* %296
%297 = load i32, i32* %37
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [2 x double], [2 x double]* %41, i64 0, i64 %298
%300 = load double, double* %299
%301 = load i32, i32* %37
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds [2 x double], [2 x double]* %42, i64 0, i64 %302
store double %300, double* %303
%304 = load i32, i32* %37
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds [2 x double], [2 x double]* %41, i64 0, i64 %305
%307 = load double, double* %306
%308 = load double*, double** %31
%309 = load i32, i32* %36
%310 = load i32, i32* %37
%311 = add nsw i32 %309, %310
%312 = load i32, i32* %35
%313 = load i32, i32* %20
%314 = mul nsw i32 %312, %313
%315 = add nsw i32 %311, %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %308, i64 %316
store double %307, double* %317
%318 = load double, double* %39
%319 = load i32, i32* %37
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [2 x double], [2 x double]* %46, i64 0, i64 %320
%322 = load double, double* %321
%323 = load double*, double** %28
%324 = load i32, i32* %36
%325 = load i32, i32* %37
%326 = add nsw i32 %324, %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %323, i64 %327
%329 = load double, double* %328
%330 = load i32, i32* %37
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [2 x double], [2 x double]* %45, i64 0, i64 %331
%333 = load double, double* %332
%334 = fmul double %329, %333
%335 = call double @llvm.fmuladd.f64(double %318, double %322, double %334)
%336 = load i32, i32* %37
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [2 x double], [2 x double]* %44, i64 0, i64 %337
store double %335, double* %338
%339 = load i32, i32* %37
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds [2 x double], [2 x double]* %45, i64 0, i64 %340
%342 = load double, double* %341
%343 = load i32, i32* %37
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [2 x double], [2 x double]* %46, i64 0, i64 %344
store double %342, double* %345
%346 = load i32, i32* %37
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [2 x double], [2 x double]* %44, i64 0, i64 %347
%349 = load double, double* %348
%350 = load i32, i32* %37
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [2 x double], [2 x double]* %45, i64 0, i64 %351
store double %349, double* %352
%353 = load i32, i32* %37
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [2 x double], [2 x double]* %44, i64 0, i64 %354
%356 = load double, double* %355
%357 = load double*, double** %32
%358 = load i32, i32* %36
%359 = load i32, i32* %37
%360 = add nsw i32 %358, %359
%361 = load i32, i32* %35
%362 = load i32, i32* %20
%363 = mul nsw i32 %361, %362
%364 = add nsw i32 %360, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %357, i64 %365
store double %356, double* %366
%367 = load double, double* %39
%368 = load i32, i32* %37
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds [2 x double], [2 x double]* %49, i64 0, i64 %369
%371 = load double, double* %370
%372 = load double*, double** %29
%373 = load i32, i32* %36
%374 = load i32, i32* %37
%375 = add nsw i32 %373, %374
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %372, i64 %376
%378 = load double, double* %377
%379 = load i32, i32* %37
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 %380
%382 = load double, double* %381
%383 = fmul double %378, %382
%384 = call double @llvm.fmuladd.f64(double %367, double %371, double %383)
%385 = load i32, i32* %37
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 %386
store double %384, double* %387
%388 = load i32, i32* %37
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 %389
%391 = load double, double* %390
%392 = load i32, i32* %37
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds [2 x double], [2 x double]* %49, i64 0, i64 %393
store double %391, double* %394
%395 = load i32, i32* %37
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 %396
%398 = load double, double* %397
%399 = load i32, i32* %37
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 %400
store double %398, double* %401
%402 = load i32, i32* %37
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 %403
%405 = load double, double* %404
%406 = load double*, double** %33
%407 = load i32, i32* %36
%408 = load i32, i32* %37
%409 = add nsw i32 %407, %408
%410 = load i32, i32* %35
%411 = load i32, i32* %20
%412 = mul nsw i32 %410, %411
%413 = add nsw i32 %409, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %406, i64 %414
store double %405, double* %415
br label %416
416: ; preds = %259
%417 = load i32, i32* %37
%418 = add nsw i32 %417, 1
store i32 %418, i32* %37
br label %256
419: ; preds = %256
br label %420
420: ; preds = %419
%421 = load i32, i32* %35
%422 = add nsw i32 %421, 1
store i32 %422, i32* %35
br label %248
423: ; preds = %248
br label %424
424: ; preds = %423
%425 = load i32, i32* %36
%426 = add nsw i32 %425, 2
store i32 %426, i32* %36
br label %145
427: ; preds = %145
store i32 0, i32* %17
br label %2363
428: ; preds = %106, %105
store i32 0, i32* %36
br label %429
429: ; preds = %708, %428
%430 = load i32, i32* %36
%431 = load i32, i32* %20
%432 = icmp slt i32 %430, %431
br i1 %432, label %433, label %711
433: ; preds = %429
store i32 0, i32* %37
br label %434
434: ; preds = %528, %433
%435 = load i32, i32* %37
%436 = icmp slt i32 %435, 2
br i1 %436, label %437, label %531
437: ; preds = %434
%438 = load double*, double** %31
%439 = load i32, i32* %36
%440 = load i32, i32* %37
%441 = add nsw i32 %439, %440
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %438, i64 %442
%444 = load double, double* %443
%445 = load i32, i32* %37
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds [2 x double], [2 x double]* %53, i64 0, i64 %446
store double %444, double* %447
%448 = load i32, i32* %37
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds [2 x double], [2 x double]* %56, i64 0, i64 %449
store double 1.000000e+00, double* %450
%451 = load double*, double** %32
%452 = load i32, i32* %36
%453 = load i32, i32* %37
%454 = add nsw i32 %452, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %451, i64 %455
store double 1.000000e+00, double* %456
%457 = load i32, i32* %37
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds [2 x double], [2 x double]* %59, i64 0, i64 %458
store double 1.000000e+00, double* %459
%460 = load double*, double** %33
%461 = load i32, i32* %36
%462 = load i32, i32* %37
%463 = add nsw i32 %461, %462
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %460, i64 %464
store double 1.000000e+00, double* %465
%466 = load double*, double** %24
%467 = load i32, i32* %36
%468 = load i32, i32* %37
%469 = add nsw i32 %467, %468
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %466, i64 %470
%472 = load double, double* %471
%473 = load double*, double** %31
%474 = load i32, i32* %36
%475 = load i32, i32* %37
%476 = add nsw i32 %474, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %473, i64 %477
%479 = load double, double* %478
%480 = fmul double %472, %479
%481 = load i32, i32* %37
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds [2 x double], [2 x double]* %52, i64 0, i64 %482
store double %480, double* %483
%484 = load double*, double** %31
%485 = load i32, i32* %36
%486 = load i32, i32* %37
%487 = add nsw i32 %485, %486
%488 = load i32, i32* %20
%489 = add nsw i32 %487, %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %484, i64 %490
store double %480, double* %491
%492 = load double*, double** %25
%493 = load i32, i32* %36
%494 = load i32, i32* %37
%495 = add nsw i32 %493, %494
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %492, i64 %496
%498 = load double, double* %497
%499 = load i32, i32* %37
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds [2 x double], [2 x double]* %55, i64 0, i64 %500
store double %498, double* %501
%502 = load double*, double** %32
%503 = load i32, i32* %36
%504 = load i32, i32* %37
%505 = add nsw i32 %503, %504
%506 = load i32, i32* %20
%507 = add nsw i32 %505, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %502, i64 %508
store double %498, double* %509
%510 = load double*, double** %26
%511 = load i32, i32* %36
%512 = load i32, i32* %37
%513 = add nsw i32 %511, %512
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %510, i64 %514
%516 = load double, double* %515
%517 = load i32, i32* %37
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds [2 x double], [2 x double]* %58, i64 0, i64 %518
store double %516, double* %519
%520 = load double*, double** %33
%521 = load i32, i32* %36
%522 = load i32, i32* %37
%523 = add nsw i32 %521, %522
%524 = load i32, i32* %20
%525 = add nsw i32 %523, %524
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double, double* %520, i64 %526
store double %516, double* %527
br label %528
528: ; preds = %437
%529 = load i32, i32* %37
%530 = add nsw i32 %529, 1
store i32 %530, i32* %37
br label %434
531: ; preds = %434
store i32 2, i32* %34
br label %532
532: ; preds = %704, %531
%533 = load i32, i32* %34
%534 = load i32, i32* %18
%535 = icmp sle i32 %533, %534
br i1 %535, label %536, label %707
536: ; preds = %532
%537 = load i32, i32* %34
%538 = sub nsw i32 %537, 1
%539 = sitofp i32 %538 to double
store double %539, double* %60
store i32 0, i32* %37
br label %540
540: ; preds = %700, %536
%541 = load i32, i32* %37
%542 = icmp slt i32 %541, 2
br i1 %542, label %543, label %703
543: ; preds = %540
%544 = load double, double* %60
%545 = load double*, double** %23
%546 = load i32, i32* %36
%547 = load i32, i32* %37
%548 = add nsw i32 %546, %547
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double, double* %545, i64 %549
%551 = load double, double* %550
%552 = fmul double %544, %551
store double %552, double* %39
%553 = load double, double* %39
%554 = load i32, i32* %37
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds [2 x double], [2 x double]* %53, i64 0, i64 %555
%557 = load double, double* %556
%558 = load double*, double** %24
%559 = load i32, i32* %36
%560 = load i32, i32* %37
%561 = add nsw i32 %559, %560
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds double, double* %558, i64 %562
%564 = load double, double* %563
%565 = load i32, i32* %37
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds [2 x double], [2 x double]* %52, i64 0, i64 %566
%568 = load double, double* %567
%569 = fmul double %564, %568
%570 = call double @llvm.fmuladd.f64(double %553, double %557, double %569)
%571 = load i32, i32* %37
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds [2 x double], [2 x double]* %51, i64 0, i64 %572
store double %570, double* %573
%574 = load i32, i32* %37
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [2 x double], [2 x double]* %52, i64 0, i64 %575
%577 = load double, double* %576
%578 = load i32, i32* %37
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds [2 x double], [2 x double]* %53, i64 0, i64 %579
store double %577, double* %580
%581 = load i32, i32* %37
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [2 x double], [2 x double]* %51, i64 0, i64 %582
%584 = load double, double* %583
%585 = load i32, i32* %37
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [2 x double], [2 x double]* %52, i64 0, i64 %586
store double %584, double* %587
%588 = load i32, i32* %37
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds [2 x double], [2 x double]* %51, i64 0, i64 %589
%591 = load double, double* %590
%592 = load double*, double** %31
%593 = load i32, i32* %36
%594 = load i32, i32* %37
%595 = add nsw i32 %593, %594
%596 = load i32, i32* %34
%597 = load i32, i32* %20
%598 = mul nsw i32 %596, %597
%599 = add nsw i32 %595, %598
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %592, i64 %600
store double %591, double* %601
%602 = load double, double* %39
%603 = load i32, i32* %37
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds [2 x double], [2 x double]* %56, i64 0, i64 %604
%606 = load double, double* %605
%607 = load double*, double** %25
%608 = load i32, i32* %36
%609 = load i32, i32* %37
%610 = add nsw i32 %608, %609
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %607, i64 %611
%613 = load double, double* %612
%614 = load i32, i32* %37
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds [2 x double], [2 x double]* %55, i64 0, i64 %615
%617 = load double, double* %616
%618 = fmul double %613, %617
%619 = call double @llvm.fmuladd.f64(double %602, double %606, double %618)
%620 = load i32, i32* %37
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds [2 x double], [2 x double]* %54, i64 0, i64 %621
store double %619, double* %622
%623 = load i32, i32* %37
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds [2 x double], [2 x double]* %55, i64 0, i64 %624
%626 = load double, double* %625
%627 = load i32, i32* %37
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds [2 x double], [2 x double]* %56, i64 0, i64 %628
store double %626, double* %629
%630 = load i32, i32* %37
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds [2 x double], [2 x double]* %54, i64 0, i64 %631
%633 = load double, double* %632
%634 = load i32, i32* %37
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds [2 x double], [2 x double]* %55, i64 0, i64 %635
store double %633, double* %636
%637 = load i32, i32* %37
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds [2 x double], [2 x double]* %54, i64 0, i64 %638
%640 = load double, double* %639
%641 = load double*, double** %32
%642 = load i32, i32* %36
%643 = load i32, i32* %37
%644 = add nsw i32 %642, %643
%645 = load i32, i32* %34
%646 = load i32, i32* %20
%647 = mul nsw i32 %645, %646
%648 = add nsw i32 %644, %647
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds double, double* %641, i64 %649
store double %640, double* %650
%651 = load double, double* %39
%652 = load i32, i32* %37
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds [2 x double], [2 x double]* %59, i64 0, i64 %653
%655 = load double, double* %654
%656 = load double*, double** %26
%657 = load i32, i32* %36
%658 = load i32, i32* %37
%659 = add nsw i32 %657, %658
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %656, i64 %660
%662 = load double, double* %661
%663 = load i32, i32* %37
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds [2 x double], [2 x double]* %58, i64 0, i64 %664
%666 = load double, double* %665
%667 = fmul double %662, %666
%668 = call double @llvm.fmuladd.f64(double %651, double %655, double %667)
%669 = load i32, i32* %37
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds [2 x double], [2 x double]* %57, i64 0, i64 %670
store double %668, double* %671
%672 = load i32, i32* %37
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds [2 x double], [2 x double]* %58, i64 0, i64 %673
%675 = load double, double* %674
%676 = load i32, i32* %37
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds [2 x double], [2 x double]* %59, i64 0, i64 %677
store double %675, double* %678
%679 = load i32, i32* %37
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds [2 x double], [2 x double]* %57, i64 0, i64 %680
%682 = load double, double* %681
%683 = load i32, i32* %37
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds [2 x double], [2 x double]* %58, i64 0, i64 %684
store double %682, double* %685
%686 = load i32, i32* %37
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds [2 x double], [2 x double]* %57, i64 0, i64 %687
%689 = load double, double* %688
%690 = load double*, double** %33
%691 = load i32, i32* %36
%692 = load i32, i32* %37
%693 = add nsw i32 %691, %692
%694 = load i32, i32* %34
%695 = load i32, i32* %20
%696 = mul nsw i32 %694, %695
%697 = add nsw i32 %693, %696
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds double, double* %690, i64 %698
store double %689, double* %699
br label %700
700: ; preds = %543
%701 = load i32, i32* %37
%702 = add nsw i32 %701, 1
store i32 %702, i32* %37
br label %540
703: ; preds = %540
br label %704
704: ; preds = %703
%705 = load i32, i32* %34
%706 = add nsw i32 %705, 1
store i32 %706, i32* %34
br label %532
707: ; preds = %532
br label %708
708: ; preds = %707
%709 = load i32, i32* %36
%710 = add nsw i32 %709, 2
store i32 %710, i32* %36
br label %429
711: ; preds = %429
store i32 0, i32* %17
br label %2363
712: ; preds = %112, %111, %109, %108
store i32 0, i32* %36
br label %713
713: ; preds = %1267, %712
%714 = load i32, i32* %36
%715 = load i32, i32* %20
%716 = icmp slt i32 %714, %715
br i1 %716, label %717, label %1270
717: ; preds = %713
store i32 0, i32* %37
br label %718
718: ; preds = %812, %717
%719 = load i32, i32* %37
%720 = icmp slt i32 %719, 2
br i1 %720, label %721, label %815
721: ; preds = %718
%722 = load double*, double** %31
%723 = load i32, i32* %36
%724 = load i32, i32* %37
%725 = add nsw i32 %723, %724
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %722, i64 %726
%728 = load double, double* %727
%729 = load i32, i32* %37
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %730
store double %728, double* %731
%732 = load i32, i32* %37
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %733
store double 1.000000e+00, double* %734
%735 = load double*, double** %32
%736 = load i32, i32* %36
%737 = load i32, i32* %37
%738 = add nsw i32 %736, %737
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds double, double* %735, i64 %739
store double 1.000000e+00, double* %740
%741 = load i32, i32* %37
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %742
store double 1.000000e+00, double* %743
%744 = load double*, double** %33
%745 = load i32, i32* %36
%746 = load i32, i32* %37
%747 = add nsw i32 %745, %746
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double, double* %744, i64 %748
store double 1.000000e+00, double* %749
%750 = load double*, double** %24
%751 = load i32, i32* %36
%752 = load i32, i32* %37
%753 = add nsw i32 %751, %752
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double, double* %750, i64 %754
%756 = load double, double* %755
%757 = load double*, double** %31
%758 = load i32, i32* %36
%759 = load i32, i32* %37
%760 = add nsw i32 %758, %759
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double, double* %757, i64 %761
%763 = load double, double* %762
%764 = fmul double %756, %763
%765 = load i32, i32* %37
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds [2 x double], [2 x double]* %62, i64 0, i64 %766
store double %764, double* %767
%768 = load double*, double** %31
%769 = load i32, i32* %36
%770 = load i32, i32* %37
%771 = add nsw i32 %769, %770
%772 = load i32, i32* %20
%773 = add nsw i32 %771, %772
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds double, double* %768, i64 %774
store double %764, double* %775
%776 = load double*, double** %25
%777 = load i32, i32* %36
%778 = load i32, i32* %37
%779 = add nsw i32 %777, %778
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds double, double* %776, i64 %780
%782 = load double, double* %781
%783 = load i32, i32* %37
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds [2 x double], [2 x double]* %66, i64 0, i64 %784
store double %782, double* %785
%786 = load double*, double** %32
%787 = load i32, i32* %36
%788 = load i32, i32* %37
%789 = add nsw i32 %787, %788
%790 = load i32, i32* %20
%791 = add nsw i32 %789, %790
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds double, double* %786, i64 %792
store double %782, double* %793
%794 = load double*, double** %26
%795 = load i32, i32* %36
%796 = load i32, i32* %37
%797 = add nsw i32 %795, %796
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %794, i64 %798
%800 = load double, double* %799
%801 = load i32, i32* %37
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds [2 x double], [2 x double]* %70, i64 0, i64 %802
store double %800, double* %803
%804 = load double*, double** %33
%805 = load i32, i32* %36
%806 = load i32, i32* %37
%807 = add nsw i32 %805, %806
%808 = load i32, i32* %20
%809 = add nsw i32 %807, %808
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds double, double* %804, i64 %810
store double %800, double* %811
br label %812
812: ; preds = %721
%813 = load i32, i32* %37
%814 = add nsw i32 %813, 1
store i32 %814, i32* %37
br label %718
815: ; preds = %718
store i32 2, i32* %34
br label %816
816: ; preds = %988, %815
%817 = load i32, i32* %34
%818 = load i32, i32* %18
%819 = icmp sle i32 %817, %818
br i1 %819, label %820, label %991
820: ; preds = %816
%821 = load i32, i32* %34
%822 = sub nsw i32 %821, 1
%823 = sitofp i32 %822 to double
store double %823, double* %73
store i32 0, i32* %37
br label %824
824: ; preds = %984, %820
%825 = load i32, i32* %37
%826 = icmp slt i32 %825, 2
br i1 %826, label %827, label %987
827: ; preds = %824
%828 = load double, double* %73
%829 = load double*, double** %23
%830 = load i32, i32* %36
%831 = load i32, i32* %37
%832 = add nsw i32 %830, %831
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %829, i64 %833
%835 = load double, double* %834
%836 = fmul double %828, %835
store double %836, double* %39
%837 = load double, double* %39
%838 = load i32, i32* %37
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %839
%841 = load double, double* %840
%842 = load double*, double** %24
%843 = load i32, i32* %36
%844 = load i32, i32* %37
%845 = add nsw i32 %843, %844
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %842, i64 %846
%848 = load double, double* %847
%849 = load i32, i32* %37
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds [2 x double], [2 x double]* %62, i64 0, i64 %850
%852 = load double, double* %851
%853 = fmul double %848, %852
%854 = call double @llvm.fmuladd.f64(double %837, double %841, double %853)
%855 = load i32, i32* %37
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %856
store double %854, double* %857
%858 = load i32, i32* %37
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds [2 x double], [2 x double]* %62, i64 0, i64 %859
%861 = load double, double* %860
%862 = load i32, i32* %37
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %863
store double %861, double* %864
%865 = load i32, i32* %37
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %866
%868 = load double, double* %867
%869 = load i32, i32* %37
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [2 x double], [2 x double]* %62, i64 0, i64 %870
store double %868, double* %871
%872 = load i32, i32* %37
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %873
%875 = load double, double* %874
%876 = load double*, double** %31
%877 = load i32, i32* %36
%878 = load i32, i32* %37
%879 = add nsw i32 %877, %878
%880 = load i32, i32* %34
%881 = load i32, i32* %20
%882 = mul nsw i32 %880, %881
%883 = add nsw i32 %879, %882
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds double, double* %876, i64 %884
store double %875, double* %885
%886 = load double, double* %39
%887 = load i32, i32* %37
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %888
%890 = load double, double* %889
%891 = load double*, double** %25
%892 = load i32, i32* %36
%893 = load i32, i32* %37
%894 = add nsw i32 %892, %893
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds double, double* %891, i64 %895
%897 = load double, double* %896
%898 = load i32, i32* %37
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds [2 x double], [2 x double]* %66, i64 0, i64 %899
%901 = load double, double* %900
%902 = fmul double %897, %901
%903 = call double @llvm.fmuladd.f64(double %886, double %890, double %902)
%904 = load i32, i32* %37
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %905
store double %903, double* %906
%907 = load i32, i32* %37
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds [2 x double], [2 x double]* %66, i64 0, i64 %908
%910 = load double, double* %909
%911 = load i32, i32* %37
%912 = sext i32 %911 to i64
%913 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %912
store double %910, double* %913
%914 = load i32, i32* %37
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %915
%917 = load double, double* %916
%918 = load i32, i32* %37
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds [2 x double], [2 x double]* %66, i64 0, i64 %919
store double %917, double* %920
%921 = load i32, i32* %37
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %922
%924 = load double, double* %923
%925 = load double*, double** %32
%926 = load i32, i32* %36
%927 = load i32, i32* %37
%928 = add nsw i32 %926, %927
%929 = load i32, i32* %34
%930 = load i32, i32* %20
%931 = mul nsw i32 %929, %930
%932 = add nsw i32 %928, %931
%933 = sext i32 %932 to i64
%934 = getelementptr inbounds double, double* %925, i64 %933
store double %924, double* %934
%935 = load double, double* %39
%936 = load i32, i32* %37
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %937
%939 = load double, double* %938
%940 = load double*, double** %26
%941 = load i32, i32* %36
%942 = load i32, i32* %37
%943 = add nsw i32 %941, %942
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %940, i64 %944
%946 = load double, double* %945
%947 = load i32, i32* %37
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds [2 x double], [2 x double]* %70, i64 0, i64 %948
%950 = load double, double* %949
%951 = fmul double %946, %950
%952 = call double @llvm.fmuladd.f64(double %935, double %939, double %951)
%953 = load i32, i32* %37
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %954
store double %952, double* %955
%956 = load i32, i32* %37
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds [2 x double], [2 x double]* %70, i64 0, i64 %957
%959 = load double, double* %958
%960 = load i32, i32* %37
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %961
store double %959, double* %962
%963 = load i32, i32* %37
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %964
%966 = load double, double* %965
%967 = load i32, i32* %37
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds [2 x double], [2 x double]* %70, i64 0, i64 %968
store double %966, double* %969
%970 = load i32, i32* %37
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %971
%973 = load double, double* %972
%974 = load double*, double** %33
%975 = load i32, i32* %36
%976 = load i32, i32* %37
%977 = add nsw i32 %975, %976
%978 = load i32, i32* %34
%979 = load i32, i32* %20
%980 = mul nsw i32 %978, %979
%981 = add nsw i32 %977, %980
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds double, double* %974, i64 %982
store double %973, double* %983
br label %984
984: ; preds = %827
%985 = load i32, i32* %37
%986 = add nsw i32 %985, 1
store i32 %986, i32* %37
br label %824
987: ; preds = %824
br label %988
988: ; preds = %987
%989 = load i32, i32* %34
%990 = add nsw i32 %989, 1
store i32 %990, i32* %34
br label %816
991: ; preds = %816
store i32 0, i32* %37
br label %992
992: ; preds = %1078, %991
%993 = load i32, i32* %37
%994 = icmp slt i32 %993, 2
br i1 %994, label %995, label %1081
995: ; preds = %992
%996 = load double*, double** %31
%997 = load i32, i32* %36
%998 = load i32, i32* %37
%999 = add nsw i32 %997, %998
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds double, double* %996, i64 %1000
%1002 = load double, double* %1001
store double %1002, double* %40
%1003 = load double, double* %40
%1004 = load i32, i32* %37
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %1005
store double %1003, double* %1006
%1007 = load i32, i32* %37
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %1008
store double 1.000000e+00, double* %1009
%1010 = load i32, i32* %37
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %1011
store double 1.000000e+00, double* %1012
%1013 = load double*, double** %27
%1014 = load i32, i32* %36
%1015 = load i32, i32* %37
%1016 = add nsw i32 %1014, %1015
%1017 = sext i32 %1016 to i64
%1018 = getelementptr inbounds double, double* %1013, i64 %1017
%1019 = load double, double* %1018
%1020 = load double, double* %40
%1021 = fmul double %1019, %1020
%1022 = load i32, i32* %37
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds [2 x double], [2 x double]* %63, i64 0, i64 %1023
store double %1021, double* %1024
%1025 = load double*, double** %31
%1026 = load i32, i32* %36
%1027 = load i32, i32* %37
%1028 = add nsw i32 %1026, %1027
%1029 = load i32, i32* %18
%1030 = add nsw i32 %1029, 1
%1031 = load i32, i32* %20
%1032 = mul nsw i32 %1030, %1031
%1033 = add nsw i32 %1028, %1032
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds double, double* %1025, i64 %1034
store double %1021, double* %1035
%1036 = load double*, double** %28
%1037 = load i32, i32* %36
%1038 = load i32, i32* %37
%1039 = add nsw i32 %1037, %1038
%1040 = sext i32 %1039 to i64
%1041 = getelementptr inbounds double, double* %1036, i64 %1040
%1042 = load double, double* %1041
%1043 = load i32, i32* %37
%1044 = sext i32 %1043 to i64
%1045 = getelementptr inbounds [2 x double], [2 x double]* %67, i64 0, i64 %1044
store double %1042, double* %1045
%1046 = load double*, double** %32
%1047 = load i32, i32* %36
%1048 = load i32, i32* %37
%1049 = add nsw i32 %1047, %1048
%1050 = load i32, i32* %18
%1051 = add nsw i32 %1050, 1
%1052 = load i32, i32* %20
%1053 = mul nsw i32 %1051, %1052
%1054 = add nsw i32 %1049, %1053
%1055 = sext i32 %1054 to i64
%1056 = getelementptr inbounds double, double* %1046, i64 %1055
store double %1042, double* %1056
%1057 = load double*, double** %29
%1058 = load i32, i32* %36
%1059 = load i32, i32* %37
%1060 = add nsw i32 %1058, %1059
%1061 = sext i32 %1060 to i64
%1062 = getelementptr inbounds double, double* %1057, i64 %1061
%1063 = load double, double* %1062
%1064 = load i32, i32* %37
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds [2 x double], [2 x double]* %71, i64 0, i64 %1065
store double %1063, double* %1066
%1067 = load double*, double** %33
%1068 = load i32, i32* %36
%1069 = load i32, i32* %37
%1070 = add nsw i32 %1068, %1069
%1071 = load i32, i32* %18
%1072 = add nsw i32 %1071, 1
%1073 = load i32, i32* %20
%1074 = mul nsw i32 %1072, %1073
%1075 = add nsw i32 %1070, %1074
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1067, i64 %1076
store double %1063, double* %1077
br label %1078
1078: ; preds = %995
%1079 = load i32, i32* %37
%1080 = add nsw i32 %1079, 1
store i32 %1080, i32* %37
br label %992
1081: ; preds = %992
store i32 2, i32* %35
br label %1082
1082: ; preds = %1263, %1081
%1083 = load i32, i32* %35
%1084 = load i32, i32* %19
%1085 = icmp sle i32 %1083, %1084
br i1 %1085, label %1086, label %1266
1086: ; preds = %1082
%1087 = load i32, i32* %35
%1088 = sub nsw i32 %1087, 1
%1089 = sitofp i32 %1088 to double
store double %1089, double* %74
store i32 0, i32* %37
br label %1090
1090: ; preds = %1259, %1086
%1091 = load i32, i32* %37
%1092 = icmp slt i32 %1091, 2
br i1 %1092, label %1093, label %1262
1093: ; preds = %1090
%1094 = load double, double* %74
%1095 = load double*, double** %22
%1096 = load i32, i32* %36
%1097 = load i32, i32* %37
%1098 = add nsw i32 %1096, %1097
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds double, double* %1095, i64 %1099
%1101 = load double, double* %1100
%1102 = fmul double %1094, %1101
store double %1102, double* %39
%1103 = load double, double* %39
%1104 = load i32, i32* %37
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %1105
%1107 = load double, double* %1106
%1108 = load double*, double** %27
%1109 = load i32, i32* %36
%1110 = load i32, i32* %37
%1111 = add nsw i32 %1109, %1110
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds double, double* %1108, i64 %1112
%1114 = load double, double* %1113
%1115 = load i32, i32* %37
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds [2 x double], [2 x double]* %63, i64 0, i64 %1116
%1118 = load double, double* %1117
%1119 = fmul double %1114, %1118
%1120 = call double @llvm.fmuladd.f64(double %1103, double %1107, double %1119)
%1121 = load i32, i32* %37
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %1122
store double %1120, double* %1123
%1124 = load i32, i32* %37
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds [2 x double], [2 x double]* %63, i64 0, i64 %1125
%1127 = load double, double* %1126
%1128 = load i32, i32* %37
%1129 = sext i32 %1128 to i64
%1130 = getelementptr inbounds [2 x double], [2 x double]* %64, i64 0, i64 %1129
store double %1127, double* %1130
%1131 = load i32, i32* %37
%1132 = sext i32 %1131 to i64
%1133 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %1132
%1134 = load double, double* %1133
%1135 = load i32, i32* %37
%1136 = sext i32 %1135 to i64
%1137 = getelementptr inbounds [2 x double], [2 x double]* %63, i64 0, i64 %1136
store double %1134, double* %1137
%1138 = load i32, i32* %37
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds [2 x double], [2 x double]* %61, i64 0, i64 %1139
%1141 = load double, double* %1140
%1142 = load double*, double** %31
%1143 = load i32, i32* %36
%1144 = load i32, i32* %37
%1145 = add nsw i32 %1143, %1144
%1146 = load i32, i32* %35
%1147 = load i32, i32* %18
%1148 = add nsw i32 %1147, 1
%1149 = mul nsw i32 %1146, %1148
%1150 = load i32, i32* %20
%1151 = mul nsw i32 %1149, %1150
%1152 = add nsw i32 %1145, %1151
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds double, double* %1142, i64 %1153
store double %1141, double* %1154
%1155 = load double, double* %39
%1156 = load i32, i32* %37
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %1157
%1159 = load double, double* %1158
%1160 = load double*, double** %28
%1161 = load i32, i32* %36
%1162 = load i32, i32* %37
%1163 = add nsw i32 %1161, %1162
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds double, double* %1160, i64 %1164
%1166 = load double, double* %1165
%1167 = load i32, i32* %37
%1168 = sext i32 %1167 to i64
%1169 = getelementptr inbounds [2 x double], [2 x double]* %67, i64 0, i64 %1168
%1170 = load double, double* %1169
%1171 = fmul double %1166, %1170
%1172 = call double @llvm.fmuladd.f64(double %1155, double %1159, double %1171)
%1173 = load i32, i32* %37
%1174 = sext i32 %1173 to i64
%1175 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %1174
store double %1172, double* %1175
%1176 = load i32, i32* %37
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds [2 x double], [2 x double]* %67, i64 0, i64 %1177
%1179 = load double, double* %1178
%1180 = load i32, i32* %37
%1181 = sext i32 %1180 to i64
%1182 = getelementptr inbounds [2 x double], [2 x double]* %68, i64 0, i64 %1181
store double %1179, double* %1182
%1183 = load i32, i32* %37
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %1184
%1186 = load double, double* %1185
%1187 = load i32, i32* %37
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds [2 x double], [2 x double]* %67, i64 0, i64 %1188
store double %1186, double* %1189
%1190 = load i32, i32* %37
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds [2 x double], [2 x double]* %65, i64 0, i64 %1191
%1193 = load double, double* %1192
%1194 = load double*, double** %32
%1195 = load i32, i32* %36
%1196 = load i32, i32* %37
%1197 = add nsw i32 %1195, %1196
%1198 = load i32, i32* %35
%1199 = load i32, i32* %18
%1200 = add nsw i32 %1199, 1
%1201 = mul nsw i32 %1198, %1200
%1202 = load i32, i32* %20
%1203 = mul nsw i32 %1201, %1202
%1204 = add nsw i32 %1197, %1203
%1205 = sext i32 %1204 to i64
%1206 = getelementptr inbounds double, double* %1194, i64 %1205
store double %1193, double* %1206
%1207 = load double, double* %39
%1208 = load i32, i32* %37
%1209 = sext i32 %1208 to i64
%1210 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %1209
%1211 = load double, double* %1210
%1212 = load double*, double** %29
%1213 = load i32, i32* %36
%1214 = load i32, i32* %37
%1215 = add nsw i32 %1213, %1214
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds double, double* %1212, i64 %1216
%1218 = load double, double* %1217
%1219 = load i32, i32* %37
%1220 = sext i32 %1219 to i64
%1221 = getelementptr inbounds [2 x double], [2 x double]* %71, i64 0, i64 %1220
%1222 = load double, double* %1221
%1223 = fmul double %1218, %1222
%1224 = call double @llvm.fmuladd.f64(double %1207, double %1211, double %1223)
%1225 = load i32, i32* %37
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %1226
store double %1224, double* %1227
%1228 = load i32, i32* %37
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds [2 x double], [2 x double]* %71, i64 0, i64 %1229
%1231 = load double, double* %1230
%1232 = load i32, i32* %37
%1233 = sext i32 %1232 to i64
%1234 = getelementptr inbounds [2 x double], [2 x double]* %72, i64 0, i64 %1233
store double %1231, double* %1234
%1235 = load i32, i32* %37
%1236 = sext i32 %1235 to i64
%1237 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %1236
%1238 = load double, double* %1237
%1239 = load i32, i32* %37
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds [2 x double], [2 x double]* %71, i64 0, i64 %1240
store double %1238, double* %1241
%1242 = load i32, i32* %37
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds [2 x double], [2 x double]* %69, i64 0, i64 %1243
%1245 = load double, double* %1244
%1246 = load double*, double** %33
%1247 = load i32, i32* %36
%1248 = load i32, i32* %37
%1249 = add nsw i32 %1247, %1248
%1250 = load i32, i32* %35
%1251 = load i32, i32* %18
%1252 = add nsw i32 %1251, 1
%1253 = mul nsw i32 %1250, %1252
%1254 = load i32, i32* %20
%1255 = mul nsw i32 %1253, %1254
%1256 = add nsw i32 %1249, %1255
%1257 = sext i32 %1256 to i64
%1258 = getelementptr inbounds double, double* %1246, i64 %1257
store double %1245, double* %1258
br label %1259
1259: ; preds = %1093
%1260 = load i32, i32* %37
%1261 = add nsw i32 %1260, 1
store i32 %1261, i32* %37
br label %1090
1262: ; preds = %1090
br label %1263
1263: ; preds = %1262
%1264 = load i32, i32* %35
%1265 = add nsw i32 %1264, 1
store i32 %1265, i32* %35
br label %1082
1266: ; preds = %1082
br label %1267
1267: ; preds = %1266
%1268 = load i32, i32* %36
%1269 = add nsw i32 %1268, 2
store i32 %1269, i32* %36
br label %713
1270: ; preds = %713
%1271 = load i32, i32* %19
%1272 = load i32, i32* %18
%1273 = icmp sle i32 %1271, %1272
br i1 %1273, label %1274, label %1833
1274: ; preds = %1270
store i32 0, i32* %36
br label %1275
1275: ; preds = %1829, %1274
%1276 = load i32, i32* %36
%1277 = load i32, i32* %20
%1278 = icmp slt i32 %1276, %1277
br i1 %1278, label %1279, label %1832
1279: ; preds = %1275
store i32 1, i32* %35
br label %1280
1280: ; preds = %1825, %1279
%1281 = load i32, i32* %35
%1282 = load i32, i32* %19
%1283 = icmp sle i32 %1281, %1282
br i1 %1283, label %1284, label %1828
1284: ; preds = %1280
%1285 = load i32, i32* %35
%1286 = sub nsw i32 %1285, 1
store i32 %1286, i32* %87
store i32 0, i32* %37
br label %1287
1287: ; preds = %1475, %1284
%1288 = load i32, i32* %37
%1289 = icmp slt i32 %1288, 2
br i1 %1289, label %1290, label %1478
1290: ; preds = %1287
%1291 = load i32, i32* %35
%1292 = sitofp i32 %1291 to double
%1293 = load double*, double** %21
%1294 = load i32, i32* %36
%1295 = load i32, i32* %37
%1296 = add nsw i32 %1294, %1295
%1297 = sext i32 %1296 to i64
%1298 = getelementptr inbounds double, double* %1293, i64 %1297
%1299 = load double, double* %1298
%1300 = fmul double %1292, %1299
store double %1300, double* %38
%1301 = load double, double* %38
%1302 = load double*, double** %31
%1303 = load i32, i32* %36
%1304 = load i32, i32* %37
%1305 = add nsw i32 %1303, %1304
%1306 = load i32, i32* %87
%1307 = load i32, i32* %18
%1308 = add nsw i32 %1307, 1
%1309 = mul nsw i32 %1306, %1308
%1310 = load i32, i32* %20
%1311 = mul nsw i32 %1309, %1310
%1312 = add nsw i32 %1305, %1311
%1313 = sext i32 %1312 to i64
%1314 = getelementptr inbounds double, double* %1302, i64 %1313
%1315 = load double, double* %1314
%1316 = load double*, double** %24
%1317 = load i32, i32* %36
%1318 = load i32, i32* %37
%1319 = add nsw i32 %1317, %1318
%1320 = sext i32 %1319 to i64
%1321 = getelementptr inbounds double, double* %1316, i64 %1320
%1322 = load double, double* %1321
%1323 = load double*, double** %31
%1324 = load i32, i32* %36
%1325 = load i32, i32* %37
%1326 = add nsw i32 %1324, %1325
%1327 = load i32, i32* %35
%1328 = load i32, i32* %18
%1329 = add nsw i32 %1328, 1
%1330 = mul nsw i32 %1327, %1329
%1331 = load i32, i32* %20
%1332 = mul nsw i32 %1330, %1331
%1333 = add nsw i32 %1326, %1332
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds double, double* %1323, i64 %1334
%1336 = load double, double* %1335
%1337 = fmul double %1322, %1336
%1338 = call double @llvm.fmuladd.f64(double %1301, double %1315, double %1337)
%1339 = load i32, i32* %37
%1340 = sext i32 %1339 to i64
%1341 = getelementptr inbounds [2 x double], [2 x double]* %76, i64 0, i64 %1340
store double %1338, double* %1341
%1342 = load double, double* %38
%1343 = load double*, double** %32
%1344 = load i32, i32* %36
%1345 = load i32, i32* %37
%1346 = add nsw i32 %1344, %1345
%1347 = load i32, i32* %87
%1348 = load i32, i32* %18
%1349 = add nsw i32 %1348, 1
%1350 = mul nsw i32 %1347, %1349
%1351 = load i32, i32* %20
%1352 = mul nsw i32 %1350, %1351
%1353 = add nsw i32 %1346, %1352
%1354 = sext i32 %1353 to i64
%1355 = getelementptr inbounds double, double* %1343, i64 %1354
%1356 = load double, double* %1355
%1357 = load double*, double** %25
%1358 = load i32, i32* %36
%1359 = load i32, i32* %37
%1360 = add nsw i32 %1358, %1359
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds double, double* %1357, i64 %1361
%1363 = load double, double* %1362
%1364 = load double*, double** %32
%1365 = load i32, i32* %36
%1366 = load i32, i32* %37
%1367 = add nsw i32 %1365, %1366
%1368 = load i32, i32* %35
%1369 = load i32, i32* %18
%1370 = add nsw i32 %1369, 1
%1371 = mul nsw i32 %1368, %1370
%1372 = load i32, i32* %20
%1373 = mul nsw i32 %1371, %1372
%1374 = add nsw i32 %1367, %1373
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds double, double* %1364, i64 %1375
%1377 = load double, double* %1376
%1378 = fmul double %1363, %1377
%1379 = call double @llvm.fmuladd.f64(double %1342, double %1356, double %1378)
%1380 = load i32, i32* %37
%1381 = sext i32 %1380 to i64
%1382 = getelementptr inbounds [2 x double], [2 x double]* %80, i64 0, i64 %1381
store double %1379, double* %1382
%1383 = load double, double* %38
%1384 = load double*, double** %33
%1385 = load i32, i32* %36
%1386 = load i32, i32* %37
%1387 = add nsw i32 %1385, %1386
%1388 = load i32, i32* %87
%1389 = load i32, i32* %18
%1390 = add nsw i32 %1389, 1
%1391 = mul nsw i32 %1388, %1390
%1392 = load i32, i32* %20
%1393 = mul nsw i32 %1391, %1392
%1394 = add nsw i32 %1387, %1393
%1395 = sext i32 %1394 to i64
%1396 = getelementptr inbounds double, double* %1384, i64 %1395
%1397 = load double, double* %1396
%1398 = load double*, double** %26
%1399 = load i32, i32* %36
%1400 = load i32, i32* %37
%1401 = add nsw i32 %1399, %1400
%1402 = sext i32 %1401 to i64
%1403 = getelementptr inbounds double, double* %1398, i64 %1402
%1404 = load double, double* %1403
%1405 = load double*, double** %33
%1406 = load i32, i32* %36
%1407 = load i32, i32* %37
%1408 = add nsw i32 %1406, %1407
%1409 = load i32, i32* %35
%1410 = load i32, i32* %18
%1411 = add nsw i32 %1410, 1
%1412 = mul nsw i32 %1409, %1411
%1413 = load i32, i32* %20
%1414 = mul nsw i32 %1412, %1413
%1415 = add nsw i32 %1408, %1414
%1416 = sext i32 %1415 to i64
%1417 = getelementptr inbounds double, double* %1405, i64 %1416
%1418 = load double, double* %1417
%1419 = fmul double %1404, %1418
%1420 = call double @llvm.fmuladd.f64(double %1383, double %1397, double %1419)
%1421 = load i32, i32* %37
%1422 = sext i32 %1421 to i64
%1423 = getelementptr inbounds [2 x double], [2 x double]* %84, i64 0, i64 %1422
store double %1420, double* %1423
%1424 = load double*, double** %31
%1425 = load i32, i32* %36
%1426 = load i32, i32* %37
%1427 = add nsw i32 %1425, %1426
%1428 = load i32, i32* %35
%1429 = load i32, i32* %18
%1430 = add nsw i32 %1429, 1
%1431 = mul nsw i32 %1428, %1430
%1432 = load i32, i32* %20
%1433 = mul nsw i32 %1431, %1432
%1434 = add nsw i32 %1427, %1433
%1435 = sext i32 %1434 to i64
%1436 = getelementptr inbounds double, double* %1424, i64 %1435
%1437 = load double, double* %1436
%1438 = load i32, i32* %37
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds [2 x double], [2 x double]* %77, i64 0, i64 %1439
store double %1437, double* %1440
%1441 = load double*, double** %32
%1442 = load i32, i32* %36
%1443 = load i32, i32* %37
%1444 = add nsw i32 %1442, %1443
%1445 = load i32, i32* %35
%1446 = load i32, i32* %18
%1447 = add nsw i32 %1446, 1
%1448 = mul nsw i32 %1445, %1447
%1449 = load i32, i32* %20
%1450 = mul nsw i32 %1448, %1449
%1451 = add nsw i32 %1444, %1450
%1452 = sext i32 %1451 to i64
%1453 = getelementptr inbounds double, double* %1441, i64 %1452
%1454 = load double, double* %1453
%1455 = load i32, i32* %37
%1456 = sext i32 %1455 to i64
%1457 = getelementptr inbounds [2 x double], [2 x double]* %81, i64 0, i64 %1456
store double %1454, double* %1457
%1458 = load double*, double** %33
%1459 = load i32, i32* %36
%1460 = load i32, i32* %37
%1461 = add nsw i32 %1459, %1460
%1462 = load i32, i32* %35
%1463 = load i32, i32* %18
%1464 = add nsw i32 %1463, 1
%1465 = mul nsw i32 %1462, %1464
%1466 = load i32, i32* %20
%1467 = mul nsw i32 %1465, %1466
%1468 = add nsw i32 %1461, %1467
%1469 = sext i32 %1468 to i64
%1470 = getelementptr inbounds double, double* %1458, i64 %1469
%1471 = load double, double* %1470
%1472 = load i32, i32* %37
%1473 = sext i32 %1472 to i64
%1474 = getelementptr inbounds [2 x double], [2 x double]* %85, i64 0, i64 %1473
store double %1471, double* %1474
br label %1475
1475: ; preds = %1290
%1476 = load i32, i32* %37
%1477 = add nsw i32 %1476, 1
store i32 %1477, i32* %37
br label %1287
1478: ; preds = %1287
store i32 0, i32* %37
br label %1479
1479: ; preds = %1537, %1478
%1480 = load i32, i32* %37
%1481 = icmp slt i32 %1480, 2
br i1 %1481, label %1482, label %1540
1482: ; preds = %1479
%1483 = load i32, i32* %37
%1484 = sext i32 %1483 to i64
%1485 = getelementptr inbounds [2 x double], [2 x double]* %76, i64 0, i64 %1484
%1486 = load double, double* %1485
%1487 = load double*, double** %31
%1488 = load i32, i32* %36
%1489 = load i32, i32* %37
%1490 = add nsw i32 %1488, %1489
%1491 = load i32, i32* %35
%1492 = load i32, i32* %18
%1493 = add nsw i32 %1492, 1
%1494 = mul nsw i32 %1491, %1493
%1495 = add nsw i32 %1494, 1
%1496 = load i32, i32* %20
%1497 = mul nsw i32 %1495, %1496
%1498 = add nsw i32 %1490, %1497
%1499 = sext i32 %1498 to i64
%1500 = getelementptr inbounds double, double* %1487, i64 %1499
store double %1486, double* %1500
%1501 = load i32, i32* %37
%1502 = sext i32 %1501 to i64
%1503 = getelementptr inbounds [2 x double], [2 x double]* %80, i64 0, i64 %1502
%1504 = load double, double* %1503
%1505 = load double*, double** %32
%1506 = load i32, i32* %36
%1507 = load i32, i32* %37
%1508 = add nsw i32 %1506, %1507
%1509 = load i32, i32* %35
%1510 = load i32, i32* %18
%1511 = add nsw i32 %1510, 1
%1512 = mul nsw i32 %1509, %1511
%1513 = add nsw i32 %1512, 1
%1514 = load i32, i32* %20
%1515 = mul nsw i32 %1513, %1514
%1516 = add nsw i32 %1508, %1515
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds double, double* %1505, i64 %1517
store double %1504, double* %1518
%1519 = load i32, i32* %37
%1520 = sext i32 %1519 to i64
%1521 = getelementptr inbounds [2 x double], [2 x double]* %84, i64 0, i64 %1520
%1522 = load double, double* %1521
%1523 = load double*, double** %33
%1524 = load i32, i32* %36
%1525 = load i32, i32* %37
%1526 = add nsw i32 %1524, %1525
%1527 = load i32, i32* %35
%1528 = load i32, i32* %18
%1529 = add nsw i32 %1528, 1
%1530 = mul nsw i32 %1527, %1529
%1531 = add nsw i32 %1530, 1
%1532 = load i32, i32* %20
%1533 = mul nsw i32 %1531, %1532
%1534 = add nsw i32 %1526, %1533
%1535 = sext i32 %1534 to i64
%1536 = getelementptr inbounds double, double* %1523, i64 %1535
store double %1522, double* %1536
br label %1537
1537: ; preds = %1482
%1538 = load i32, i32* %37
%1539 = add nsw i32 %1538, 1
store i32 %1539, i32* %37
br label %1479
1540: ; preds = %1479
store i32 2, i32* %34
br label %1541
1541: ; preds = %1821, %1540
%1542 = load i32, i32* %34
%1543 = load i32, i32* %18
%1544 = icmp sle i32 %1542, %1543
br i1 %1544, label %1545, label %1824
1545: ; preds = %1541
%1546 = load i32, i32* %34
%1547 = sub nsw i32 %1546, 1
store i32 %1547, i32* %88
store i32 0, i32* %37
br label %1548
1548: ; preds = %1752, %1545
%1549 = load i32, i32* %37
%1550 = icmp slt i32 %1549, 2
br i1 %1550, label %1551, label %1755
1551: ; preds = %1548
%1552 = load i32, i32* %35
%1553 = sitofp i32 %1552 to double
%1554 = load double*, double** %21
%1555 = load i32, i32* %36
%1556 = load i32, i32* %37
%1557 = add nsw i32 %1555, %1556
%1558 = sext i32 %1557 to i64
%1559 = getelementptr inbounds double, double* %1554, i64 %1558
%1560 = load double, double* %1559
%1561 = fmul double %1553, %1560
store double %1561, double* %38
%1562 = load i32, i32* %88
%1563 = sitofp i32 %1562 to double
%1564 = load double*, double** %23
%1565 = load i32, i32* %36
%1566 = load i32, i32* %37
%1567 = add nsw i32 %1565, %1566
%1568 = sext i32 %1567 to i64
%1569 = getelementptr inbounds double, double* %1564, i64 %1568
%1570 = load double, double* %1569
%1571 = fmul double %1563, %1570
store double %1571, double* %39
%1572 = load double*, double** %31
%1573 = load i32, i32* %36
%1574 = load i32, i32* %37
%1575 = add nsw i32 %1573, %1574
%1576 = load i32, i32* %88
%1577 = load i32, i32* %87
%1578 = load i32, i32* %18
%1579 = add nsw i32 %1578, 1
%1580 = mul nsw i32 %1577, %1579
%1581 = add nsw i32 %1576, %1580
%1582 = load i32, i32* %20
%1583 = mul nsw i32 %1581, %1582
%1584 = add nsw i32 %1575, %1583
%1585 = sext i32 %1584 to i64
%1586 = getelementptr inbounds double, double* %1572, i64 %1585
%1587 = load double, double* %1586
%1588 = load i32, i32* %37
%1589 = sext i32 %1588 to i64
%1590 = getelementptr inbounds [2 x double], [2 x double]* %78, i64 0, i64 %1589
store double %1587, double* %1590
%1591 = load double, double* %38
%1592 = load i32, i32* %37
%1593 = sext i32 %1592 to i64
%1594 = getelementptr inbounds [2 x double], [2 x double]* %78, i64 0, i64 %1593
%1595 = load double, double* %1594
%1596 = load double, double* %39
%1597 = load i32, i32* %37
%1598 = sext i32 %1597 to i64
%1599 = getelementptr inbounds [2 x double], [2 x double]* %77, i64 0, i64 %1598
%1600 = load double, double* %1599
%1601 = fmul double %1596, %1600
%1602 = call double @llvm.fmuladd.f64(double %1591, double %1595, double %1601)
%1603 = load double*, double** %24
%1604 = load i32, i32* %36
%1605 = load i32, i32* %37
%1606 = add nsw i32 %1604, %1605
%1607 = sext i32 %1606 to i64
%1608 = getelementptr inbounds double, double* %1603, i64 %1607
%1609 = load double, double* %1608
%1610 = load i32, i32* %37
%1611 = sext i32 %1610 to i64
%1612 = getelementptr inbounds [2 x double], [2 x double]* %76, i64 0, i64 %1611
%1613 = load double, double* %1612
%1614 = call double @llvm.fmuladd.f64(double %1609, double %1613, double %1602)
%1615 = load i32, i32* %37
%1616 = sext i32 %1615 to i64
%1617 = getelementptr inbounds [2 x double], [2 x double]* %75, i64 0, i64 %1616
store double %1614, double* %1617
%1618 = load i32, i32* %37
%1619 = sext i32 %1618 to i64
%1620 = getelementptr inbounds [2 x double], [2 x double]* %76, i64 0, i64 %1619
%1621 = load double, double* %1620
%1622 = load i32, i32* %37
%1623 = sext i32 %1622 to i64
%1624 = getelementptr inbounds [2 x double], [2 x double]* %77, i64 0, i64 %1623
store double %1621, double* %1624
%1625 = load i32, i32* %37
%1626 = sext i32 %1625 to i64
%1627 = getelementptr inbounds [2 x double], [2 x double]* %75, i64 0, i64 %1626
%1628 = load double, double* %1627
%1629 = load i32, i32* %37
%1630 = sext i32 %1629 to i64
%1631 = getelementptr inbounds [2 x double], [2 x double]* %76, i64 0, i64 %1630
store double %1628, double* %1631
%1632 = load double*, double** %32
%1633 = load i32, i32* %36
%1634 = load i32, i32* %37
%1635 = add nsw i32 %1633, %1634
%1636 = load i32, i32* %88
%1637 = load i32, i32* %87
%1638 = load i32, i32* %18
%1639 = add nsw i32 %1638, 1
%1640 = mul nsw i32 %1637, %1639
%1641 = add nsw i32 %1636, %1640
%1642 = load i32, i32* %20
%1643 = mul nsw i32 %1641, %1642
%1644 = add nsw i32 %1635, %1643
%1645 = sext i32 %1644 to i64
%1646 = getelementptr inbounds double, double* %1632, i64 %1645
%1647 = load double, double* %1646
%1648 = load i32, i32* %37
%1649 = sext i32 %1648 to i64
%1650 = getelementptr inbounds [2 x double], [2 x double]* %82, i64 0, i64 %1649
store double %1647, double* %1650
%1651 = load double, double* %38
%1652 = load i32, i32* %37
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds [2 x double], [2 x double]* %82, i64 0, i64 %1653
%1655 = load double, double* %1654
%1656 = load double, double* %39
%1657 = load i32, i32* %37
%1658 = sext i32 %1657 to i64
%1659 = getelementptr inbounds [2 x double], [2 x double]* %81, i64 0, i64 %1658
%1660 = load double, double* %1659
%1661 = fmul double %1656, %1660
%1662 = call double @llvm.fmuladd.f64(double %1651, double %1655, double %1661)
%1663 = load double*, double** %25
%1664 = load i32, i32* %36
%1665 = load i32, i32* %37
%1666 = add nsw i32 %1664, %1665
%1667 = sext i32 %1666 to i64
%1668 = getelementptr inbounds double, double* %1663, i64 %1667
%1669 = load double, double* %1668
%1670 = load i32, i32* %37
%1671 = sext i32 %1670 to i64
%1672 = getelementptr inbounds [2 x double], [2 x double]* %80, i64 0, i64 %1671
%1673 = load double, double* %1672
%1674 = call double @llvm.fmuladd.f64(double %1669, double %1673, double %1662)
%1675 = load i32, i32* %37
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds [2 x double], [2 x double]* %79, i64 0, i64 %1676
store double %1674, double* %1677
%1678 = load i32, i32* %37
%1679 = sext i32 %1678 to i64
%1680 = getelementptr inbounds [2 x double], [2 x double]* %80, i64 0, i64 %1679
%1681 = load double, double* %1680
%1682 = load i32, i32* %37
%1683 = sext i32 %1682 to i64
%1684 = getelementptr inbounds [2 x double], [2 x double]* %81, i64 0, i64 %1683
store double %1681, double* %1684
%1685 = load i32, i32* %37
%1686 = sext i32 %1685 to i64
%1687 = getelementptr inbounds [2 x double], [2 x double]* %79, i64 0, i64 %1686
%1688 = load double, double* %1687
%1689 = load i32, i32* %37
%1690 = sext i32 %1689 to i64
%1691 = getelementptr inbounds [2 x double], [2 x double]* %80, i64 0, i64 %1690
store double %1688, double* %1691
%1692 = load double*, double** %33
%1693 = load i32, i32* %36
%1694 = load i32, i32* %37
%1695 = add nsw i32 %1693, %1694
%1696 = load i32, i32* %88
%1697 = load i32, i32* %87
%1698 = load i32, i32* %18
%1699 = add nsw i32 %1698, 1
%1700 = mul nsw i32 %1697, %1699
%1701 = add nsw i32 %1696, %1700
%1702 = load i32, i32* %20
%1703 = mul nsw i32 %1701, %1702
%1704 = add nsw i32 %1695, %1703
%1705 = sext i32 %1704 to i64
%1706 = getelementptr inbounds double, double* %1692, i64 %1705
%1707 = load double, double* %1706
%1708 = load i32, i32* %37
%1709 = sext i32 %1708 to i64
%1710 = getelementptr inbounds [2 x double], [2 x double]* %86, i64 0, i64 %1709
store double %1707, double* %1710
%1711 = load double, double* %38
%1712 = load i32, i32* %37
%1713 = sext i32 %1712 to i64
%1714 = getelementptr inbounds [2 x double], [2 x double]* %86, i64 0, i64 %1713
%1715 = load double, double* %1714
%1716 = load double, double* %39
%1717 = load i32, i32* %37
%1718 = sext i32 %1717 to i64
%1719 = getelementptr inbounds [2 x double], [2 x double]* %85, i64 0, i64 %1718
%1720 = load double, double* %1719
%1721 = fmul double %1716, %1720
%1722 = call double @llvm.fmuladd.f64(double %1711, double %1715, double %1721)
%1723 = load double*, double** %26
%1724 = load i32, i32* %36
%1725 = load i32, i32* %37
%1726 = add nsw i32 %1724, %1725
%1727 = sext i32 %1726 to i64
%1728 = getelementptr inbounds double, double* %1723, i64 %1727
%1729 = load double, double* %1728
%1730 = load i32, i32* %37
%1731 = sext i32 %1730 to i64
%1732 = getelementptr inbounds [2 x double], [2 x double]* %84, i64 0, i64 %1731
%1733 = load double, double* %1732
%1734 = call double @llvm.fmuladd.f64(double %1729, double %1733, double %1722)
%1735 = load i32, i32* %37
%1736 = sext i32 %1735 to i64
%1737 = getelementptr inbounds [2 x double], [2 x double]* %83, i64 0, i64 %1736
store double %1734, double* %1737
%1738 = load i32, i32* %37
%1739 = sext i32 %1738 to i64
%1740 = getelementptr inbounds [2 x double], [2 x double]* %84, i64 0, i64 %1739
%1741 = load double, double* %1740
%1742 = load i32, i32* %37
%1743 = sext i32 %1742 to i64
%1744 = getelementptr inbounds [2 x double], [2 x double]* %85, i64 0, i64 %1743
store double %1741, double* %1744
%1745 = load i32, i32* %37
%1746 = sext i32 %1745 to i64
%1747 = getelementptr inbounds [2 x double], [2 x double]* %83, i64 0, i64 %1746
%1748 = load double, double* %1747
%1749 = load i32, i32* %37
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds [2 x double], [2 x double]* %84, i64 0, i64 %1750
store double %1748, double* %1751
br label %1752
1752: ; preds = %1551
%1753 = load i32, i32* %37
%1754 = add nsw i32 %1753, 1
store i32 %1754, i32* %37
br label %1548
1755: ; preds = %1548
store i32 0, i32* %37
br label %1756
1756: ; preds = %1817, %1755
%1757 = load i32, i32* %37
%1758 = icmp slt i32 %1757, 2
br i1 %1758, label %1759, label %1820
1759: ; preds = %1756
%1760 = load i32, i32* %37
%1761 = sext i32 %1760 to i64
%1762 = getelementptr inbounds [2 x double], [2 x double]* %75, i64 0, i64 %1761
%1763 = load double, double* %1762
%1764 = load double*, double** %31
%1765 = load i32, i32* %36
%1766 = load i32, i32* %37
%1767 = add nsw i32 %1765, %1766
%1768 = load i32, i32* %34
%1769 = load i32, i32* %35
%1770 = load i32, i32* %18
%1771 = add nsw i32 %1770, 1
%1772 = mul nsw i32 %1769, %1771
%1773 = add nsw i32 %1768, %1772
%1774 = load i32, i32* %20
%1775 = mul nsw i32 %1773, %1774
%1776 = add nsw i32 %1767, %1775
%1777 = sext i32 %1776 to i64
%1778 = getelementptr inbounds double, double* %1764, i64 %1777
store double %1763, double* %1778
%1779 = load i32, i32* %37
%1780 = sext i32 %1779 to i64
%1781 = getelementptr inbounds [2 x double], [2 x double]* %79, i64 0, i64 %1780
%1782 = load double, double* %1781
%1783 = load double*, double** %32
%1784 = load i32, i32* %36
%1785 = load i32, i32* %37
%1786 = add nsw i32 %1784, %1785
%1787 = load i32, i32* %34
%1788 = load i32, i32* %35
%1789 = load i32, i32* %18
%1790 = add nsw i32 %1789, 1
%1791 = mul nsw i32 %1788, %1790
%1792 = add nsw i32 %1787, %1791
%1793 = load i32, i32* %20
%1794 = mul nsw i32 %1792, %1793
%1795 = add nsw i32 %1786, %1794
%1796 = sext i32 %1795 to i64
%1797 = getelementptr inbounds double, double* %1783, i64 %1796
store double %1782, double* %1797
%1798 = load i32, i32* %37
%1799 = sext i32 %1798 to i64
%1800 = getelementptr inbounds [2 x double], [2 x double]* %83, i64 0, i64 %1799
%1801 = load double, double* %1800
%1802 = load double*, double** %33
%1803 = load i32, i32* %36
%1804 = load i32, i32* %37
%1805 = add nsw i32 %1803, %1804
%1806 = load i32, i32* %34
%1807 = load i32, i32* %35
%1808 = load i32, i32* %18
%1809 = add nsw i32 %1808, 1
%1810 = mul nsw i32 %1807, %1809
%1811 = add nsw i32 %1806, %1810
%1812 = load i32, i32* %20
%1813 = mul nsw i32 %1811, %1812
%1814 = add nsw i32 %1805, %1813
%1815 = sext i32 %1814 to i64
%1816 = getelementptr inbounds double, double* %1802, i64 %1815
store double %1801, double* %1816
br label %1817
1817: ; preds = %1759
%1818 = load i32, i32* %37
%1819 = add nsw i32 %1818, 1
store i32 %1819, i32* %37
br label %1756
1820: ; preds = %1756
br label %1821
1821: ; preds = %1820
%1822 = load i32, i32* %34
%1823 = add nsw i32 %1822, 1
store i32 %1823, i32* %34
br label %1541
1824: ; preds = %1541
br label %1825
1825: ; preds = %1824
%1826 = load i32, i32* %35
%1827 = add nsw i32 %1826, 1
store i32 %1827, i32* %35
br label %1280
1828: ; preds = %1280
br label %1829
1829: ; preds = %1828
%1830 = load i32, i32* %36
%1831 = add nsw i32 %1830, 2
store i32 %1831, i32* %36
br label %1275
1832: ; preds = %1275
br label %2362
1833: ; preds = %1270
store i32 0, i32* %36
br label %1834
1834: ; preds = %2358, %1833
%1835 = load i32, i32* %36
%1836 = load i32, i32* %20
%1837 = icmp slt i32 %1835, %1836
br i1 %1837, label %1838, label %2361
1838: ; preds = %1834
store i32 1, i32* %34
br label %1839
1839: ; preds = %2354, %1838
%1840 = load i32, i32* %34
%1841 = load i32, i32* %18
%1842 = icmp sle i32 %1840, %1841
br i1 %1842, label %1843, label %2357
1843: ; preds = %1839
%1844 = load i32, i32* %34
%1845 = sub nsw i32 %1844, 1
store i32 %1845, i32* %101
store i32 0, i32* %37
br label %1846
1846: ; preds = %2007, %1843
%1847 = load i32, i32* %37
%1848 = icmp slt i32 %1847, 2
br i1 %1848, label %1849, label %2010
1849: ; preds = %1846
%1850 = load i32, i32* %34
%1851 = sitofp i32 %1850 to double
%1852 = load double*, double** %21
%1853 = load i32, i32* %36
%1854 = load i32, i32* %37
%1855 = add nsw i32 %1853, %1854
%1856 = sext i32 %1855 to i64
%1857 = getelementptr inbounds double, double* %1852, i64 %1856
%1858 = load double, double* %1857
%1859 = fmul double %1851, %1858
store double %1859, double* %38
%1860 = load double, double* %38
%1861 = load double*, double** %31
%1862 = load i32, i32* %36
%1863 = load i32, i32* %37
%1864 = add nsw i32 %1862, %1863
%1865 = load i32, i32* %101
%1866 = load i32, i32* %20
%1867 = mul nsw i32 %1865, %1866
%1868 = add nsw i32 %1864, %1867
%1869 = sext i32 %1868 to i64
%1870 = getelementptr inbounds double, double* %1861, i64 %1869
%1871 = load double, double* %1870
%1872 = load double*, double** %27
%1873 = load i32, i32* %36
%1874 = load i32, i32* %37
%1875 = add nsw i32 %1873, %1874
%1876 = sext i32 %1875 to i64
%1877 = getelementptr inbounds double, double* %1872, i64 %1876
%1878 = load double, double* %1877
%1879 = load double*, double** %31
%1880 = load i32, i32* %36
%1881 = load i32, i32* %37
%1882 = add nsw i32 %1880, %1881
%1883 = load i32, i32* %34
%1884 = load i32, i32* %20
%1885 = mul nsw i32 %1883, %1884
%1886 = add nsw i32 %1882, %1885
%1887 = sext i32 %1886 to i64
%1888 = getelementptr inbounds double, double* %1879, i64 %1887
%1889 = load double, double* %1888
%1890 = fmul double %1878, %1889
%1891 = call double @llvm.fmuladd.f64(double %1860, double %1871, double %1890)
%1892 = load i32, i32* %37
%1893 = sext i32 %1892 to i64
%1894 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 %1893
store double %1891, double* %1894
%1895 = load double, double* %38
%1896 = load double*, double** %32
%1897 = load i32, i32* %36
%1898 = load i32, i32* %37
%1899 = add nsw i32 %1897, %1898
%1900 = load i32, i32* %101
%1901 = load i32, i32* %20
%1902 = mul nsw i32 %1900, %1901
%1903 = add nsw i32 %1899, %1902
%1904 = sext i32 %1903 to i64
%1905 = getelementptr inbounds double, double* %1896, i64 %1904
%1906 = load double, double* %1905
%1907 = load double*, double** %28
%1908 = load i32, i32* %36
%1909 = load i32, i32* %37
%1910 = add nsw i32 %1908, %1909
%1911 = sext i32 %1910 to i64
%1912 = getelementptr inbounds double, double* %1907, i64 %1911
%1913 = load double, double* %1912
%1914 = load double*, double** %32
%1915 = load i32, i32* %36
%1916 = load i32, i32* %37
%1917 = add nsw i32 %1915, %1916
%1918 = load i32, i32* %34
%1919 = load i32, i32* %20
%1920 = mul nsw i32 %1918, %1919
%1921 = add nsw i32 %1917, %1920
%1922 = sext i32 %1921 to i64
%1923 = getelementptr inbounds double, double* %1914, i64 %1922
%1924 = load double, double* %1923
%1925 = fmul double %1913, %1924
%1926 = call double @llvm.fmuladd.f64(double %1895, double %1906, double %1925)
%1927 = load i32, i32* %37
%1928 = sext i32 %1927 to i64
%1929 = getelementptr inbounds [2 x double], [2 x double]* %94, i64 0, i64 %1928
store double %1926, double* %1929
%1930 = load double, double* %38
%1931 = load double*, double** %33
%1932 = load i32, i32* %36
%1933 = load i32, i32* %37
%1934 = add nsw i32 %1932, %1933
%1935 = load i32, i32* %101
%1936 = load i32, i32* %20
%1937 = mul nsw i32 %1935, %1936
%1938 = add nsw i32 %1934, %1937
%1939 = sext i32 %1938 to i64
%1940 = getelementptr inbounds double, double* %1931, i64 %1939
%1941 = load double, double* %1940
%1942 = load double*, double** %29
%1943 = load i32, i32* %36
%1944 = load i32, i32* %37
%1945 = add nsw i32 %1943, %1944
%1946 = sext i32 %1945 to i64
%1947 = getelementptr inbounds double, double* %1942, i64 %1946
%1948 = load double, double* %1947
%1949 = load double*, double** %33
%1950 = load i32, i32* %36
%1951 = load i32, i32* %37
%1952 = add nsw i32 %1950, %1951
%1953 = load i32, i32* %34
%1954 = load i32, i32* %20
%1955 = mul nsw i32 %1953, %1954
%1956 = add nsw i32 %1952, %1955
%1957 = sext i32 %1956 to i64
%1958 = getelementptr inbounds double, double* %1949, i64 %1957
%1959 = load double, double* %1958
%1960 = fmul double %1948, %1959
%1961 = call double @llvm.fmuladd.f64(double %1930, double %1941, double %1960)
%1962 = load i32, i32* %37
%1963 = sext i32 %1962 to i64
%1964 = getelementptr inbounds [2 x double], [2 x double]* %98, i64 0, i64 %1963
store double %1961, double* %1964
%1965 = load double*, double** %31
%1966 = load i32, i32* %36
%1967 = load i32, i32* %37
%1968 = add nsw i32 %1966, %1967
%1969 = load i32, i32* %34
%1970 = load i32, i32* %20
%1971 = mul nsw i32 %1969, %1970
%1972 = add nsw i32 %1968, %1971
%1973 = sext i32 %1972 to i64
%1974 = getelementptr inbounds double, double* %1965, i64 %1973
%1975 = load double, double* %1974
%1976 = load i32, i32* %37
%1977 = sext i32 %1976 to i64
%1978 = getelementptr inbounds [2 x double], [2 x double]* %91, i64 0, i64 %1977
store double %1975, double* %1978
%1979 = load double*, double** %32
%1980 = load i32, i32* %36
%1981 = load i32, i32* %37
%1982 = add nsw i32 %1980, %1981
%1983 = load i32, i32* %34
%1984 = load i32, i32* %20
%1985 = mul nsw i32 %1983, %1984
%1986 = add nsw i32 %1982, %1985
%1987 = sext i32 %1986 to i64
%1988 = getelementptr inbounds double, double* %1979, i64 %1987
%1989 = load double, double* %1988
%1990 = load i32, i32* %37
%1991 = sext i32 %1990 to i64
%1992 = getelementptr inbounds [2 x double], [2 x double]* %95, i64 0, i64 %1991
store double %1989, double* %1992
%1993 = load double*, double** %33
%1994 = load i32, i32* %36
%1995 = load i32, i32* %37
%1996 = add nsw i32 %1994, %1995
%1997 = load i32, i32* %34
%1998 = load i32, i32* %20
%1999 = mul nsw i32 %1997, %1998
%2000 = add nsw i32 %1996, %1999
%2001 = sext i32 %2000 to i64
%2002 = getelementptr inbounds double, double* %1993, i64 %2001
%2003 = load double, double* %2002
%2004 = load i32, i32* %37
%2005 = sext i32 %2004 to i64
%2006 = getelementptr inbounds [2 x double], [2 x double]* %99, i64 0, i64 %2005
store double %2003, double* %2006
br label %2007
2007: ; preds = %1849
%2008 = load i32, i32* %37
%2009 = add nsw i32 %2008, 1
store i32 %2009, i32* %37
br label %1846
2010: ; preds = %1846
store i32 0, i32* %37
br label %2011
2011: ; preds = %2066, %2010
%2012 = load i32, i32* %37
%2013 = icmp slt i32 %2012, 2
br i1 %2013, label %2014, label %2069
2014: ; preds = %2011
%2015 = load i32, i32* %37
%2016 = sext i32 %2015 to i64
%2017 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 %2016
%2018 = load double, double* %2017
%2019 = load double*, double** %31
%2020 = load i32, i32* %36
%2021 = load i32, i32* %37
%2022 = add nsw i32 %2020, %2021
%2023 = load i32, i32* %34
%2024 = load i32, i32* %18
%2025 = add nsw i32 %2024, 1
%2026 = add nsw i32 %2023, %2025
%2027 = load i32, i32* %20
%2028 = mul nsw i32 %2026, %2027
%2029 = add nsw i32 %2022, %2028
%2030 = sext i32 %2029 to i64
%2031 = getelementptr inbounds double, double* %2019, i64 %2030
store double %2018, double* %2031
%2032 = load i32, i32* %37
%2033 = sext i32 %2032 to i64
%2034 = getelementptr inbounds [2 x double], [2 x double]* %94, i64 0, i64 %2033
%2035 = load double, double* %2034
%2036 = load double*, double** %32
%2037 = load i32, i32* %36
%2038 = load i32, i32* %37
%2039 = add nsw i32 %2037, %2038
%2040 = load i32, i32* %34
%2041 = load i32, i32* %18
%2042 = add nsw i32 %2041, 1
%2043 = add nsw i32 %2040, %2042
%2044 = load i32, i32* %20
%2045 = mul nsw i32 %2043, %2044
%2046 = add nsw i32 %2039, %2045
%2047 = sext i32 %2046 to i64
%2048 = getelementptr inbounds double, double* %2036, i64 %2047
store double %2035, double* %2048
%2049 = load i32, i32* %37
%2050 = sext i32 %2049 to i64
%2051 = getelementptr inbounds [2 x double], [2 x double]* %98, i64 0, i64 %2050
%2052 = load double, double* %2051
%2053 = load double*, double** %33
%2054 = load i32, i32* %36
%2055 = load i32, i32* %37
%2056 = add nsw i32 %2054, %2055
%2057 = load i32, i32* %34
%2058 = load i32, i32* %18
%2059 = add nsw i32 %2058, 1
%2060 = add nsw i32 %2057, %2059
%2061 = load i32, i32* %20
%2062 = mul nsw i32 %2060, %2061
%2063 = add nsw i32 %2056, %2062
%2064 = sext i32 %2063 to i64
%2065 = getelementptr inbounds double, double* %2053, i64 %2064
store double %2052, double* %2065
br label %2066
2066: ; preds = %2014
%2067 = load i32, i32* %37
%2068 = add nsw i32 %2067, 1
store i32 %2068, i32* %37
br label %2011
2069: ; preds = %2011
store i32 2, i32* %35
br label %2070
2070: ; preds = %2350, %2069
%2071 = load i32, i32* %35
%2072 = load i32, i32* %19
%2073 = icmp sle i32 %2071, %2072
br i1 %2073, label %2074, label %2353
2074: ; preds = %2070
%2075 = load i32, i32* %35
%2076 = sub nsw i32 %2075, 1
store i32 %2076, i32* %102
store i32 0, i32* %37
br label %2077
2077: ; preds = %2281, %2074
%2078 = load i32, i32* %37
%2079 = icmp slt i32 %2078, 2
br i1 %2079, label %2080, label %2284
2080: ; preds = %2077
%2081 = load i32, i32* %34
%2082 = sitofp i32 %2081 to double
%2083 = load double*, double** %21
%2084 = load i32, i32* %36
%2085 = load i32, i32* %37
%2086 = add nsw i32 %2084, %2085
%2087 = sext i32 %2086 to i64
%2088 = getelementptr inbounds double, double* %2083, i64 %2087
%2089 = load double, double* %2088
%2090 = fmul double %2082, %2089
store double %2090, double* %38
%2091 = load i32, i32* %102
%2092 = sitofp i32 %2091 to double
%2093 = load double*, double** %22
%2094 = load i32, i32* %36
%2095 = load i32, i32* %37
%2096 = add nsw i32 %2094, %2095
%2097 = sext i32 %2096 to i64
%2098 = getelementptr inbounds double, double* %2093, i64 %2097
%2099 = load double, double* %2098
%2100 = fmul double %2092, %2099
store double %2100, double* %39
%2101 = load double*, double** %31
%2102 = load i32, i32* %36
%2103 = load i32, i32* %37
%2104 = add nsw i32 %2102, %2103
%2105 = load i32, i32* %101
%2106 = load i32, i32* %102
%2107 = load i32, i32* %18
%2108 = add nsw i32 %2107, 1
%2109 = mul nsw i32 %2106, %2108
%2110 = add nsw i32 %2105, %2109
%2111 = load i32, i32* %20
%2112 = mul nsw i32 %2110, %2111
%2113 = add nsw i32 %2104, %2112
%2114 = sext i32 %2113 to i64
%2115 = getelementptr inbounds double, double* %2101, i64 %2114
%2116 = load double, double* %2115
%2117 = load i32, i32* %37
%2118 = sext i32 %2117 to i64
%2119 = getelementptr inbounds [2 x double], [2 x double]* %92, i64 0, i64 %2118
store double %2116, double* %2119
%2120 = load double, double* %38
%2121 = load i32, i32* %37
%2122 = sext i32 %2121 to i64
%2123 = getelementptr inbounds [2 x double], [2 x double]* %92, i64 0, i64 %2122
%2124 = load double, double* %2123
%2125 = load double, double* %39
%2126 = load i32, i32* %37
%2127 = sext i32 %2126 to i64
%2128 = getelementptr inbounds [2 x double], [2 x double]* %91, i64 0, i64 %2127
%2129 = load double, double* %2128
%2130 = fmul double %2125, %2129
%2131 = call double @llvm.fmuladd.f64(double %2120, double %2124, double %2130)
%2132 = load double*, double** %27
%2133 = load i32, i32* %36
%2134 = load i32, i32* %37
%2135 = add nsw i32 %2133, %2134
%2136 = sext i32 %2135 to i64
%2137 = getelementptr inbounds double, double* %2132, i64 %2136
%2138 = load double, double* %2137
%2139 = load i32, i32* %37
%2140 = sext i32 %2139 to i64
%2141 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 %2140
%2142 = load double, double* %2141
%2143 = call double @llvm.fmuladd.f64(double %2138, double %2142, double %2131)
%2144 = load i32, i32* %37
%2145 = sext i32 %2144 to i64
%2146 = getelementptr inbounds [2 x double], [2 x double]* %89, i64 0, i64 %2145
store double %2143, double* %2146
%2147 = load i32, i32* %37
%2148 = sext i32 %2147 to i64
%2149 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 %2148
%2150 = load double, double* %2149
%2151 = load i32, i32* %37
%2152 = sext i32 %2151 to i64
%2153 = getelementptr inbounds [2 x double], [2 x double]* %91, i64 0, i64 %2152
store double %2150, double* %2153
%2154 = load i32, i32* %37
%2155 = sext i32 %2154 to i64
%2156 = getelementptr inbounds [2 x double], [2 x double]* %89, i64 0, i64 %2155
%2157 = load double, double* %2156
%2158 = load i32, i32* %37
%2159 = sext i32 %2158 to i64
%2160 = getelementptr inbounds [2 x double], [2 x double]* %90, i64 0, i64 %2159
store double %2157, double* %2160
%2161 = load double*, double** %32
%2162 = load i32, i32* %36
%2163 = load i32, i32* %37
%2164 = add nsw i32 %2162, %2163
%2165 = load i32, i32* %101
%2166 = load i32, i32* %102
%2167 = load i32, i32* %18
%2168 = add nsw i32 %2167, 1
%2169 = mul nsw i32 %2166, %2168
%2170 = add nsw i32 %2165, %2169
%2171 = load i32, i32* %20
%2172 = mul nsw i32 %2170, %2171
%2173 = add nsw i32 %2164, %2172
%2174 = sext i32 %2173 to i64
%2175 = getelementptr inbounds double, double* %2161, i64 %2174
%2176 = load double, double* %2175
%2177 = load i32, i32* %37
%2178 = sext i32 %2177 to i64
%2179 = getelementptr inbounds [2 x double], [2 x double]* %96, i64 0, i64 %2178
store double %2176, double* %2179
%2180 = load double, double* %38
%2181 = load i32, i32* %37
%2182 = sext i32 %2181 to i64
%2183 = getelementptr inbounds [2 x double], [2 x double]* %96, i64 0, i64 %2182
%2184 = load double, double* %2183
%2185 = load double, double* %39
%2186 = load i32, i32* %37
%2187 = sext i32 %2186 to i64
%2188 = getelementptr inbounds [2 x double], [2 x double]* %95, i64 0, i64 %2187
%2189 = load double, double* %2188
%2190 = fmul double %2185, %2189
%2191 = call double @llvm.fmuladd.f64(double %2180, double %2184, double %2190)
%2192 = load double*, double** %28
%2193 = load i32, i32* %36
%2194 = load i32, i32* %37
%2195 = add nsw i32 %2193, %2194
%2196 = sext i32 %2195 to i64
%2197 = getelementptr inbounds double, double* %2192, i64 %2196
%2198 = load double, double* %2197
%2199 = load i32, i32* %37
%2200 = sext i32 %2199 to i64
%2201 = getelementptr inbounds [2 x double], [2 x double]* %94, i64 0, i64 %2200
%2202 = load double, double* %2201
%2203 = call double @llvm.fmuladd.f64(double %2198, double %2202, double %2191)
%2204 = load i32, i32* %37
%2205 = sext i32 %2204 to i64
%2206 = getelementptr inbounds [2 x double], [2 x double]* %93, i64 0, i64 %2205
store double %2203, double* %2206
%2207 = load i32, i32* %37
%2208 = sext i32 %2207 to i64
%2209 = getelementptr inbounds [2 x double], [2 x double]* %94, i64 0, i64 %2208
%2210 = load double, double* %2209
%2211 = load i32, i32* %37
%2212 = sext i32 %2211 to i64
%2213 = getelementptr inbounds [2 x double], [2 x double]* %95, i64 0, i64 %2212
store double %2210, double* %2213
%2214 = load i32, i32* %37
%2215 = sext i32 %2214 to i64
%2216 = getelementptr inbounds [2 x double], [2 x double]* %93, i64 0, i64 %2215
%2217 = load double, double* %2216
%2218 = load i32, i32* %37
%2219 = sext i32 %2218 to i64
%2220 = getelementptr inbounds [2 x double], [2 x double]* %94, i64 0, i64 %2219
store double %2217, double* %2220
%2221 = load double*, double** %33
%2222 = load i32, i32* %36
%2223 = load i32, i32* %37
%2224 = add nsw i32 %2222, %2223
%2225 = load i32, i32* %101
%2226 = load i32, i32* %102
%2227 = load i32, i32* %18
%2228 = add nsw i32 %2227, 1
%2229 = mul nsw i32 %2226, %2228
%2230 = add nsw i32 %2225, %2229
%2231 = load i32, i32* %20
%2232 = mul nsw i32 %2230, %2231
%2233 = add nsw i32 %2224, %2232
%2234 = sext i32 %2233 to i64
%2235 = getelementptr inbounds double, double* %2221, i64 %2234
%2236 = load double, double* %2235
%2237 = load i32, i32* %37
%2238 = sext i32 %2237 to i64
%2239 = getelementptr inbounds [2 x double], [2 x double]* %100, i64 0, i64 %2238
store double %2236, double* %2239
%2240 = load double, double* %38
%2241 = load i32, i32* %37
%2242 = sext i32 %2241 to i64
%2243 = getelementptr inbounds [2 x double], [2 x double]* %100, i64 0, i64 %2242
%2244 = load double, double* %2243
%2245 = load double, double* %39
%2246 = load i32, i32* %37
%2247 = sext i32 %2246 to i64
%2248 = getelementptr inbounds [2 x double], [2 x double]* %99, i64 0, i64 %2247
%2249 = load double, double* %2248
%2250 = fmul double %2245, %2249
%2251 = call double @llvm.fmuladd.f64(double %2240, double %2244, double %2250)
%2252 = load double*, double** %29
%2253 = load i32, i32* %36
%2254 = load i32, i32* %37
%2255 = add nsw i32 %2253, %2254
%2256 = sext i32 %2255 to i64
%2257 = getelementptr inbounds double, double* %2252, i64 %2256
%2258 = load double, double* %2257
%2259 = load i32, i32* %37
%2260 = sext i32 %2259 to i64
%2261 = getelementptr inbounds [2 x double], [2 x double]* %98, i64 0, i64 %2260
%2262 = load double, double* %2261
%2263 = call double @llvm.fmuladd.f64(double %2258, double %2262, double %2251)
%2264 = load i32, i32* %37
%2265 = sext i32 %2264 to i64
%2266 = getelementptr inbounds [2 x double], [2 x double]* %97, i64 0, i64 %2265
store double %2263, double* %2266
%2267 = load i32, i32* %37
%2268 = sext i32 %2267 to i64
%2269 = getelementptr inbounds [2 x double], [2 x double]* %98, i64 0, i64 %2268
%2270 = load double, double* %2269
%2271 = load i32, i32* %37
%2272 = sext i32 %2271 to i64
%2273 = getelementptr inbounds [2 x double], [2 x double]* %99, i64 0, i64 %2272
store double %2270, double* %2273
%2274 = load i32, i32* %37
%2275 = sext i32 %2274 to i64
%2276 = getelementptr inbounds [2 x double], [2 x double]* %97, i64 0, i64 %2275
%2277 = load double, double* %2276
%2278 = load i32, i32* %37
%2279 = sext i32 %2278 to i64
%2280 = getelementptr inbounds [2 x double], [2 x double]* %98, i64 0, i64 %2279
store double %2277, double* %2280
br label %2281
2281: ; preds = %2080
%2282 = load i32, i32* %37
%2283 = add nsw i32 %2282, 1
store i32 %2283, i32* %37
br label %2077
2284: ; preds = %2077
store i32 0, i32* %37
br label %2285
2285: ; preds = %2346, %2284
%2286 = load i32, i32* %37
%2287 = icmp slt i32 %2286, 2
br i1 %2287, label %2288, label %2349
2288: ; preds = %2285
%2289 = load i32, i32* %37
%2290 = sext i32 %2289 to i64
%2291 = getelementptr inbounds [2 x double], [2 x double]* %89, i64 0, i64 %2290
%2292 = load double, double* %2291
%2293 = load double*, double** %31
%2294 = load i32, i32* %36
%2295 = load i32, i32* %37
%2296 = add nsw i32 %2294, %2295
%2297 = load i32, i32* %34
%2298 = load i32, i32* %35
%2299 = load i32, i32* %18
%2300 = add nsw i32 %2299, 1
%2301 = mul nsw i32 %2298, %2300
%2302 = add nsw i32 %2297, %2301
%2303 = load i32, i32* %20
%2304 = mul nsw i32 %2302, %2303
%2305 = add nsw i32 %2296, %2304
%2306 = sext i32 %2305 to i64
%2307 = getelementptr inbounds double, double* %2293, i64 %2306
store double %2292, double* %2307
%2308 = load i32, i32* %37
%2309 = sext i32 %2308 to i64
%2310 = getelementptr inbounds [2 x double], [2 x double]* %93, i64 0, i64 %2309
%2311 = load double, double* %2310
%2312 = load double*, double** %32
%2313 = load i32, i32* %36
%2314 = load i32, i32* %37
%2315 = add nsw i32 %2313, %2314
%2316 = load i32, i32* %34
%2317 = load i32, i32* %35
%2318 = load i32, i32* %18
%2319 = add nsw i32 %2318, 1
%2320 = mul nsw i32 %2317, %2319
%2321 = add nsw i32 %2316, %2320
%2322 = load i32, i32* %20
%2323 = mul nsw i32 %2321, %2322
%2324 = add nsw i32 %2315, %2323
%2325 = sext i32 %2324 to i64
%2326 = getelementptr inbounds double, double* %2312, i64 %2325
store double %2311, double* %2326
%2327 = load i32, i32* %37
%2328 = sext i32 %2327 to i64
%2329 = getelementptr inbounds [2 x double], [2 x double]* %97, i64 0, i64 %2328
%2330 = load double, double* %2329
%2331 = load double*, double** %33
%2332 = load i32, i32* %36
%2333 = load i32, i32* %37
%2334 = add nsw i32 %2332, %2333
%2335 = load i32, i32* %34
%2336 = load i32, i32* %35
%2337 = load i32, i32* %18
%2338 = add nsw i32 %2337, 1
%2339 = mul nsw i32 %2336, %2338
%2340 = add nsw i32 %2335, %2339
%2341 = load i32, i32* %20
%2342 = mul nsw i32 %2340, %2341
%2343 = add nsw i32 %2334, %2342
%2344 = sext i32 %2343 to i64
%2345 = getelementptr inbounds double, double* %2331, i64 %2344
store double %2330, double* %2345
br label %2346
2346: ; preds = %2288
%2347 = load i32, i32* %37
%2348 = add nsw i32 %2347, 1
store i32 %2348, i32* %37
br label %2285
2349: ; preds = %2285
br label %2350
2350: ; preds = %2349
%2351 = load i32, i32* %35
%2352 = add nsw i32 %2351, 1
store i32 %2352, i32* %35
br label %2070
2353: ; preds = %2070
br label %2354
2354: ; preds = %2353
%2355 = load i32, i32* %34
%2356 = add nsw i32 %2355, 1
store i32 %2356, i32* %34
br label %1839
2357: ; preds = %1839
br label %2358
2358: ; preds = %2357
%2359 = load i32, i32* %36
%2360 = add nsw i32 %2359, 2
store i32 %2360, i32* %36
br label %1834
2361: ; preds = %1834
br label %2362
2362: ; preds = %2361, %1832
store i32 0, i32* %17
br label %2363
2363: ; preds = %2362, %711, %427, %143
%2364 = load i32, i32* %17
ret i32 %2364
}

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