void blts(int nx, int ny, int nz, int k, double omega,
          double v[64][64 / 2 * 2 + 1][64 / 2 * 2 + 1][5],
          double ldz[64][64][5][5], double ldy[64][64][5][5],
          double ldx[64][64][5][5], double d[64][64][5][5], int ist, int iend,
          int jst, int jend, int nx0, int ny0) {
  int i, j, m;
  double tmp, tmp1;
  double tmat[5][5];
#pragma omp for nowait schedule(static)
  for (i = ist; i <= iend; i++) {
    for (j = jst; j <= jend; j++) {
      for (m = 0; m < 5; m++) {
        v[i][j][k][m] =
            v[i][j][k][m] - omega * (ldz[i][j][m][0] * v[i][j][k - 1][0] +
                                     ldz[i][j][m][1] * v[i][j][k - 1][1] +
                                     ldz[i][j][m][2] * v[i][j][k - 1][2] +
                                     ldz[i][j][m][3] * v[i][j][k - 1][3] +
                                     ldz[i][j][m][4] * v[i][j][k - 1][4]);
      }
    }
  }
#pragma omp for nowait schedule(static)
  for (i = ist; i <= iend; i++) {
    for (j = jst; j <= jend; j++) {
      for (m = 0; m < 5; m++) {
        v[i][j][k][m] =
            v[i][j][k][m] - omega * (ldy[i][j][m][0] * v[i][j - 1][k][0] +
                                     ldx[i][j][m][0] * v[i - 1][j][k][0] +
                                     ldy[i][j][m][1] * v[i][j - 1][k][1] +
                                     ldx[i][j][m][1] * v[i - 1][j][k][1] +
                                     ldy[i][j][m][2] * v[i][j - 1][k][2] +
                                     ldx[i][j][m][2] * v[i - 1][j][k][2] +
                                     ldy[i][j][m][3] * v[i][j - 1][k][3] +
                                     ldx[i][j][m][3] * v[i - 1][j][k][3] +
                                     ldy[i][j][m][4] * v[i][j - 1][k][4] +
                                     ldx[i][j][m][4] * v[i - 1][j][k][4]);
      }
      for (m = 0; m < 5; m++) {
        tmat[m][0] = d[i][j][m][0];
        tmat[m][1] = d[i][j][m][1];
        tmat[m][2] = d[i][j][m][2];
        tmat[m][3] = d[i][j][m][3];
        tmat[m][4] = d[i][j][m][4];
      }
      tmp1 = 1.0 / tmat[0][0];
      tmp = tmp1 * tmat[1][0];
      tmat[1][1] = tmat[1][1] - tmp * tmat[0][1];
      tmat[1][2] = tmat[1][2] - tmp * tmat[0][2];
      tmat[1][3] = tmat[1][3] - tmp * tmat[0][3];
      tmat[1][4] = tmat[1][4] - tmp * tmat[0][4];
      v[i][j][k][1] = v[i][j][k][1] - v[i][j][k][0] * tmp;
      tmp = tmp1 * tmat[2][0];
      tmat[2][1] = tmat[2][1] - tmp * tmat[0][1];
      tmat[2][2] = tmat[2][2] - tmp * tmat[0][2];
      tmat[2][3] = tmat[2][3] - tmp * tmat[0][3];
      tmat[2][4] = tmat[2][4] - tmp * tmat[0][4];
      v[i][j][k][2] = v[i][j][k][2] - v[i][j][k][0] * tmp;
      tmp = tmp1 * tmat[3][0];
      tmat[3][1] = tmat[3][1] - tmp * tmat[0][1];
      tmat[3][2] = tmat[3][2] - tmp * tmat[0][2];
      tmat[3][3] = tmat[3][3] - tmp * tmat[0][3];
      tmat[3][4] = tmat[3][4] - tmp * tmat[0][4];
      v[i][j][k][3] = v[i][j][k][3] - v[i][j][k][0] * tmp;
      tmp = tmp1 * tmat[4][0];
      tmat[4][1] = tmat[4][1] - tmp * tmat[0][1];
      tmat[4][2] = tmat[4][2] - tmp * tmat[0][2];
      tmat[4][3] = tmat[4][3] - tmp * tmat[0][3];
      tmat[4][4] = tmat[4][4] - tmp * tmat[0][4];
      v[i][j][k][4] = v[i][j][k][4] - v[i][j][k][0] * tmp;
      tmp1 = 1.0 / tmat[1][1];
      tmp = tmp1 * tmat[2][1];
      tmat[2][2] = tmat[2][2] - tmp * tmat[1][2];
      tmat[2][3] = tmat[2][3] - tmp * tmat[1][3];
      tmat[2][4] = tmat[2][4] - tmp * tmat[1][4];
      v[i][j][k][2] = v[i][j][k][2] - v[i][j][k][1] * tmp;
      tmp = tmp1 * tmat[3][1];
      tmat[3][2] = tmat[3][2] - tmp * tmat[1][2];
      tmat[3][3] = tmat[3][3] - tmp * tmat[1][3];
      tmat[3][4] = tmat[3][4] - tmp * tmat[1][4];
      v[i][j][k][3] = v[i][j][k][3] - v[i][j][k][1] * tmp;
      tmp = tmp1 * tmat[4][1];
      tmat[4][2] = tmat[4][2] - tmp * tmat[1][2];
      tmat[4][3] = tmat[4][3] - tmp * tmat[1][3];
      tmat[4][4] = tmat[4][4] - tmp * tmat[1][4];
      v[i][j][k][4] = v[i][j][k][4] - v[i][j][k][1] * tmp;
      tmp1 = 1.0 / tmat[2][2];
      tmp = tmp1 * tmat[3][2];
      tmat[3][3] = tmat[3][3] - tmp * tmat[2][3];
      tmat[3][4] = tmat[3][4] - tmp * tmat[2][4];
      v[i][j][k][3] = v[i][j][k][3] - v[i][j][k][2] * tmp;
      tmp = tmp1 * tmat[4][2];
      tmat[4][3] = tmat[4][3] - tmp * tmat[2][3];
      tmat[4][4] = tmat[4][4] - tmp * tmat[2][4];
      v[i][j][k][4] = v[i][j][k][4] - v[i][j][k][2] * tmp;
      tmp1 = 1.0 / tmat[3][3];
      tmp = tmp1 * tmat[4][3];
      tmat[4][4] = tmat[4][4] - tmp * tmat[3][4];
      v[i][j][k][4] = v[i][j][k][4] - v[i][j][k][3] * tmp;
      v[i][j][k][4] = v[i][j][k][4] / tmat[4][4];
      v[i][j][k][3] = v[i][j][k][3] - tmat[3][4] * v[i][j][k][4];
      v[i][j][k][3] = v[i][j][k][3] / tmat[3][3];
      v[i][j][k][2] = v[i][j][k][2] - tmat[2][3] * v[i][j][k][3] -
                      tmat[2][4] * v[i][j][k][4];
      v[i][j][k][2] = v[i][j][k][2] / tmat[2][2];
      v[i][j][k][1] = v[i][j][k][1] - tmat[1][2] * v[i][j][k][2] -
                      tmat[1][3] * v[i][j][k][3] - tmat[1][4] * v[i][j][k][4];
      v[i][j][k][1] = v[i][j][k][1] / tmat[1][1];
      v[i][j][k][0] = v[i][j][k][0] - tmat[0][1] * v[i][j][k][1] -
                      tmat[0][2] * v[i][j][k][2] - tmat[0][3] * v[i][j][k][3] -
                      tmat[0][4] * v[i][j][k][4];
      v[i][j][k][0] = v[i][j][k][0] / tmat[0][0];
    }
  }
}


x86 assembly (clang, -O0):
<blts>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x30(%rbp),%eax
jg     144e <blts+0x34e>
mov    0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x40(%rbp),%eax
jg     143b <blts+0x33b>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    1428 <blts+0x328>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm4
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    116d <blts+0x6d>
jmp    142d <blts+0x32d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115a <blts+0x5a>
jmp    1440 <blts+0x340>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1148 <blts+0x48>
mov    0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x30(%rbp),%eax
jg     3077 <blts+0x1f77>
mov    0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x40(%rbp),%eax
jg     3064 <blts+0x1f64>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    1953 <blts+0x853>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm4
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm3
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mulsd  (%rax),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1479 <blts+0x379>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    1ad3 <blts+0x9d3>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3200,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    195a <blts+0x85a>
movsd  0x2525(%rip),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0x1e63(%rip),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0x1a01(%rip),%xmm0
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0x178b(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
divsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x108(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xf8(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa28,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1466 <blts+0x366>
jmp    3069 <blts+0x1f69>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1454 <blts+0x354>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blts>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    0xb0(%rsp),%r13d
mov    0xa8(%rsp),%r10d
cmp    %r13d,%r10d
jg     13c4 <blts+0x2c4>
mov    0xc0(%rsp),%r11d
mov    0xb8(%rsp),%r15d
movslq %ecx,%rdx
lea    -0x1(%rdx),%eax
cltq
xorpd  0xeb9(%rip),%xmm0
movslq %r15d,%r12
movslq %r10d,%rdi
imul   $0x29428,%rdi,%rcx
add    %r8,%rcx
imul   $0xa28,%r12,%rsi
mov    %rsi,-0x78(%rsp)
add    %rsi,%rcx
mov    %rdx,-0x18(%rsp)
lea    (%rdx,%rdx,4),%rbx
lea    (%rcx,%rbx,8),%rbp
add    $0x20,%rbp
imul   $0x3200,%rdi,%rdx
add    %rdx,%r9
imul   $0xc8,%r12,%rdx
mov    %rdx,-0x70(%rsp)
lea    (%rdx,%r9,1),%r14
add    $0xc0,%r14
lea    (%rax,%rax,4),%rax
lea    (%rcx,%rax,8),%rsi
add    $0x20,%rsi
mov    %r11d,%r9d
mov    %r12,-0x20(%rsp)
sub    %r12d,%r9d
add    $0x1,%r9d
lea    0x1(%r13),%ecx
jmp    11e1 <blts+0xe1>
nopl   0x0(%rax)
add    $0x1,%rdi
add    $0x29428,%rbp
add    $0x3200,%r14
add    $0x29428,%rsi
cmp    %edi,%ecx
je     13bb <blts+0x2bb>
cmp    %r11d,%r15d
jg     11c0 <blts+0xc0>
mov    %r9d,%edx
mov    %r14,%rax
xor    %r12d,%r12d
nop
movsd  -0x20(%rsi,%r12,1),%xmm7
movsd  -0x18(%rsi,%r12,1),%xmm1
movsd  -0xb8(%rax),%xmm2
ff
mulsd  %xmm1,%xmm2
movsd  -0xc0(%rax),%xmm3
ff
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x10(%rsi,%r12,1),%xmm2
movsd  -0xb0(%rax),%xmm4
ff
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  -0x8(%rsi,%r12,1),%xmm3
movsd  -0xa8(%rax),%xmm5
ff
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rsi,%r12,1),%xmm4
movsd  -0xa0(%rax),%xmm6
ff
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm6
addsd  -0x20(%rbp,%r12,1),%xmm6
movsd  %xmm6,-0x20(%rbp,%r12,1)
movsd  -0x90(%rax),%xmm5
ff
mulsd  %xmm1,%xmm5
movsd  -0x98(%rax),%xmm6
ff
mulsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x88(%rax),%xmm5
ff
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  -0x80(%rax),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x78(%rax),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm0,%xmm5
addsd  -0x18(%rbp,%r12,1),%xmm5
movsd  %xmm5,-0x18(%rbp,%r12,1)
movsd  -0x68(%rax),%xmm5
mulsd  %xmm1,%xmm5
movsd  -0x70(%rax),%xmm6
mulsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x60(%rax),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  -0x58(%rax),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x50(%rax),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm0,%xmm5
addsd  -0x10(%rbp,%r12,1),%xmm5
movsd  %xmm5,-0x10(%rbp,%r12,1)
movsd  -0x40(%rax),%xmm5
mulsd  %xmm1,%xmm5
movsd  -0x48(%rax),%xmm6
mulsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x38(%rax),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  -0x30(%rax),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x28(%rax),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm0,%xmm5
addsd  -0x8(%rbp,%r12,1),%xmm5
movsd  %xmm5,-0x8(%rbp,%r12,1)
mulsd  -0x18(%rax),%xmm1
mulsd  -0x20(%rax),%xmm7
addsd  %xmm1,%xmm7
mulsd  -0x10(%rax),%xmm2
mulsd  -0x8(%rax),%xmm3
addsd  %xmm7,%xmm2
addsd  %xmm2,%xmm3
mulsd  (%rax),%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
addsd  0x0(%rbp,%r12,1),%xmm4
movsd  %xmm4,0x0(%rbp,%r12,1)
add    $0xa28,%r12
add    $0xc8,%rax
add    $0xffffffff,%edx
jne    11f0 <blts+0xf0>
jmp    11c0 <blts+0xc0>
mov    %ecx,-0x5c(%rsp)
cmp    %r13d,%r10d
jle    13d3 <blts+0x2d3>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%r11),%r13d
movslq %r10d,%rdi
imul   $0x29428,%rdi,%rcx
add    %r8,%rcx
add    -0x78(%rsp),%rcx
lea    (%rcx,%rbx,8),%rax
mov    %rax,-0x58(%rsp)
imul   $0x3200,%rdi,%rcx
mov    0x90(%rsp),%rax
add    %rcx,%rax
mov    -0x70(%rsp),%rdx
add    %rdx,%rax
mov    %rax,-0x50(%rsp)
mov    0x98(%rsp),%rax
add    %rcx,%rax
add    %rdx,%rax
mov    %rax,-0x48(%rsp)
movapd %xmm0,0x40(%rsp)
jmp    1469 <blts+0x369>
nopl   0x0(%rax)
add    $0x1,%rdi
addq   $0x29428,-0x58(%rsp)
addq   $0x3200,-0x50(%rsp)
addq   $0x3200,-0x48(%rsp)
cmp    %edi,-0x5c(%rsp)
mov    0xc0(%rsp),%r11d
mov    0xb8(%rsp),%r15d
je     13c4 <blts+0x2c4>
cmp    %r11d,%r15d
jg     1430 <blts+0x330>
lea    -0x1(%rdi),%rsi
mov    -0x48(%rsp),%rbp
mov    -0x50(%rsp),%r12
mov    -0x58(%rsp),%r10
mov    -0x20(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
imul   $0x29428,%rdi,%r9
add    %r8,%r9
imul   $0xa28,%r14,%rcx
add    %rcx,%r9
mov    -0x18(%rsp),%rax
lea    0x0(,%rax,8),%rdx
lea    (%rdx,%rdx,4),%rdx
imul   $0x29428,%rsi,%rax
add    %r8,%rax
add    %rcx,%rax
movsd  -0xa28(%r9,%rdx,1),%xmm8
f5 ff ff
movsd  -0xa20(%r9,%rdx,1),%xmm9
f5 ff ff
movsd  (%rax,%rdx,1),%xmm10
movsd  0x8(%rax,%rdx,1),%xmm11
movsd  -0xa18(%r9,%rdx,1),%xmm12
f5 ff ff
movsd  0x10(%rax,%rdx,1),%xmm13
movsd  -0xa10(%r9,%rdx,1),%xmm6
f5 ff ff
movsd  0x18(%rax,%rdx,1),%xmm7
movsd  -0xa08(%r9,%rdx,1),%xmm5
f5 ff ff
movsd  0x20(%rax,%rdx,1),%xmm1
mov    $0x4,%ecx
mov    %r10,%rdx
nopl   0x0(%rax)
movsd  -0x20(%rbp,%rcx,8),%xmm2
mulsd  %xmm10,%xmm2
movsd  -0x20(%r12,%rcx,8),%xmm3
mulsd  %xmm8,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x18(%r12,%rcx,8),%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm3,%xmm2
movsd  -0x18(%rbp,%rcx,8),%xmm3
mulsd  %xmm11,%xmm3
movsd  -0x10(%r12,%rcx,8),%xmm4
addsd  %xmm2,%xmm3
mulsd  %xmm12,%xmm4
movsd  -0x10(%rbp,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
movsd  -0x8(%r12,%rcx,8),%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x8(%rbp,%rcx,8),%xmm2
mulsd  %xmm7,%xmm2
movsd  (%r12,%rcx,8),%xmm4
addsd  %xmm3,%xmm2
mulsd  %xmm5,%xmm4
movsd  0x0(%rbp,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
addsd  (%rdx),%xmm3
movsd  %xmm3,(%rdx)
add    $0x8,%rdx
add    $0x5,%rcx
cmp    $0x1d,%rcx
jne    1520 <blts+0x420>
imul   $0x3200,%rdi,%r15
add    0xa0(%rsp),%r15
imul   $0xc8,%r14,%r11
movsd  (%r11,%r15,1),%xmm2
movsd  %xmm2,0x38(%rsp)
movsd  0x8(%r11,%r15,1),%xmm3
movsd  0x10(%r11,%r15,1),%xmm4
movsd  0x18(%r11,%r15,1),%xmm10
movsd  0x20(%r11,%r15,1),%xmm13
movsd  0x30(%r11,%r15,1),%xmm6
movsd  0x38(%r11,%r15,1),%xmm7
movsd  0x40(%r11,%r15,1),%xmm5
movsd  0x48(%r11,%r15,1),%xmm8
movsd  0x58(%r11,%r15,1),%xmm11
movsd  0x60(%r11,%r15,1),%xmm12
movsd  0x9cf(%rip),%xmm9
divsd  %xmm2,%xmm9
movsd  0x28(%r11,%r15,1),%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm6
movsd  %xmm6,-0x28(%rsp)
movapd %xmm2,%xmm1
mulsd  %xmm4,%xmm1
subsd  %xmm1,%xmm7
movsd  %xmm7,-0x40(%rsp)
movapd %xmm2,%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm5
movsd  %xmm5,-0x38(%rsp)
movapd %xmm2,%xmm1
mulsd  %xmm13,%xmm1
subsd  %xmm1,%xmm8
movsd  %xmm8,-0x30(%rsp)
movsd  (%r9,%rbx,8),%xmm1
movsd  0x8(%r9,%rbx,8),%xmm8
mulsd  %xmm1,%xmm2
movapd %xmm1,%xmm14
subsd  %xmm2,%xmm8
movsd  0x50(%r11,%r15,1),%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm11
movapd %xmm2,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm4,%xmm7
subsd  %xmm1,%xmm12
movsd  %xmm12,-0x68(%rsp)
movapd %xmm2,%xmm1
mulsd  %xmm10,%xmm1
movsd  0x68(%r11,%r15,1),%xmm4
subsd  %xmm1,%xmm4
movsd  %xmm4,-0x78(%rsp)
movapd %xmm14,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm13,%xmm2
movsd  0x70(%r11,%r15,1),%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,-0x70(%rsp)
movsd  0x10(%r9,%rbx,8),%xmm6
subsd  %xmm1,%xmm6
movsd  0x78(%r11,%r15,1),%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm3,0x28(%rsp)
movsd  0x80(%r11,%r15,1),%xmm15
subsd  %xmm1,%xmm15
movapd %xmm4,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm7,%xmm12
movsd  %xmm7,0x20(%rsp)
movsd  0x88(%r11,%r15,1),%xmm5
subsd  %xmm1,%xmm5
movapd %xmm4,%xmm1
movsd  %xmm10,0x30(%rsp)
mulsd  %xmm10,%xmm1
movsd  0x90(%r11,%r15,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
movapd %xmm14,%xmm0
movsd  %xmm14,0x10(%rsp)
movapd %xmm14,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm13,%xmm7
movsd  %xmm13,0x18(%rsp)
mulsd  %xmm13,%xmm4
movsd  0x98(%r11,%r15,1),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rsp)
mulsd  0xa0(%r11,%r15,1),%xmm9
movsd  0x18(%r9,%rbx,8),%xmm1
subsd  %xmm2,%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm3,%xmm2
movsd  0xa8(%r11,%r15,1),%xmm13
subsd  %xmm2,%xmm13
movapd %xmm9,%xmm2
mulsd  %xmm12,%xmm2
movsd  0xb0(%r11,%r15,1),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rsp)
movapd %xmm9,%xmm12
mulsd  %xmm10,%xmm12
movsd  0xb8(%r11,%r15,1),%xmm2
subsd  %xmm12,%xmm2
movsd  %xmm2,-0x10(%rsp)
movapd %xmm14,%xmm12
mulsd  %xmm9,%xmm12
mulsd  %xmm7,%xmm9
movsd  0xc0(%r11,%r15,1),%xmm14
subsd  %xmm9,%xmm14
movsd  0x20(%r9,%rbx,8),%xmm9
subsd  %xmm12,%xmm9
movsd  0x79e(%rip),%xmm12
divsd  -0x28(%rsp),%xmm12
mulsd  %xmm12,%xmm11
movapd %xmm11,%xmm10
movsd  -0x40(%rsp),%xmm0
mulsd  %xmm0,%xmm10
movsd  -0x68(%rsp),%xmm2
subsd  %xmm10,%xmm2
movsd  %xmm2,-0x68(%rsp)
movapd %xmm11,%xmm7
movsd  -0x38(%rsp),%xmm4
mulsd  %xmm4,%xmm7
movsd  -0x78(%rsp),%xmm3
subsd  %xmm7,%xmm3
movsd  %xmm3,-0x78(%rsp)
movapd %xmm8,%xmm7
mulsd  %xmm11,%xmm7
movsd  -0x30(%rsp),%xmm10
mulsd  %xmm10,%xmm11
movsd  -0x70(%rsp),%xmm3
subsd  %xmm11,%xmm3
movsd  %xmm3,-0x70(%rsp)
subsd  %xmm7,%xmm6
mulsd  %xmm12,%xmm15
movapd %xmm15,%xmm7
mulsd  %xmm0,%xmm7
movapd %xmm0,%xmm2
subsd  %xmm7,%xmm5
movapd %xmm15,%xmm7
mulsd  %xmm4,%xmm7
movsd  0x8(%rsp),%xmm0
subsd  %xmm7,%xmm0
movapd %xmm8,%xmm7
mulsd  %xmm15,%xmm7
mulsd  %xmm10,%xmm15
movapd %xmm10,%xmm3
movsd  (%rsp),%xmm11
subsd  %xmm15,%xmm11
subsd  %xmm7,%xmm1
mulsd  %xmm13,%xmm12
movapd %xmm12,%xmm7
mulsd  %xmm2,%xmm7
movsd  -0x8(%rsp),%xmm10
subsd  %xmm7,%xmm10
movapd %xmm12,%xmm7
mulsd  %xmm4,%xmm7
movsd  -0x10(%rsp),%xmm2
subsd  %xmm7,%xmm2
movapd %xmm8,%xmm7
mulsd  %xmm12,%xmm7
mulsd  %xmm3,%xmm12
subsd  %xmm12,%xmm14
subsd  %xmm7,%xmm9
movsd  0x68d(%rip),%xmm7
movsd  -0x68(%rsp),%xmm15
divsd  %xmm15,%xmm7
mulsd  %xmm7,%xmm5
movapd %xmm5,%xmm4
movsd  -0x78(%rsp),%xmm13
mulsd  %xmm13,%xmm4
subsd  %xmm4,%xmm0
movapd %xmm0,%xmm12
movapd %xmm6,%xmm4
mulsd  %xmm5,%xmm4
movsd  -0x70(%rsp),%xmm3
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm11
movapd 0x40(%rsp),%xmm0
subsd  %xmm4,%xmm1
mulsd  %xmm10,%xmm7
movapd %xmm7,%xmm4
mulsd  %xmm13,%xmm4
subsd  %xmm4,%xmm2
movapd %xmm6,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm3,%xmm7
subsd  %xmm7,%xmm14
subsd  %xmm4,%xmm9
movsd  0x613(%rip),%xmm4
divsd  %xmm12,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm11,%xmm4
subsd  %xmm4,%xmm14
subsd  %xmm2,%xmm9
divsd  %xmm14,%xmm9
mulsd  %xmm9,%xmm11
subsd  %xmm11,%xmm1
divsd  %xmm12,%xmm1
mulsd  %xmm1,%xmm13
subsd  %xmm13,%xmm6
mulsd  %xmm9,%xmm3
subsd  %xmm3,%xmm6
divsd  %xmm15,%xmm6
movsd  -0x40(%rsp),%xmm2
mulsd  %xmm6,%xmm2
subsd  %xmm2,%xmm8
movsd  -0x38(%rsp),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm8
movsd  -0x30(%rsp),%xmm2
mulsd  %xmm9,%xmm2
subsd  %xmm2,%xmm8
divsd  -0x28(%rsp),%xmm8
movsd  %xmm9,0x20(%r9,%rbx,8)
movsd  %xmm1,0x18(%r9,%rbx,8)
movsd  %xmm6,0x10(%r9,%rbx,8)
movsd  %xmm8,0x8(%r9,%rbx,8)
mulsd  0x28(%rsp),%xmm8
movsd  0x10(%rsp),%xmm2
subsd  %xmm8,%xmm2
mulsd  0x20(%rsp),%xmm6
subsd  %xmm6,%xmm2
mulsd  0x30(%rsp),%xmm1
subsd  %xmm1,%xmm2
mulsd  0x18(%rsp),%xmm9
subsd  %xmm9,%xmm2
divsd  0x38(%rsp),%xmm2
movsd  %xmm2,(%r9,%rbx,8)
add    $0x1,%r14
add    $0xa28,%r10
add    $0xc8,%r12
add    $0xc8,%rbp
cmp    %r14d,%r13d
jne    1490 <blts+0x390>
jmp    1430 <blts+0x330>

LLVM IR (-O0):
define void @blts(i32 %0, i32 %1, i32 %2, i32 %3, double %4, [65 x [65 x [5 x double]]]* %5, [64 x [5 x [5 x double]]]* %6, [64 x [5 x [5 x double]]]* %7, [64 x [5 x [5 x double]]]* %8, [64 x [5 x [5 x double]]]* %9, i32 %10, i32 %11, i32 %12, i32 %13, i32 %14, i32 %15) {
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca double
%22 = alloca [65 x [65 x [5 x double]]]*
%23 = alloca [64 x [5 x [5 x double]]]*
%24 = alloca [64 x [5 x [5 x double]]]*
%25 = alloca [64 x [5 x [5 x double]]]*
%26 = alloca [64 x [5 x [5 x double]]]*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
%37 = alloca double
%38 = alloca [5 x [5 x double]]
store i32 %0, i32* %17
store i32 %1, i32* %18
store i32 %2, i32* %19
store i32 %3, i32* %20
store double %4, double* %21
store [65 x [65 x [5 x double]]]* %5, [65 x [65 x [5 x double]]]** %22
store [64 x [5 x [5 x double]]]* %6, [64 x [5 x [5 x double]]]** %23
store [64 x [5 x [5 x double]]]* %7, [64 x [5 x [5 x double]]]** %24
store [64 x [5 x [5 x double]]]* %8, [64 x [5 x [5 x double]]]** %25
store [64 x [5 x [5 x double]]]* %9, [64 x [5 x [5 x double]]]** %26
store i32 %10, i32* %27
store i32 %11, i32* %28
store i32 %12, i32* %29
store i32 %13, i32* %30
store i32 %14, i32* %31
store i32 %15, i32* %32
%39 = load i32, i32* %27
store i32 %39, i32* %33
br label %40
40: ; preds = %223, %16
%41 = load i32, i32* %33
%42 = load i32, i32* %28
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %226
44: ; preds = %40
%45 = load i32, i32* %29
store i32 %45, i32* %34
br label %46
46: ; preds = %219, %44
%47 = load i32, i32* %34
%48 = load i32, i32* %30
%49 = icmp sle i32 %47, %48
br i1 %49, label %50, label %222
50: ; preds = %46
store i32 0, i32* %35
br label %51
51: ; preds = %215, %50
%52 = load i32, i32* %35
%53 = icmp slt i32 %52, 5
br i1 %53, label %54, label %218
54: ; preds = %51
%55 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%56 = load i32, i32* %33
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %55, i64 %57
%59 = load i32, i32* %34
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %58, i64 0, i64 %60
%62 = load i32, i32* %20
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %61, i64 0, i64 %63
%65 = load i32, i32* %35
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [5 x double], [5 x double]* %64, i64 0, i64 %66
%68 = load double, double* %67
%69 = load double, double* %21
%70 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %23
%71 = load i32, i32* %33
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %70, i64 %72
%74 = load i32, i32* %34
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %73, i64 0, i64 %75
%77 = load i32, i32* %35
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %76, i64 0, i64 %78
%80 = getelementptr inbounds [5 x double], [5 x double]* %79, i64 0, i64 0
%81 = load double, double* %80
%82 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%83 = load i32, i32* %33
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %82, i64 %84
%86 = load i32, i32* %34
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %85, i64 0, i64 %87
%89 = load i32, i32* %20
%90 = sub nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %88, i64 0, i64 %91
%93 = getelementptr inbounds [5 x double], [5 x double]* %92, i64 0, i64 0
%94 = load double, double* %93
%95 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %23
%96 = load i32, i32* %33
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %95, i64 %97
%99 = load i32, i32* %34
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %98, i64 0, i64 %100
%102 = load i32, i32* %35
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %101, i64 0, i64 %103
%105 = getelementptr inbounds [5 x double], [5 x double]* %104, i64 0, i64 1
%106 = load double, double* %105
%107 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%108 = load i32, i32* %33
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %107, i64 %109
%111 = load i32, i32* %34
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %110, i64 0, i64 %112
%114 = load i32, i32* %20
%115 = sub nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %113, i64 0, i64 %116
%118 = getelementptr inbounds [5 x double], [5 x double]* %117, i64 0, i64 1
%119 = load double, double* %118
%120 = fmul double %106, %119
%121 = call double @llvm.fmuladd.f64(double %81, double %94, double %120)
%122 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %23
%123 = load i32, i32* %33
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %122, i64 %124
%126 = load i32, i32* %34
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %125, i64 0, i64 %127
%129 = load i32, i32* %35
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %128, i64 0, i64 %130
%132 = getelementptr inbounds [5 x double], [5 x double]* %131, i64 0, i64 2
%133 = load double, double* %132
%134 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%135 = load i32, i32* %33
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %134, i64 %136
%138 = load i32, i32* %34
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %137, i64 0, i64 %139
%141 = load i32, i32* %20
%142 = sub nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %140, i64 0, i64 %143
%145 = getelementptr inbounds [5 x double], [5 x double]* %144, i64 0, i64 2
%146 = load double, double* %145
%147 = call double @llvm.fmuladd.f64(double %133, double %146, double %121)
%148 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %23
%149 = load i32, i32* %33
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %148, i64 %150
%152 = load i32, i32* %34
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %151, i64 0, i64 %153
%155 = load i32, i32* %35
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %154, i64 0, i64 %156
%158 = getelementptr inbounds [5 x double], [5 x double]* %157, i64 0, i64 3
%159 = load double, double* %158
%160 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%161 = load i32, i32* %33
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %160, i64 %162
%164 = load i32, i32* %34
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %163, i64 0, i64 %165
%167 = load i32, i32* %20
%168 = sub nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %166, i64 0, i64 %169
%171 = getelementptr inbounds [5 x double], [5 x double]* %170, i64 0, i64 3
%172 = load double, double* %171
%173 = call double @llvm.fmuladd.f64(double %159, double %172, double %147)
%174 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %23
%175 = load i32, i32* %33
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %174, i64 %176
%178 = load i32, i32* %34
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %177, i64 0, i64 %179
%181 = load i32, i32* %35
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %180, i64 0, i64 %182
%184 = getelementptr inbounds [5 x double], [5 x double]* %183, i64 0, i64 4
%185 = load double, double* %184
%186 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%187 = load i32, i32* %33
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %186, i64 %188
%190 = load i32, i32* %34
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %189, i64 0, i64 %191
%193 = load i32, i32* %20
%194 = sub nsw i32 %193, 1
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %192, i64 0, i64 %195
%197 = getelementptr inbounds [5 x double], [5 x double]* %196, i64 0, i64 4
%198 = load double, double* %197
%199 = call double @llvm.fmuladd.f64(double %185, double %198, double %173)
%200 = fneg double %69
%201 = call double @llvm.fmuladd.f64(double %200, double %199, double %68)
%202 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%203 = load i32, i32* %33
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %202, i64 %204
%206 = load i32, i32* %34
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %205, i64 0, i64 %207
%209 = load i32, i32* %20
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %208, i64 0, i64 %210
%212 = load i32, i32* %35
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [5 x double], [5 x double]* %211, i64 0, i64 %213
store double %201, double* %214
br label %215
215: ; preds = %54
%216 = load i32, i32* %35
%217 = add nsw i32 %216, 1
store i32 %217, i32* %35
br label %51
218: ; preds = %51
br label %219
219: ; preds = %218
%220 = load i32, i32* %34
%221 = add nsw i32 %220, 1
store i32 %221, i32* %34
br label %46
222: ; preds = %46
br label %223
223: ; preds = %222
%224 = load i32, i32* %33
%225 = add nsw i32 %224, 1
store i32 %225, i32* %33
br label %40
226: ; preds = %40
%227 = load i32, i32* %27
store i32 %227, i32* %33
br label %228
228: ; preds = %1802, %226
%229 = load i32, i32* %33
%230 = load i32, i32* %28
%231 = icmp sle i32 %229, %230
br i1 %231, label %232, label %1805
232: ; preds = %228
%233 = load i32, i32* %29
store i32 %233, i32* %34
br label %234
234: ; preds = %1798, %232
%235 = load i32, i32* %34
%236 = load i32, i32* %30
%237 = icmp sle i32 %235, %236
br i1 %237, label %238, label %1801
238: ; preds = %234
store i32 0, i32* %35
br label %239
239: ; preds = %533, %238
%240 = load i32, i32* %35
%241 = icmp slt i32 %240, 5
br i1 %241, label %242, label %536
242: ; preds = %239
%243 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%244 = load i32, i32* %33
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %243, i64 %245
%247 = load i32, i32* %34
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %246, i64 0, i64 %248
%250 = load i32, i32* %20
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %249, i64 0, i64 %251
%253 = load i32, i32* %35
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [5 x double], [5 x double]* %252, i64 0, i64 %254
%256 = load double, double* %255
%257 = load double, double* %21
%258 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %24
%259 = load i32, i32* %33
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %258, i64 %260
%262 = load i32, i32* %34
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %261, i64 0, i64 %263
%265 = load i32, i32* %35
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %264, i64 0, i64 %266
%268 = getelementptr inbounds [5 x double], [5 x double]* %267, i64 0, i64 0
%269 = load double, double* %268
%270 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%271 = load i32, i32* %33
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %270, i64 %272
%274 = load i32, i32* %34
%275 = sub nsw i32 %274, 1
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %273, i64 0, i64 %276
%278 = load i32, i32* %20
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %277, i64 0, i64 %279
%281 = getelementptr inbounds [5 x double], [5 x double]* %280, i64 0, i64 0
%282 = load double, double* %281
%283 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %25
%284 = load i32, i32* %33
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %283, i64 %285
%287 = load i32, i32* %34
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %286, i64 0, i64 %288
%290 = load i32, i32* %35
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %289, i64 0, i64 %291
%293 = getelementptr inbounds [5 x double], [5 x double]* %292, i64 0, i64 0
%294 = load double, double* %293
%295 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%296 = load i32, i32* %33
%297 = sub nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %295, i64 %298
%300 = load i32, i32* %34
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %299, i64 0, i64 %301
%303 = load i32, i32* %20
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %302, i64 0, i64 %304
%306 = getelementptr inbounds [5 x double], [5 x double]* %305, i64 0, i64 0
%307 = load double, double* %306
%308 = fmul double %294, %307
%309 = call double @llvm.fmuladd.f64(double %269, double %282, double %308)
%310 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %24
%311 = load i32, i32* %33
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %310, i64 %312
%314 = load i32, i32* %34
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %313, i64 0, i64 %315
%317 = load i32, i32* %35
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %316, i64 0, i64 %318
%320 = getelementptr inbounds [5 x double], [5 x double]* %319, i64 0, i64 1
%321 = load double, double* %320
%322 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%323 = load i32, i32* %33
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %322, i64 %324
%326 = load i32, i32* %34
%327 = sub nsw i32 %326, 1
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %325, i64 0, i64 %328
%330 = load i32, i32* %20
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %329, i64 0, i64 %331
%333 = getelementptr inbounds [5 x double], [5 x double]* %332, i64 0, i64 1
%334 = load double, double* %333
%335 = call double @llvm.fmuladd.f64(double %321, double %334, double %309)
%336 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %25
%337 = load i32, i32* %33
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %336, i64 %338
%340 = load i32, i32* %34
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %339, i64 0, i64 %341
%343 = load i32, i32* %35
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %342, i64 0, i64 %344
%346 = getelementptr inbounds [5 x double], [5 x double]* %345, i64 0, i64 1
%347 = load double, double* %346
%348 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%349 = load i32, i32* %33
%350 = sub nsw i32 %349, 1
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %348, i64 %351
%353 = load i32, i32* %34
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %352, i64 0, i64 %354
%356 = load i32, i32* %20
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %355, i64 0, i64 %357
%359 = getelementptr inbounds [5 x double], [5 x double]* %358, i64 0, i64 1
%360 = load double, double* %359
%361 = call double @llvm.fmuladd.f64(double %347, double %360, double %335)
%362 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %24
%363 = load i32, i32* %33
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %362, i64 %364
%366 = load i32, i32* %34
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %365, i64 0, i64 %367
%369 = load i32, i32* %35
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %368, i64 0, i64 %370
%372 = getelementptr inbounds [5 x double], [5 x double]* %371, i64 0, i64 2
%373 = load double, double* %372
%374 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%375 = load i32, i32* %33
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %374, i64 %376
%378 = load i32, i32* %34
%379 = sub nsw i32 %378, 1
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %377, i64 0, i64 %380
%382 = load i32, i32* %20
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %381, i64 0, i64 %383
%385 = getelementptr inbounds [5 x double], [5 x double]* %384, i64 0, i64 2
%386 = load double, double* %385
%387 = call double @llvm.fmuladd.f64(double %373, double %386, double %361)
%388 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %25
%389 = load i32, i32* %33
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %388, i64 %390
%392 = load i32, i32* %34
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %391, i64 0, i64 %393
%395 = load i32, i32* %35
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %394, i64 0, i64 %396
%398 = getelementptr inbounds [5 x double], [5 x double]* %397, i64 0, i64 2
%399 = load double, double* %398
%400 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%401 = load i32, i32* %33
%402 = sub nsw i32 %401, 1
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %400, i64 %403
%405 = load i32, i32* %34
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %404, i64 0, i64 %406
%408 = load i32, i32* %20
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %407, i64 0, i64 %409
%411 = getelementptr inbounds [5 x double], [5 x double]* %410, i64 0, i64 2
%412 = load double, double* %411
%413 = call double @llvm.fmuladd.f64(double %399, double %412, double %387)
%414 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %24
%415 = load i32, i32* %33
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %414, i64 %416
%418 = load i32, i32* %34
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %417, i64 0, i64 %419
%421 = load i32, i32* %35
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %420, i64 0, i64 %422
%424 = getelementptr inbounds [5 x double], [5 x double]* %423, i64 0, i64 3
%425 = load double, double* %424
%426 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%427 = load i32, i32* %33
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %426, i64 %428
%430 = load i32, i32* %34
%431 = sub nsw i32 %430, 1
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %429, i64 0, i64 %432
%434 = load i32, i32* %20
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %433, i64 0, i64 %435
%437 = getelementptr inbounds [5 x double], [5 x double]* %436, i64 0, i64 3
%438 = load double, double* %437
%439 = call double @llvm.fmuladd.f64(double %425, double %438, double %413)
%440 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %25
%441 = load i32, i32* %33
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %440, i64 %442
%444 = load i32, i32* %34
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %443, i64 0, i64 %445
%447 = load i32, i32* %35
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %446, i64 0, i64 %448
%450 = getelementptr inbounds [5 x double], [5 x double]* %449, i64 0, i64 3
%451 = load double, double* %450
%452 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%453 = load i32, i32* %33
%454 = sub nsw i32 %453, 1
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %452, i64 %455
%457 = load i32, i32* %34
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %456, i64 0, i64 %458
%460 = load i32, i32* %20
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %459, i64 0, i64 %461
%463 = getelementptr inbounds [5 x double], [5 x double]* %462, i64 0, i64 3
%464 = load double, double* %463
%465 = call double @llvm.fmuladd.f64(double %451, double %464, double %439)
%466 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %24
%467 = load i32, i32* %33
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %466, i64 %468
%470 = load i32, i32* %34
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %469, i64 0, i64 %471
%473 = load i32, i32* %35
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %472, i64 0, i64 %474
%476 = getelementptr inbounds [5 x double], [5 x double]* %475, i64 0, i64 4
%477 = load double, double* %476
%478 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%479 = load i32, i32* %33
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %478, i64 %480
%482 = load i32, i32* %34
%483 = sub nsw i32 %482, 1
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %481, i64 0, i64 %484
%486 = load i32, i32* %20
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %485, i64 0, i64 %487
%489 = getelementptr inbounds [5 x double], [5 x double]* %488, i64 0, i64 4
%490 = load double, double* %489
%491 = call double @llvm.fmuladd.f64(double %477, double %490, double %465)
%492 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %25
%493 = load i32, i32* %33
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %492, i64 %494
%496 = load i32, i32* %34
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %495, i64 0, i64 %497
%499 = load i32, i32* %35
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %498, i64 0, i64 %500
%502 = getelementptr inbounds [5 x double], [5 x double]* %501, i64 0, i64 4
%503 = load double, double* %502
%504 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%505 = load i32, i32* %33
%506 = sub nsw i32 %505, 1
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %504, i64 %507
%509 = load i32, i32* %34
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %508, i64 0, i64 %510
%512 = load i32, i32* %20
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %511, i64 0, i64 %513
%515 = getelementptr inbounds [5 x double], [5 x double]* %514, i64 0, i64 4
%516 = load double, double* %515
%517 = call double @llvm.fmuladd.f64(double %503, double %516, double %491)
%518 = fneg double %257
%519 = call double @llvm.fmuladd.f64(double %518, double %517, double %256)
%520 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%521 = load i32, i32* %33
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %520, i64 %522
%524 = load i32, i32* %34
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %523, i64 0, i64 %525
%527 = load i32, i32* %20
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %526, i64 0, i64 %528
%530 = load i32, i32* %35
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds [5 x double], [5 x double]* %529, i64 0, i64 %531
store double %519, double* %532
br label %533
533: ; preds = %242
%534 = load i32, i32* %35
%535 = add nsw i32 %534, 1
store i32 %535, i32* %35
br label %239
536: ; preds = %239
store i32 0, i32* %35
br label %537
537: ; preds = %621, %536
%538 = load i32, i32* %35
%539 = icmp slt i32 %538, 5
br i1 %539, label %540, label %624
540: ; preds = %537
%541 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %26
%542 = load i32, i32* %33
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %541, i64 %543
%545 = load i32, i32* %34
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %544, i64 0, i64 %546
%548 = load i32, i32* %35
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %547, i64 0, i64 %549
%551 = getelementptr inbounds [5 x double], [5 x double]* %550, i64 0, i64 0
%552 = load double, double* %551
%553 = load i32, i32* %35
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 %554
%556 = getelementptr inbounds [5 x double], [5 x double]* %555, i64 0, i64 0
store double %552, double* %556
%557 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %26
%558 = load i32, i32* %33
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %557, i64 %559
%561 = load i32, i32* %34
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %560, i64 0, i64 %562
%564 = load i32, i32* %35
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %563, i64 0, i64 %565
%567 = getelementptr inbounds [5 x double], [5 x double]* %566, i64 0, i64 1
%568 = load double, double* %567
%569 = load i32, i32* %35
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 %570
%572 = getelementptr inbounds [5 x double], [5 x double]* %571, i64 0, i64 1
store double %568, double* %572
%573 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %26
%574 = load i32, i32* %33
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %573, i64 %575
%577 = load i32, i32* %34
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %576, i64 0, i64 %578
%580 = load i32, i32* %35
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %579, i64 0, i64 %581
%583 = getelementptr inbounds [5 x double], [5 x double]* %582, i64 0, i64 2
%584 = load double, double* %583
%585 = load i32, i32* %35
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 %586
%588 = getelementptr inbounds [5 x double], [5 x double]* %587, i64 0, i64 2
store double %584, double* %588
%589 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %26
%590 = load i32, i32* %33
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %589, i64 %591
%593 = load i32, i32* %34
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %592, i64 0, i64 %594
%596 = load i32, i32* %35
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %595, i64 0, i64 %597
%599 = getelementptr inbounds [5 x double], [5 x double]* %598, i64 0, i64 3
%600 = load double, double* %599
%601 = load i32, i32* %35
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 %602
%604 = getelementptr inbounds [5 x double], [5 x double]* %603, i64 0, i64 3
store double %600, double* %604
%605 = load [64 x [5 x [5 x double]]]*, [64 x [5 x [5 x double]]]** %26
%606 = load i32, i32* %33
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %605, i64 %607
%609 = load i32, i32* %34
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds [64 x [5 x [5 x double]]], [64 x [5 x [5 x double]]]* %608, i64 0, i64 %610
%612 = load i32, i32* %35
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %611, i64 0, i64 %613
%615 = getelementptr inbounds [5 x double], [5 x double]* %614, i64 0, i64 4
%616 = load double, double* %615
%617 = load i32, i32* %35
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 %618
%620 = getelementptr inbounds [5 x double], [5 x double]* %619, i64 0, i64 4
store double %616, double* %620
br label %621
621: ; preds = %540
%622 = load i32, i32* %35
%623 = add nsw i32 %622, 1
store i32 %623, i32* %35
br label %537
624: ; preds = %537
%625 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%626 = getelementptr inbounds [5 x double], [5 x double]* %625, i64 0, i64 0
%627 = load double, double* %626
%628 = fdiv double 1.000000e+00, %627
store double %628, double* %37
%629 = load double, double* %37
%630 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%631 = getelementptr inbounds [5 x double], [5 x double]* %630, i64 0, i64 0
%632 = load double, double* %631
%633 = fmul double %629, %632
store double %633, double* %36
%634 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%635 = getelementptr inbounds [5 x double], [5 x double]* %634, i64 0, i64 1
%636 = load double, double* %635
%637 = load double, double* %36
%638 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%639 = getelementptr inbounds [5 x double], [5 x double]* %638, i64 0, i64 1
%640 = load double, double* %639
%641 = fneg double %637
%642 = call double @llvm.fmuladd.f64(double %641, double %640, double %636)
%643 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%644 = getelementptr inbounds [5 x double], [5 x double]* %643, i64 0, i64 1
store double %642, double* %644
%645 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%646 = getelementptr inbounds [5 x double], [5 x double]* %645, i64 0, i64 2
%647 = load double, double* %646
%648 = load double, double* %36
%649 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%650 = getelementptr inbounds [5 x double], [5 x double]* %649, i64 0, i64 2
%651 = load double, double* %650
%652 = fneg double %648
%653 = call double @llvm.fmuladd.f64(double %652, double %651, double %647)
%654 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%655 = getelementptr inbounds [5 x double], [5 x double]* %654, i64 0, i64 2
store double %653, double* %655
%656 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%657 = getelementptr inbounds [5 x double], [5 x double]* %656, i64 0, i64 3
%658 = load double, double* %657
%659 = load double, double* %36
%660 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%661 = getelementptr inbounds [5 x double], [5 x double]* %660, i64 0, i64 3
%662 = load double, double* %661
%663 = fneg double %659
%664 = call double @llvm.fmuladd.f64(double %663, double %662, double %658)
%665 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%666 = getelementptr inbounds [5 x double], [5 x double]* %665, i64 0, i64 3
store double %664, double* %666
%667 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%668 = getelementptr inbounds [5 x double], [5 x double]* %667, i64 0, i64 4
%669 = load double, double* %668
%670 = load double, double* %36
%671 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%672 = getelementptr inbounds [5 x double], [5 x double]* %671, i64 0, i64 4
%673 = load double, double* %672
%674 = fneg double %670
%675 = call double @llvm.fmuladd.f64(double %674, double %673, double %669)
%676 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%677 = getelementptr inbounds [5 x double], [5 x double]* %676, i64 0, i64 4
store double %675, double* %677
%678 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%679 = load i32, i32* %33
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %678, i64 %680
%682 = load i32, i32* %34
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %681, i64 0, i64 %683
%685 = load i32, i32* %20
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %684, i64 0, i64 %686
%688 = getelementptr inbounds [5 x double], [5 x double]* %687, i64 0, i64 1
%689 = load double, double* %688
%690 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%691 = load i32, i32* %33
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %690, i64 %692
%694 = load i32, i32* %34
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %693, i64 0, i64 %695
%697 = load i32, i32* %20
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %696, i64 0, i64 %698
%700 = getelementptr inbounds [5 x double], [5 x double]* %699, i64 0, i64 0
%701 = load double, double* %700
%702 = load double, double* %36
%703 = fneg double %701
%704 = call double @llvm.fmuladd.f64(double %703, double %702, double %689)
%705 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%706 = load i32, i32* %33
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %705, i64 %707
%709 = load i32, i32* %34
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %708, i64 0, i64 %710
%712 = load i32, i32* %20
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %711, i64 0, i64 %713
%715 = getelementptr inbounds [5 x double], [5 x double]* %714, i64 0, i64 1
store double %704, double* %715
%716 = load double, double* %37
%717 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%718 = getelementptr inbounds [5 x double], [5 x double]* %717, i64 0, i64 0
%719 = load double, double* %718
%720 = fmul double %716, %719
store double %720, double* %36
%721 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%722 = getelementptr inbounds [5 x double], [5 x double]* %721, i64 0, i64 1
%723 = load double, double* %722
%724 = load double, double* %36
%725 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%726 = getelementptr inbounds [5 x double], [5 x double]* %725, i64 0, i64 1
%727 = load double, double* %726
%728 = fneg double %724
%729 = call double @llvm.fmuladd.f64(double %728, double %727, double %723)
%730 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%731 = getelementptr inbounds [5 x double], [5 x double]* %730, i64 0, i64 1
store double %729, double* %731
%732 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%733 = getelementptr inbounds [5 x double], [5 x double]* %732, i64 0, i64 2
%734 = load double, double* %733
%735 = load double, double* %36
%736 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%737 = getelementptr inbounds [5 x double], [5 x double]* %736, i64 0, i64 2
%738 = load double, double* %737
%739 = fneg double %735
%740 = call double @llvm.fmuladd.f64(double %739, double %738, double %734)
%741 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%742 = getelementptr inbounds [5 x double], [5 x double]* %741, i64 0, i64 2
store double %740, double* %742
%743 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%744 = getelementptr inbounds [5 x double], [5 x double]* %743, i64 0, i64 3
%745 = load double, double* %744
%746 = load double, double* %36
%747 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%748 = getelementptr inbounds [5 x double], [5 x double]* %747, i64 0, i64 3
%749 = load double, double* %748
%750 = fneg double %746
%751 = call double @llvm.fmuladd.f64(double %750, double %749, double %745)
%752 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%753 = getelementptr inbounds [5 x double], [5 x double]* %752, i64 0, i64 3
store double %751, double* %753
%754 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%755 = getelementptr inbounds [5 x double], [5 x double]* %754, i64 0, i64 4
%756 = load double, double* %755
%757 = load double, double* %36
%758 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%759 = getelementptr inbounds [5 x double], [5 x double]* %758, i64 0, i64 4
%760 = load double, double* %759
%761 = fneg double %757
%762 = call double @llvm.fmuladd.f64(double %761, double %760, double %756)
%763 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%764 = getelementptr inbounds [5 x double], [5 x double]* %763, i64 0, i64 4
store double %762, double* %764
%765 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%766 = load i32, i32* %33
%767 = sext i32 %766 to i64
%768 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %765, i64 %767
%769 = load i32, i32* %34
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %768, i64 0, i64 %770
%772 = load i32, i32* %20
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %771, i64 0, i64 %773
%775 = getelementptr inbounds [5 x double], [5 x double]* %774, i64 0, i64 2
%776 = load double, double* %775
%777 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%778 = load i32, i32* %33
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %777, i64 %779
%781 = load i32, i32* %34
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %780, i64 0, i64 %782
%784 = load i32, i32* %20
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %783, i64 0, i64 %785
%787 = getelementptr inbounds [5 x double], [5 x double]* %786, i64 0, i64 0
%788 = load double, double* %787
%789 = load double, double* %36
%790 = fneg double %788
%791 = call double @llvm.fmuladd.f64(double %790, double %789, double %776)
%792 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%793 = load i32, i32* %33
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %792, i64 %794
%796 = load i32, i32* %34
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %795, i64 0, i64 %797
%799 = load i32, i32* %20
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %798, i64 0, i64 %800
%802 = getelementptr inbounds [5 x double], [5 x double]* %801, i64 0, i64 2
store double %791, double* %802
%803 = load double, double* %37
%804 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%805 = getelementptr inbounds [5 x double], [5 x double]* %804, i64 0, i64 0
%806 = load double, double* %805
%807 = fmul double %803, %806
store double %807, double* %36
%808 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%809 = getelementptr inbounds [5 x double], [5 x double]* %808, i64 0, i64 1
%810 = load double, double* %809
%811 = load double, double* %36
%812 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%813 = getelementptr inbounds [5 x double], [5 x double]* %812, i64 0, i64 1
%814 = load double, double* %813
%815 = fneg double %811
%816 = call double @llvm.fmuladd.f64(double %815, double %814, double %810)
%817 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%818 = getelementptr inbounds [5 x double], [5 x double]* %817, i64 0, i64 1
store double %816, double* %818
%819 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%820 = getelementptr inbounds [5 x double], [5 x double]* %819, i64 0, i64 2
%821 = load double, double* %820
%822 = load double, double* %36
%823 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%824 = getelementptr inbounds [5 x double], [5 x double]* %823, i64 0, i64 2
%825 = load double, double* %824
%826 = fneg double %822
%827 = call double @llvm.fmuladd.f64(double %826, double %825, double %821)
%828 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%829 = getelementptr inbounds [5 x double], [5 x double]* %828, i64 0, i64 2
store double %827, double* %829
%830 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%831 = getelementptr inbounds [5 x double], [5 x double]* %830, i64 0, i64 3
%832 = load double, double* %831
%833 = load double, double* %36
%834 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%835 = getelementptr inbounds [5 x double], [5 x double]* %834, i64 0, i64 3
%836 = load double, double* %835
%837 = fneg double %833
%838 = call double @llvm.fmuladd.f64(double %837, double %836, double %832)
%839 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%840 = getelementptr inbounds [5 x double], [5 x double]* %839, i64 0, i64 3
store double %838, double* %840
%841 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%842 = getelementptr inbounds [5 x double], [5 x double]* %841, i64 0, i64 4
%843 = load double, double* %842
%844 = load double, double* %36
%845 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%846 = getelementptr inbounds [5 x double], [5 x double]* %845, i64 0, i64 4
%847 = load double, double* %846
%848 = fneg double %844
%849 = call double @llvm.fmuladd.f64(double %848, double %847, double %843)
%850 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%851 = getelementptr inbounds [5 x double], [5 x double]* %850, i64 0, i64 4
store double %849, double* %851
%852 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%853 = load i32, i32* %33
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %852, i64 %854
%856 = load i32, i32* %34
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %855, i64 0, i64 %857
%859 = load i32, i32* %20
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %858, i64 0, i64 %860
%862 = getelementptr inbounds [5 x double], [5 x double]* %861, i64 0, i64 3
%863 = load double, double* %862
%864 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%865 = load i32, i32* %33
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %864, i64 %866
%868 = load i32, i32* %34
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %867, i64 0, i64 %869
%871 = load i32, i32* %20
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %870, i64 0, i64 %872
%874 = getelementptr inbounds [5 x double], [5 x double]* %873, i64 0, i64 0
%875 = load double, double* %874
%876 = load double, double* %36
%877 = fneg double %875
%878 = call double @llvm.fmuladd.f64(double %877, double %876, double %863)
%879 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%880 = load i32, i32* %33
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %879, i64 %881
%883 = load i32, i32* %34
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %882, i64 0, i64 %884
%886 = load i32, i32* %20
%887 = sext i32 %886 to i64
%888 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %885, i64 0, i64 %887
%889 = getelementptr inbounds [5 x double], [5 x double]* %888, i64 0, i64 3
store double %878, double* %889
%890 = load double, double* %37
%891 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%892 = getelementptr inbounds [5 x double], [5 x double]* %891, i64 0, i64 0
%893 = load double, double* %892
%894 = fmul double %890, %893
store double %894, double* %36
%895 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%896 = getelementptr inbounds [5 x double], [5 x double]* %895, i64 0, i64 1
%897 = load double, double* %896
%898 = load double, double* %36
%899 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%900 = getelementptr inbounds [5 x double], [5 x double]* %899, i64 0, i64 1
%901 = load double, double* %900
%902 = fneg double %898
%903 = call double @llvm.fmuladd.f64(double %902, double %901, double %897)
%904 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%905 = getelementptr inbounds [5 x double], [5 x double]* %904, i64 0, i64 1
store double %903, double* %905
%906 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%907 = getelementptr inbounds [5 x double], [5 x double]* %906, i64 0, i64 2
%908 = load double, double* %907
%909 = load double, double* %36
%910 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%911 = getelementptr inbounds [5 x double], [5 x double]* %910, i64 0, i64 2
%912 = load double, double* %911
%913 = fneg double %909
%914 = call double @llvm.fmuladd.f64(double %913, double %912, double %908)
%915 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%916 = getelementptr inbounds [5 x double], [5 x double]* %915, i64 0, i64 2
store double %914, double* %916
%917 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%918 = getelementptr inbounds [5 x double], [5 x double]* %917, i64 0, i64 3
%919 = load double, double* %918
%920 = load double, double* %36
%921 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%922 = getelementptr inbounds [5 x double], [5 x double]* %921, i64 0, i64 3
%923 = load double, double* %922
%924 = fneg double %920
%925 = call double @llvm.fmuladd.f64(double %924, double %923, double %919)
%926 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%927 = getelementptr inbounds [5 x double], [5 x double]* %926, i64 0, i64 3
store double %925, double* %927
%928 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%929 = getelementptr inbounds [5 x double], [5 x double]* %928, i64 0, i64 4
%930 = load double, double* %929
%931 = load double, double* %36
%932 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%933 = getelementptr inbounds [5 x double], [5 x double]* %932, i64 0, i64 4
%934 = load double, double* %933
%935 = fneg double %931
%936 = call double @llvm.fmuladd.f64(double %935, double %934, double %930)
%937 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%938 = getelementptr inbounds [5 x double], [5 x double]* %937, i64 0, i64 4
store double %936, double* %938
%939 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%940 = load i32, i32* %33
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %939, i64 %941
%943 = load i32, i32* %34
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %942, i64 0, i64 %944
%946 = load i32, i32* %20
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %945, i64 0, i64 %947
%949 = getelementptr inbounds [5 x double], [5 x double]* %948, i64 0, i64 4
%950 = load double, double* %949
%951 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%952 = load i32, i32* %33
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %951, i64 %953
%955 = load i32, i32* %34
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %954, i64 0, i64 %956
%958 = load i32, i32* %20
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %957, i64 0, i64 %959
%961 = getelementptr inbounds [5 x double], [5 x double]* %960, i64 0, i64 0
%962 = load double, double* %961
%963 = load double, double* %36
%964 = fneg double %962
%965 = call double @llvm.fmuladd.f64(double %964, double %963, double %950)
%966 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%967 = load i32, i32* %33
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %966, i64 %968
%970 = load i32, i32* %34
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %969, i64 0, i64 %971
%973 = load i32, i32* %20
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %972, i64 0, i64 %974
%976 = getelementptr inbounds [5 x double], [5 x double]* %975, i64 0, i64 4
store double %965, double* %976
%977 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%978 = getelementptr inbounds [5 x double], [5 x double]* %977, i64 0, i64 1
%979 = load double, double* %978
%980 = fdiv double 1.000000e+00, %979
store double %980, double* %37
%981 = load double, double* %37
%982 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%983 = getelementptr inbounds [5 x double], [5 x double]* %982, i64 0, i64 1
%984 = load double, double* %983
%985 = fmul double %981, %984
store double %985, double* %36
%986 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%987 = getelementptr inbounds [5 x double], [5 x double]* %986, i64 0, i64 2
%988 = load double, double* %987
%989 = load double, double* %36
%990 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%991 = getelementptr inbounds [5 x double], [5 x double]* %990, i64 0, i64 2
%992 = load double, double* %991
%993 = fneg double %989
%994 = call double @llvm.fmuladd.f64(double %993, double %992, double %988)
%995 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%996 = getelementptr inbounds [5 x double], [5 x double]* %995, i64 0, i64 2
store double %994, double* %996
%997 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%998 = getelementptr inbounds [5 x double], [5 x double]* %997, i64 0, i64 3
%999 = load double, double* %998
%1000 = load double, double* %36
%1001 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1002 = getelementptr inbounds [5 x double], [5 x double]* %1001, i64 0, i64 3
%1003 = load double, double* %1002
%1004 = fneg double %1000
%1005 = call double @llvm.fmuladd.f64(double %1004, double %1003, double %999)
%1006 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1007 = getelementptr inbounds [5 x double], [5 x double]* %1006, i64 0, i64 3
store double %1005, double* %1007
%1008 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1009 = getelementptr inbounds [5 x double], [5 x double]* %1008, i64 0, i64 4
%1010 = load double, double* %1009
%1011 = load double, double* %36
%1012 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1013 = getelementptr inbounds [5 x double], [5 x double]* %1012, i64 0, i64 4
%1014 = load double, double* %1013
%1015 = fneg double %1011
%1016 = call double @llvm.fmuladd.f64(double %1015, double %1014, double %1010)
%1017 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1018 = getelementptr inbounds [5 x double], [5 x double]* %1017, i64 0, i64 4
store double %1016, double* %1018
%1019 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1020 = load i32, i32* %33
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1019, i64 %1021
%1023 = load i32, i32* %34
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1022, i64 0, i64 %1024
%1026 = load i32, i32* %20
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1025, i64 0, i64 %1027
%1029 = getelementptr inbounds [5 x double], [5 x double]* %1028, i64 0, i64 2
%1030 = load double, double* %1029
%1031 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1032 = load i32, i32* %33
%1033 = sext i32 %1032 to i64
%1034 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1031, i64 %1033
%1035 = load i32, i32* %34
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1034, i64 0, i64 %1036
%1038 = load i32, i32* %20
%1039 = sext i32 %1038 to i64
%1040 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1037, i64 0, i64 %1039
%1041 = getelementptr inbounds [5 x double], [5 x double]* %1040, i64 0, i64 1
%1042 = load double, double* %1041
%1043 = load double, double* %36
%1044 = fneg double %1042
%1045 = call double @llvm.fmuladd.f64(double %1044, double %1043, double %1030)
%1046 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1047 = load i32, i32* %33
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1046, i64 %1048
%1050 = load i32, i32* %34
%1051 = sext i32 %1050 to i64
%1052 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1049, i64 0, i64 %1051
%1053 = load i32, i32* %20
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1052, i64 0, i64 %1054
%1056 = getelementptr inbounds [5 x double], [5 x double]* %1055, i64 0, i64 2
store double %1045, double* %1056
%1057 = load double, double* %37
%1058 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1059 = getelementptr inbounds [5 x double], [5 x double]* %1058, i64 0, i64 1
%1060 = load double, double* %1059
%1061 = fmul double %1057, %1060
store double %1061, double* %36
%1062 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1063 = getelementptr inbounds [5 x double], [5 x double]* %1062, i64 0, i64 2
%1064 = load double, double* %1063
%1065 = load double, double* %36
%1066 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1067 = getelementptr inbounds [5 x double], [5 x double]* %1066, i64 0, i64 2
%1068 = load double, double* %1067
%1069 = fneg double %1065
%1070 = call double @llvm.fmuladd.f64(double %1069, double %1068, double %1064)
%1071 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1072 = getelementptr inbounds [5 x double], [5 x double]* %1071, i64 0, i64 2
store double %1070, double* %1072
%1073 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1074 = getelementptr inbounds [5 x double], [5 x double]* %1073, i64 0, i64 3
%1075 = load double, double* %1074
%1076 = load double, double* %36
%1077 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1078 = getelementptr inbounds [5 x double], [5 x double]* %1077, i64 0, i64 3
%1079 = load double, double* %1078
%1080 = fneg double %1076
%1081 = call double @llvm.fmuladd.f64(double %1080, double %1079, double %1075)
%1082 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1083 = getelementptr inbounds [5 x double], [5 x double]* %1082, i64 0, i64 3
store double %1081, double* %1083
%1084 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1085 = getelementptr inbounds [5 x double], [5 x double]* %1084, i64 0, i64 4
%1086 = load double, double* %1085
%1087 = load double, double* %36
%1088 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1089 = getelementptr inbounds [5 x double], [5 x double]* %1088, i64 0, i64 4
%1090 = load double, double* %1089
%1091 = fneg double %1087
%1092 = call double @llvm.fmuladd.f64(double %1091, double %1090, double %1086)
%1093 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1094 = getelementptr inbounds [5 x double], [5 x double]* %1093, i64 0, i64 4
store double %1092, double* %1094
%1095 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1096 = load i32, i32* %33
%1097 = sext i32 %1096 to i64
%1098 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1095, i64 %1097
%1099 = load i32, i32* %34
%1100 = sext i32 %1099 to i64
%1101 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1098, i64 0, i64 %1100
%1102 = load i32, i32* %20
%1103 = sext i32 %1102 to i64
%1104 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1101, i64 0, i64 %1103
%1105 = getelementptr inbounds [5 x double], [5 x double]* %1104, i64 0, i64 3
%1106 = load double, double* %1105
%1107 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1108 = load i32, i32* %33
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1107, i64 %1109
%1111 = load i32, i32* %34
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1110, i64 0, i64 %1112
%1114 = load i32, i32* %20
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1113, i64 0, i64 %1115
%1117 = getelementptr inbounds [5 x double], [5 x double]* %1116, i64 0, i64 1
%1118 = load double, double* %1117
%1119 = load double, double* %36
%1120 = fneg double %1118
%1121 = call double @llvm.fmuladd.f64(double %1120, double %1119, double %1106)
%1122 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1123 = load i32, i32* %33
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1122, i64 %1124
%1126 = load i32, i32* %34
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1125, i64 0, i64 %1127
%1129 = load i32, i32* %20
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1128, i64 0, i64 %1130
%1132 = getelementptr inbounds [5 x double], [5 x double]* %1131, i64 0, i64 3
store double %1121, double* %1132
%1133 = load double, double* %37
%1134 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1135 = getelementptr inbounds [5 x double], [5 x double]* %1134, i64 0, i64 1
%1136 = load double, double* %1135
%1137 = fmul double %1133, %1136
store double %1137, double* %36
%1138 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1139 = getelementptr inbounds [5 x double], [5 x double]* %1138, i64 0, i64 2
%1140 = load double, double* %1139
%1141 = load double, double* %36
%1142 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1143 = getelementptr inbounds [5 x double], [5 x double]* %1142, i64 0, i64 2
%1144 = load double, double* %1143
%1145 = fneg double %1141
%1146 = call double @llvm.fmuladd.f64(double %1145, double %1144, double %1140)
%1147 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1148 = getelementptr inbounds [5 x double], [5 x double]* %1147, i64 0, i64 2
store double %1146, double* %1148
%1149 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1150 = getelementptr inbounds [5 x double], [5 x double]* %1149, i64 0, i64 3
%1151 = load double, double* %1150
%1152 = load double, double* %36
%1153 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1154 = getelementptr inbounds [5 x double], [5 x double]* %1153, i64 0, i64 3
%1155 = load double, double* %1154
%1156 = fneg double %1152
%1157 = call double @llvm.fmuladd.f64(double %1156, double %1155, double %1151)
%1158 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1159 = getelementptr inbounds [5 x double], [5 x double]* %1158, i64 0, i64 3
store double %1157, double* %1159
%1160 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1161 = getelementptr inbounds [5 x double], [5 x double]* %1160, i64 0, i64 4
%1162 = load double, double* %1161
%1163 = load double, double* %36
%1164 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1165 = getelementptr inbounds [5 x double], [5 x double]* %1164, i64 0, i64 4
%1166 = load double, double* %1165
%1167 = fneg double %1163
%1168 = call double @llvm.fmuladd.f64(double %1167, double %1166, double %1162)
%1169 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1170 = getelementptr inbounds [5 x double], [5 x double]* %1169, i64 0, i64 4
store double %1168, double* %1170
%1171 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1172 = load i32, i32* %33
%1173 = sext i32 %1172 to i64
%1174 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1171, i64 %1173
%1175 = load i32, i32* %34
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1174, i64 0, i64 %1176
%1178 = load i32, i32* %20
%1179 = sext i32 %1178 to i64
%1180 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1177, i64 0, i64 %1179
%1181 = getelementptr inbounds [5 x double], [5 x double]* %1180, i64 0, i64 4
%1182 = load double, double* %1181
%1183 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1184 = load i32, i32* %33
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1183, i64 %1185
%1187 = load i32, i32* %34
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1186, i64 0, i64 %1188
%1190 = load i32, i32* %20
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1189, i64 0, i64 %1191
%1193 = getelementptr inbounds [5 x double], [5 x double]* %1192, i64 0, i64 1
%1194 = load double, double* %1193
%1195 = load double, double* %36
%1196 = fneg double %1194
%1197 = call double @llvm.fmuladd.f64(double %1196, double %1195, double %1182)
%1198 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1199 = load i32, i32* %33
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1198, i64 %1200
%1202 = load i32, i32* %34
%1203 = sext i32 %1202 to i64
%1204 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1201, i64 0, i64 %1203
%1205 = load i32, i32* %20
%1206 = sext i32 %1205 to i64
%1207 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1204, i64 0, i64 %1206
%1208 = getelementptr inbounds [5 x double], [5 x double]* %1207, i64 0, i64 4
store double %1197, double* %1208
%1209 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1210 = getelementptr inbounds [5 x double], [5 x double]* %1209, i64 0, i64 2
%1211 = load double, double* %1210
%1212 = fdiv double 1.000000e+00, %1211
store double %1212, double* %37
%1213 = load double, double* %37
%1214 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1215 = getelementptr inbounds [5 x double], [5 x double]* %1214, i64 0, i64 2
%1216 = load double, double* %1215
%1217 = fmul double %1213, %1216
store double %1217, double* %36
%1218 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1219 = getelementptr inbounds [5 x double], [5 x double]* %1218, i64 0, i64 3
%1220 = load double, double* %1219
%1221 = load double, double* %36
%1222 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1223 = getelementptr inbounds [5 x double], [5 x double]* %1222, i64 0, i64 3
%1224 = load double, double* %1223
%1225 = fneg double %1221
%1226 = call double @llvm.fmuladd.f64(double %1225, double %1224, double %1220)
%1227 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1228 = getelementptr inbounds [5 x double], [5 x double]* %1227, i64 0, i64 3
store double %1226, double* %1228
%1229 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1230 = getelementptr inbounds [5 x double], [5 x double]* %1229, i64 0, i64 4
%1231 = load double, double* %1230
%1232 = load double, double* %36
%1233 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1234 = getelementptr inbounds [5 x double], [5 x double]* %1233, i64 0, i64 4
%1235 = load double, double* %1234
%1236 = fneg double %1232
%1237 = call double @llvm.fmuladd.f64(double %1236, double %1235, double %1231)
%1238 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1239 = getelementptr inbounds [5 x double], [5 x double]* %1238, i64 0, i64 4
store double %1237, double* %1239
%1240 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1241 = load i32, i32* %33
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1240, i64 %1242
%1244 = load i32, i32* %34
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1243, i64 0, i64 %1245
%1247 = load i32, i32* %20
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1246, i64 0, i64 %1248
%1250 = getelementptr inbounds [5 x double], [5 x double]* %1249, i64 0, i64 3
%1251 = load double, double* %1250
%1252 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1253 = load i32, i32* %33
%1254 = sext i32 %1253 to i64
%1255 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1252, i64 %1254
%1256 = load i32, i32* %34
%1257 = sext i32 %1256 to i64
%1258 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1255, i64 0, i64 %1257
%1259 = load i32, i32* %20
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1258, i64 0, i64 %1260
%1262 = getelementptr inbounds [5 x double], [5 x double]* %1261, i64 0, i64 2
%1263 = load double, double* %1262
%1264 = load double, double* %36
%1265 = fneg double %1263
%1266 = call double @llvm.fmuladd.f64(double %1265, double %1264, double %1251)
%1267 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1268 = load i32, i32* %33
%1269 = sext i32 %1268 to i64
%1270 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1267, i64 %1269
%1271 = load i32, i32* %34
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1270, i64 0, i64 %1272
%1274 = load i32, i32* %20
%1275 = sext i32 %1274 to i64
%1276 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1273, i64 0, i64 %1275
%1277 = getelementptr inbounds [5 x double], [5 x double]* %1276, i64 0, i64 3
store double %1266, double* %1277
%1278 = load double, double* %37
%1279 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1280 = getelementptr inbounds [5 x double], [5 x double]* %1279, i64 0, i64 2
%1281 = load double, double* %1280
%1282 = fmul double %1278, %1281
store double %1282, double* %36
%1283 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1284 = getelementptr inbounds [5 x double], [5 x double]* %1283, i64 0, i64 3
%1285 = load double, double* %1284
%1286 = load double, double* %36
%1287 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1288 = getelementptr inbounds [5 x double], [5 x double]* %1287, i64 0, i64 3
%1289 = load double, double* %1288
%1290 = fneg double %1286
%1291 = call double @llvm.fmuladd.f64(double %1290, double %1289, double %1285)
%1292 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1293 = getelementptr inbounds [5 x double], [5 x double]* %1292, i64 0, i64 3
store double %1291, double* %1293
%1294 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1295 = getelementptr inbounds [5 x double], [5 x double]* %1294, i64 0, i64 4
%1296 = load double, double* %1295
%1297 = load double, double* %36
%1298 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1299 = getelementptr inbounds [5 x double], [5 x double]* %1298, i64 0, i64 4
%1300 = load double, double* %1299
%1301 = fneg double %1297
%1302 = call double @llvm.fmuladd.f64(double %1301, double %1300, double %1296)
%1303 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1304 = getelementptr inbounds [5 x double], [5 x double]* %1303, i64 0, i64 4
store double %1302, double* %1304
%1305 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1306 = load i32, i32* %33
%1307 = sext i32 %1306 to i64
%1308 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1305, i64 %1307
%1309 = load i32, i32* %34
%1310 = sext i32 %1309 to i64
%1311 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1308, i64 0, i64 %1310
%1312 = load i32, i32* %20
%1313 = sext i32 %1312 to i64
%1314 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1311, i64 0, i64 %1313
%1315 = getelementptr inbounds [5 x double], [5 x double]* %1314, i64 0, i64 4
%1316 = load double, double* %1315
%1317 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1318 = load i32, i32* %33
%1319 = sext i32 %1318 to i64
%1320 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1317, i64 %1319
%1321 = load i32, i32* %34
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1320, i64 0, i64 %1322
%1324 = load i32, i32* %20
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1323, i64 0, i64 %1325
%1327 = getelementptr inbounds [5 x double], [5 x double]* %1326, i64 0, i64 2
%1328 = load double, double* %1327
%1329 = load double, double* %36
%1330 = fneg double %1328
%1331 = call double @llvm.fmuladd.f64(double %1330, double %1329, double %1316)
%1332 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1333 = load i32, i32* %33
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1332, i64 %1334
%1336 = load i32, i32* %34
%1337 = sext i32 %1336 to i64
%1338 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1335, i64 0, i64 %1337
%1339 = load i32, i32* %20
%1340 = sext i32 %1339 to i64
%1341 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1338, i64 0, i64 %1340
%1342 = getelementptr inbounds [5 x double], [5 x double]* %1341, i64 0, i64 4
store double %1331, double* %1342
%1343 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1344 = getelementptr inbounds [5 x double], [5 x double]* %1343, i64 0, i64 3
%1345 = load double, double* %1344
%1346 = fdiv double 1.000000e+00, %1345
store double %1346, double* %37
%1347 = load double, double* %37
%1348 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1349 = getelementptr inbounds [5 x double], [5 x double]* %1348, i64 0, i64 3
%1350 = load double, double* %1349
%1351 = fmul double %1347, %1350
store double %1351, double* %36
%1352 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1353 = getelementptr inbounds [5 x double], [5 x double]* %1352, i64 0, i64 4
%1354 = load double, double* %1353
%1355 = load double, double* %36
%1356 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1357 = getelementptr inbounds [5 x double], [5 x double]* %1356, i64 0, i64 4
%1358 = load double, double* %1357
%1359 = fneg double %1355
%1360 = call double @llvm.fmuladd.f64(double %1359, double %1358, double %1354)
%1361 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1362 = getelementptr inbounds [5 x double], [5 x double]* %1361, i64 0, i64 4
store double %1360, double* %1362
%1363 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1364 = load i32, i32* %33
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1363, i64 %1365
%1367 = load i32, i32* %34
%1368 = sext i32 %1367 to i64
%1369 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1366, i64 0, i64 %1368
%1370 = load i32, i32* %20
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1369, i64 0, i64 %1371
%1373 = getelementptr inbounds [5 x double], [5 x double]* %1372, i64 0, i64 4
%1374 = load double, double* %1373
%1375 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1376 = load i32, i32* %33
%1377 = sext i32 %1376 to i64
%1378 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1375, i64 %1377
%1379 = load i32, i32* %34
%1380 = sext i32 %1379 to i64
%1381 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1378, i64 0, i64 %1380
%1382 = load i32, i32* %20
%1383 = sext i32 %1382 to i64
%1384 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1381, i64 0, i64 %1383
%1385 = getelementptr inbounds [5 x double], [5 x double]* %1384, i64 0, i64 3
%1386 = load double, double* %1385
%1387 = load double, double* %36
%1388 = fneg double %1386
%1389 = call double @llvm.fmuladd.f64(double %1388, double %1387, double %1374)
%1390 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1391 = load i32, i32* %33
%1392 = sext i32 %1391 to i64
%1393 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1390, i64 %1392
%1394 = load i32, i32* %34
%1395 = sext i32 %1394 to i64
%1396 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1393, i64 0, i64 %1395
%1397 = load i32, i32* %20
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1396, i64 0, i64 %1398
%1400 = getelementptr inbounds [5 x double], [5 x double]* %1399, i64 0, i64 4
store double %1389, double* %1400
%1401 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1402 = load i32, i32* %33
%1403 = sext i32 %1402 to i64
%1404 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1401, i64 %1403
%1405 = load i32, i32* %34
%1406 = sext i32 %1405 to i64
%1407 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1404, i64 0, i64 %1406
%1408 = load i32, i32* %20
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1407, i64 0, i64 %1409
%1411 = getelementptr inbounds [5 x double], [5 x double]* %1410, i64 0, i64 4
%1412 = load double, double* %1411
%1413 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 4
%1414 = getelementptr inbounds [5 x double], [5 x double]* %1413, i64 0, i64 4
%1415 = load double, double* %1414
%1416 = fdiv double %1412, %1415
%1417 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1418 = load i32, i32* %33
%1419 = sext i32 %1418 to i64
%1420 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1417, i64 %1419
%1421 = load i32, i32* %34
%1422 = sext i32 %1421 to i64
%1423 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1420, i64 0, i64 %1422
%1424 = load i32, i32* %20
%1425 = sext i32 %1424 to i64
%1426 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1423, i64 0, i64 %1425
%1427 = getelementptr inbounds [5 x double], [5 x double]* %1426, i64 0, i64 4
store double %1416, double* %1427
%1428 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1429 = load i32, i32* %33
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1428, i64 %1430
%1432 = load i32, i32* %34
%1433 = sext i32 %1432 to i64
%1434 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1431, i64 0, i64 %1433
%1435 = load i32, i32* %20
%1436 = sext i32 %1435 to i64
%1437 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1434, i64 0, i64 %1436
%1438 = getelementptr inbounds [5 x double], [5 x double]* %1437, i64 0, i64 3
%1439 = load double, double* %1438
%1440 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1441 = getelementptr inbounds [5 x double], [5 x double]* %1440, i64 0, i64 4
%1442 = load double, double* %1441
%1443 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1444 = load i32, i32* %33
%1445 = sext i32 %1444 to i64
%1446 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1443, i64 %1445
%1447 = load i32, i32* %34
%1448 = sext i32 %1447 to i64
%1449 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1446, i64 0, i64 %1448
%1450 = load i32, i32* %20
%1451 = sext i32 %1450 to i64
%1452 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1449, i64 0, i64 %1451
%1453 = getelementptr inbounds [5 x double], [5 x double]* %1452, i64 0, i64 4
%1454 = load double, double* %1453
%1455 = fneg double %1442
%1456 = call double @llvm.fmuladd.f64(double %1455, double %1454, double %1439)
%1457 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1458 = load i32, i32* %33
%1459 = sext i32 %1458 to i64
%1460 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1457, i64 %1459
%1461 = load i32, i32* %34
%1462 = sext i32 %1461 to i64
%1463 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1460, i64 0, i64 %1462
%1464 = load i32, i32* %20
%1465 = sext i32 %1464 to i64
%1466 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1463, i64 0, i64 %1465
%1467 = getelementptr inbounds [5 x double], [5 x double]* %1466, i64 0, i64 3
store double %1456, double* %1467
%1468 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1469 = load i32, i32* %33
%1470 = sext i32 %1469 to i64
%1471 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1468, i64 %1470
%1472 = load i32, i32* %34
%1473 = sext i32 %1472 to i64
%1474 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1471, i64 0, i64 %1473
%1475 = load i32, i32* %20
%1476 = sext i32 %1475 to i64
%1477 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1474, i64 0, i64 %1476
%1478 = getelementptr inbounds [5 x double], [5 x double]* %1477, i64 0, i64 3
%1479 = load double, double* %1478
%1480 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 3
%1481 = getelementptr inbounds [5 x double], [5 x double]* %1480, i64 0, i64 3
%1482 = load double, double* %1481
%1483 = fdiv double %1479, %1482
%1484 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1485 = load i32, i32* %33
%1486 = sext i32 %1485 to i64
%1487 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1484, i64 %1486
%1488 = load i32, i32* %34
%1489 = sext i32 %1488 to i64
%1490 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1487, i64 0, i64 %1489
%1491 = load i32, i32* %20
%1492 = sext i32 %1491 to i64
%1493 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1490, i64 0, i64 %1492
%1494 = getelementptr inbounds [5 x double], [5 x double]* %1493, i64 0, i64 3
store double %1483, double* %1494
%1495 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1496 = load i32, i32* %33
%1497 = sext i32 %1496 to i64
%1498 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1495, i64 %1497
%1499 = load i32, i32* %34
%1500 = sext i32 %1499 to i64
%1501 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1498, i64 0, i64 %1500
%1502 = load i32, i32* %20
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1501, i64 0, i64 %1503
%1505 = getelementptr inbounds [5 x double], [5 x double]* %1504, i64 0, i64 2
%1506 = load double, double* %1505
%1507 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1508 = getelementptr inbounds [5 x double], [5 x double]* %1507, i64 0, i64 3
%1509 = load double, double* %1508
%1510 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1511 = load i32, i32* %33
%1512 = sext i32 %1511 to i64
%1513 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1510, i64 %1512
%1514 = load i32, i32* %34
%1515 = sext i32 %1514 to i64
%1516 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1513, i64 0, i64 %1515
%1517 = load i32, i32* %20
%1518 = sext i32 %1517 to i64
%1519 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1516, i64 0, i64 %1518
%1520 = getelementptr inbounds [5 x double], [5 x double]* %1519, i64 0, i64 3
%1521 = load double, double* %1520
%1522 = fneg double %1509
%1523 = call double @llvm.fmuladd.f64(double %1522, double %1521, double %1506)
%1524 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1525 = getelementptr inbounds [5 x double], [5 x double]* %1524, i64 0, i64 4
%1526 = load double, double* %1525
%1527 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1528 = load i32, i32* %33
%1529 = sext i32 %1528 to i64
%1530 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1527, i64 %1529
%1531 = load i32, i32* %34
%1532 = sext i32 %1531 to i64
%1533 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1530, i64 0, i64 %1532
%1534 = load i32, i32* %20
%1535 = sext i32 %1534 to i64
%1536 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1533, i64 0, i64 %1535
%1537 = getelementptr inbounds [5 x double], [5 x double]* %1536, i64 0, i64 4
%1538 = load double, double* %1537
%1539 = fneg double %1526
%1540 = call double @llvm.fmuladd.f64(double %1539, double %1538, double %1523)
%1541 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1542 = load i32, i32* %33
%1543 = sext i32 %1542 to i64
%1544 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1541, i64 %1543
%1545 = load i32, i32* %34
%1546 = sext i32 %1545 to i64
%1547 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1544, i64 0, i64 %1546
%1548 = load i32, i32* %20
%1549 = sext i32 %1548 to i64
%1550 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1547, i64 0, i64 %1549
%1551 = getelementptr inbounds [5 x double], [5 x double]* %1550, i64 0, i64 2
store double %1540, double* %1551
%1552 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1553 = load i32, i32* %33
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1552, i64 %1554
%1556 = load i32, i32* %34
%1557 = sext i32 %1556 to i64
%1558 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1555, i64 0, i64 %1557
%1559 = load i32, i32* %20
%1560 = sext i32 %1559 to i64
%1561 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1558, i64 0, i64 %1560
%1562 = getelementptr inbounds [5 x double], [5 x double]* %1561, i64 0, i64 2
%1563 = load double, double* %1562
%1564 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 2
%1565 = getelementptr inbounds [5 x double], [5 x double]* %1564, i64 0, i64 2
%1566 = load double, double* %1565
%1567 = fdiv double %1563, %1566
%1568 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1569 = load i32, i32* %33
%1570 = sext i32 %1569 to i64
%1571 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1568, i64 %1570
%1572 = load i32, i32* %34
%1573 = sext i32 %1572 to i64
%1574 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1571, i64 0, i64 %1573
%1575 = load i32, i32* %20
%1576 = sext i32 %1575 to i64
%1577 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1574, i64 0, i64 %1576
%1578 = getelementptr inbounds [5 x double], [5 x double]* %1577, i64 0, i64 2
store double %1567, double* %1578
%1579 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1580 = load i32, i32* %33
%1581 = sext i32 %1580 to i64
%1582 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1579, i64 %1581
%1583 = load i32, i32* %34
%1584 = sext i32 %1583 to i64
%1585 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1582, i64 0, i64 %1584
%1586 = load i32, i32* %20
%1587 = sext i32 %1586 to i64
%1588 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1585, i64 0, i64 %1587
%1589 = getelementptr inbounds [5 x double], [5 x double]* %1588, i64 0, i64 1
%1590 = load double, double* %1589
%1591 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1592 = getelementptr inbounds [5 x double], [5 x double]* %1591, i64 0, i64 2
%1593 = load double, double* %1592
%1594 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1595 = load i32, i32* %33
%1596 = sext i32 %1595 to i64
%1597 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1594, i64 %1596
%1598 = load i32, i32* %34
%1599 = sext i32 %1598 to i64
%1600 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1597, i64 0, i64 %1599
%1601 = load i32, i32* %20
%1602 = sext i32 %1601 to i64
%1603 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1600, i64 0, i64 %1602
%1604 = getelementptr inbounds [5 x double], [5 x double]* %1603, i64 0, i64 2
%1605 = load double, double* %1604
%1606 = fneg double %1593
%1607 = call double @llvm.fmuladd.f64(double %1606, double %1605, double %1590)
%1608 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1609 = getelementptr inbounds [5 x double], [5 x double]* %1608, i64 0, i64 3
%1610 = load double, double* %1609
%1611 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1612 = load i32, i32* %33
%1613 = sext i32 %1612 to i64
%1614 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1611, i64 %1613
%1615 = load i32, i32* %34
%1616 = sext i32 %1615 to i64
%1617 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1614, i64 0, i64 %1616
%1618 = load i32, i32* %20
%1619 = sext i32 %1618 to i64
%1620 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1617, i64 0, i64 %1619
%1621 = getelementptr inbounds [5 x double], [5 x double]* %1620, i64 0, i64 3
%1622 = load double, double* %1621
%1623 = fneg double %1610
%1624 = call double @llvm.fmuladd.f64(double %1623, double %1622, double %1607)
%1625 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1626 = getelementptr inbounds [5 x double], [5 x double]* %1625, i64 0, i64 4
%1627 = load double, double* %1626
%1628 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1629 = load i32, i32* %33
%1630 = sext i32 %1629 to i64
%1631 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1628, i64 %1630
%1632 = load i32, i32* %34
%1633 = sext i32 %1632 to i64
%1634 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1631, i64 0, i64 %1633
%1635 = load i32, i32* %20
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1634, i64 0, i64 %1636
%1638 = getelementptr inbounds [5 x double], [5 x double]* %1637, i64 0, i64 4
%1639 = load double, double* %1638
%1640 = fneg double %1627
%1641 = call double @llvm.fmuladd.f64(double %1640, double %1639, double %1624)
%1642 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1643 = load i32, i32* %33
%1644 = sext i32 %1643 to i64
%1645 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1642, i64 %1644
%1646 = load i32, i32* %34
%1647 = sext i32 %1646 to i64
%1648 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1645, i64 0, i64 %1647
%1649 = load i32, i32* %20
%1650 = sext i32 %1649 to i64
%1651 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1648, i64 0, i64 %1650
%1652 = getelementptr inbounds [5 x double], [5 x double]* %1651, i64 0, i64 1
store double %1641, double* %1652
%1653 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1654 = load i32, i32* %33
%1655 = sext i32 %1654 to i64
%1656 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1653, i64 %1655
%1657 = load i32, i32* %34
%1658 = sext i32 %1657 to i64
%1659 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1656, i64 0, i64 %1658
%1660 = load i32, i32* %20
%1661 = sext i32 %1660 to i64
%1662 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1659, i64 0, i64 %1661
%1663 = getelementptr inbounds [5 x double], [5 x double]* %1662, i64 0, i64 1
%1664 = load double, double* %1663
%1665 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 1
%1666 = getelementptr inbounds [5 x double], [5 x double]* %1665, i64 0, i64 1
%1667 = load double, double* %1666
%1668 = fdiv double %1664, %1667
%1669 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1670 = load i32, i32* %33
%1671 = sext i32 %1670 to i64
%1672 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1669, i64 %1671
%1673 = load i32, i32* %34
%1674 = sext i32 %1673 to i64
%1675 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1672, i64 0, i64 %1674
%1676 = load i32, i32* %20
%1677 = sext i32 %1676 to i64
%1678 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1675, i64 0, i64 %1677
%1679 = getelementptr inbounds [5 x double], [5 x double]* %1678, i64 0, i64 1
store double %1668, double* %1679
%1680 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1681 = load i32, i32* %33
%1682 = sext i32 %1681 to i64
%1683 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1680, i64 %1682
%1684 = load i32, i32* %34
%1685 = sext i32 %1684 to i64
%1686 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1683, i64 0, i64 %1685
%1687 = load i32, i32* %20
%1688 = sext i32 %1687 to i64
%1689 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1686, i64 0, i64 %1688
%1690 = getelementptr inbounds [5 x double], [5 x double]* %1689, i64 0, i64 0
%1691 = load double, double* %1690
%1692 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%1693 = getelementptr inbounds [5 x double], [5 x double]* %1692, i64 0, i64 1
%1694 = load double, double* %1693
%1695 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1696 = load i32, i32* %33
%1697 = sext i32 %1696 to i64
%1698 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1695, i64 %1697
%1699 = load i32, i32* %34
%1700 = sext i32 %1699 to i64
%1701 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1698, i64 0, i64 %1700
%1702 = load i32, i32* %20
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1701, i64 0, i64 %1703
%1705 = getelementptr inbounds [5 x double], [5 x double]* %1704, i64 0, i64 1
%1706 = load double, double* %1705
%1707 = fneg double %1694
%1708 = call double @llvm.fmuladd.f64(double %1707, double %1706, double %1691)
%1709 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%1710 = getelementptr inbounds [5 x double], [5 x double]* %1709, i64 0, i64 2
%1711 = load double, double* %1710
%1712 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1713 = load i32, i32* %33
%1714 = sext i32 %1713 to i64
%1715 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1712, i64 %1714
%1716 = load i32, i32* %34
%1717 = sext i32 %1716 to i64
%1718 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1715, i64 0, i64 %1717
%1719 = load i32, i32* %20
%1720 = sext i32 %1719 to i64
%1721 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1718, i64 0, i64 %1720
%1722 = getelementptr inbounds [5 x double], [5 x double]* %1721, i64 0, i64 2
%1723 = load double, double* %1722
%1724 = fneg double %1711
%1725 = call double @llvm.fmuladd.f64(double %1724, double %1723, double %1708)
%1726 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%1727 = getelementptr inbounds [5 x double], [5 x double]* %1726, i64 0, i64 3
%1728 = load double, double* %1727
%1729 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1730 = load i32, i32* %33
%1731 = sext i32 %1730 to i64
%1732 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1729, i64 %1731
%1733 = load i32, i32* %34
%1734 = sext i32 %1733 to i64
%1735 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1732, i64 0, i64 %1734
%1736 = load i32, i32* %20
%1737 = sext i32 %1736 to i64
%1738 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1735, i64 0, i64 %1737
%1739 = getelementptr inbounds [5 x double], [5 x double]* %1738, i64 0, i64 3
%1740 = load double, double* %1739
%1741 = fneg double %1728
%1742 = call double @llvm.fmuladd.f64(double %1741, double %1740, double %1725)
%1743 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%1744 = getelementptr inbounds [5 x double], [5 x double]* %1743, i64 0, i64 4
%1745 = load double, double* %1744
%1746 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1747 = load i32, i32* %33
%1748 = sext i32 %1747 to i64
%1749 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1746, i64 %1748
%1750 = load i32, i32* %34
%1751 = sext i32 %1750 to i64
%1752 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1749, i64 0, i64 %1751
%1753 = load i32, i32* %20
%1754 = sext i32 %1753 to i64
%1755 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1752, i64 0, i64 %1754
%1756 = getelementptr inbounds [5 x double], [5 x double]* %1755, i64 0, i64 4
%1757 = load double, double* %1756
%1758 = fneg double %1745
%1759 = call double @llvm.fmuladd.f64(double %1758, double %1757, double %1742)
%1760 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1761 = load i32, i32* %33
%1762 = sext i32 %1761 to i64
%1763 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1760, i64 %1762
%1764 = load i32, i32* %34
%1765 = sext i32 %1764 to i64
%1766 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1763, i64 0, i64 %1765
%1767 = load i32, i32* %20
%1768 = sext i32 %1767 to i64
%1769 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1766, i64 0, i64 %1768
%1770 = getelementptr inbounds [5 x double], [5 x double]* %1769, i64 0, i64 0
store double %1759, double* %1770
%1771 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1772 = load i32, i32* %33
%1773 = sext i32 %1772 to i64
%1774 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1771, i64 %1773
%1775 = load i32, i32* %34
%1776 = sext i32 %1775 to i64
%1777 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1774, i64 0, i64 %1776
%1778 = load i32, i32* %20
%1779 = sext i32 %1778 to i64
%1780 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1777, i64 0, i64 %1779
%1781 = getelementptr inbounds [5 x double], [5 x double]* %1780, i64 0, i64 0
%1782 = load double, double* %1781
%1783 = getelementptr inbounds [5 x [5 x double]], [5 x [5 x double]]* %38, i64 0, i64 0
%1784 = getelementptr inbounds [5 x double], [5 x double]* %1783, i64 0, i64 0
%1785 = load double, double* %1784
%1786 = fdiv double %1782, %1785
%1787 = load [65 x [65 x [5 x double]]]*, [65 x [65 x [5 x double]]]** %22
%1788 = load i32, i32* %33
%1789 = sext i32 %1788 to i64
%1790 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1787, i64 %1789
%1791 = load i32, i32* %34
%1792 = sext i32 %1791 to i64
%1793 = getelementptr inbounds [65 x [65 x [5 x double]]], [65 x [65 x [5 x double]]]* %1790, i64 0, i64 %1792
%1794 = load i32, i32* %20
%1795 = sext i32 %1794 to i64
%1796 = getelementptr inbounds [65 x [5 x double]], [65 x [5 x double]]* %1793, i64 0, i64 %1795
%1797 = getelementptr inbounds [5 x double], [5 x double]* %1796, i64 0, i64 0
store double %1786, double* %1797
br label %1798
1798: ; preds = %624
%1799 = load i32, i32* %34
%1800 = add nsw i32 %1799, 1
store i32 %1800, i32* %34
br label %234
1801: ; preds = %234
br label %1802
1802: ; preds = %1801
%1803 = load i32, i32* %33
%1804 = add nsw i32 %1803, 1
store i32 %1804, i32* %33
br label %228
1805: ; preds = %228
ret void
}

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