void buts(int nx, int ny, int nz, int k, double omega,
          double v[64][64 / 2 * 2 + 1][64 / 2 * 2 + 1][5], double tv[64][64][5],
          double d[64][64][5][5], double udx[64][64][5][5],
          double udy[64][64][5][5], double udz[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 = iend; i >= ist; i--) {
    for (j = jend; j >= jst; j--) {
      for (m = 0; m < 5; m++) {
        tv[i][j][m] = omega * (udz[i][j][m][0] * v[i][j][k + 1][0] +
                               udz[i][j][m][1] * v[i][j][k + 1][1] +
                               udz[i][j][m][2] * v[i][j][k + 1][2] +
                               udz[i][j][m][3] * v[i][j][k + 1][3] +
                               udz[i][j][m][4] * v[i][j][k + 1][4]);
      }
    }
  }
#pragma omp for nowait schedule(static)
  for (i = iend; i >= ist; i--) {
    for (j = jend; j >= jst; j--) {
      for (m = 0; m < 5; m++) {
        tv[i][j][m] =
            tv[i][j][m] + omega * (udy[i][j][m][0] * v[i][j + 1][k][0] +
                                   udx[i][j][m][0] * v[i + 1][j][k][0] +
                                   udy[i][j][m][1] * v[i][j + 1][k][1] +
                                   udx[i][j][m][1] * v[i + 1][j][k][1] +
                                   udy[i][j][m][2] * v[i][j + 1][k][2] +
                                   udx[i][j][m][2] * v[i + 1][j][k][2] +
                                   udy[i][j][m][3] * v[i][j + 1][k][3] +
                                   udx[i][j][m][3] * v[i + 1][j][k][3] +
                                   udy[i][j][m][4] * v[i][j + 1][k][4] +
                                   udx[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];
      tv[i][j][1] = tv[i][j][1] - tv[i][j][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];
      tv[i][j][2] = tv[i][j][2] - tv[i][j][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];
      tv[i][j][3] = tv[i][j][3] - tv[i][j][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];
      tv[i][j][4] = tv[i][j][4] - tv[i][j][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];
      tv[i][j][2] = tv[i][j][2] - tv[i][j][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];
      tv[i][j][3] = tv[i][j][3] - tv[i][j][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];
      tv[i][j][4] = tv[i][j][4] - tv[i][j][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];
      tv[i][j][3] = tv[i][j][3] - tv[i][j][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];
      tv[i][j][4] = tv[i][j][4] - tv[i][j][2] * tmp;
      tmp1 = 1.0 / tmat[3][3];
      tmp = tmp1 * tmat[4][3];
      tmat[4][4] = tmat[4][4] - tmp * tmat[3][4];
      tv[i][j][4] = tv[i][j][4] - tv[i][j][3] * tmp;
      tv[i][j][4] = tv[i][j][4] / tmat[4][4];
      tv[i][j][3] = tv[i][j][3] - tmat[3][4] * tv[i][j][4];
      tv[i][j][3] = tv[i][j][3] / tmat[3][3];
      tv[i][j][2] =
          tv[i][j][2] - tmat[2][3] * tv[i][j][3] - tmat[2][4] * tv[i][j][4];
      tv[i][j][2] = tv[i][j][2] / tmat[2][2];
      tv[i][j][1] = tv[i][j][1] - tmat[1][2] * tv[i][j][2] -
                    tmat[1][3] * tv[i][j][3] - tmat[1][4] * tv[i][j][4];
      tv[i][j][1] = tv[i][j][1] / tmat[1][1];
      tv[i][j][0] = tv[i][j][0] - tmat[0][1] * tv[i][j][1] -
                    tmat[0][2] * tv[i][j][2] - tmat[0][3] * tv[i][j][3] -
                    tmat[0][4] * tv[i][j][4];
      tv[i][j][0] = tv[i][j][0] / tmat[0][0];
      v[i][j][k][0] = v[i][j][k][0] - tv[i][j][0];
      v[i][j][k][1] = v[i][j][k][1] - tv[i][j][1];
      v[i][j][k][2] = v[i][j][k][2] - tv[i][j][2];
      v[i][j][k][3] = v[i][j][k][3] - tv[i][j][3];
      v[i][j][k][4] = v[i][j][k][4] - tv[i][j][4];
    }
  }
}


x86 assembly (clang, -O0):
<buts>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
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    0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x30(%rbp),%eax
jl     13f5 <buts+0x2f5>
mov    0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x40(%rbp),%eax
jl     13e2 <buts+0x2e2>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    13cf <buts+0x2cf>
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),%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
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%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  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
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%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  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
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
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),%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
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%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  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
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    1171 <buts+0x71>
jmp    13d4 <buts+0x2d4>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    115e <buts+0x5e>
jmp    13e7 <buts+0x2e7>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    114c <buts+0x4c>
mov    0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x30(%rbp),%eax
jl     2f46 <buts+0x1e46>
mov    0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x40(%rbp),%eax
jl     2f33 <buts+0x1e33>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    18c7 <buts+0x7c7>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
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),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $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
add    $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    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),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $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
add    $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    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),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $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
add    $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    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),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $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
add    $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    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),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x29428,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $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
add    $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
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    1420 <buts+0x320>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    1a47 <buts+0x947>
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),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
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),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
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),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
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),%xmm0
movslq -0x34(%rbp),%rcx
lea    -0x110(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
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),%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    18ce <buts+0x7ce>
movsd  0x15b1(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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
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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0xf97(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0xbb3(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  0x991(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x18(%rax),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
divsd  -0xb0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x108(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%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
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
subsd  (%rax),%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  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
subsd  0x8(%rax),%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  0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
subsd  0x10(%rax),%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  0x18(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
subsd  0x18(%rax),%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  0x20(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa00,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
subsd  0x20(%rax),%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    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    140d <buts+0x30d>
jmp    2f38 <buts+0x1e38>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    13fb <buts+0x2fb>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<buts>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,-0x60(%rsp)
mov    %r8,-0x38(%rsp)
movapd %xmm0,(%rsp)
mov    0xb8(%rsp),%eax
cmp    0xb0(%rsp),%eax
jl     17fd <buts+0x6fd>
mov    0xc8(%rsp),%ebx
movslq %ecx,%rdi
movslq %ebx,%rbp
movslq 0xc0(%rsp),%r12
movslq %eax,%r8
lea    0x1(%rbp),%rax
mov    %rax,-0x40(%rsp)
sub    %r12,%rax
mov    %rax,-0x70(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rbp,%rcx
mov    %rax,-0x68(%rsp)
sub    %rax,%rcx
mov    %rcx,-0x30(%rsp)
movapd (%rsp),%xmm8
unpcklpd %xmm8,%xmm8
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
imul   $0x29428,%r8,%rcx
add    -0x38(%rsp),%rcx
imul   $0xa28,%rbp,%rdx
mov    %rdx,-0x48(%rsp)
add    %rcx,%rdx
lea    0x8(,%rdi,8),%rsi
lea    (%rsi,%rsi,4),%rsi
lea    (%rdx,%rsi,1),%r14
add    $0x20,%r14
lea    (%rcx,%rsi,1),%r10
add    $0x10,%r10
lea    (%r8,%r8,4),%r11
shl    $0x9,%r11
add    -0x60(%rsp),%r11
lea    (%r11,%rax,8),%r9
add    $0xffffffffffffffd8,%r9
imul   $0x3200,%r8,%r13
add    0xa8(%rsp),%r13
mov    %rbp,-0x78(%rsp)
imul   $0xc8,%rbp,%r15
add    %r13,%r15
lea    0x1(%rdi),%rax
mov    %rax,-0x50(%rsp)
movslq 0xb0(%rsp),%rcx
mov    %rdi,-0x8(%rsp)
lea    0x2(%rdi),%rax
mov    %rax,-0x58(%rsp)
mov    %rcx,-0x10(%rsp)
jmp    125a <buts+0x15a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%r8),%rax
add    $0xfffffffffffff600,%r9
add    $0xfffffffffffd6bd8,%r14
add    $0xffffffffffffce00,%r15
add    $0xffffffffffffce00,%r13
add    $0xfffffffffffff600,%r11
add    $0xfffffffffffd6bd8,%r10
cmp    %rcx,%r8
mov    %rax,%r8
jle    17e8 <buts+0x6e8>
cmp    0xc0(%rsp),%ebx
jl     1220 <buts+0x120>
mov    -0x78(%rsp),%rbp
cmpq   $0x2,-0x70(%rsp)
jae    1460 <buts+0x360>
lea    0x1(%rbp),%rdx
imul   $0xc8,%rbp,%rsi
add    %r13,%rsi
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%r11,%rax,8),%rdi
imul   $0xa28,%rbp,%rbp
add    %r10,%rbp
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rsi),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  (%rsi),%xmm1
mulsd  -0x10(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%rsi),%xmm0
mulsd  0x0(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rsi),%xmm1
mulsd  0x8(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rsi),%xmm0
mulsd  0x10(%rbp),%xmm0
addsd  %xmm1,%xmm0
movapd (%rsp),%xmm3
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rdi)
movsd  0x28(%rsi),%xmm0
movsd  0x30(%rsi),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm0
movsd  0x38(%rsi),%xmm2
mulsd  0x0(%rbp),%xmm2
addsd  %xmm1,%xmm0
movsd  0x40(%rsi),%xmm1
mulsd  0x8(%rbp),%xmm1
addsd  %xmm0,%xmm2
movsd  0x48(%rsi),%xmm0
mulsd  0x10(%rbp),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%rdi)
movsd  0x50(%rsi),%xmm0
movsd  0x58(%rsi),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0x60(%rsi),%xmm1
mulsd  0x0(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x68(%rsi),%xmm0
mulsd  0x8(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0x70(%rsi),%xmm1
mulsd  0x10(%rbp),%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,0x10(%rdi)
movsd  0x80(%rsi),%xmm0
mulsd  -0x8(%rbp),%xmm0
movsd  0x78(%rsi),%xmm1
mulsd  -0x10(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x88(%rsi),%xmm0
mulsd  0x0(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0x90(%rsi),%xmm1
mulsd  0x8(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x98(%rsi),%xmm0
mulsd  0x10(%rbp),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x18(%rdi)
movsd  0xa0(%rsi),%xmm0
movsd  0xa8(%rsi),%xmm1
mulsd  -0x8(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0xb0(%rsi),%xmm1
mulsd  0x0(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  0xb8(%rsi),%xmm0
mulsd  0x8(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0xc0(%rsi),%xmm1
mulsd  0x10(%rbp),%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,0x20(%rdi)
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffff38,%rsi
add    $0xffffffffffffffd8,%rdi
add    $0xfffffffffffff5d8,%rbp
cmp    %r12,%rdx
jg     12a0 <buts+0x1a0>
jmp    1220 <buts+0x120>
nopl   0x0(%rax)
lea    (%r8,%r8,4),%rax
shl    $0x9,%rax
add    -0x60(%rsp),%rax
imul   $0x3200,%r8,%rdx
add    0xa8(%rsp),%rdx
imul   $0xc8,%r12,%rsi
add    %rdx,%rsi
mov    -0x40(%rsp),%rbx
imul   $0xc8,%rbx,%rdi
add    %rdx,%rdi
imul   $0x29428,%r8,%rdx
add    -0x38(%rsp),%rdx
imul   $0xa28,%r12,%rbp
add    %rdx,%rbp
add    -0x48(%rsp),%rdx
lea    (%r12,%r12,4),%rcx
lea    (%rax,%rcx,8),%rcx
lea    (%rbx,%rbx,4),%rbx
lea    (%rax,%rbx,8),%rax
mov    -0x58(%rsp),%rbx
lea    (%rbx,%rbx,4),%rbx
lea    (%rdx,%rbx,8),%rdx
cmp    %rdi,%rcx
setb   %dil
cmp    %rax,%rsi
setb   %bl
cmp    %rdx,%rcx
mov    -0x50(%rsp),%rcx
lea    (%rcx,%rcx,4),%rcx
lea    0x0(%rbp,%rcx,8),%rcx
setb   %dl
cmp    %rax,%rcx
mov    -0x10(%rsp),%rcx
setb   %al
mov    -0x78(%rsp),%rbp
test   %bl,%dil
mov    0xc8(%rsp),%ebx
jne    1274 <buts+0x174>
mov    -0x78(%rsp),%rbp
and    %al,%dl
jne    1274 <buts+0x174>
mov    %r15,%rdx
mov    %r14,%rsi
mov    %r9,%rdi
mov    -0x68(%rsp),%rbp
nopl   0x0(%rax)
movsd  (%rdx),%xmm2
movsd  0x8(%rdx),%xmm3
movsd  0x10(%rdx),%xmm1
movsd  0x18(%rdx),%xmm0
movhpd -0xc8(%rdx),%xmm2
ff
movsd  -0x20(%rsi),%xmm11
movsd  -0x18(%rsi),%xmm6
movsd  -0x10(%rsi),%xmm10
movsd  -0x8(%rsi),%xmm9
movhpd -0xa48(%rsi),%xmm11
ff ff
movhpd -0xc0(%rdx),%xmm3
ff
movhpd -0xa40(%rsi),%xmm6
ff
mulpd  %xmm6,%xmm3
mulpd  %xmm11,%xmm2
movhpd -0xb8(%rdx),%xmm1
ff
movhpd -0xa38(%rsi),%xmm10
ff ff
addpd  %xmm3,%xmm2
mulpd  %xmm10,%xmm1
movhpd -0xb0(%rdx),%xmm0
ff
addpd  %xmm2,%xmm1
movhpd -0xa30(%rsi),%xmm9
ff ff
mulpd  %xmm9,%xmm0
addpd  %xmm1,%xmm0
movsd  0x20(%rdx),%xmm3
movhpd -0xa8(%rdx),%xmm3
ff
movsd  (%rsi),%xmm1
movhpd -0xa28(%rsi),%xmm1
ff
mulpd  %xmm1,%xmm3
addpd  %xmm0,%xmm3
movsd  0x28(%rdx),%xmm0
movhpd -0xa0(%rdx),%xmm0
ff
mulpd  %xmm8,%xmm3
movsd  0x30(%rdx),%xmm2
movhpd -0x98(%rdx),%xmm2
ff
mulpd  %xmm6,%xmm2
mulpd  %xmm11,%xmm0
addpd  %xmm2,%xmm0
movsd  0x38(%rdx),%xmm2
movhpd -0x90(%rdx),%xmm2
ff
mulpd  %xmm10,%xmm2
addpd  %xmm0,%xmm2
movsd  0x40(%rdx),%xmm0
movhpd -0x88(%rdx),%xmm0
ff
mulpd  %xmm9,%xmm0
addpd  %xmm2,%xmm0
movsd  0x48(%rdx),%xmm7
movhpd -0x80(%rdx),%xmm7
mulpd  %xmm1,%xmm7
movsd  0x50(%rdx),%xmm2
movhpd -0x78(%rdx),%xmm2
addpd  %xmm0,%xmm7
movsd  0x58(%rdx),%xmm0
movhpd -0x70(%rdx),%xmm0
mulpd  %xmm8,%xmm7
mulpd  %xmm6,%xmm0
mulpd  %xmm11,%xmm2
addpd  %xmm0,%xmm2
movsd  0x60(%rdx),%xmm4
movhpd -0x68(%rdx),%xmm4
mulpd  %xmm10,%xmm4
addpd  %xmm2,%xmm4
movsd  0x68(%rdx),%xmm2
movhpd -0x60(%rdx),%xmm2
mulpd  %xmm9,%xmm2
movsd  0x70(%rdx),%xmm0
movhpd -0x58(%rdx),%xmm0
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm8,%xmm0
movsd  0x78(%rdx),%xmm2
movhpd -0x50(%rdx),%xmm2
movsd  0x80(%rdx),%xmm4
movhpd -0x48(%rdx),%xmm4
mulpd  %xmm6,%xmm4
mulpd  %xmm11,%xmm2
addpd  %xmm4,%xmm2
movsd  0x88(%rdx),%xmm4
movhpd -0x40(%rdx),%xmm4
mulpd  %xmm10,%xmm4
movsd  0x90(%rdx),%xmm5
movhpd -0x38(%rdx),%xmm5
addpd  %xmm2,%xmm4
mulpd  %xmm9,%xmm5
addpd  %xmm4,%xmm5
movsd  0x98(%rdx),%xmm2
movhpd -0x30(%rdx),%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm8,%xmm2
movsd  0xa0(%rdx),%xmm4
movhpd -0x28(%rdx),%xmm4
movsd  0xa8(%rdx),%xmm5
movhpd -0x20(%rdx),%xmm5
mulpd  %xmm6,%xmm5
mulpd  %xmm11,%xmm4
movsd  0xb0(%rdx),%xmm6
movhpd -0x18(%rdx),%xmm6
addpd  %xmm5,%xmm4
mulpd  %xmm10,%xmm6
addpd  %xmm4,%xmm6
movsd  0xb8(%rdx),%xmm4
movhpd -0x10(%rdx),%xmm4
mulpd  %xmm9,%xmm4
addpd  %xmm6,%xmm4
movsd  0xc0(%rdx),%xmm5
movhpd -0x8(%rdx),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm8,%xmm5
movapd %xmm5,%xmm1
shufpd $0x1,%xmm3,%xmm1
unpckhpd %xmm7,%xmm3
unpcklpd %xmm0,%xmm7
unpckhpd %xmm2,%xmm0
unpcklpd %xmm5,%xmm2
movupd %xmm2,0x40(%rdi)
movupd %xmm7,0x30(%rdi)
movupd %xmm1,0x20(%rdi)
movupd %xmm0,0x10(%rdi)
movupd %xmm3,(%rdi)
add    $0xffffffffffffffb0,%rdi
add    $0xffffffffffffebb0,%rsi
add    $0xfffffffffffffe70,%rdx
add    $0xfffffffffffffffe,%rbp
jne    1530 <buts+0x430>
mov    -0x30(%rsp),%rbp
mov    -0x68(%rsp),%rax
cmp    %rax,-0x70(%rsp)
je     1220 <buts+0x120>
jmp    1274 <buts+0x174>
mov    0xb8(%rsp),%eax
cmp    0xb0(%rsp),%eax
mov    -0x8(%rsp),%rdi
jge    180c <buts+0x70c>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %ebx,%rsi
movslq %eax,%r13
lea    0x0(,%r13,4),%rax
add    %r13,%rax
shl    $0x9,%rax
add    -0x60(%rsp),%rax
lea    (%rsi,%rsi,4),%rcx
lea    (%rax,%rcx,8),%rax
mov    %rax,-0x28(%rsp)
imul   $0x3200,%r13,%rax
mov    0xa0(%rsp),%rdx
add    %rax,%rdx
mov    %rsi,0x10(%rsp)
imul   $0xc8,%rsi,%rcx
add    %rcx,%rdx
mov    %rdx,-0x18(%rsp)
mov    0x98(%rsp),%rdx
add    %rax,%rdx
add    %rcx,%rdx
mov    %rdx,-0x20(%rsp)
jmp    18a4 <buts+0x7a4>
xchg   %ax,%ax
lea    -0x1(%r13),%rax
addq   $0xfffffffffffff600,-0x28(%rsp)
ff ff
addq   $0xffffffffffffce00,-0x18(%rsp)
ff ff
addq   $0xffffffffffffce00,-0x20(%rsp)
ff ff
cmp    -0x10(%rsp),%r13
mov    %rax,%r13
mov    0xc8(%rsp),%ebx
jle    17fd <buts+0x6fd>
cmp    0xc0(%rsp),%ebx
jl     1870 <buts+0x770>
lea    0x1(%r13),%r8
mov    -0x20(%rsp),%rdx
mov    -0x18(%rsp),%rax
mov    -0x28(%rsp),%r15
mov    0x10(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
imul   $0x29428,%r13,%r14
mov    -0x38(%rsp),%rbx
add    %rbx,%r14
imul   $0xa28,%r9,%rcx
add    %rcx,%r14
lea    0x0(,%rdi,8),%rsi
lea    (%rsi,%rsi,4),%rdi
lea    (%r14,%rdi,1),%rsi
add    $0xa28,%rsi
imul   $0x29428,%r8,%rbp
add    %rbx,%rbp
add    %rcx,%rbp
lea    (%rdi,%rbp,1),%rbx
add    %rdi,%rbp
add    $0x8,%rbp
mov    $0x4,%ecx
mov    %r15,%rdi
movsd  -0x20(%rdx,%rcx,8),%xmm0
mulsd  (%rbx),%xmm0
movsd  -0x20(%rax,%rcx,8),%xmm1
mulsd  (%rsi),%xmm1
movsd  -0x18(%rax,%rcx,8),%xmm2
mulsd  0x8(%rsi),%xmm2
movsd  -0x18(%rdx,%rcx,8),%xmm3
addsd  %xmm0,%xmm1
mulsd  0x0(%rbp),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x10(%rax,%rcx,8),%xmm0
mulsd  0x10(%rsi),%xmm0
addsd  %xmm2,%xmm3
movsd  -0x10(%rdx,%rcx,8),%xmm1
mulsd  0x8(%rbp),%xmm1
addsd  %xmm3,%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm2
mulsd  0x18(%rsi),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  0x10(%rbp),%xmm0
addsd  %xmm1,%xmm2
movsd  (%rax,%rcx,8),%xmm1
mulsd  0x20(%rsi),%xmm1
addsd  %xmm2,%xmm0
movsd  (%rdx,%rcx,8),%xmm2
mulsd  0x18(%rbp),%xmm2
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
mulsd  (%rsp),%xmm2
addsd  (%rdi),%xmm2
movsd  %xmm2,(%rdi)
add    $0x8,%rdi
add    $0x5,%rcx
cmp    $0x1d,%rcx
jne    1920 <buts+0x820>
imul   $0x3200,%r13,%r10
add    0x90(%rsp),%r10
imul   $0xc8,%r9,%r11
movsd  (%r11,%r10,1),%xmm2
movsd  %xmm2,-0x30(%rsp)
movsd  0x8(%r11,%r10,1),%xmm4
movsd  0x10(%r11,%r10,1),%xmm10
movsd  0x18(%r11,%r10,1),%xmm9
movsd  0x20(%r11,%r10,1),%xmm14
movsd  0x30(%r11,%r10,1),%xmm3
movsd  0x38(%r11,%r10,1),%xmm6
movsd  0x40(%r11,%r10,1),%xmm5
movsd  0x48(%r11,%r10,1),%xmm7
movsd  0x58(%r11,%r10,1),%xmm8
movsd  0x60(%r11,%r10,1),%xmm13
movsd  0x5c3(%rip),%xmm1
divsd  %xmm2,%xmm1
movsd  0x28(%r11,%r10,1),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm4,%xmm11
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x40(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm10,%xmm2
subsd  %xmm2,%xmm6
movsd  %xmm6,-0x68(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm9,%xmm2
subsd  %xmm2,%xmm5
movsd  %xmm5,-0x58(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm14,%xmm2
movapd %xmm14,%xmm4
subsd  %xmm2,%xmm7
movsd  %xmm7,-0x50(%rsp)
lea    0x0(,%r13,4),%rsi
add    %r13,%rsi
shl    $0x9,%rsi
add    -0x60(%rsp),%rsi
lea    (%r9,%r9,4),%rbx
movsd  (%rsi,%rbx,8),%xmm2
movsd  0x8(%rsi,%rbx,8),%xmm12
mulsd  %xmm2,%xmm0
movapd %xmm2,%xmm15
subsd  %xmm0,%xmm12
movsd  0x50(%r11,%r10,1),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
movsd  %xmm11,-0x48(%rsp)
mulsd  %xmm11,%xmm2
subsd  %xmm2,%xmm8
movapd %xmm0,%xmm2
mulsd  %xmm10,%xmm2
movapd %xmm13,%xmm3
subsd  %xmm2,%xmm3
movapd %xmm0,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm9,%xmm14
movsd  0x68(%r11,%r10,1),%xmm5
subsd  %xmm2,%xmm5
movsd  %xmm5,-0x78(%rsp)
movapd %xmm15,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm4,%xmm0
movsd  0x70(%r11,%r10,1),%xmm5
subsd  %xmm0,%xmm5
movsd  %xmm5,0x30(%rsp)
movsd  0x10(%rsi,%rbx,8),%xmm6
subsd  %xmm2,%xmm6
movsd  0x78(%r11,%r10,1),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm11,%xmm2
movsd  0x80(%r11,%r10,1),%xmm9
subsd  %xmm2,%xmm9
movapd %xmm0,%xmm2
mulsd  %xmm10,%xmm2
movsd  %xmm10,0x48(%rsp)
movsd  0x88(%r11,%r10,1),%xmm13
subsd  %xmm2,%xmm13
movapd %xmm0,%xmm2
mulsd  %xmm14,%xmm2
movsd  %xmm14,0x50(%rsp)
movsd  0x90(%r11,%r10,1),%xmm5
subsd  %xmm2,%xmm5
movsd  %xmm5,0x28(%rsp)
movapd %xmm15,%xmm5
movsd  %xmm15,0x38(%rsp)
movapd %xmm15,%xmm11
mulsd  %xmm0,%xmm11
movsd  %xmm4,0x40(%rsp)
mulsd  %xmm4,%xmm0
movsd  0x98(%r11,%r10,1),%xmm15
subsd  %xmm0,%xmm15
mulsd  0xa0(%r11,%r10,1),%xmm1
movsd  0x18(%rsi,%rbx,8),%xmm2
subsd  %xmm11,%xmm2
movapd %xmm1,%xmm0
mulsd  -0x48(%rsp),%xmm0
movsd  0xa8(%r11,%r10,1),%xmm7
subsd  %xmm0,%xmm7
movsd  %xmm7,0x20(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm10,%xmm0
movsd  0xb0(%r11,%r10,1),%xmm7
subsd  %xmm0,%xmm7
movsd  %xmm7,-0x70(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm14,%xmm0
movsd  0xb8(%r11,%r10,1),%xmm11
subsd  %xmm0,%xmm11
movapd %xmm5,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm1
movsd  0xc0(%r11,%r10,1),%xmm14
subsd  %xmm1,%xmm14
movsd  0x20(%rsi,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x38a(%rip),%xmm0
divsd  -0x40(%rsp),%xmm0
mulsd  %xmm0,%xmm8
movapd %xmm8,%xmm10
movsd  -0x68(%rsp),%xmm7
mulsd  %xmm7,%xmm10
subsd  %xmm10,%xmm3
movsd  %xmm3,0x18(%rsp)
movapd %xmm8,%xmm3
movsd  -0x58(%rsp),%xmm4
mulsd  %xmm4,%xmm3
movsd  -0x78(%rsp),%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,-0x78(%rsp)
movapd %xmm12,%xmm3
mulsd  %xmm8,%xmm3
movsd  -0x50(%rsp),%xmm10
mulsd  %xmm10,%xmm8
movsd  0x30(%rsp),%xmm5
subsd  %xmm8,%xmm5
subsd  %xmm3,%xmm6
mulsd  %xmm0,%xmm9
movapd %xmm9,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm3,%xmm13
movapd %xmm9,%xmm3
mulsd  %xmm4,%xmm3
movsd  0x28(%rsp),%xmm8
subsd  %xmm3,%xmm8
movapd %xmm12,%xmm3
mulsd  %xmm9,%xmm3
mulsd  %xmm10,%xmm9
subsd  %xmm9,%xmm15
subsd  %xmm3,%xmm2
mulsd  0x20(%rsp),%xmm0
movapd %xmm0,%xmm3
mulsd  %xmm7,%xmm3
movsd  -0x70(%rsp),%xmm7
subsd  %xmm3,%xmm7
movsd  %xmm7,-0x70(%rsp)
movapd %xmm0,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm3,%xmm11
movapd %xmm12,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm10,%xmm0
subsd  %xmm0,%xmm14
subsd  %xmm3,%xmm1
movsd  0x295(%rip),%xmm10
movapd %xmm10,%xmm0
movsd  0x18(%rsp),%xmm9
divsd  %xmm9,%xmm0
mulsd  %xmm0,%xmm13
movapd %xmm13,%xmm3
movsd  -0x78(%rsp),%xmm4
mulsd  %xmm4,%xmm3
subsd  %xmm3,%xmm8
movapd %xmm6,%xmm3
mulsd  %xmm13,%xmm3
movapd %xmm5,%xmm7
mulsd  %xmm5,%xmm13
subsd  %xmm13,%xmm15
subsd  %xmm3,%xmm2
mulsd  -0x70(%rsp),%xmm0
movapd %xmm0,%xmm3
mulsd  %xmm4,%xmm3
movapd %xmm4,%xmm13
subsd  %xmm3,%xmm11
movapd %xmm6,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm14
subsd  %xmm3,%xmm1
divsd  %xmm8,%xmm10
mulsd  %xmm11,%xmm10
movapd %xmm2,%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm15,%xmm10
subsd  %xmm10,%xmm14
subsd  %xmm3,%xmm1
divsd  %xmm14,%xmm1
mulsd  %xmm1,%xmm15
subsd  %xmm15,%xmm2
divsd  %xmm8,%xmm2
movapd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm6
movapd %xmm5,%xmm0
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm6
divsd  %xmm9,%xmm6
movsd  -0x68(%rsp),%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm0,%xmm12
movsd  -0x58(%rsp),%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm12
movsd  -0x50(%rsp),%xmm0
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm12
divsd  -0x40(%rsp),%xmm12
movsd  %xmm1,0x20(%rsi,%rbx,8)
movsd  %xmm2,0x18(%rsi,%rbx,8)
movsd  %xmm6,0x10(%rsi,%rbx,8)
movsd  %xmm12,0x8(%rsi,%rbx,8)
mulsd  -0x48(%rsp),%xmm12
movsd  0x38(%rsp),%xmm0
subsd  %xmm12,%xmm0
mulsd  0x48(%rsp),%xmm6
subsd  %xmm6,%xmm0
mulsd  0x50(%rsp),%xmm2
subsd  %xmm2,%xmm0
mulsd  0x40(%rsp),%xmm1
subsd  %xmm1,%xmm0
divsd  -0x30(%rsp),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
movapd %xmm0,%xmm1
mov    -0x8(%rsp),%rdi
lea    (%rdi,%rdi,4),%rcx
movsd  (%r14,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm0,(%r14,%rcx,8)
subsd  0x8(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
subsd  0x10(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
subsd  0x18(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rcx,8)
movsd  0x20(%r14,%rcx,8),%xmm0
subsd  0x20(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x20(%r14,%rcx,8)
lea    -0x1(%r9),%rcx
add    $0xffffffffffffffd8,%r15
add    $0xffffffffffffff38,%rax
add    $0xffffffffffffff38,%rdx
cmp    %r12,%r9
mov    %rcx,%r9
jg     18d0 <buts+0x7d0>
jmp    1870 <buts+0x770>

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

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