void s_update_hessian_box_mhe(int N, int k0, int k1, int kmax, int cnz,
                              float sigma_mu, float **t, float **t_inv,
                              float **lam, float **lamt, float **dlam,
                              float **bd, float **bl, float **pd, float **pl,
                              float **pl2, float **db) {
  const int bs = 8;
  float temp0, temp1;
  float *ptr_t, *ptr_lam, *ptr_lamt, *ptr_dlam, *ptr_tinv, *ptr_pd, *ptr_pl,
      *ptr_pl2, *ptr_bd, *ptr_bl, *ptr_db;
  int ii, jj, ll, bs0;
  for (jj = 0; jj < N; jj++) {
    ptr_t = t[jj];
    ptr_lam = lam[jj];
    ptr_lamt = lamt[jj];
    ptr_dlam = dlam[jj];
    ptr_tinv = t_inv[jj];
    ptr_pd = pd[jj];
    ptr_pl = pl[jj];
    ptr_pl2 = pl2[jj];
    ptr_bd = bd[jj];
    ptr_bl = bl[jj];
    ptr_db = db[jj];
    ii = 0;
    for (; ii < kmax - 7; ii += 8) {
      ptr_tinv[0] = 1.0 / ptr_t[0];
      ptr_tinv[1] = 1.0 / ptr_t[1];
      ptr_lamt[0] = ptr_lam[0] * ptr_tinv[0];
      ptr_lamt[1] = ptr_lam[1] * ptr_tinv[1];
      ptr_dlam[0] = ptr_tinv[0] * sigma_mu;
      ptr_dlam[1] = ptr_tinv[1] * sigma_mu;
      ptr_pd[0 + (ii + 0) * bs + ii * cnz] =
          ptr_bd[ii + 0] + ptr_lamt[0] + ptr_lamt[1];
      ptr_pl[(ii + 0) * bs] = ptr_bl[ii + 0] + ptr_lam[1] +
                              ptr_lamt[1] * ptr_db[2 * ii + 1] + ptr_dlam[1] -
                              ptr_lam[0] - ptr_lamt[0] * ptr_db[2 * ii + 0] -
                              ptr_dlam[0];
      ptr_pl2[ii + 0] = ptr_pl[(ii + 0) * bs];
      ptr_tinv[2] = 1.0 / ptr_t[2];
      ptr_tinv[3] = 1.0 / ptr_t[3];
      ptr_lamt[2] = ptr_lam[2] * ptr_tinv[2];
      ptr_lamt[3] = ptr_lam[3] * ptr_tinv[3];
      ptr_dlam[2] = ptr_tinv[2] * sigma_mu;
      ptr_dlam[3] = ptr_tinv[3] * sigma_mu;
      ptr_pd[1 + (ii + 1) * bs + ii * cnz] =
          ptr_bd[ii + 1] + ptr_lamt[2] + ptr_lamt[3];
      ptr_pl[(ii + 1) * bs] = ptr_bl[ii + 1] + ptr_lam[3] +
                              ptr_lamt[3] * ptr_db[2 * ii + 3] + ptr_dlam[3] -
                              ptr_lam[2] - ptr_lamt[2] * ptr_db[2 * ii + 2] -
                              ptr_dlam[2];
      ptr_pl2[ii + 1] = ptr_pl[(ii + 1) * bs];
      ptr_tinv[4] = 1.0 / ptr_t[4];
      ptr_tinv[5] = 1.0 / ptr_t[5];
      ptr_lamt[4] = ptr_lam[4] * ptr_tinv[4];
      ptr_lamt[5] = ptr_lam[5] * ptr_tinv[5];
      ptr_dlam[4] = ptr_tinv[4] * sigma_mu;
      ptr_dlam[5] = ptr_tinv[5] * sigma_mu;
      ptr_pd[2 + (ii + 2) * bs + ii * cnz] =
          ptr_bd[ii + 2] + ptr_lamt[4] + ptr_lamt[5];
      ptr_pl[(ii + 2) * bs] = ptr_bl[ii + 2] + ptr_lam[5] +
                              ptr_lamt[5] * ptr_db[2 * ii + 5] + ptr_dlam[5] -
                              ptr_lam[4] - ptr_lamt[4] * ptr_db[2 * ii + 4] -
                              ptr_dlam[4];
      ptr_pl2[ii + 2] = ptr_pl[(ii + 2) * bs];
      ptr_tinv[6] = 1.0 / ptr_t[6];
      ptr_tinv[7] = 1.0 / ptr_t[7];
      ptr_lamt[6] = ptr_lam[6] * ptr_tinv[6];
      ptr_lamt[7] = ptr_lam[7] * ptr_tinv[7];
      ptr_dlam[6] = ptr_tinv[6] * sigma_mu;
      ptr_dlam[7] = ptr_tinv[7] * sigma_mu;
      ptr_pd[3 + (ii + 3) * bs + ii * cnz] =
          ptr_bd[ii + 3] + ptr_lamt[6] + ptr_lamt[7];
      ptr_pl[(ii + 3) * bs] = ptr_bl[ii + 3] + ptr_lam[7] +
                              ptr_lamt[7] * ptr_db[2 * ii + 7] + ptr_dlam[7] -
                              ptr_lam[6] - ptr_lamt[6] * ptr_db[2 * ii + 6] -
                              ptr_dlam[6];
      ptr_pl2[ii + 3] = ptr_pl[(ii + 3) * bs];
      ptr_tinv[8] = 1.0 / ptr_t[8];
      ptr_tinv[9] = 1.0 / ptr_t[9];
      ptr_lamt[8] = ptr_lam[8] * ptr_tinv[8];
      ptr_lamt[9] = ptr_lam[9] * ptr_tinv[9];
      ptr_dlam[8] = ptr_tinv[8] * sigma_mu;
      ptr_dlam[9] = ptr_tinv[9] * sigma_mu;
      ptr_pd[4 + (ii + 4) * bs + ii * cnz] =
          ptr_bd[ii + 4] + ptr_lamt[8] + ptr_lamt[9];
      ptr_pl[(ii + 4) * bs] = ptr_bl[ii + 4] + ptr_lam[9] +
                              ptr_lamt[9] * ptr_db[2 * ii + 9] + ptr_dlam[9] -
                              ptr_lam[8] - ptr_lamt[8] * ptr_db[2 * ii + 8] -
                              ptr_dlam[8];
      ptr_pl2[ii + 4] = ptr_pl[(ii + 4) * bs];
      ptr_tinv[10] = 1.0 / ptr_t[10];
      ptr_tinv[11] = 1.0 / ptr_t[11];
      ptr_lamt[10] = ptr_lam[10] * ptr_tinv[10];
      ptr_lamt[11] = ptr_lam[11] * ptr_tinv[11];
      ptr_dlam[10] = ptr_tinv[10] * sigma_mu;
      ptr_dlam[11] = ptr_tinv[11] * sigma_mu;
      ptr_pd[5 + (ii + 5) * bs + ii * cnz] =
          ptr_bd[ii + 5] + ptr_lamt[10] + ptr_lamt[11];
      ptr_pl[(ii + 5) * bs] = ptr_bl[ii + 5] + ptr_lam[11] +
                              ptr_lamt[11] * ptr_db[2 * ii + 11] +
                              ptr_dlam[11] - ptr_lam[10] -
                              ptr_lamt[10] * ptr_db[2 * ii + 10] - ptr_dlam[10];
      ptr_pl2[ii + 5] = ptr_pl[(ii + 5) * bs];
      ptr_tinv[12] = 1.0 / ptr_t[12];
      ptr_tinv[13] = 1.0 / ptr_t[13];
      ptr_lamt[12] = ptr_lam[12] * ptr_tinv[12];
      ptr_lamt[13] = ptr_lam[13] * ptr_tinv[13];
      ptr_dlam[12] = ptr_tinv[12] * sigma_mu;
      ptr_dlam[13] = ptr_tinv[13] * sigma_mu;
      ptr_pd[6 + (ii + 6) * bs + ii * cnz] =
          ptr_bd[ii + 6] + ptr_lamt[12] + ptr_lamt[13];
      ptr_pl[(ii + 6) * bs] = ptr_bl[ii + 6] + ptr_lam[13] +
                              ptr_lamt[13] * ptr_db[2 * ii + 13] +
                              ptr_dlam[13] - ptr_lam[12] -
                              ptr_lamt[12] * ptr_db[2 * ii + 12] - ptr_dlam[12];
      ptr_pl2[ii + 6] = ptr_pl[(ii + 6) * bs];
      ptr_tinv[14] = 1.0 / ptr_t[14];
      ptr_tinv[15] = 1.0 / ptr_t[15];
      ptr_lamt[14] = ptr_lam[14] * ptr_tinv[14];
      ptr_lamt[15] = ptr_lam[15] * ptr_tinv[15];
      ptr_dlam[14] = ptr_tinv[14] * sigma_mu;
      ptr_dlam[15] = ptr_tinv[15] * sigma_mu;
      ptr_pd[7 + (ii + 7) * bs + ii * cnz] =
          ptr_bd[ii + 7] + ptr_lamt[14] + ptr_lamt[15];
      ptr_pl[(ii + 7) * bs] = ptr_bl[ii + 7] + ptr_lam[15] +
                              ptr_lamt[15] * ptr_db[2 * ii + 15] +
                              ptr_dlam[15] - ptr_lam[14] -
                              ptr_lamt[14] * ptr_db[2 * ii + 14] - ptr_dlam[14];
      ptr_pl2[ii + 7] = ptr_pl[(ii + 7) * bs];
      ptr_t += 16;
      ptr_lam += 16;
      ptr_lamt += 16;
      ptr_dlam += 16;
      ptr_tinv += 16;
    }
    if (ii < kmax) {
      bs0 = kmax - ii;
      for (ll = 0; ll < bs0; ll++) {
        ptr_tinv[0] = 1.0 / ptr_t[0];
        ptr_tinv[1] = 1.0 / ptr_t[1];
        ptr_lamt[0] = ptr_lam[0] * ptr_tinv[0];
        ptr_lamt[1] = ptr_lam[1] * ptr_tinv[1];
        ptr_dlam[0] = ptr_tinv[0] * sigma_mu;
        ptr_dlam[1] = ptr_tinv[1] * sigma_mu;
        ptr_pd[ll + (ii + ll) * bs + ii * cnz] =
            ptr_bd[ii + ll] + ptr_lamt[0] + ptr_lamt[1];
        ptr_pl[(ii + ll) * bs] = ptr_bl[ii + ll] + ptr_lam[1] +
                                 ptr_lamt[1] * ptr_db[2 * ii + 2 * ll + 1] +
                                 ptr_dlam[1] - ptr_lam[0] -
                                 ptr_lamt[0] * ptr_db[2 * ii + 2 * ll + 0] -
                                 ptr_dlam[0];
        ptr_pl2[ii + ll + 0] = ptr_pl[(ii + ll) * bs];
        ptr_t += 2;
        ptr_lam += 2;
        ptr_lamt += 2;
        ptr_dlam += 2;
        ptr_tinv += 2;
      }
    }
  }
  ptr_t = t[N] + 2 * k1;
  ptr_lam = lam[N] + 2 * k1;
  ptr_lamt = lamt[N] + 2 * k1;
  ptr_dlam = dlam[N] + 2 * k1;
  ptr_tinv = t_inv[N] + 2 * k1;
  ptr_pd = pd[N];
  ptr_pl = pl[N];
  ptr_pl2 = pl2[N];
  ptr_bd = bd[N];
  ptr_bl = bl[N];
  ptr_db = db[N];
  ii = k1;
  for (; ii < kmax - 7; ii += 8) {
    ptr_tinv[0] = 1.0 / ptr_t[0];
    ptr_tinv[1] = 1.0 / ptr_t[1];
    ptr_lamt[0] = ptr_lam[0] * ptr_tinv[0];
    ptr_lamt[1] = ptr_lam[1] * ptr_tinv[1];
    ptr_dlam[0] = ptr_tinv[0] * sigma_mu;
    ptr_dlam[1] = ptr_tinv[1] * sigma_mu;
    ptr_pd[0 + (ii + 0) * bs + ii * cnz] =
        ptr_bd[ii + 0] + ptr_lamt[0] + ptr_lamt[1];
    ptr_pl[(ii + 0) * bs] = ptr_bl[ii + 0] + ptr_lam[1] +
                            ptr_lamt[1] * ptr_db[2 * ii + 1] + ptr_dlam[1] -
                            ptr_lam[0] - ptr_lamt[0] * ptr_db[2 * ii + 0] -
                            ptr_dlam[0];
    ptr_pl2[ii + 0] = ptr_pl[(ii + 0) * bs];
    ptr_tinv[2] = 1.0 / ptr_t[2];
    ptr_tinv[3] = 1.0 / ptr_t[3];
    ptr_lamt[2] = ptr_lam[2] * ptr_tinv[2];
    ptr_lamt[3] = ptr_lam[3] * ptr_tinv[3];
    ptr_dlam[2] = ptr_tinv[2] * sigma_mu;
    ptr_dlam[3] = ptr_tinv[3] * sigma_mu;
    ptr_pd[1 + (ii + 1) * bs + ii * cnz] =
        ptr_bd[ii + 1] + ptr_lamt[2] + ptr_lamt[3];
    ptr_pl[(ii + 1) * bs] = ptr_bl[ii + 1] + ptr_lam[3] +
                            ptr_lamt[3] * ptr_db[2 * ii + 3] + ptr_dlam[3] -
                            ptr_lam[2] - ptr_lamt[2] * ptr_db[2 * ii + 2] -
                            ptr_dlam[2];
    ptr_pl2[ii + 1] = ptr_pl[(ii + 1) * bs];
    ptr_tinv[4] = 1.0 / ptr_t[4];
    ptr_tinv[5] = 1.0 / ptr_t[5];
    ptr_lamt[4] = ptr_lam[4] * ptr_tinv[4];
    ptr_lamt[5] = ptr_lam[5] * ptr_tinv[5];
    ptr_dlam[4] = ptr_tinv[4] * sigma_mu;
    ptr_dlam[5] = ptr_tinv[5] * sigma_mu;
    ptr_pd[2 + (ii + 2) * bs + ii * cnz] =
        ptr_bd[ii + 2] + ptr_lamt[4] + ptr_lamt[5];
    ptr_pl[(ii + 2) * bs] = ptr_bl[ii + 2] + ptr_lam[5] +
                            ptr_lamt[5] * ptr_db[2 * ii + 5] + ptr_dlam[5] -
                            ptr_lam[4] - ptr_lamt[4] * ptr_db[2 * ii + 4] -
                            ptr_dlam[4];
    ptr_pl2[ii + 2] = ptr_pl[(ii + 2) * bs];
    ptr_tinv[6] = 1.0 / ptr_t[6];
    ptr_tinv[7] = 1.0 / ptr_t[7];
    ptr_lamt[6] = ptr_lam[6] * ptr_tinv[6];
    ptr_lamt[7] = ptr_lam[7] * ptr_tinv[7];
    ptr_dlam[6] = ptr_tinv[6] * sigma_mu;
    ptr_dlam[7] = ptr_tinv[7] * sigma_mu;
    ptr_pd[3 + (ii + 3) * bs + ii * cnz] =
        ptr_bd[ii + 3] + ptr_lamt[6] + ptr_lamt[7];
    ptr_pl[(ii + 3) * bs] = ptr_bl[ii + 3] + ptr_lam[7] +
                            ptr_lamt[7] * ptr_db[2 * ii + 7] + ptr_dlam[7] -
                            ptr_lam[6] - ptr_lamt[6] * ptr_db[2 * ii + 6] -
                            ptr_dlam[6];
    ptr_pl2[ii + 3] = ptr_pl[(ii + 3) * bs];
    ptr_tinv[8] = 1.0 / ptr_t[8];
    ptr_tinv[9] = 1.0 / ptr_t[9];
    ptr_lamt[8] = ptr_lam[8] * ptr_tinv[8];
    ptr_lamt[9] = ptr_lam[9] * ptr_tinv[9];
    ptr_dlam[8] = ptr_tinv[8] * sigma_mu;
    ptr_dlam[9] = ptr_tinv[9] * sigma_mu;
    ptr_pd[4 + (ii + 4) * bs + ii * cnz] =
        ptr_bd[ii + 4] + ptr_lamt[8] + ptr_lamt[9];
    ptr_pl[(ii + 4) * bs] = ptr_bl[ii + 4] + ptr_lam[9] +
                            ptr_lamt[9] * ptr_db[2 * ii + 9] + ptr_dlam[9] -
                            ptr_lam[8] - ptr_lamt[8] * ptr_db[2 * ii + 8] -
                            ptr_dlam[8];
    ptr_pl2[ii + 4] = ptr_pl[(ii + 4) * bs];
    ptr_tinv[10] = 1.0 / ptr_t[10];
    ptr_tinv[11] = 1.0 / ptr_t[11];
    ptr_lamt[10] = ptr_lam[10] * ptr_tinv[10];
    ptr_lamt[11] = ptr_lam[11] * ptr_tinv[11];
    ptr_dlam[10] = ptr_tinv[10] * sigma_mu;
    ptr_dlam[11] = ptr_tinv[11] * sigma_mu;
    ptr_pd[5 + (ii + 5) * bs + ii * cnz] =
        ptr_bd[ii + 5] + ptr_lamt[10] + ptr_lamt[11];
    ptr_pl[(ii + 5) * bs] = ptr_bl[ii + 5] + ptr_lam[11] +
                            ptr_lamt[11] * ptr_db[2 * ii + 11] + ptr_dlam[11] -
                            ptr_lam[10] - ptr_lamt[10] * ptr_db[2 * ii + 10] -
                            ptr_dlam[10];
    ptr_pl2[ii + 5] = ptr_pl[(ii + 5) * bs];
    ptr_tinv[12] = 1.0 / ptr_t[12];
    ptr_tinv[13] = 1.0 / ptr_t[13];
    ptr_lamt[12] = ptr_lam[12] * ptr_tinv[12];
    ptr_lamt[13] = ptr_lam[13] * ptr_tinv[13];
    ptr_dlam[12] = ptr_tinv[12] * sigma_mu;
    ptr_dlam[13] = ptr_tinv[13] * sigma_mu;
    ptr_pd[6 + (ii + 6) * bs + ii * cnz] =
        ptr_bd[ii + 6] + ptr_lamt[12] + ptr_lamt[13];
    ptr_pl[(ii + 6) * bs] = ptr_bl[ii + 6] + ptr_lam[13] +
                            ptr_lamt[13] * ptr_db[2 * ii + 13] + ptr_dlam[13] -
                            ptr_lam[12] - ptr_lamt[12] * ptr_db[2 * ii + 12] -
                            ptr_dlam[12];
    ptr_pl2[ii + 6] = ptr_pl[(ii + 6) * bs];
    ptr_tinv[14] = 1.0 / ptr_t[14];
    ptr_tinv[15] = 1.0 / ptr_t[15];
    ptr_lamt[14] = ptr_lam[14] * ptr_tinv[14];
    ptr_lamt[15] = ptr_lam[15] * ptr_tinv[15];
    ptr_dlam[14] = ptr_tinv[14] * sigma_mu;
    ptr_dlam[15] = ptr_tinv[15] * sigma_mu;
    ptr_pd[7 + (ii + 7) * bs + ii * cnz] =
        ptr_bd[ii + 7] + ptr_lamt[14] + ptr_lamt[15];
    ptr_pl[(ii + 7) * bs] = ptr_bl[ii + 7] + ptr_lam[15] +
                            ptr_lamt[15] * ptr_db[2 * ii + 15] + ptr_dlam[15] -
                            ptr_lam[14] - ptr_lamt[14] * ptr_db[2 * ii + 14] -
                            ptr_dlam[14];
    ptr_pl2[ii + 7] = ptr_pl[(ii + 7) * bs];
    ptr_t += 16;
    ptr_lam += 16;
    ptr_lamt += 16;
    ptr_dlam += 16;
    ptr_tinv += 16;
  }
  if (ii < kmax) {
    bs0 = kmax - ii;
    for (ll = 0; ll < bs0; ll++) {
      ptr_tinv[0] = 1.0 / ptr_t[0];
      ptr_tinv[1] = 1.0 / ptr_t[1];
      ptr_lamt[0] = ptr_lam[0] * ptr_tinv[0];
      ptr_lamt[1] = ptr_lam[1] * ptr_tinv[1];
      ptr_dlam[0] = ptr_tinv[0] * sigma_mu;
      ptr_dlam[1] = ptr_tinv[1] * sigma_mu;
      ptr_pd[ll + (ii + ll) * bs + ii * cnz] =
          ptr_bd[ii + ll] + ptr_lamt[0] + ptr_lamt[1];
      ptr_pl[(ii + ll) * bs] =
          ptr_bl[ii + ll] + ptr_lam[1] +
          ptr_lamt[1] * ptr_db[2 * ii + 2 * ll + 1] + ptr_dlam[1] - ptr_lam[0] -
          ptr_lamt[0] * ptr_db[2 * ii + 2 * ll + 0] - ptr_dlam[0];
      ptr_pl2[ii + ll + 0] = ptr_pl[(ii + ll) * bs];
      ptr_t += 2;
      ptr_lam += 2;
      ptr_lamt += 2;
      ptr_dlam += 2;
      ptr_tinv += 2;
    }
  }
}


x86 assembly (clang, -O0):
<s_update_hessian_box_mhe>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movl   $0x8,-0x24(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2456 <s_update_hessian_box_mhe+0x1356>
mov    -0x20(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    0x18(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    0x20(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    0x28(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    0x40(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    0x48(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    0x50(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
mov    0x30(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
mov    0x38(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
mov    0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    21a8 <s_update_hessian_box_mhe+0x10a8>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2d91(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2d6c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x4(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  (%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2bba(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x38(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2b94(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x40(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x58(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x58(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0xc(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0xc(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0xc(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x8(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x8(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x29d9(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x38(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x29b3(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x40(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x10(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x40(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x58(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x58(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x14(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x14(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x14(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x10(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x27f8(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x38(%rbp),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x27d2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x40(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x40(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x58(%rbp),%rax
movss  0x18(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x58(%rbp),%rax
movss  0x1c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x18(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x1c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x1c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x1c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x18(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x18(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2617(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x38(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x25f1(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x40(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x20(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x40(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x58(%rbp),%rax
movss  0x20(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x58(%rbp),%rax
movss  0x24(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x20(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x24(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x24(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x24(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x20(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x20(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2436(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x38(%rbp),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2410(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x40(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x40(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x2c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x58(%rbp),%rax
movss  0x28(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x58(%rbp),%rax
movss  0x2c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x28(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x2c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x2c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x2c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x28(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x28(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2255(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x38(%rbp),%rax
movss  0x34(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x222f(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x40(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x30(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x40(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x58(%rbp),%rax
movss  0x30(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x58(%rbp),%rax
movss  0x34(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x30(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x34(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x30(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x30(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x38(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2074(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x38(%rbp),%rax
movss  0x3c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x204e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x40(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x40(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x3c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x58(%rbp),%rax
movss  0x38(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x58(%rbp),%rax
movss  0x3c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x38(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x3c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x3c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x3c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x38(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x38(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x8c(%rbp)
jmp    1247 <s_update_hessian_box_mhe+0x147>
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    243d <s_update_hessian_box_mhe+0x133d>
mov    -0x10(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    2438 <s_update_hessian_box_mhe+0x1338>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e0a(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1de5(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    -0x8c(%rbp),%edx
add    -0x94(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x94(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x4(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  (%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x94(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    21d0 <s_update_hessian_box_mhe+0x10d0>
jmp    243d <s_update_hessian_box_mhe+0x133d>
jmp    2442 <s_update_hessian_box_mhe+0x1342>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    115a <s_update_hessian_box_mhe+0x5a>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    0x40(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    0x50(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
mov    0x30(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
mov    0x38(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
mov    0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x88(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    34c3 <s_update_hessian_box_mhe+0x23c3>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1a76(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1a51(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
add    $0x0,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x4(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  (%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x189f(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x38(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1879(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x40(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x58(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x58(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0xc(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0xc(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0xc(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x8(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x8(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x16be(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x38(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1698(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x40(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x10(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x40(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x58(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x58(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x14(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x14(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x14(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x10(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x18(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x14dd(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x38(%rbp),%rax
movss  0x1c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x14b7(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x40(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x40(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x58(%rbp),%rax
movss  0x18(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x58(%rbp),%rax
movss  0x1c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x18(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x1c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x1c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x1c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x18(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x18(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x20(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x12fc(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x38(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x12d6(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x40(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x20(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x40(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x58(%rbp),%rax
movss  0x20(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x58(%rbp),%rax
movss  0x24(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x20(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x24(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x24(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x24(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x20(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x20(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x28(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x111b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x38(%rbp),%rax
movss  0x2c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x10f5(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x40(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x40(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x2c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x58(%rbp),%rax
movss  0x28(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x58(%rbp),%rax
movss  0x2c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x28(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x2c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x2c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x2c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x28(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x28(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x30(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xf3a(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x38(%rbp),%rax
movss  0x34(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xf14(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x40(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x30(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x40(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x58(%rbp),%rax
movss  0x30(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x58(%rbp),%rax
movss  0x34(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x30(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x34(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x30(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x30(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movss  0x38(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd59(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x38(%rbp),%rax
movss  0x3c(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd33(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x40(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x40(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x3c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x58(%rbp),%rax
movss  0x38(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x58(%rbp),%rax
movss  0x3c(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  0x38(%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x3c(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x3c(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x3c(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  0x38(%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  0x38(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x8c(%rbp)
jmp    2562 <s_update_hessian_box_mhe+0x1462>
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    3758 <s_update_hessian_box_mhe+0x2658>
mov    -0x10(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    3753 <s_update_hessian_box_mhe+0x2653>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xaef(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xaca(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
addss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    -0x8c(%rbp),%edx
add    -0x94(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x94(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x50(%rbp),%rax
addss  0x4(%rax),%xmm1
mov    -0x40(%rbp),%rax
subss  (%rax),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x8c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x94(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    34eb <s_update_hessian_box_mhe+0x23eb>
jmp    3758 <s_update_hessian_box_mhe+0x2658>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_update_hessian_box_mhe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9,-0x38(%rsp)
mov    %ecx,%r14d
mov    %rdx,-0x18(%rsp)
lea    -0x7(%r14),%ecx
movslq %r8d,%rax
mov    %rax,-0x28(%rsp)
mov    %ecx,-0x40(%rsp)
movslq %ecx,%rax
mov    %rax,-0x30(%rsp)
mov    %edi,-0x54(%rsp)
test   %edi,%edi
mov    %r8,-0x10(%rsp)
mov    %r14,-0x50(%rsp)
jle    1b6b <s_update_hessian_box_mhe+0xa6b>
mov    -0x54(%rsp),%eax
mov    %rax,-0x8(%rsp)
lea    0x8(%r8),%eax
mov    %eax,-0x3c(%rsp)
xor    %edi,%edi
movss  0x1e9f(%rip),%xmm1
jmp    1188 <s_update_hessian_box_mhe+0x88>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rdi
add    $0x1,%rdi
cmp    -0x8(%rsp),%rdi
mov    -0x50(%rsp),%r14
je     1b6b <s_update_hessian_box_mhe+0xa6b>
mov    -0x38(%rsp),%rax
mov    (%rax,%rdi,8),%r12
mov    0x48(%rsp),%rax
mov    (%rax,%rdi,8),%rbx
mov    0x50(%rsp),%rax
mov    (%rax,%rdi,8),%rbp
mov    0x58(%rsp),%rax
mov    (%rax,%rdi,8),%r13
mov    0x40(%rsp),%rax
mov    (%rax,%rdi,8),%r10
mov    0x70(%rsp),%rax
mov    (%rax,%rdi,8),%r11
mov    0x78(%rsp),%rax
mov    (%rax,%rdi,8),%r8
mov    0x80(%rsp),%rax
mov    (%rax,%rdi,8),%r9
mov    0x60(%rsp),%rax
mov    (%rax,%rdi,8),%rsi
mov    0x68(%rsp),%rcx
mov    (%rcx,%rdi,8),%rax
mov    0x88(%rsp),%rdx
mov    (%rdx,%rdi,8),%r15
cmp    $0x8,%r14d
mov    %rdi,(%rsp)
mov    %rsi,-0x60(%rsp)
mov    %rax,-0x20(%rsp)
jl     19d0 <s_update_hessian_box_mhe+0x8d0>
mov    %r11,-0x68(%rsp)
mov    %r8,-0x48(%rsp)
mov    %r9,-0x78(%rsp)
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    %rsi,-0x80(%rsp)
movaps %xmm1,%xmm2
divss  (%r12),%xmm2
movss  %xmm2,(%r10)
movaps %xmm1,%xmm3
divss  0x4(%r12),%xmm3
movss  %xmm3,0x4(%r10)
mulss  (%rbx),%xmm2
movss  %xmm2,0x0(%rbp)
movss  0x4(%rbx),%xmm2
mulss  0x4(%r10),%xmm2
movss  %xmm2,0x4(%rbp)
movss  (%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x0(%r13)
movss  0x4(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%r13)
mov    -0x60(%rsp),%rax
movss  (%rax,%rsi,4),%xmm2
mov    %rax,%r8
addss  0x0(%rbp),%xmm2
addss  0x4(%rbp),%xmm2
lea    0x0(,%rsi,8),%edi
mov    %rsi,%rax
imul   -0x28(%rsp),%rax
movslq %edi,%rdx
add    %rax,%rdx
mov    %rax,%rsi
mov    -0x68(%rsp),%r11
movss  %xmm2,(%r11,%rdx,4)
movss  0x4(%rbp),%xmm2
mov    -0x20(%rsp),%rax
mov    -0x80(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    %r15,%r9
mov    -0x80(%rsp),%rcx
mulss  0x4(%r15,%rcx,8),%xmm2
addss  0x4(%rbx),%xmm3
addss  %xmm3,%xmm2
addss  0x4(%r13),%xmm2
movss  0x0(%rbp),%xmm3
mov    -0x80(%rsp),%rcx
mulss  (%r15,%rcx,8),%xmm3
subss  (%rbx),%xmm2
subss  %xmm3,%xmm2
subss  0x0(%r13),%xmm2
mov    -0x48(%rsp),%rcx
movss  %xmm2,(%rcx,%rdi,4)
mov    -0x80(%rsp),%rdi
mov    -0x78(%rsp),%rdx
movss  %xmm2,(%rdx,%rdi,4)
movaps %xmm1,%xmm2
divss  0x8(%r12),%xmm2
movss  %xmm2,0x8(%r10)
movaps %xmm1,%xmm3
divss  0xc(%r12),%xmm3
movss  %xmm3,0xc(%r10)
mulss  0x8(%rbx),%xmm2
movss  %xmm2,0x8(%rbp)
movss  0xc(%rbx),%xmm2
mulss  0xc(%r10),%xmm2
movss  %xmm2,0xc(%rbp)
movss  0x8(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%r13)
movss  0xc(%r10),%xmm2
mulss  %xmm0,%xmm2
mov    -0x80(%rsp),%rdi
movss  %xmm2,0xc(%r13)
or     $0x1,%rdi
movss  (%r8,%rdi,4),%xmm2
addss  0x8(%rbp),%xmm2
addss  0xc(%rbp),%xmm2
mov    -0x80(%rsp),%rdx
lea    0x0(,%rdx,8),%r14
mov    %esi,%edx
mov    %rsi,%r8
or     $0x1,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
movss  %xmm2,(%r11,%rdx,4)
movss  (%rax,%rdi,4),%xmm2
mov    %rax,%r15
movss  0xc(%rbp),%xmm3
mov    %r14,%rdx
addss  0xc(%rbx),%xmm2
or     $0xc,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0xc(%r13),%xmm3
mov    %r14,%rdx
or     $0x8,%rdx
movss  0x8(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x8(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x8(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
movss  %xmm3,(%rcx,%rdx,4)
mov    -0x78(%rsp),%rsi
movss  %xmm3,(%rsi,%rdi,4)
movaps %xmm1,%xmm2
divss  0x10(%r12),%xmm2
movss  %xmm2,0x10(%r10)
movaps %xmm1,%xmm3
divss  0x14(%r12),%xmm3
movss  %xmm3,0x14(%r10)
mulss  0x10(%rbx),%xmm2
movss  %xmm2,0x10(%rbp)
movss  0x14(%rbx),%xmm2
mulss  0x14(%r10),%xmm2
movss  %xmm2,0x14(%rbp)
movss  0x10(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%r13)
movss  0x14(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x14(%r13)
mov    -0x80(%rsp),%rdi
or     $0x2,%rdi
mov    -0x60(%rsp),%rax
movss  (%rax,%rdi,4),%xmm2
addss  0x10(%rbp),%xmm2
addss  0x14(%rbp),%xmm2
mov    %r8,-0x70(%rsp)
mov    %r8d,%edx
or     $0x2,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
movss  %xmm2,(%r11,%rdx,4)
movss  (%r15,%rdi,4),%xmm2
movss  0x14(%rbp),%xmm3
mov    %r14,%rdx
addss  0x14(%rbx),%xmm2
or     $0x14,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x14(%r13),%xmm3
mov    %r14,%rdx
or     $0x10,%rdx
movss  0x10(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x10(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x10(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
movss  %xmm3,(%rcx,%rdx,4)
movss  %xmm3,(%rsi,%rdi,4)
movaps %xmm1,%xmm2
divss  0x18(%r12),%xmm2
movss  %xmm2,0x18(%r10)
movaps %xmm1,%xmm3
divss  0x1c(%r12),%xmm3
movss  %xmm3,0x1c(%r10)
mulss  0x18(%rbx),%xmm2
movss  %xmm2,0x18(%rbp)
movss  0x1c(%rbx),%xmm2
mulss  0x1c(%r10),%xmm2
movss  %xmm2,0x1c(%rbp)
movss  0x18(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x18(%r13)
movss  0x1c(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r13)
mov    -0x80(%rsp),%rdi
or     $0x3,%rdi
movss  (%rax,%rdi,4),%xmm2
addss  0x18(%rbp),%xmm2
addss  0x1c(%rbp),%xmm2
mov    %r8d,%edx
or     $0x3,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
movss  %xmm2,(%r11,%rdx,4)
mov    %r15,%rcx
movss  (%r15,%rdi,4),%xmm2
movss  0x1c(%rbp),%xmm3
mov    %r14,%rdx
addss  0x1c(%rbx),%xmm2
or     $0x1c,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x1c(%r13),%xmm3
mov    %r14,%rdx
or     $0x18,%rdx
movss  0x18(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x18(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x18(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
mov    -0x48(%rsp),%r8
movss  %xmm3,(%r8,%rdx,4)
movss  %xmm3,(%rsi,%rdi,4)
movaps %xmm1,%xmm2
divss  0x20(%r12),%xmm2
movss  %xmm2,0x20(%r10)
movaps %xmm1,%xmm3
divss  0x24(%r12),%xmm3
movss  %xmm3,0x24(%r10)
mulss  0x20(%rbx),%xmm2
movss  %xmm2,0x20(%rbp)
movss  0x24(%rbx),%xmm2
mulss  0x24(%r10),%xmm2
movss  %xmm2,0x24(%rbp)
movss  0x20(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x20(%r13)
movss  0x24(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x24(%r13)
mov    -0x80(%rsp),%rdi
or     $0x4,%rdi
mov    %rax,%r15
movss  (%rax,%rdi,4),%xmm2
addss  0x20(%rbp),%xmm2
addss  0x24(%rbp),%xmm2
mov    -0x70(%rsp),%r11
mov    %r11d,%edx
or     $0x4,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
mov    -0x68(%rsp),%rax
movss  %xmm2,(%rax,%rdx,4)
movss  (%rcx,%rdi,4),%xmm2
movss  0x24(%rbp),%xmm3
mov    %r14,%rdx
addss  0x24(%rbx),%xmm2
or     $0x24,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x24(%r13),%xmm3
mov    %r14,%rdx
or     $0x20,%rdx
movss  0x20(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x20(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x20(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
movss  %xmm3,(%r8,%rdx,4)
mov    %r8,%rax
movss  %xmm3,(%rsi,%rdi,4)
movaps %xmm1,%xmm2
divss  0x28(%r12),%xmm2
movss  %xmm2,0x28(%r10)
movaps %xmm1,%xmm3
divss  0x2c(%r12),%xmm3
movss  %xmm3,0x2c(%r10)
mulss  0x28(%rbx),%xmm2
movss  %xmm2,0x28(%rbp)
movss  0x2c(%rbx),%xmm2
mulss  0x2c(%r10),%xmm2
movss  %xmm2,0x2c(%rbp)
movss  0x28(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x28(%r13)
movss  0x2c(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x2c(%r13)
mov    -0x80(%rsp),%rdi
or     $0x5,%rdi
movss  (%r15,%rdi,4),%xmm2
addss  0x28(%rbp),%xmm2
addss  0x2c(%rbp),%xmm2
mov    %r11,%r8
mov    %r8d,%edx
or     $0x5,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
mov    -0x68(%rsp),%r11
movss  %xmm2,(%r11,%rdx,4)
movss  (%rcx,%rdi,4),%xmm2
movss  0x2c(%rbp),%xmm3
mov    %r14,%rdx
addss  0x2c(%rbx),%xmm2
or     $0x2c,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x2c(%r13),%xmm3
mov    %r14,%rdx
or     $0x28,%rdx
movss  0x28(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x28(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x28(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
movss  %xmm3,(%rax,%rdx,4)
movss  %xmm3,(%rsi,%rdi,4)
movaps %xmm1,%xmm2
divss  0x30(%r12),%xmm2
movss  %xmm2,0x30(%r10)
movaps %xmm1,%xmm3
divss  0x34(%r12),%xmm3
movss  %xmm3,0x34(%r10)
mulss  0x30(%rbx),%xmm2
movss  %xmm2,0x30(%rbp)
movss  0x34(%rbx),%xmm2
mulss  0x34(%r10),%xmm2
movss  %xmm2,0x34(%rbp)
movss  0x30(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x30(%r13)
movss  0x34(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x34(%r13)
mov    -0x80(%rsp),%rdi
or     $0x6,%rdi
mov    %r15,%rsi
movss  (%r15,%rdi,4),%xmm2
addss  0x30(%rbp),%xmm2
addss  0x34(%rbp),%xmm2
mov    %r8d,%edx
or     $0x6,%edx
lea    (%rdx,%rdi,8),%edx
movslq %edx,%rdx
movss  %xmm2,(%r11,%rdx,4)
movss  (%rcx,%rdi,4),%xmm2
mov    %rcx,%r15
movss  0x34(%rbp),%xmm3
mov    %r14,%rdx
addss  0x34(%rbx),%xmm2
or     $0x34,%rdx
mulss  (%r9,%rdx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x34(%r13),%xmm3
mov    %r14,%rdx
or     $0x30,%rdx
movss  0x30(%rbp),%xmm2
mulss  (%r9,%rdx,1),%xmm2
subss  0x30(%rbx),%xmm3
subss  %xmm2,%xmm3
subss  0x30(%r13),%xmm3
lea    0x0(,%rdi,8),%edx
movss  %xmm3,(%rax,%rdx,4)
mov    %rax,%r8
mov    -0x78(%rsp),%rcx
movss  %xmm3,(%rcx,%rdi,4)
movaps %xmm1,%xmm2
divss  0x38(%r12),%xmm2
movss  %xmm2,0x38(%r10)
movaps %xmm1,%xmm3
divss  0x3c(%r12),%xmm3
movss  %xmm3,0x3c(%r10)
mulss  0x38(%rbx),%xmm2
movss  %xmm2,0x38(%rbp)
movss  0x3c(%rbx),%xmm2
mulss  0x3c(%r10),%xmm2
movss  %xmm2,0x3c(%rbp)
movss  0x38(%r10),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x38(%r13)
movss  0x3c(%r10),%xmm2
mulss  %xmm0,%xmm2
mov    -0x80(%rsp),%rdi
movss  %xmm2,0x3c(%r13)
or     $0x7,%rdi
movss  (%rsi,%rdi,4),%xmm2
mov    -0x80(%rsp),%rsi
addss  0x38(%rbp),%xmm2
addss  0x3c(%rbp),%xmm2
mov    -0x70(%rsp),%rax
or     $0x7,%eax
lea    (%rax,%rdi,8),%edx
movslq %edx,%rdx
movss  %xmm2,(%r11,%rdx,4)
mov    %r14,%rdx
movss  0x3c(%rbp),%xmm2
or     $0x3c,%rdx
mulss  (%r9,%rdx,1),%xmm2
movss  (%r15,%rdi,4),%xmm3
addss  0x3c(%rbx),%xmm3
movss  0x38(%rbp),%xmm4
addss  %xmm3,%xmm2
addss  0x3c(%r13),%xmm2
subss  0x38(%rbx),%xmm2
or     $0x38,%r14
mov    %r9,%r15
mulss  (%r9,%r14,1),%xmm4
lea    0x0(,%rdi,8),%edx
subss  %xmm4,%xmm2
subss  0x38(%r13),%xmm2
movss  %xmm2,(%r8,%rdx,4)
movss  %xmm2,(%rcx,%rdi,4)
add    $0x40,%r12
add    $0x40,%rbp
add    $0x40,%rbx
add    $0x40,%r13
add    $0x40,%r10
add    $0x8,%rsi
cmp    -0x30(%rsp),%rsi
jl     1220 <s_update_hessian_box_mhe+0x120>
mov    -0x78(%rsp),%r9
mov    -0x48(%rsp),%rax
mov    -0x68(%rsp),%r11
mov    -0x50(%rsp),%r14
cmp    %r14d,%esi
jge    1170 <s_update_hessian_box_mhe+0x70>
jmp    19de <s_update_hessian_box_mhe+0x8de>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8,%rax
xor    %esi,%esi
cmp    %r14d,%esi
jge    1170 <s_update_hessian_box_mhe+0x70>
mov    -0x50(%rsp),%rdx
mov    %edx,%edi
sub    %esi,%edi
test   %edi,%edi
jle    1170 <s_update_hessian_box_mhe+0x70>
mov    %rax,%rcx
movslq %esi,%r14
mov    %edi,%r8d
mov    -0x3c(%rsp),%edx
mov    %edx,%edi
imul   %esi,%edi
lea    (%rsi,%rsi,1),%eax
mov    %rax,-0x80(%rsp)
lea    (%r9,%r14,4),%rax
mov    %rax,-0x78(%rsp)
mov    -0x20(%rsp),%rax
lea    (%rax,%r14,4),%rax
mov    %rax,-0x70(%rsp)
mov    -0x60(%rsp),%rax
lea    (%rax,%r14,4),%rax
mov    %rax,-0x60(%rsp)
shl    $0x21,%r14
shl    $0x3,%esi
add    %r8,%r8
mov    %r8,%rax
xor    %r8d,%r8d
xchg   %ax,%ax
movaps %xmm1,%xmm2
divss  (%r12,%r8,4),%xmm2
movss  %xmm2,(%r10,%r8,4)
movaps %xmm1,%xmm3
divss  0x4(%r12,%r8,4),%xmm3
movss  %xmm3,0x4(%r10,%r8,4)
mulss  (%rbx,%r8,4),%xmm2
movss  %xmm2,0x0(%rbp,%r8,4)
movss  0x4(%rbx,%r8,4),%xmm2
mulss  0x4(%r10,%r8,4),%xmm2
movss  %xmm2,0x4(%rbp,%r8,4)
movss  (%r10,%r8,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x0(%r13,%r8,4)
movss  0x4(%r10,%r8,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%r13,%r8,4)
mov    -0x60(%rsp),%rdx
movss  (%rdx,%r8,2),%xmm2
addss  0x0(%rbp,%r8,4),%xmm2
addss  0x4(%rbp,%r8,4),%xmm2
movslq %edi,%rdi
movss  %xmm2,(%r11,%rdi,4)
mov    -0x70(%rsp),%rdx
movss  (%rdx,%r8,2),%xmm2
addss  0x4(%rbx,%r8,4),%xmm2
movss  0x0(%rbp,%r8,4),%xmm3
movss  0x4(%rbp,%r8,4),%xmm4
mov    %r14,%rdx
sar    $0x1e,%rdx
or     $0x4,%rdx
mov    %r11,%r9
mov    %rsi,%r11
mov    %r15,%rsi
mulss  (%r15,%rdx,1),%xmm4
addss  %xmm2,%xmm4
addss  0x4(%r13,%r8,4),%xmm4
subss  (%rbx,%r8,4),%xmm4
mov    -0x80(%rsp),%rdx
add    %r8d,%edx
movslq %edx,%rdx
mulss  (%r15,%rdx,4),%xmm3
mov    %r11,%rsi
mov    %r9,%r11
subss  %xmm3,%xmm4
subss  0x0(%r13,%r8,4),%xmm4
mov    %esi,%edx
movss  %xmm4,(%rcx,%rdx,4)
mov    -0x78(%rsp),%rdx
movss  %xmm4,(%rdx,%r8,2)
add    $0x9,%edi
add    $0x2,%r8
movabs $0x200000000,%rdx
add    %rdx,%r14
add    $0x8,%esi
cmp    %r8,%rax
jne    1a40 <s_update_hessian_box_mhe+0x940>
jmp    1170 <s_update_hessian_box_mhe+0x70>
movslq -0x54(%rsp),%rdx
mov    -0x18(%rsp),%r9
lea    (%r9,%r9,1),%eax
movslq %eax,%rcx
shl    $0x2,%rcx
mov    -0x38(%rsp),%rax
mov    (%rax,%rdx,8),%r13
add    %rcx,%r13
mov    0x48(%rsp),%rax
mov    (%rax,%rdx,8),%rbp
add    %rcx,%rbp
mov    0x50(%rsp),%rax
mov    (%rax,%rdx,8),%rbx
add    %rcx,%rbx
mov    0x58(%rsp),%rax
mov    (%rax,%rdx,8),%rax
add    %rcx,%rax
mov    0x40(%rsp),%rsi
add    (%rsi,%rdx,8),%rcx
mov    0x70(%rsp),%rsi
mov    (%rsi,%rdx,8),%rsi
mov    %rsi,-0x70(%rsp)
mov    0x78(%rsp),%rsi
mov    (%rsi,%rdx,8),%rsi
mov    %rsi,-0x80(%rsp)
mov    0x80(%rsp),%rsi
mov    (%rsi,%rdx,8),%r11
mov    0x60(%rsp),%rsi
mov    (%rsi,%rdx,8),%r10
mov    0x68(%rsp),%rsi
mov    (%rsi,%rdx,8),%r15
mov    0x88(%rsp),%rsi
mov    (%rsi,%rdx,8),%r12
cmp    %r9d,-0x40(%rsp)
jle    2281 <s_update_hessian_box_mhe+0x1181>
movslq %r9d,%r9
movss  0x13eb(%rip),%xmm1
mov    -0x70(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm2
divss  0x0(%r13),%xmm2
movss  %xmm2,(%rcx)
movaps %xmm1,%xmm3
divss  0x4(%r13),%xmm3
movss  %xmm3,0x4(%rcx)
mulss  0x0(%rbp),%xmm2
movss  %xmm2,(%rbx)
movss  0x4(%rbp),%xmm2
mulss  0x4(%rcx),%xmm2
movss  %xmm2,0x4(%rbx)
movss  (%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rax)
movss  0x4(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%rax)
movss  (%r10,%r9,4),%xmm2
addss  (%rbx),%xmm2
addss  0x4(%rbx),%xmm2
lea    0x0(,%r9,8),%edx
mov    %r9,%r8
imul   -0x28(%rsp),%r8
movslq %edx,%rdx
lea    (%r8,%rdx,1),%rsi
movss  %xmm2,(%r14,%rsi,4)
movss  (%r15,%r9,4),%xmm2
movss  0x4(%rbx),%xmm3
lea    (%r9,%r9,1),%esi
lea    0x1(%r9,%r9,1),%edi
addss  0x4(%rbp),%xmm2
movslq %edi,%rdi
mulss  (%r12,%rdi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x4(%rax),%xmm3
movslq %esi,%rsi
movss  (%rbx),%xmm2
mulss  (%r12,%rsi,4),%xmm2
subss  0x0(%rbp),%xmm3
subss  %xmm2,%xmm3
subss  (%rax),%xmm3
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x8(%r13),%xmm2
movss  %xmm2,0x8(%rcx)
movaps %xmm1,%xmm3
divss  0xc(%r13),%xmm3
movss  %xmm3,0xc(%rcx)
mulss  0x8(%rbp),%xmm2
movss  %xmm2,0x8(%rbx)
movss  0xc(%rbp),%xmm2
mulss  0xc(%rcx),%xmm2
movss  %xmm2,0xc(%rbx)
movss  0x8(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%rax)
movss  0xc(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0xc(%rax)
movss  0x4(%r10,%r9,4),%xmm2
addss  0x8(%rbx),%xmm2
lea    0x1(%r9),%rdx
addss  0xc(%rbx),%xmm2
lea    0x1(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x4(%r15,%r9,4),%xmm2
addss  0xc(%rbp),%xmm2
movss  0xc(%rbx),%xmm3
mulss  0xc(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0xc(%rax),%xmm3
subss  0x8(%rbp),%xmm3
movss  0x8(%rbx),%xmm2
mulss  0x8(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x8(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0x4(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x10(%r13),%xmm2
movss  %xmm2,0x10(%rcx)
movaps %xmm1,%xmm3
divss  0x14(%r13),%xmm3
movss  %xmm3,0x14(%rcx)
mulss  0x10(%rbp),%xmm2
movss  %xmm2,0x10(%rbx)
movss  0x14(%rbp),%xmm2
mulss  0x14(%rcx),%xmm2
movss  %xmm2,0x14(%rbx)
movss  0x10(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%rax)
movss  0x14(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x14(%rax)
movss  0x8(%r10,%r9,4),%xmm2
addss  0x10(%rbx),%xmm2
lea    0x2(%r9),%rdx
addss  0x14(%rbx),%xmm2
lea    0x2(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x8(%r15,%r9,4),%xmm2
addss  0x14(%rbp),%xmm2
movss  0x14(%rbx),%xmm3
mulss  0x14(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x14(%rax),%xmm3
subss  0x10(%rbp),%xmm3
movss  0x10(%rbx),%xmm2
mulss  0x10(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x10(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0x8(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x18(%r13),%xmm2
movss  %xmm2,0x18(%rcx)
movaps %xmm1,%xmm3
divss  0x1c(%r13),%xmm3
movss  %xmm3,0x1c(%rcx)
mulss  0x18(%rbp),%xmm2
movss  %xmm2,0x18(%rbx)
movss  0x1c(%rbp),%xmm2
mulss  0x1c(%rcx),%xmm2
movss  %xmm2,0x1c(%rbx)
movss  0x18(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x18(%rax)
movss  0x1c(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x1c(%rax)
movss  0xc(%r10,%r9,4),%xmm2
addss  0x18(%rbx),%xmm2
lea    0x3(%r9),%rdx
addss  0x1c(%rbx),%xmm2
lea    0x3(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0xc(%r15,%r9,4),%xmm2
addss  0x1c(%rbp),%xmm2
movss  0x1c(%rbx),%xmm3
mulss  0x1c(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x1c(%rax),%xmm3
subss  0x18(%rbp),%xmm3
movss  0x18(%rbx),%xmm2
mulss  0x18(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x18(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0xc(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x20(%r13),%xmm2
movss  %xmm2,0x20(%rcx)
movaps %xmm1,%xmm3
divss  0x24(%r13),%xmm3
movss  %xmm3,0x24(%rcx)
mulss  0x20(%rbp),%xmm2
movss  %xmm2,0x20(%rbx)
movss  0x24(%rbp),%xmm2
mulss  0x24(%rcx),%xmm2
movss  %xmm2,0x24(%rbx)
movss  0x20(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x20(%rax)
movss  0x24(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x24(%rax)
movss  0x10(%r10,%r9,4),%xmm2
addss  0x20(%rbx),%xmm2
lea    0x4(%r9),%rdx
addss  0x24(%rbx),%xmm2
lea    0x4(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x10(%r15,%r9,4),%xmm2
addss  0x24(%rbp),%xmm2
movss  0x24(%rbx),%xmm3
mulss  0x24(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x24(%rax),%xmm3
subss  0x20(%rbp),%xmm3
movss  0x20(%rbx),%xmm2
mulss  0x20(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x20(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0x10(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x28(%r13),%xmm2
movss  %xmm2,0x28(%rcx)
movaps %xmm1,%xmm3
divss  0x2c(%r13),%xmm3
movss  %xmm3,0x2c(%rcx)
mulss  0x28(%rbp),%xmm2
movss  %xmm2,0x28(%rbx)
movss  0x2c(%rbp),%xmm2
mulss  0x2c(%rcx),%xmm2
movss  %xmm2,0x2c(%rbx)
movss  0x28(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x28(%rax)
movss  0x2c(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x2c(%rax)
movss  0x14(%r10,%r9,4),%xmm2
addss  0x28(%rbx),%xmm2
lea    0x5(%r9),%rdx
addss  0x2c(%rbx),%xmm2
lea    0x5(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x14(%r15,%r9,4),%xmm2
addss  0x2c(%rbp),%xmm2
movss  0x2c(%rbx),%xmm3
mulss  0x2c(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x2c(%rax),%xmm3
subss  0x28(%rbp),%xmm3
movss  0x28(%rbx),%xmm2
mulss  0x28(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x28(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0x14(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x30(%r13),%xmm2
movss  %xmm2,0x30(%rcx)
movaps %xmm1,%xmm3
divss  0x34(%r13),%xmm3
movss  %xmm3,0x34(%rcx)
mulss  0x30(%rbp),%xmm2
movss  %xmm2,0x30(%rbx)
movss  0x34(%rbp),%xmm2
mulss  0x34(%rcx),%xmm2
movss  %xmm2,0x34(%rbx)
movss  0x30(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x30(%rax)
movss  0x34(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x34(%rax)
movss  0x18(%r10,%r9,4),%xmm2
addss  0x30(%rbx),%xmm2
lea    0x6(%r9),%rdx
addss  0x34(%rbx),%xmm2
lea    0x6(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x18(%r15,%r9,4),%xmm2
addss  0x34(%rbp),%xmm2
movss  0x34(%rbx),%xmm3
mulss  0x34(%r12,%rsi,4),%xmm3
addss  %xmm2,%xmm3
addss  0x34(%rax),%xmm3
subss  0x30(%rbp),%xmm3
movss  0x30(%rbx),%xmm2
mulss  0x30(%r12,%rsi,4),%xmm2
shl    $0x3,%edx
subss  %xmm2,%xmm3
subss  0x30(%rax),%xmm3
movslq %edx,%rdx
mov    -0x80(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm3,0x18(%r11,%r9,4)
movaps %xmm1,%xmm2
divss  0x38(%r13),%xmm2
movss  %xmm2,0x38(%rcx)
movaps %xmm1,%xmm3
divss  0x3c(%r13),%xmm3
movss  %xmm3,0x3c(%rcx)
mulss  0x38(%rbp),%xmm2
movss  %xmm2,0x38(%rbx)
movss  0x3c(%rbp),%xmm2
mulss  0x3c(%rcx),%xmm2
movss  %xmm2,0x3c(%rbx)
movss  0x38(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x38(%rax)
movss  0x3c(%rcx),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x3c(%rax)
movss  0x1c(%r10,%r9,4),%xmm2
addss  0x38(%rbx),%xmm2
lea    0x7(%r9),%rdx
addss  0x3c(%rbx),%xmm2
lea    0x7(%r8,%rdx,8),%edi
movslq %edi,%rdi
movss  %xmm2,(%r14,%rdi,4)
movss  0x3c(%rbx),%xmm2
movss  0x38(%rbx),%xmm3
mulss  0x3c(%r12,%rsi,4),%xmm2
mulss  0x38(%r12,%rsi,4),%xmm3
movss  0x1c(%r15,%r9,4),%xmm4
addss  0x3c(%rbp),%xmm4
addss  %xmm4,%xmm2
addss  0x3c(%rax),%xmm2
shl    $0x3,%edx
subss  0x38(%rbp),%xmm2
subss  %xmm3,%xmm2
subss  0x38(%rax),%xmm2
movslq %edx,%rdx
mov    -0x80(%rsp),%rsi
movss  %xmm2,(%rsi,%rdx,4)
add    $0x40,%r13
add    $0x40,%rbp
add    $0x40,%rbx
movss  %xmm2,0x1c(%r11,%r9,4)
add    $0x40,%rax
add    $0x40,%rcx
add    $0x8,%r9
cmp    -0x30(%rsp),%r9
jl     1c20 <s_update_hessian_box_mhe+0xb20>
mov    -0x50(%rsp),%r14
cmp    %r14d,%r9d
mov    -0x10(%rsp),%r8
mov    -0x70(%rsp),%rdi
jge    23d5 <s_update_hessian_box_mhe+0x12d5>
sub    %r9d,%r14d
test   %r14d,%r14d
jle    23d5 <s_update_hessian_box_mhe+0x12d5>
movslq %r9d,%rdx
mov    %r14d,%r14d
add    $0x8,%r8d
imul   %r9d,%r8d
lea    (%r9,%r9,1),%esi
mov    %rsi,-0x68(%rsp)
shl    $0x3,%r9d
lea    (%r10,%rdx,4),%rsi
mov    %rsi,-0x78(%rsp)
lea    (%r15,%rdx,4),%r15
lea    (%r11,%rdx,4),%r11
add    %r14,%r14
xor    %esi,%esi
movss  0xd27(%rip),%xmm1
nopl   0x0(%rax)
movaps %xmm1,%xmm2
divss  0x0(%r13,%rsi,4),%xmm2
movss  %xmm2,(%rcx,%rsi,4)
movaps %xmm1,%xmm3
divss  0x4(%r13,%rsi,4),%xmm3
movss  %xmm3,0x4(%rcx,%rsi,4)
mulss  0x0(%rbp,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
movss  0x4(%rbp,%rsi,4),%xmm2
mulss  0x4(%rcx,%rsi,4),%xmm2
movss  %xmm2,0x4(%rbx,%rsi,4)
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rax,%rsi,4)
movss  0x4(%rcx,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%rax,%rsi,4)
mov    -0x78(%rsp),%rdx
movss  (%rdx,%rsi,2),%xmm2
addss  (%rbx,%rsi,4),%xmm2
addss  0x4(%rbx,%rsi,4),%xmm2
movslq %r8d,%r8
movss  %xmm2,(%rdi,%r8,4)
movss  0x4(%rbx,%rsi,4),%xmm2
mov    %rdi,%r10
mov    -0x68(%rsp),%rdx
lea    (%rdx,%rsi,1),%rdi
lea    0x1(%rdi),%edx
movslq %edx,%rdx
mulss  (%r12,%rdx,4),%xmm2
movss  (%rbx,%rsi,4),%xmm3
movslq %edi,%rdx
mov    %r10,%rdi
mulss  (%r12,%rdx,4),%xmm3
movss  (%r15,%rsi,2),%xmm4
addss  0x4(%rbp,%rsi,4),%xmm4
addss  %xmm4,%xmm2
addss  0x4(%rax,%rsi,4),%xmm2
subss  0x0(%rbp,%rsi,4),%xmm2
subss  %xmm3,%xmm2
subss  (%rax,%rsi,4),%xmm2
movslq %r9d,%r9
mov    -0x80(%rsp),%rdx
movss  %xmm2,(%rdx,%r9,4)
movss  %xmm2,(%r11,%rsi,2)
add    $0x9,%r8d
add    $0x2,%rsi
add    $0x8,%r9d
cmp    %rsi,%r14
jne    22e0 <s_update_hessian_box_mhe+0x11e0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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