void s_update_hessian_box_mpc(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 = 4;
  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;
  ptr_t = t[0];
  ptr_lam = lam[0];
  ptr_lamt = lamt[0];
  ptr_dlam = dlam[0];
  ptr_tinv = t_inv[0];
  ptr_pd = pd[0];
  ptr_pl = pl[0];
  ptr_pl2 = pl2[0];
  ptr_bd = bd[0];
  ptr_bl = bl[0];
  ptr_db = db[0];
  ii = 0;
  for (; ii < k0 - 3; ii += 4) {
    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_t += 8;
    ptr_lam += 8;
    ptr_lamt += 8;
    ptr_dlam += 8;
    ptr_tinv += 8;
  }
  if (ii < k0) {
    bs0 = k0 - 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;
    }
  }
  for (jj = 1; 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 - 3; ii += 4) {
      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_t += 8;
      ptr_lam += 8;
      ptr_lamt += 8;
      ptr_dlam += 8;
      ptr_tinv += 8;
    }
    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 - 3; ii += 4) {
    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_t += 8;
    ptr_lam += 8;
    ptr_lamt += 8;
    ptr_dlam += 8;
    ptr_tinv += 8;
  }
  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_mpc>:
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   $0x4,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
mov    0x40(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x60(%rbp)
mov    0x48(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
mov    0x50(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x80(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    19b3 <s_update_hessian_box_mpc+0x8b3>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2e02(%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  0x2ddd(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%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  0x2c2b(%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  0x2c05(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%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  0x2a4a(%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  0x2a24(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%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  0x2869(%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  0x2843(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%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
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x8c(%rbp)
jmp    11d6 <s_update_hessian_box_mpc+0xd6>
mov    -0x8c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c48 <s_update_hessian_box_mpc+0xb48>
mov    -0x8(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1c43 <s_update_hessian_box_mpc+0xb43>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x25ff(%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  0x25da(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x2,%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    19db <s_update_hessian_box_mpc+0x8db>
jmp    1c48 <s_update_hessian_box_mpc+0xb48>
movl   $0x1,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    27ca <s_update_hessian_box_mpc+0x16ca>
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    $0x3,%ecx
cmp    %ecx,%eax
jge    251c <s_update_hessian_box_mpc+0x141c>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2299(%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  0x2274(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%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  0x20c2(%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  0x209c(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%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  0x1ee1(%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  0x1ebb(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%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  0x1d00(%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  0x1cda(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%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
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x8c(%rbp)
jmp    1d3f <s_update_hessian_box_mpc+0xc3f>
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    27b1 <s_update_hessian_box_mpc+0x16b1>
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    27ac <s_update_hessian_box_mpc+0x16ac>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1a96(%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  0x1a71(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x2,%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    2544 <s_update_hessian_box_mpc+0x1444>
jmp    27b1 <s_update_hessian_box_mpc+0x16b1>
jmp    27b6 <s_update_hessian_box_mpc+0x16b6>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1c52 <s_update_hessian_box_mpc+0xb52>
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    $0x3,%ecx
cmp    %ecx,%eax
jge    30b3 <s_update_hessian_box_mpc+0x1fb3>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1702(%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  0x16dd(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x2,%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  0x152b(%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  0x1505(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x2,%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  0x134a(%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  0x1324(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x2,%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  0x1169(%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  0x1143(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x2,%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
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x8c(%rbp)
jmp    28d6 <s_update_hessian_box_mpc+0x17d6>
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    3348 <s_update_hessian_box_mpc+0x2248>
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    3343 <s_update_hessian_box_mpc+0x2243>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeff(%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  0xeda(%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    $0x2,%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    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
shl    $0x2,%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    30db <s_update_hessian_box_mpc+0x1fdb>
jmp    3348 <s_update_hessian_box_mpc+0x2248>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_update_hessian_box_mpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,-0x20(%rsp)
mov    %edx,%r12d
mov    %edi,-0x30(%rsp)
mov    0xc8(%rsp),%r15
mov    0xc0(%rsp),%rdx
mov    0xb8(%rsp),%r14
mov    0xb0(%rsp),%r13
mov    0xa8(%rsp),%rax
mov    0xa0(%rsp),%rbx
mov    0x98(%rsp),%rdi
mov    0x90(%rsp),%rcx
mov    %r9,-0x28(%rsp)
mov    (%r9),%r9
mov    (%rdi),%r11
mov    (%rbx),%rbp
mov    (%rax),%rbx
mov    (%rcx),%rax
mov    (%rdx),%rcx
mov    %rcx,-0x80(%rsp)
mov    (%r15),%r10
mov    0xd0(%rsp),%rcx
mov    (%rcx),%rdx
mov    0x0(%r13),%r13
mov    (%r14),%r14
mov    0xd8(%rsp),%rcx
mov    (%rcx),%r15
xor    %edi,%edi
cmp    $0x4,%esi
mov    %r8,(%rsp)
mov    %r12,0x20(%rsp)
mov    %r10,-0x68(%rsp)
jl     15f8 <s_update_hessian_box_mpc+0x4f8>
mov    %rsi,-0x48(%rsp)
add    $0xfffffffd,%esi
mov    %rsi,-0x8(%rsp)
movslq %r8d,%rsi
lea    0x10(,%rsi,4),%ecx
mov    %ecx,-0x18(%rsp)
shl    $0x2,%rsi
mov    %rsi,-0x10(%rsp)
mov    %rdx,-0x40(%rsp)
mov    $0xf,%esi
xor    %ecx,%ecx
movss  0x1e19(%rip),%xmm1
xor    %r12d,%r12d
mov    %r13,-0x58(%rsp)
xor    %edx,%edx
xor    %edi,%edi
mov    %r14,-0x60(%rsp)
mov    -0x58(%rsp),%r8
mov    -0x60(%rsp),%r10
mov    -0x40(%rsp),%r13
nopw   0x0(%rax,%rax,1)
mov    %rdx,-0x50(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %rcx,-0x70(%rsp)
movaps %xmm1,%xmm2
divss  (%r9,%r12,2),%xmm2
movslq %r12d,%r14
movss  %xmm2,(%rax,%r12,2)
movaps %xmm1,%xmm3
divss  0x4(%r9,%r12,2),%xmm3
lea    (%rdx,%r14,1),%rcx
movss  %xmm3,0x4(%rax,%r12,2)
mulss  (%r11,%r12,2),%xmm2
movss  %xmm2,0x0(%rbp,%r12,2)
movss  0x4(%r11,%r12,2),%xmm2
mulss  0x4(%rax,%r12,2),%xmm2
movss  %xmm2,0x4(%rbp,%r12,2)
movss  (%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%r12,2)
movss  0x4(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%rbx,%r12,2)
movss  (%r8,%r12,1),%xmm2
addss  0x0(%rbp,%r12,2),%xmm2
addss  0x4(%rbp,%r12,2),%xmm2
mov    -0x80(%rsp),%rdi
movss  %xmm2,(%rdi,%rcx,4)
movss  (%r10,%r12,1),%xmm2
addss  0x4(%r11,%r12,2),%xmm2
movss  0x4(%rbp,%r12,2),%xmm3
mulss  0x4(%r15,%r12,2),%xmm3
movss  0x0(%rbp,%r12,2),%xmm4
addss  %xmm2,%xmm3
addss  0x4(%rbx,%r12,2),%xmm3
subss  (%r11,%r12,2),%xmm3
mulss  (%r15,%r12,2),%xmm4
subss  %xmm4,%xmm3
subss  (%rbx,%r12,2),%xmm3
mov    %r14d,%ecx
mov    -0x68(%rsp),%rdx
movss  %xmm3,(%rdx,%rcx,4)
movss  %xmm3,0x0(%r13,%r12,1)
movaps %xmm1,%xmm2
divss  0x8(%r9,%r12,2),%xmm2
movss  %xmm2,0x8(%rax,%r12,2)
movaps %xmm1,%xmm3
divss  0xc(%r9,%r12,2),%xmm3
movss  %xmm3,0xc(%rax,%r12,2)
mulss  0x8(%r11,%r12,2),%xmm2
movss  %xmm2,0x8(%rbp,%r12,2)
movss  0xc(%r11,%r12,2),%xmm2
mulss  0xc(%rax,%r12,2),%xmm2
movss  %xmm2,0xc(%rbp,%r12,2)
movss  0x8(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%rbx,%r12,2)
movss  0xc(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0xc(%rbx,%r12,2)
movss  0x4(%r8,%r12,1),%xmm2
addss  0x8(%rbp,%r12,2),%xmm2
addss  0xc(%rbp,%r12,2),%xmm2
lea    -0xa(%rsi),%ecx
movslq %ecx,%rcx
movss  %xmm2,(%rdi,%rcx,4)
movss  0x4(%r10,%r12,1),%xmm2
addss  0xc(%r11,%r12,2),%xmm2
movss  0xc(%rbp,%r12,2),%xmm3
mulss  0xc(%r15,%r12,2),%xmm3
movss  0x8(%rbp,%r12,2),%xmm4
addss  %xmm2,%xmm3
addss  0xc(%rbx,%r12,2),%xmm3
subss  0x8(%r11,%r12,2),%xmm3
mulss  0x8(%r15,%r12,2),%xmm4
lea    0x4(%r14),%ecx
subss  %xmm4,%xmm3
subss  0x8(%rbx,%r12,2),%xmm3
movss  %xmm3,(%rdx,%rcx,4)
movss  %xmm3,0x4(%r13,%r12,1)
movaps %xmm1,%xmm2
divss  0x10(%r9,%r12,2),%xmm2
movss  %xmm2,0x10(%rax,%r12,2)
movaps %xmm1,%xmm3
divss  0x14(%r9,%r12,2),%xmm3
movss  %xmm3,0x14(%rax,%r12,2)
mulss  0x10(%r11,%r12,2),%xmm2
movss  %xmm2,0x10(%rbp,%r12,2)
movss  0x14(%r11,%r12,2),%xmm2
mulss  0x14(%rax,%r12,2),%xmm2
movss  %xmm2,0x14(%rbp,%r12,2)
movss  0x10(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%rbx,%r12,2)
movss  0x14(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x14(%rbx,%r12,2)
movss  0x8(%r8,%r12,1),%xmm2
addss  0x10(%rbp,%r12,2),%xmm2
addss  0x14(%rbp,%r12,2),%xmm2
lea    -0x5(%rsi),%ecx
movslq %ecx,%rcx
movss  %xmm2,(%rdi,%rcx,4)
movss  0x8(%r10,%r12,1),%xmm2
addss  0x14(%r11,%r12,2),%xmm2
movss  0x14(%rbp,%r12,2),%xmm3
mulss  0x14(%r15,%r12,2),%xmm3
movss  0x10(%rbp,%r12,2),%xmm4
addss  %xmm2,%xmm3
addss  0x14(%rbx,%r12,2),%xmm3
subss  0x10(%r11,%r12,2),%xmm3
mulss  0x10(%r15,%r12,2),%xmm4
lea    0x8(%r14),%ecx
subss  %xmm4,%xmm3
subss  0x10(%rbx,%r12,2),%xmm3
movss  %xmm3,(%rdx,%rcx,4)
mov    -0x70(%rsp),%rcx
movss  %xmm3,0x8(%r13,%r12,1)
movaps %xmm1,%xmm2
divss  0x18(%r9,%r12,2),%xmm2
movss  %xmm2,0x18(%rax,%r12,2)
movaps %xmm1,%xmm3
divss  0x1c(%r9,%r12,2),%xmm3
movss  %xmm3,0x1c(%rax,%r12,2)
mulss  0x18(%r11,%r12,2),%xmm2
movss  %xmm2,0x18(%rbp,%r12,2)
movss  0x1c(%r11,%r12,2),%xmm2
mulss  0x1c(%rax,%r12,2),%xmm2
movss  %xmm2,0x1c(%rbp,%r12,2)
movss  0x18(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x18(%rbx,%r12,2)
movss  0x1c(%rax,%r12,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x1c(%rbx,%r12,2)
movss  0xc(%r8,%r12,1),%xmm2
addss  0x18(%rbp,%r12,2),%xmm2
addss  0x1c(%rbp,%r12,2),%xmm2
movslq %esi,%rsi
movss  %xmm2,(%rdi,%rsi,4)
movss  0xc(%r10,%r12,1),%xmm2
addss  0x1c(%r11,%r12,2),%xmm2
movss  0x1c(%rbp,%r12,2),%xmm3
mulss  0x1c(%r15,%r12,2),%xmm3
movss  0x18(%rbp,%r12,2),%xmm4
addss  %xmm2,%xmm3
addss  0x1c(%rbx,%r12,2),%xmm3
subss  0x18(%r11,%r12,2),%xmm3
mulss  0x18(%r15,%r12,2),%xmm4
add    $0xc,%r14d
subss  %xmm4,%xmm3
subss  0x18(%rbx,%r12,2),%xmm3
movss  %xmm3,(%rdx,%r14,4)
mov    -0x50(%rsp),%rdx
mov    -0x78(%rsp),%rdi
movss  %xmm3,0xc(%r13,%r12,1)
add    $0x4,%rdi
add    -0x18(%rsp),%esi
add    -0x10(%rsp),%rdx
add    $0x10,%r12
add    $0x20,%rcx
cmp    -0x8(%rsp),%rdi
jb     1210 <s_update_hessian_box_mpc+0x110>
mov    -0x40(%rsp),%r8
add    %rcx,%rax
add    %rcx,%rbx
add    %rcx,%rbp
add    %rcx,%r11
add    %rcx,%r9
mov    -0x48(%rsp),%rsi
mov    -0x58(%rsp),%r13
mov    -0x60(%rsp),%r14
cmp    %esi,%edi
jl     1603 <s_update_hessian_box_mpc+0x503>
jmp    1776 <s_update_hessian_box_mpc+0x676>
mov    %rdx,%r8
cmp    %esi,%edi
jge    1776 <s_update_hessian_box_mpc+0x676>
sub    %edi,%esi
test   %esi,%esi
jle    1776 <s_update_hessian_box_mpc+0x676>
movslq %edi,%r12
mov    %esi,%r10d
mov    (%rsp),%rdx
add    $0x4,%edx
imul   %edi,%edx
lea    (%rdi,%rdi,1),%esi
lea    (%r8,%r12,4),%rcx
mov    %rcx,-0x70(%rsp)
lea    (%r14,%r12,4),%rcx
mov    %rcx,-0x78(%rsp)
lea    0x0(%r13,%r12,4),%r13
mov    -0x80(%rsp),%r8
shl    $0x21,%r12
shl    $0x2,%edi
shl    $0x2,%r10
xor    %r14d,%r14d
movss  0x19ae(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm1,%xmm2
divss  (%r9,%r14,2),%xmm2
movss  %xmm2,(%rax,%r14,2)
movaps %xmm1,%xmm3
divss  0x4(%r9,%r14,2),%xmm3
movss  %xmm3,0x4(%rax,%r14,2)
mulss  (%r11,%r14,2),%xmm2
movss  %xmm2,0x0(%rbp,%r14,2)
movss  0x4(%r11,%r14,2),%xmm2
mulss  0x4(%rax,%r14,2),%xmm2
movss  %xmm2,0x4(%rbp,%r14,2)
movss  (%rax,%r14,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%r14,2)
movss  0x4(%rax,%r14,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%rbx,%r14,2)
movss  0x0(%r13,%r14,1),%xmm2
addss  0x0(%rbp,%r14,2),%xmm2
addss  0x4(%rbp,%r14,2),%xmm2
movslq %edx,%rdx
movss  %xmm2,(%r8,%rdx,4)
mov    -0x78(%rsp),%rcx
movss  (%rcx,%r14,1),%xmm2
addss  0x4(%r11,%r14,2),%xmm2
movss  0x4(%rbp,%r14,2),%xmm3
mov    %r12,%rcx
sar    $0x1e,%rcx
or     $0x4,%rcx
mulss  (%r15,%rcx,1),%xmm3
addss  %xmm2,%xmm3
addss  0x4(%rbx,%r14,2),%xmm3
subss  (%r11,%r14,2),%xmm3
movss  0x0(%rbp,%r14,2),%xmm2
movslq %esi,%rsi
mulss  (%r15,%rsi,4),%xmm2
subss  %xmm2,%xmm3
subss  (%rbx,%r14,2),%xmm3
lea    (%rdi,%r14,1),%ecx
mov    -0x68(%rsp),%r8
movss  %xmm3,(%r8,%rcx,4)
mov    -0x80(%rsp),%r8
mov    -0x70(%rsp),%rcx
movss  %xmm3,(%rcx,%r14,1)
add    $0x5,%edx
add    $0x2,%esi
movabs $0x200000000,%rcx
add    %rcx,%r12
add    $0x4,%r14
cmp    %r14,%r10
jne    1660 <s_update_hessian_box_mpc+0x560>
mov    -0x20(%rsp),%r14
lea    -0x3(%r14),%eax
mov    %eax,0x8(%rsp)
cmpl   $0x2,-0x30(%rsp)
jl     1e3e <s_update_hessian_box_mpc+0xd3e>
mov    (%rsp),%rax
movslq %eax,%rdi
movslq 0x8(%rsp),%r9
mov    -0x30(%rsp),%ecx
mov    %rcx,0x18(%rsp)
lea    0x10(,%rax,4),%ebp
shl    $0x2,%rdi
add    $0x4,%eax
mov    %eax,0x10(%rsp)
mov    $0x1,%edx
movss  0x183e(%rip),%xmm1
mov    %rdi,-0x8(%rsp)
mov    %r9,-0x10(%rsp)
mov    %ebp,-0x18(%rsp)
jmp    17f9 <s_update_hessian_box_mpc+0x6f9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x48(%rsp),%rdx
add    $0x1,%rdx
cmp    0x18(%rsp),%rdx
mov    -0x20(%rsp),%r14
je     1e3e <s_update_hessian_box_mpc+0xd3e>
mov    -0x28(%rsp),%rax
mov    (%rax,%rdx,8),%rax
mov    %rax,-0x38(%rsp)
mov    0x98(%rsp),%rax
mov    (%rax,%rdx,8),%rsi
mov    0xa0(%rsp),%rax
mov    (%rax,%rdx,8),%r12
mov    0xa8(%rsp),%rax
mov    (%rax,%rdx,8),%r10
mov    0x90(%rsp),%rax
mov    (%rax,%rdx,8),%r11
mov    0xc0(%rsp),%rax
mov    (%rax,%rdx,8),%r8
mov    0xc8(%rsp),%rax
mov    (%rax,%rdx,8),%r15
mov    0xd0(%rsp),%rax
mov    (%rax,%rdx,8),%rax
mov    %rax,-0x58(%rsp)
mov    0xb0(%rsp),%rax
mov    (%rax,%rdx,8),%r13
mov    0xb8(%rsp),%rax
mov    (%rax,%rdx,8),%rbx
mov    0xd8(%rsp),%rcx
mov    (%rcx,%rdx,8),%rcx
cmp    $0x4,%r14d
mov    %rdx,-0x48(%rsp)
mov    %rbx,-0x60(%rsp)
mov    %r8,-0x80(%rsp)
mov    %r15,-0x68(%rsp)
jl     1cc0 <s_update_hessian_box_mpc+0xbc0>
mov    $0xf,%ebp
xor    %edx,%edx
mov    %r13,-0x40(%rsp)
xor    %r13d,%r13d
xor    %eax,%eax
xor    %ebx,%ebx
mov    -0x38(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    %rbx,-0x50(%rsp)
mov    %rax,-0x78(%rsp)
mov    %rdx,-0x70(%rsp)
movaps %xmm1,%xmm2
divss  (%rdi,%r13,2),%xmm2
movslq %r13d,%r9
movss  %xmm2,(%r11,%r13,2)
movaps %xmm1,%xmm3
divss  0x4(%rdi,%r13,2),%xmm3
lea    (%rax,%r9,1),%rdx
movss  %xmm3,0x4(%r11,%r13,2)
mulss  (%rsi,%r13,2),%xmm2
movss  %xmm2,(%r12,%r13,2)
movss  0x4(%rsi,%r13,2),%xmm2
mulss  0x4(%r11,%r13,2),%xmm2
movss  %xmm2,0x4(%r12,%r13,2)
movss  (%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%r10,%r13,2)
movss  0x4(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%r10,%r13,2)
mov    -0x40(%rsp),%r8
movss  (%r8,%r13,1),%xmm2
addss  (%r12,%r13,2),%xmm2
addss  0x4(%r12,%r13,2),%xmm2
mov    -0x80(%rsp),%rbx
movss  %xmm2,(%rbx,%rdx,4)
mov    -0x60(%rsp),%rax
movss  (%rax,%r13,1),%xmm2
addss  0x4(%rsi,%r13,2),%xmm2
movss  0x4(%r12,%r13,2),%xmm3
mulss  0x4(%rcx,%r13,2),%xmm3
movss  (%r12,%r13,2),%xmm4
addss  %xmm2,%xmm3
addss  0x4(%r10,%r13,2),%xmm3
subss  (%rsi,%r13,2),%xmm3
mulss  (%rcx,%r13,2),%xmm4
subss  %xmm4,%xmm3
subss  (%r10,%r13,2),%xmm3
mov    %r9d,%edx
mov    -0x68(%rsp),%r14
movss  %xmm3,(%r14,%rdx,4)
mov    -0x58(%rsp),%r15
movss  %xmm3,(%r15,%r13,1)
movaps %xmm1,%xmm2
divss  0x8(%rdi,%r13,2),%xmm2
movss  %xmm2,0x8(%r11,%r13,2)
movaps %xmm1,%xmm3
divss  0xc(%rdi,%r13,2),%xmm3
movss  %xmm3,0xc(%r11,%r13,2)
mulss  0x8(%rsi,%r13,2),%xmm2
movss  %xmm2,0x8(%r12,%r13,2)
movss  0xc(%rsi,%r13,2),%xmm2
mulss  0xc(%r11,%r13,2),%xmm2
movss  %xmm2,0xc(%r12,%r13,2)
movss  0x8(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%r10,%r13,2)
movss  0xc(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0xc(%r10,%r13,2)
movss  0x4(%r8,%r13,1),%xmm2
addss  0x8(%r12,%r13,2),%xmm2
addss  0xc(%r12,%r13,2),%xmm2
lea    -0xa(%rbp),%edx
movslq %edx,%rdx
movss  %xmm2,(%rbx,%rdx,4)
movss  0x4(%rax,%r13,1),%xmm2
addss  0xc(%rsi,%r13,2),%xmm2
movss  0xc(%r12,%r13,2),%xmm3
mulss  0xc(%rcx,%r13,2),%xmm3
movss  0x8(%r12,%r13,2),%xmm4
addss  %xmm2,%xmm3
addss  0xc(%r10,%r13,2),%xmm3
subss  0x8(%rsi,%r13,2),%xmm3
mulss  0x8(%rcx,%r13,2),%xmm4
lea    0x4(%r9),%edx
subss  %xmm4,%xmm3
subss  0x8(%r10,%r13,2),%xmm3
movss  %xmm3,(%r14,%rdx,4)
movss  %xmm3,0x4(%r15,%r13,1)
movaps %xmm1,%xmm2
divss  0x10(%rdi,%r13,2),%xmm2
movss  %xmm2,0x10(%r11,%r13,2)
movaps %xmm1,%xmm3
divss  0x14(%rdi,%r13,2),%xmm3
movss  %xmm3,0x14(%r11,%r13,2)
mulss  0x10(%rsi,%r13,2),%xmm2
movss  %xmm2,0x10(%r12,%r13,2)
movss  0x14(%rsi,%r13,2),%xmm2
mulss  0x14(%r11,%r13,2),%xmm2
movss  %xmm2,0x14(%r12,%r13,2)
movss  0x10(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%r10,%r13,2)
movss  0x14(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x14(%r10,%r13,2)
movss  0x8(%r8,%r13,1),%xmm2
addss  0x10(%r12,%r13,2),%xmm2
addss  0x14(%r12,%r13,2),%xmm2
lea    -0x5(%rbp),%edx
movslq %edx,%rdx
movss  %xmm2,(%rbx,%rdx,4)
movss  0x8(%rax,%r13,1),%xmm2
addss  0x14(%rsi,%r13,2),%xmm2
movss  0x14(%r12,%r13,2),%xmm3
mulss  0x14(%rcx,%r13,2),%xmm3
movss  0x10(%r12,%r13,2),%xmm4
addss  %xmm2,%xmm3
addss  0x14(%r10,%r13,2),%xmm3
subss  0x10(%rsi,%r13,2),%xmm3
mulss  0x10(%rcx,%r13,2),%xmm4
lea    0x8(%r9),%edx
subss  %xmm4,%xmm3
subss  0x10(%r10,%r13,2),%xmm3
movss  %xmm3,(%r14,%rdx,4)
mov    -0x70(%rsp),%rdx
movss  %xmm3,0x8(%r15,%r13,1)
movaps %xmm1,%xmm2
divss  0x18(%rdi,%r13,2),%xmm2
movss  %xmm2,0x18(%r11,%r13,2)
movaps %xmm1,%xmm3
divss  0x1c(%rdi,%r13,2),%xmm3
movss  %xmm3,0x1c(%r11,%r13,2)
mulss  0x18(%rsi,%r13,2),%xmm2
movss  %xmm2,0x18(%r12,%r13,2)
movss  0x1c(%rsi,%r13,2),%xmm2
mulss  0x1c(%r11,%r13,2),%xmm2
movss  %xmm2,0x1c(%r12,%r13,2)
movss  0x18(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x18(%r10,%r13,2)
movss  0x1c(%r11,%r13,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r10,%r13,2)
movss  0xc(%r8,%r13,1),%xmm2
addss  0x18(%r12,%r13,2),%xmm2
addss  0x1c(%r12,%r13,2),%xmm2
movslq %ebp,%rbp
movss  %xmm2,(%rbx,%rbp,4)
mov    -0x50(%rsp),%rbx
movss  0xc(%rax,%r13,1),%xmm2
mov    -0x78(%rsp),%rax
addss  0x1c(%rsi,%r13,2),%xmm2
movss  0x1c(%r12,%r13,2),%xmm3
mulss  0x1c(%rcx,%r13,2),%xmm3
movss  0x18(%r12,%r13,2),%xmm4
addss  %xmm2,%xmm3
addss  0x1c(%r10,%r13,2),%xmm3
subss  0x18(%rsi,%r13,2),%xmm3
mulss  0x18(%rcx,%r13,2),%xmm4
add    $0xc,%r9d
subss  %xmm4,%xmm3
subss  0x18(%r10,%r13,2),%xmm3
movss  %xmm3,(%r14,%r9,4)
movss  %xmm3,0xc(%r15,%r13,1)
add    $0x4,%rbx
add    -0x18(%rsp),%ebp
add    -0x8(%rsp),%rax
add    $0x10,%r13
add    $0x20,%rdx
cmp    -0x10(%rsp),%rbx
jl     18c0 <s_update_hessian_box_mpc+0x7c0>
add    %rdx,%r11
add    %rdx,%r10
add    %rdx,%r12
add    %rdx,%rsi
add    %rdx,%rdi
mov    -0x20(%rsp),%r14
mov    -0x40(%rsp),%r13
mov    -0x58(%rsp),%r9
mov    %rdi,%r15
cmp    %r14d,%ebx
jge    17e0 <s_update_hessian_box_mpc+0x6e0>
jmp    1cd5 <s_update_hessian_box_mpc+0xbd5>
cs nopw 0x0(%rax,%rax,1)
xor    %ebx,%ebx
mov    -0x58(%rsp),%r9
mov    -0x38(%rsp),%r15
cmp    %r14d,%ebx
jge    17e0 <s_update_hessian_box_mpc+0x6e0>
mov    -0x20(%rsp),%rdx
mov    %edx,%edi
sub    %ebx,%edi
test   %edi,%edi
jle    17e0 <s_update_hessian_box_mpc+0x6e0>
movslq %ebx,%rdx
mov    %edi,%r14d
mov    0x10(%rsp),%edi
mov    %edi,%ebp
imul   %ebx,%ebp
lea    (%rbx,%rbx,1),%edi
lea    (%r9,%rdx,4),%rax
mov    %rax,-0x70(%rsp)
mov    -0x60(%rsp),%rax
lea    (%rax,%rdx,4),%rax
mov    %rax,-0x78(%rsp)
lea    0x0(%r13,%rdx,4),%r13
mov    %rdx,%r9
shl    $0x21,%r9
shl    $0x2,%ebx
shl    $0x2,%r14
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm1,%xmm2
divss  (%r15,%rdx,2),%xmm2
movss  %xmm2,(%r11,%rdx,2)
movaps %xmm1,%xmm3
divss  0x4(%r15,%rdx,2),%xmm3
movss  %xmm3,0x4(%r11,%rdx,2)
mulss  (%rsi,%rdx,2),%xmm2
movss  %xmm2,(%r12,%rdx,2)
movss  0x4(%rsi,%rdx,2),%xmm2
mulss  0x4(%r11,%rdx,2),%xmm2
movss  %xmm2,0x4(%r12,%rdx,2)
movss  (%r11,%rdx,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%r10,%rdx,2)
movss  0x4(%r11,%rdx,2),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%r10,%rdx,2)
movss  0x0(%r13,%rdx,1),%xmm2
addss  (%r12,%rdx,2),%xmm2
addss  0x4(%r12,%rdx,2),%xmm2
movslq %ebp,%rbp
mov    -0x80(%rsp),%rax
movss  %xmm2,(%rax,%rbp,4)
mov    -0x78(%rsp),%rax
movss  (%rax,%rdx,1),%xmm2
addss  0x4(%rsi,%rdx,2),%xmm2
movss  0x4(%r12,%rdx,2),%xmm3
mov    %r9,%rax
sar    $0x1e,%rax
or     $0x4,%rax
mulss  (%rcx,%rax,1),%xmm3
addss  %xmm2,%xmm3
addss  0x4(%r10,%rdx,2),%xmm3
subss  (%rsi,%rdx,2),%xmm3
movss  (%r12,%rdx,2),%xmm2
movslq %edi,%rdi
mulss  (%rcx,%rdi,4),%xmm2
subss  %xmm2,%xmm3
subss  (%r10,%rdx,2),%xmm3
lea    (%rbx,%rdx,1),%eax
mov    -0x68(%rsp),%r8
movss  %xmm3,(%r8,%rax,4)
mov    -0x70(%rsp),%rax
movss  %xmm3,(%rax,%rdx,1)
add    $0x5,%ebp
add    $0x2,%edi
movabs $0x200000000,%rax
add    %rax,%r9
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1d30 <s_update_hessian_box_mpc+0xc30>
jmp    17e0 <s_update_hessian_box_mpc+0x6e0>
movslq -0x30(%rsp),%rax
mov    -0x28(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
mov    0x20(%rsp),%rbp
lea    0x0(%rbp,%rbp,1),%ecx
mov    %ecx,-0x60(%rsp)
movslq %ecx,%rdx
mov    %rsi,-0x68(%rsp)
lea    (%rsi,%rdx,4),%rcx
mov    %rcx,-0x38(%rsp)
mov    0x98(%rsp),%rdi
mov    (%rdi,%rax,8),%r8
mov    0xa0(%rsp),%rdi
mov    (%rdi,%rax,8),%rbx
mov    0xa8(%rsp),%rdi
mov    (%rdi,%rax,8),%rcx
mov    0x90(%rsp),%rdi
mov    (%rdi,%rax,8),%rsi
mov    0xc0(%rsp),%rdi
mov    (%rdi,%rax,8),%rdi
mov    %rdi,-0x70(%rsp)
mov    0xc8(%rsp),%rdi
mov    (%rdi,%rax,8),%r10
mov    0xd0(%rsp),%rdi
mov    (%rdi,%rax,8),%rdi
mov    %rdi,0x38(%rsp)
mov    0xb0(%rsp),%rdi
mov    (%rdi,%rax,8),%rdi
mov    %rdi,0x30(%rsp)
mov    0xb8(%rsp),%rdi
mov    (%rdi,%rax,8),%r9
mov    0xd8(%rsp),%rdi
mov    (%rdi,%rax,8),%r12
lea    (%r8,%rdx,4),%r13
mov    %rbx,-0x28(%rsp)
lea    (%rbx,%rdx,4),%r15
mov    %rcx,0x18(%rsp)
lea    (%rcx,%rdx,4),%rcx
mov    %rcx,-0x48(%rsp)
lea    (%rsi,%rdx,4),%r11
mov    0x8(%rsp),%edi
cmp    %ebp,%edi
jle    2492 <s_update_hessian_box_mpc+0x1392>
mov    %r8,%rax
mov    %rsi,%r8
mov    %rdx,0x40(%rsp)
movslq %ebp,%rsi
mov    %r12,0x10(%rsp)
mov    %r9,%rbx
mov    %rax,%r9
mov    (%rsp),%rdx
movslq %edx,%rcx
movslq %edi,%rdi
mov    %rdi,0x8(%rsp)
mov    %rbx,%rdi
lea    0x4(%rdx),%eax
imul   %ebp,%eax
add    $0xf,%eax
mov    %rax,-0x58(%rsp)
lea    0x10(,%rdx,4),%eax
mov    %eax,0x2c(%rsp)
mov    %r10,-0x78(%rsp)
mov    -0x68(%rsp),%r12
mov    %ebp,%ebx
shl    $0x2,%ebx
lea    0xc(,%rbp,4),%r10d
mov    0x30(%rsp),%rax
lea    (%rax,%rsi,4),%rdx
add    $0xc,%rdx
mov    %rdx,0x20(%rsp)
mov    %rdi,0x48(%rsp)
lea    0xc(%rdi,%rsi,4),%rdx
mov    %rdx,-0x50(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rsi,4),%rdx
add    $0xc,%rdx
mov    %rdx,-0x80(%rsp)
mov    %rcx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rcx
mov    %rcx,-0x30(%rsp)
mov    -0x60(%rsp),%ecx
mov    %rcx,0x50(%rsp)
mov    %r8,%rdi
xor    %ecx,%ecx
movss  0x1030(%rip),%xmm1
mov    -0x48(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9,-0x10(%rsp)
mov    %r12,-0x68(%rsp)
mov    %rdi,-0x8(%rsp)
mov    %rdx,-0x40(%rsp)
mov    %rsi,-0x60(%rsp)
movaps %xmm1,%xmm2
mov    -0x38(%rsp),%rsi
divss  (%rsi,%rcx,4),%xmm2
movslq %ebx,%rbx
mov    %rbx,-0x18(%rsp)
movss  %xmm2,(%r11,%rcx,4)
movaps %xmm1,%xmm3
divss  0x4(%rsi,%rcx,4),%xmm3
lea    (%rdx,%rbx,1),%rdi
movss  %xmm3,0x4(%r11,%rcx,4)
mulss  0x0(%r13,%rcx,4),%xmm2
movss  %xmm2,(%r15,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm2
mulss  0x4(%r11,%rcx,4),%xmm2
movss  %xmm2,0x4(%r15,%rcx,4)
movss  (%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%r14,%rcx,4)
movss  0x4(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%r14,%rcx,4)
mov    0x20(%rsp),%r12
movss  -0xc(%r12,%rcx,2),%xmm2
addss  (%r15,%rcx,4),%xmm2
addss  0x4(%r15,%rcx,4),%xmm2
mov    -0x70(%rsp),%rax
movss  %xmm2,(%rax,%rdi,4)
movss  0x4(%r15,%rcx,4),%xmm2
mov    0x50(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
lea    0x1(%rdi),%edx
movslq %edx,%rdx
mov    0x10(%rsp),%rbp
mulss  0x0(%rbp,%rdx,4),%xmm2
lea    -0xc(%r10),%edx
mov    -0x50(%rsp),%rax
movss  -0xc(%rax,%rcx,2),%xmm3
addss  0x4(%r13,%rcx,4),%xmm3
addss  %xmm3,%xmm2
addss  0x4(%r14,%rcx,4),%xmm2
subss  0x0(%r13,%rcx,4),%xmm2
movss  (%r15,%rcx,4),%xmm3
movslq %edi,%rbx
mulss  0x0(%rbp,%rbx,4),%xmm3
movslq %edx,%rdx
subss  %xmm3,%xmm2
subss  (%r14,%rcx,4),%xmm2
mov    -0x78(%rsp),%r9
movss  %xmm2,(%r9,%rdx,4)
mov    -0x80(%rsp),%rax
movss  %xmm2,-0xc(%rax,%rcx,2)
movaps %xmm1,%xmm2
divss  0x8(%rsi,%rcx,4),%xmm2
movss  %xmm2,0x8(%r11,%rcx,4)
movaps %xmm1,%xmm3
divss  0xc(%rsi,%rcx,4),%xmm3
movss  %xmm3,0xc(%r11,%rcx,4)
mulss  0x8(%r13,%rcx,4),%xmm2
movss  %xmm2,0x8(%r15,%rcx,4)
movss  0xc(%r13,%rcx,4),%xmm2
mulss  0xc(%r11,%rcx,4),%xmm2
movss  %xmm2,0xc(%r15,%rcx,4)
movss  0x8(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x8(%r14,%rcx,4)
movss  0xc(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0xc(%r14,%rcx,4)
movss  -0x8(%r12,%rcx,2),%xmm2
addss  0x8(%r15,%rcx,4),%xmm2
addss  0xc(%r15,%rcx,4),%xmm2
mov    -0x58(%rsp),%r8
lea    -0xa(%r8),%edx
movslq %edx,%rdx
mov    -0x70(%rsp),%rdi
movss  %xmm2,(%rdi,%rdx,4)
movss  0x8(%r15,%rcx,4),%xmm2
movss  0xc(%r15,%rcx,4),%xmm3
lea    0x3(%rbx),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm3
lea    0x2(%rbx),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm2
lea    -0x8(%r10),%edx
mov    -0x50(%rsp),%rdi
movss  -0x8(%rdi,%rcx,2),%xmm4
addss  0xc(%r13,%rcx,4),%xmm4
addss  %xmm4,%xmm3
addss  0xc(%r14,%rcx,4),%xmm3
subss  0x8(%r13,%rcx,4),%xmm3
subss  %xmm2,%xmm3
subss  0x8(%r14,%rcx,4),%xmm3
movslq %edx,%rdx
movss  %xmm3,(%r9,%rdx,4)
movss  %xmm3,-0x8(%rax,%rcx,2)
movaps %xmm1,%xmm2
divss  0x10(%rsi,%rcx,4),%xmm2
movss  %xmm2,0x10(%r11,%rcx,4)
movaps %xmm1,%xmm3
divss  0x14(%rsi,%rcx,4),%xmm3
movss  %xmm3,0x14(%r11,%rcx,4)
mulss  0x10(%r13,%rcx,4),%xmm2
movss  %xmm2,0x10(%r15,%rcx,4)
movss  0x14(%r13,%rcx,4),%xmm2
mulss  0x14(%r11,%rcx,4),%xmm2
movss  %xmm2,0x14(%r15,%rcx,4)
movss  0x10(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x10(%r14,%rcx,4)
movss  0x14(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x14(%r14,%rcx,4)
movss  -0x4(%r12,%rcx,2),%xmm2
addss  0x10(%r15,%rcx,4),%xmm2
addss  0x14(%r15,%rcx,4),%xmm2
lea    -0x5(%r8),%edx
movslq %edx,%rdx
mov    -0x70(%rsp),%rax
movss  %xmm2,(%rax,%rdx,4)
movss  0x10(%r15,%rcx,4),%xmm2
movss  0x14(%r15,%rcx,4),%xmm3
lea    0x5(%rbx),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm3
lea    0x4(%rbx),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm2
lea    -0x4(%r10),%edx
movss  -0x4(%rdi,%rcx,2),%xmm4
addss  0x14(%r13,%rcx,4),%xmm4
addss  %xmm4,%xmm3
addss  0x14(%r14,%rcx,4),%xmm3
subss  0x10(%r13,%rcx,4),%xmm3
subss  %xmm2,%xmm3
subss  0x10(%r14,%rcx,4),%xmm3
movslq %edx,%rdx
mov    -0x78(%rsp),%rdi
movss  %xmm3,(%rdi,%rdx,4)
mov    -0x80(%rsp),%rdx
movss  %xmm3,-0x4(%rdx,%rcx,2)
movaps %xmm1,%xmm2
divss  0x18(%rsi,%rcx,4),%xmm2
movss  %xmm2,0x18(%r11,%rcx,4)
movaps %xmm1,%xmm3
divss  0x1c(%rsi,%rcx,4),%xmm3
movss  %xmm3,0x1c(%r11,%rcx,4)
mulss  0x18(%r13,%rcx,4),%xmm2
movss  %xmm2,0x18(%r15,%rcx,4)
movss  0x1c(%r13,%rcx,4),%xmm2
mulss  0x1c(%r11,%rcx,4),%xmm2
movss  %xmm2,0x1c(%r15,%rcx,4)
movss  0x18(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x18(%r14,%rcx,4)
movss  0x1c(%r11,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r14,%rcx,4)
movss  (%r12,%rcx,2),%xmm2
addss  0x18(%r15,%rcx,4),%xmm2
addss  0x1c(%r15,%rcx,4),%xmm2
movslq %r8d,%r8
movss  %xmm2,(%rax,%r8,4)
movss  0x1c(%r15,%rcx,4),%xmm2
lea    0x7(%rbx),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm2
movss  0x18(%r15,%rcx,4),%xmm3
add    $0x6,%ebx
movslq %ebx,%rdx
mov    -0x18(%rsp),%rbx
mov    -0x68(%rsp),%r12
mov    -0x10(%rsp),%r9
mov    -0x60(%rsp),%rsi
mulss  0x0(%rbp,%rdx,4),%xmm3
mov    -0x8(%rsp),%rdi
mov    -0x40(%rsp),%rdx
mov    -0x50(%rsp),%rax
movss  (%rax,%rcx,2),%xmm4
addss  0x1c(%r13,%rcx,4),%xmm4
addss  %xmm4,%xmm2
addss  0x1c(%r14,%rcx,4),%xmm2
subss  0x18(%r13,%rcx,4),%xmm2
subss  %xmm3,%xmm2
subss  0x18(%r14,%rcx,4),%xmm2
movslq %r10d,%r10
mov    -0x78(%rsp),%rax
movss  %xmm2,(%rax,%r10,4)
mov    -0x80(%rsp),%rbp
movss  %xmm2,0x0(%rbp,%rcx,2)
add    $0x4,%rsi
add    0x2c(%rsp),%r8d
mov    %r8,-0x58(%rsp)
add    $0x10,%r10d
add    $0x8,%rcx
add    -0x30(%rsp),%rdx
add    $0x10,%ebx
add    $0x20,%rdi
addq   $0x20,0x18(%rsp)
addq   $0x20,-0x28(%rsp)
add    $0x20,%r9
add    $0x20,%r12
cmp    0x8(%rsp),%rsi
jl     1fe0 <s_update_hessian_box_mpc+0xee0>
mov    0x10(%rsp),%rbx
mov    -0x78(%rsp),%r10
mov    0x40(%rsp),%rcx
lea    (%rdi,%rcx,4),%r11
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,4),%rax
mov    %rax,-0x48(%rsp)
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rcx,4),%r15
lea    (%r9,%rcx,4),%r13
lea    (%r12,%rcx,4),%rax
mov    %rax,-0x38(%rsp)
mov    %esi,%ebp
mov    -0x20(%rsp),%r14
mov    0x48(%rsp),%r9
jmp    2495 <s_update_hessian_box_mpc+0x1395>
mov    %r12,%rbx
cmp    %r14d,%ebp
mov    (%rsp),%rax
mov    -0x38(%rsp),%r8
mov    -0x70(%rsp),%rdi
jge    260c <s_update_hessian_box_mpc+0x150c>
sub    %ebp,%r14d
test   %r14d,%r14d
jle    260c <s_update_hessian_box_mpc+0x150c>
movslq %ebp,%rcx
mov    %r14d,%r14d
add    $0x4,%eax
imul   %ebp,%eax
lea    0x0(%rbp,%rbp,1),%edx
mov    %rdx,-0x50(%rsp)
shl    $0x2,%ebp
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
mov    %rdx,-0x80(%rsp)
lea    (%r9,%rcx,4),%rdx
mov    %rdx,-0x68(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%r12
add    %r14,%r14
xor    %edx,%edx
movss  0xb03(%rip),%xmm1
mov    -0x48(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm1,%xmm2
divss  (%r8,%rdx,4),%xmm2
movss  %xmm2,(%r11,%rdx,4)
movaps %xmm1,%xmm3
divss  0x4(%r8,%rdx,4),%xmm3
movss  %xmm3,0x4(%r11,%rdx,4)
mulss  0x0(%r13,%rdx,4),%xmm2
movss  %xmm2,(%r15,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm2
mulss  0x4(%r11,%rdx,4),%xmm2
movss  %xmm2,0x4(%r15,%rdx,4)
movss  (%r11,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rsi,%rdx,4)
movss  0x4(%r11,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x4(%rsi,%rdx,4)
mov    -0x80(%rsp),%rcx
movss  (%rcx,%rdx,2),%xmm2
addss  (%r15,%rdx,4),%xmm2
addss  0x4(%r15,%rdx,4),%xmm2
cltq
movss  %xmm2,(%rdi,%rax,4)
movss  0x4(%r15,%rdx,4),%xmm2
mov    %rdi,%r9
mov    -0x50(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
lea    0x1(%rdi),%ecx
movslq %ecx,%rcx
mulss  (%rbx,%rcx,4),%xmm2
movss  (%r15,%rdx,4),%xmm3
movslq %edi,%rcx
mov    %r9,%rdi
mulss  (%rbx,%rcx,4),%xmm3
mov    -0x68(%rsp),%rcx
movss  (%rcx,%rdx,2),%xmm4
addss  0x4(%r13,%rdx,4),%xmm4
addss  %xmm4,%xmm2
addss  0x4(%rsi,%rdx,4),%xmm2
subss  0x0(%r13,%rdx,4),%xmm2
subss  %xmm3,%xmm2
subss  (%rsi,%rdx,4),%xmm2
movslq %ebp,%rbp
movss  %xmm2,(%r10,%rbp,4)
movss  %xmm2,(%r12,%rdx,2)
add    $0x5,%eax
add    $0x2,%rdx
add    $0x4,%ebp
cmp    %rdx,%r14
jne    2510 <s_update_hessian_box_mpc+0x1410>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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