void s_update_var_mpc(int nx, int nu, int N, int nb, int nbu, float *ptr_mu,
                      float mu_scal, float alpha, float **ux, float **dux,
                      float **t, float **dt, float **lam, float **dlam,
                      float **pi, float **dpi) {
  int jj, ll;
  float mu = 0;
  for (ll = 0; ll < nu; ll++)
    ux[0][ll] += alpha * (dux[0][ll] - ux[0][ll]);
  for (ll = 0; ll < 2 * nbu; ll += 2) {
    lam[0][ll + 0] += alpha * dlam[0][ll + 0];
    lam[0][ll + 1] += alpha * dlam[0][ll + 1];
    t[0][ll + 0] += alpha * dt[0][ll + 0];
    t[0][ll + 1] += alpha * dt[0][ll + 1];
    mu += lam[0][ll + 0] * t[0][ll + 0] + lam[0][ll + 1] * t[0][ll + 1];
  }
  for (jj = 1; jj < N; jj++) {
    for (ll = 0; ll < nu; ll++)
      ux[jj][ll] += alpha * (dux[jj][ll] - ux[jj][ll]);
    for (ll = 0; ll < nx; ll++)
      ux[jj][nu + ll] += alpha * (dux[jj][nu + ll] - ux[jj][nu + ll]);
    for (ll = 0; ll < nx; ll++)
      pi[jj][ll] += alpha * (dpi[jj][ll] - pi[jj][ll]);
    for (ll = 0; ll < 2 * nb; ll += 2) {
      lam[jj][ll + 0] += alpha * dlam[jj][ll + 0];
      lam[jj][ll + 1] += alpha * dlam[jj][ll + 1];
      t[jj][ll + 0] += alpha * dt[jj][ll + 0];
      t[jj][ll + 1] += alpha * dt[jj][ll + 1];
      mu += lam[jj][ll + 0] * t[jj][ll + 0] + lam[jj][ll + 1] * t[jj][ll + 1];
    }
  }
  for (ll = 0; ll < nx; ll++)
    ux[N][nu + ll] += alpha * (dux[N][nu + ll] - ux[N][nu + ll]);
  for (ll = 0; ll < nx; ll++)
    pi[N][ll] += alpha * (dpi[N][ll] - pi[N][ll]);
  for (ll = 2 * nu; ll < 2 * nb; ll += 2) {
    lam[N][ll + 0] += alpha * dlam[N][ll + 0];
    lam[N][ll + 1] += alpha * dlam[N][ll + 1];
    t[N][ll + 0] += alpha * dt[N][ll + 0];
    t[N][ll + 1] += alpha * dt[N][ll + 1];
    mu += lam[N][ll + 0] * t[N][ll + 0] + lam[N][ll + 1] * t[N][ll + 1];
  }
  mu *= mu_scal;
  ptr_mu[0] = mu;
  return;
}


x86 assembly (clang, -O0):
<s_update_var_mpc>:
push   %rbp
mov    %rsp,%rbp
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)
mov    %r9,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11ad <s_update_var_mpc+0xad>
movss  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1151 <s_update_var_mpc+0x51>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1329 <s_update_var_mpc+0x229>
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    11b4 <s_update_var_mpc+0xb4>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    166c <s_update_var_mpc+0x56c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ae <s_update_var_mpc+0x2ae>
movss  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1343 <s_update_var_mpc+0x243>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    142f <s_update_var_mpc+0x32f>
movss  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b5 <s_update_var_mpc+0x2b5>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14a1 <s_update_var_mpc+0x3a1>
movss  -0x28(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1436 <s_update_var_mpc+0x336>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1659 <s_update_var_mpc+0x559>
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    14a8 <s_update_var_mpc+0x3a8>
jmp    165e <s_update_var_mpc+0x55e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1330 <s_update_var_mpc+0x230>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ed <s_update_var_mpc+0x5ed>
movss  -0x28(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1673 <s_update_var_mpc+0x573>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    175f <s_update_var_mpc+0x65f>
movss  -0x28(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16f4 <s_update_var_mpc+0x5f4>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1919 <s_update_var_mpc+0x819>
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    1768 <s_update_var_mpc+0x668>
movss  -0x24(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_update_var_mpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%r12d
mov    %esi,%r14d
test   %esi,%esi
jle    12af <s_update_var_mpc+0x1af>
mov    0x40(%rsp),%rax
mov    (%rax),%r11
mov    0x38(%rsp),%rcx
mov    (%rcx),%rax
cmp    $0x8,%esi
jb     1147 <s_update_var_mpc+0x47>
lea    (%r11,%r14,4),%rcx
cmp    %rcx,%rax
jae    11c9 <s_update_var_mpc+0xc9>
lea    (%rax,%r14,4),%rcx
cmp    %rcx,%r11
jae    11c9 <s_update_var_mpc+0xc9>
xor    %ebx,%ebx
mov    %rbx,%rcx
not    %rcx
test   $0x1,%r14b
je     1175 <s_update_var_mpc+0x75>
movss  (%r11,%rbx,4),%xmm2
movss  (%rax,%rbx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rax,%rbx,4)
or     $0x1,%rbx
add    %r14,%rcx
je     12af <s_update_var_mpc+0x1af>
xchg   %ax,%ax
movss  (%r11,%rbx,4),%xmm2
movss  (%rax,%rbx,4),%xmm3
movss  0x4(%rax,%rbx,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rax,%rbx,4)
movss  0x4(%r11,%rbx,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rax,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r14
jne    1180 <s_update_var_mpc+0x80>
jmp    12af <s_update_var_mpc+0x1af>
mov    %r14d,%ebx
and    $0xfffffff8,%ebx
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
lea    -0x8(%rbx),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1dcb <s_update_var_mpc+0xccb>
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r11,%rcx,4),%xmm3
movups 0x10(%r11,%rcx,4),%xmm4
movups (%rax,%rcx,4),%xmm5
movups 0x10(%rax,%rcx,4),%xmm6
movups 0x20(%rax,%rcx,4),%xmm7
movups 0x30(%rax,%rcx,4),%xmm2
subps  %xmm5,%xmm3
subps  %xmm6,%xmm4
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
movups %xmm3,(%rax,%rcx,4)
movups %xmm4,0x10(%rax,%rcx,4)
movups 0x20(%r11,%rcx,4),%xmm3
movups 0x30(%r11,%rcx,4),%xmm4
subps  %xmm7,%xmm3
subps  %xmm2,%xmm4
mulps  %xmm8,%xmm3
addps  %xmm7,%xmm3
mulps  %xmm8,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,0x20(%rax,%rcx,4)
movups %xmm4,0x30(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1200 <s_update_var_mpc+0x100>
test   $0x1,%r10b
je     12a6 <s_update_var_mpc+0x1a6>
movups (%r11,%rcx,4),%xmm2
movups 0x10(%r11,%rcx,4),%xmm3
movups (%rax,%rcx,4),%xmm4
movups 0x10(%rax,%rcx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rax,%rcx,4)
movups %xmm3,0x10(%rax,%rcx,4)
cmp    %r14,%rbx
jne    1149 <s_update_var_mpc+0x49>
mov    0x60(%rsp),%rax
mov    0x58(%rsp),%rcx
mov    0x50(%rsp),%rbx
mov    0x48(%rsp),%rbp
test   %r8d,%r8d
mov    %r9,-0x68(%rsp)
jle    1365 <s_update_var_mpc+0x265>
add    %r8d,%r8d
mov    (%rax),%r9
mov    (%rcx),%rcx
mov    (%rbx),%rax
mov    0x0(%rbp),%rbp
movslq %r8d,%r8
xorps  %xmm9,%xmm9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movss  (%r9,%rbx,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%rcx,%rbx,4),%xmm3
movss  %xmm3,(%rcx,%rbx,4)
movss  0x4(%r9,%rbx,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rcx,%rbx,4),%xmm3
movss  %xmm3,0x4(%rcx,%rbx,4)
movss  (%rax,%rbx,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x0(%rbp,%rbx,4),%xmm3
movss  %xmm3,0x0(%rbp,%rbx,4)
movss  0x4(%rax,%rbx,4),%xmm4
mulss  %xmm1,%xmm4
addss  0x4(%rbp,%rbx,4),%xmm4
movss  %xmm4,0x4(%rbp,%rbx,4)
mulss  0x4(%rcx,%rbx,4),%xmm4
mulss  (%rcx,%rbx,4),%xmm3
addss  %xmm4,%xmm3
addss  %xmm3,%xmm9
add    $0x2,%rbx
cmp    %r8,%rbx
jl     12f0 <s_update_var_mpc+0x1f0>
jmp    1369 <s_update_var_mpc+0x269>
xorps  %xmm9,%xmm9
movslq %esi,%rcx
mov    %edi,%r11d
cmp    $0x2,%edx
mov    %rcx,%rax
mov    %rcx,-0x78(%rsp)
mov    %edx,-0x6c(%rsp)
jl     19fa <s_update_var_mpc+0x8fa>
lea    (%r12,%r12,1),%eax
movslq %eax,%r9
mov    %edx,%r15d
lea    (%rcx,%r11,1),%rax
mov    %rax,-0x10(%rsp)
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x60(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rsp)
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
mov    %rdx,%rax
mov    %rdx,-0x30(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x50(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
mov    %r11,%r8
neg    %r8
mov    %rbp,%rax
mov    %rbp,-0x48(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x58(%rsp)
lea    0x4(%rcx),%rax
mov    %rax,-0x38(%rsp)
lea    0x0(,%r11,4),%r10
and    $0xffffffffffffffe0,%r10
lea    0x1(%rcx),%rax
mov    %rax,-0x18(%rsp)
mov    $0x1,%r13d
mov    %edi,-0x7c(%rsp)
jmp    144d <s_update_var_mpc+0x34d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r15,%r13
je     19fa <s_update_var_mpc+0x8fa>
mov    %r12,%rdx
test   %esi,%esi
jle    15f0 <s_update_var_mpc+0x4f0>
mov    0x40(%rsp),%rax
mov    (%rax,%r13,8),%rbp
mov    0x38(%rsp),%rax
mov    (%rax,%r13,8),%r12
cmp    $0x8,%esi
jb     1490 <s_update_var_mpc+0x390>
lea    0x0(,%r14,4),%rax
add    %rbp,%rax
cmp    %rax,%r12
jae    151c <s_update_var_mpc+0x41c>
lea    (%r12,%r14,4),%rax
cmp    %rax,%rbp
jae    151c <s_update_var_mpc+0x41c>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r14b
je     14c0 <s_update_var_mpc+0x3c0>
movss  0x0(%rbp,%rcx,4),%xmm2
movss  (%r12,%rcx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%r12,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    -0x8(%rsp),%rcx
je     15f0 <s_update_var_mpc+0x4f0>
xchg   %ax,%ax
movss  0x0(%rbp,%rax,4),%xmm2
movss  (%r12,%rax,4),%xmm3
movss  0x4(%r12,%rax,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%r12,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%r12,%rax,4)
add    $0x2,%rax
cmp    %rax,%r14
jne    14d0 <s_update_var_mpc+0x3d0>
jmp    15f0 <s_update_var_mpc+0x4f0>
cmpq   $0x0,-0x28(%rsp)
je     19d6 <s_update_var_mpc+0x8d6>
mov    -0x50(%rsp),%rcx
xor    %ebx,%ebx
nop
movups 0x0(%rbp,%rbx,4),%xmm4
movups 0x10(%rbp,%rbx,4),%xmm5
movups (%r12,%rbx,4),%xmm6
movups 0x10(%r12,%rbx,4),%xmm7
movups 0x20(%r12,%rbx,4),%xmm3
movups 0x30(%r12,%rbx,4),%xmm2
subps  %xmm6,%xmm4
subps  %xmm7,%xmm5
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
mulps  %xmm8,%xmm5
addps  %xmm7,%xmm5
movups %xmm4,(%r12,%rbx,4)
movups %xmm5,0x10(%r12,%rbx,4)
movups 0x20(%rbp,%rbx,4),%xmm4
movups 0x30(%rbp,%rbx,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm2,%xmm5
mulps  %xmm8,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm8,%xmm5
addps  %xmm2,%xmm5
movups %xmm4,0x20(%r12,%rbx,4)
movups %xmm5,0x30(%r12,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1530 <s_update_var_mpc+0x430>
testb  $0x1,-0x30(%rsp)
je     15df <s_update_var_mpc+0x4df>
movups 0x0(%rbp,%rbx,4),%xmm2
movups 0x10(%rbp,%rbx,4),%xmm3
movups (%r12,%rbx,4),%xmm4
movups 0x10(%r12,%rbx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%r12,%rbx,4)
movups %xmm3,0x10(%r12,%rbx,4)
mov    -0x20(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
jne    1492 <s_update_var_mpc+0x392>
test   %edi,%edi
mov    %rdx,%r12
jle    1930 <s_update_var_mpc+0x830>
mov    0x40(%rsp),%rax
mov    (%rax,%r13,8),%rbx
mov    0x38(%rsp),%rax
mov    (%rax,%r13,8),%rbp
cmp    $0x8,%edi
jae    1620 <s_update_var_mpc+0x520>
xor    %ecx,%ecx
jmp    16f0 <s_update_var_mpc+0x5f0>
nopl   0x0(%rax)
mov    %esi,%edi
mov    %r12,%rsi
mov    %r8,%r12
mov    %r15,%r8
mov    -0x78(%rsp),%rdx
lea    0x0(,%rdx,4),%rax
add    %rbp,%rax
mov    -0x10(%rsp),%r15
lea    (%rbx,%r15,4),%rcx
cmp    %rcx,%rax
jae    1673 <s_update_var_mpc+0x573>
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
lea    (%rbx,%rdx,4),%rcx
cmp    %rax,%rcx
jae    1673 <s_update_var_mpc+0x573>
xor    %ecx,%ecx
mov    %r8,%r15
mov    %r12,%r8
mov    %rsi,%r12
mov    %edi,%esi
mov    -0x7c(%rsp),%edi
jmp    16f0 <s_update_var_mpc+0x5f0>
mov    -0x38(%rsp),%rcx
lea    0x0(,%rcx,4),%rax
add    %rbp,%rax
lea    (%rbx,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rcx,%rdx,1),%xmm2
movups (%rcx,%rdx,1),%xmm3
movups -0x10(%rax,%rdx,1),%xmm4
movups (%rax,%rdx,1),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,-0x10(%rax,%rdx,1)
movups %xmm3,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1690 <s_update_var_mpc+0x590>
mov    -0x60(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
mov    %r8,%r15
mov    %r12,%r8
mov    %rsi,%r12
mov    %edi,%esi
mov    -0x7c(%rsp),%edi
je     1792 <s_update_var_mpc+0x692>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rax
test   $0x1,%r11b
je     1725 <s_update_var_mpc+0x625>
mov    -0x78(%rsp),%rax
add    %rcx,%rax
movss  (%rbx,%rax,4),%xmm2
movss  0x0(%rbp,%rax,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rax,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r8,%rcx
je     1792 <s_update_var_mpc+0x692>
mov    -0x18(%rsp),%rdx
lea    (%rbx,%rdx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rax,4),%xmm2
movss  -0x4(%rdx,%rax,4),%xmm3
movss  (%rdx,%rax,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,-0x4(%rdx,%rax,4)
movss  (%rcx,%rax,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1750 <s_update_var_mpc+0x650>
test   %edi,%edi
jle    1930 <s_update_var_mpc+0x830>
mov    0x70(%rsp),%rax
mov    (%rax,%r13,8),%rbp
mov    0x68(%rsp),%rax
mov    (%rax,%r13,8),%rbx
cmp    $0x8,%edi
jb     17d2 <s_update_var_mpc+0x6d2>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1858 <s_update_var_mpc+0x758>
lea    (%rbx,%r11,4),%rax
cmp    %rax,%rbp
jae    1858 <s_update_var_mpc+0x758>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r11b
je     1800 <s_update_var_mpc+0x700>
movss  0x0(%rbp,%rcx,4),%xmm2
movss  (%rbx,%rcx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r8,%rcx
je     1930 <s_update_var_mpc+0x830>
nopl   0x0(%rax)
movss  0x0(%rbp,%rax,4),%xmm2
movss  (%rbx,%rax,4),%xmm3
movss  0x4(%rbx,%rax,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rbx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1810 <s_update_var_mpc+0x710>
jmp    1930 <s_update_var_mpc+0x830>
cmpq   $0x0,-0x40(%rsp)
je     19e8 <s_update_var_mpc+0x8e8>
mov    -0x58(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,4),%xmm2
movups 0x10(%rbp,%rcx,4),%xmm3
movups (%rbx,%rcx,4),%xmm4
movups 0x10(%rbx,%rcx,4),%xmm5
movups 0x20(%rbx,%rcx,4),%xmm6
movups 0x30(%rbx,%rcx,4),%xmm7
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm2
movups 0x30(%rbp,%rcx,4),%xmm3
subps  %xmm6,%xmm2
subps  %xmm7,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm6,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm7,%xmm3
movups %xmm2,0x20(%rbx,%rcx,4)
movups %xmm3,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1870 <s_update_var_mpc+0x770>
testb  $0x1,-0x48(%rsp)
je     1913 <s_update_var_mpc+0x813>
movups 0x0(%rbp,%rcx,4),%xmm2
movups 0x10(%rbp,%rcx,4),%xmm3
movups (%rbx,%rcx,4),%xmm4
movups 0x10(%rbx,%rcx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
mov    -0x60(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
jne    17d4 <s_update_var_mpc+0x6d4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r12d,%r12d
jle    1440 <s_update_var_mpc+0x340>
mov    0x60(%rsp),%rax
mov    (%rax,%r13,8),%rcx
mov    0x58(%rsp),%rax
mov    (%rax,%r13,8),%rbx
mov    0x50(%rsp),%rax
mov    (%rax,%r13,8),%rdx
mov    0x48(%rsp),%rax
mov    (%rax,%r13,8),%rbp
xor    %eax,%eax
nop
movss  (%rcx,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rbx,%rax,4),%xmm2
movss  %xmm2,(%rbx,%rax,4)
movss  0x4(%rcx,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rbx,%rax,4),%xmm2
movss  %xmm2,0x4(%rbx,%rax,4)
movss  (%rdx,%rax,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x0(%rbp,%rax,4),%xmm2
movss  %xmm2,0x0(%rbp,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rbp,%rax,4),%xmm3
movss  %xmm3,0x4(%rbp,%rax,4)
mulss  0x4(%rbx,%rax,4),%xmm3
mulss  (%rbx,%rax,4),%xmm2
addss  %xmm3,%xmm2
addss  %xmm2,%xmm9
add    $0x2,%rax
cmp    %r9,%rax
jl     1960 <s_update_var_mpc+0x860>
jmp    1440 <s_update_var_mpc+0x340>
xor    %ebx,%ebx
testb  $0x1,-0x30(%rsp)
jne    15ab <s_update_var_mpc+0x4ab>
jmp    15df <s_update_var_mpc+0x4df>
xor    %ecx,%ecx
testb  $0x1,-0x48(%rsp)
jne    18e3 <s_update_var_mpc+0x7e3>
jmp    1913 <s_update_var_mpc+0x813>
movslq -0x6c(%rsp),%r9
test   %edi,%edi
jle    1cfb <s_update_var_mpc+0xbfb>
mov    0x40(%rsp),%rax
mov    (%rax,%r9,8),%r8
mov    0x38(%rsp),%rax
mov    (%rax,%r9,8),%r10
cmp    $0x8,%edi
jae    1a2a <s_update_var_mpc+0x92a>
xor    %ecx,%ecx
mov    -0x78(%rsp),%r14
jmp    1abf <s_update_var_mpc+0x9bf>
mov    -0x78(%rsp),%r14
lea    (%r10,%r14,4),%rcx
lea    (%r14,%r11,1),%rax
lea    (%r8,%rax,4),%rdx
cmp    %rdx,%rcx
jae    1a51 <s_update_var_mpc+0x951>
lea    (%r10,%rax,4),%rax
lea    (%r8,%r14,4),%rcx
cmp    %rax,%rcx
jae    1a51 <s_update_var_mpc+0x951>
xor    %ecx,%ecx
jmp    1abf <s_update_var_mpc+0x9bf>
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
lea    (%r10,%r14,4),%rax
add    $0x10,%rax
lea    (%r8,%r14,4),%rdx
add    $0x10,%rdx
lea    0x0(,%r11,4),%rbp
and    $0xffffffffffffffe0,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rdx,%rbx,1),%xmm2
movups (%rdx,%rbx,1),%xmm4
movups -0x10(%rax,%rbx,1),%xmm5
movups (%rax,%rbx,1),%xmm6
subps  %xmm5,%xmm2
subps  %xmm6,%xmm4
mulps  %xmm3,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movups %xmm2,-0x10(%rax,%rbx,1)
movups %xmm4,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    1a80 <s_update_var_mpc+0x980>
cmp    %r11,%rcx
je     1b52 <s_update_var_mpc+0xa52>
mov    %rcx,%rax
not    %rax
test   $0x1,%r11b
je     1af1 <s_update_var_mpc+0x9f1>
lea    (%rcx,%r14,1),%rdx
movss  (%r8,%rdx,4),%xmm2
movss  (%r10,%rdx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%r10,%rdx,4)
or     $0x1,%rcx
add    %r11,%rax
je     1b52 <s_update_var_mpc+0xa52>
lea    (%r8,%r14,4),%rax
add    $0x4,%rax
lea    (%r10,%r14,4),%rdx
add    $0x4,%rdx
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rax,%rcx,4),%xmm2
movss  -0x4(%rdx,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,-0x4(%rdx,%rcx,4)
movss  (%rax,%rcx,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    1b10 <s_update_var_mpc+0xa10>
test   %edi,%edi
jle    1cfb <s_update_var_mpc+0xbfb>
mov    0x70(%rsp),%rax
mov    (%rax,%r9,8),%rbp
mov    0x68(%rsp),%rax
mov    (%rax,%r9,8),%rbx
cmp    $0x8,%edi
jb     1b92 <s_update_var_mpc+0xa92>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1c18 <s_update_var_mpc+0xb18>
lea    (%rbx,%r11,4),%rax
cmp    %rax,%rbp
jae    1c18 <s_update_var_mpc+0xb18>
xor    %edi,%edi
mov    %rdi,%rax
not    %rax
test   $0x1,%r11b
je     1bc0 <s_update_var_mpc+0xac0>
movss  0x0(%rbp,%rdi,4),%xmm2
movss  (%rbx,%rdi,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rbx,%rdi,4)
or     $0x1,%rdi
add    %r11,%rax
je     1cfb <s_update_var_mpc+0xbfb>
nopl   0x0(%rax)
movss  0x0(%rbp,%rdi,4),%xmm2
movss  (%rbx,%rdi,4),%xmm3
movss  0x4(%rbx,%rdi,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rbx,%rdi,4)
movss  0x4(%rbp,%rdi,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rbx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r11
jne    1bd0 <s_update_var_mpc+0xad0>
jmp    1cfb <s_update_var_mpc+0xbfb>
mov    %r11d,%edi
and    $0xfffffff8,%edi
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
lea    -0x8(%rdi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1ddc <s_update_var_mpc+0xcdc>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,4),%xmm2
movups 0x10(%rbp,%rcx,4),%xmm4
movups (%rbx,%rcx,4),%xmm5
movups 0x10(%rbx,%rcx,4),%xmm6
movups 0x20(%rbx,%rcx,4),%xmm7
movups 0x30(%rbx,%rcx,4),%xmm3
subps  %xmm5,%xmm2
subps  %xmm6,%xmm4
mulps  %xmm8,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
movups %xmm2,(%rbx,%rcx,4)
movups %xmm4,0x10(%rbx,%rcx,4)
movups 0x20(%rbp,%rcx,4),%xmm2
movups 0x30(%rbp,%rcx,4),%xmm4
subps  %xmm7,%xmm2
subps  %xmm3,%xmm4
mulps  %xmm8,%xmm2
addps  %xmm7,%xmm2
mulps  %xmm8,%xmm4
addps  %xmm3,%xmm4
movups %xmm2,0x20(%rbx,%rcx,4)
movups %xmm4,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1c50 <s_update_var_mpc+0xb50>
test   $0x1,%r8b
je     1cf2 <s_update_var_mpc+0xbf2>
movups 0x0(%rbp,%rcx,4),%xmm2
movups 0x10(%rbp,%rcx,4),%xmm3
movups (%rbx,%rcx,4),%xmm4
movups 0x10(%rbx,%rcx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
cmp    %r11,%rdi
jne    1b94 <s_update_var_mpc+0xa94>
add    %esi,%esi
add    %r12d,%r12d
cmp    %r12d,%esi
jge    1db1 <s_update_var_mpc+0xcb1>
mov    0x60(%rsp),%rax
mov    (%rax,%r9,8),%rax
mov    0x58(%rsp),%rcx
mov    (%rcx,%r9,8),%rcx
mov    0x50(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x48(%rsp),%rdi
mov    (%rdi,%r9,8),%rdi
movslq %esi,%rsi
movslq %r12d,%rbp
mov    -0x68(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rcx,%rsi,4),%xmm2
movss  %xmm2,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rcx,%rsi,4),%xmm2
movss  %xmm2,0x4(%rcx,%rsi,4)
movss  (%rdx,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdi,%rsi,4),%xmm2
movss  %xmm2,(%rdi,%rsi,4)
movss  0x4(%rdx,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rdi,%rsi,4),%xmm3
movss  %xmm3,0x4(%rdi,%rsi,4)
mulss  0x4(%rcx,%rsi,4),%xmm3
mulss  (%rcx,%rsi,4),%xmm2
addss  %xmm3,%xmm2
addss  %xmm2,%xmm9
add    $0x2,%rsi
cmp    %rbp,%rsi
jl     1d40 <s_update_var_mpc+0xc40>
jmp    1db6 <s_update_var_mpc+0xcb6>
mov    -0x68(%rsp),%rbx
mulss  %xmm0,%xmm9
movss  %xmm9,(%rbx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%r10b
jne    1275 <s_update_var_mpc+0x175>
jmp    12a6 <s_update_var_mpc+0x1a6>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1cc2 <s_update_var_mpc+0xbc2>
jmp    1cf2 <s_update_var_mpc+0xbf2>

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

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