void s_update_var_mhe(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 (jj = 0; 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_mhe>:
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,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    148d <s_update_var_mhe+0x38d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11cf <s_update_var_mhe+0xcf>
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    1164 <s_update_var_mhe+0x64>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1250 <s_update_var_mhe+0x150>
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    11d6 <s_update_var_mhe+0xd6>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c2 <s_update_var_mhe+0x1c2>
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    1257 <s_update_var_mhe+0x157>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    147a <s_update_var_mhe+0x37a>
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    12c9 <s_update_var_mhe+0x1c9>
jmp    147f <s_update_var_mhe+0x37f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1151 <s_update_var_mhe+0x51>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    150e <s_update_var_mhe+0x40e>
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    1494 <s_update_var_mhe+0x394>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1580 <s_update_var_mhe+0x480>
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    1515 <s_update_var_mhe+0x415>
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    173a <s_update_var_mhe+0x63a>
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    1589 <s_update_var_mhe+0x489>
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_mhe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%r13d
movslq %esi,%rcx
mov    %edi,%r10d
test   %edx,%edx
mov    %rcx,%rax
mov    %rcx,-0x78(%rsp)
mov    %r9,-0x58(%rsp)
mov    %edx,-0x6c(%rsp)
jle    17ba <s_update_var_mhe+0x6ba>
lea    0x0(%r13,%r13,1),%eax
movslq %eax,%r14
mov    %edx,%r9d
mov    %ecx,%r11d
lea    (%rcx,%r10,1),%rax
mov    %rax,-0x10(%rsp)
mov    %r11d,%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    %r10d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x68(%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    %r11,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
mov    %r10,%r12
neg    %r12
mov    %rbp,%rax
mov    %rbp,-0x48(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x60(%rsp)
lea    0x0(,%r10,4),%r8
and    $0xffffffffffffffe0,%r8
xorps  %xmm9,%xmm9
lea    0x4(%rcx),%rax
mov    %rax,-0x38(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,-0x18(%rsp)
xor    %r15d,%r15d
mov    %edi,-0x7c(%rsp)
jmp    11fd <s_update_var_mhe+0xfd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %r9,%r15
je     17be <s_update_var_mhe+0x6be>
mov    %r13,%rbx
test   %esi,%esi
jle    13b0 <s_update_var_mhe+0x2b0>
mov    0x40(%rsp),%rax
mov    (%rax,%r15,8),%r13
mov    0x38(%rsp),%rax
mov    (%rax,%r15,8),%rbp
cmp    $0x8,%esi
jb     1247 <s_update_var_mhe+0x147>
lea    0x0(,%r11,4),%rax
add    %r13,%rax
cmp    %rax,%rbp
jae    12dc <s_update_var_mhe+0x1dc>
lea    0x0(,%r11,4),%rax
add    %rbp,%rax
cmp    %rax,%r13
jae    12dc <s_update_var_mhe+0x1dc>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r11b
je     1278 <s_update_var_mhe+0x178>
movss  0x0(%r13,%rcx,4),%xmm2
movss  0x0(%rbp,%rcx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    -0x8(%rsp),%rcx
je     13b0 <s_update_var_mhe+0x2b0>
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm2
movss  0x0(%rbp,%rax,4),%xmm3
movss  0x4(%rbp,%rax,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rax,4)
movss  0x4(%r13,%rax,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1290 <s_update_var_mhe+0x190>
jmp    13b0 <s_update_var_mhe+0x2b0>
cmpq   $0x0,-0x28(%rsp)
je     1796 <s_update_var_mhe+0x696>
mov    -0x50(%rsp),%rdx
xor    %eax,%eax
nop
movups 0x0(%r13,%rax,4),%xmm4
movups 0x10(%r13,%rax,4),%xmm5
movups 0x0(%rbp,%rax,4),%xmm6
movups 0x10(%rbp,%rax,4),%xmm7
movups 0x20(%rbp,%rax,4),%xmm3
movups 0x30(%rbp,%rax,4),%xmm2
subps  %xmm6,%xmm4
subps  %xmm7,%xmm5
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
mulps  %xmm8,%xmm5
addps  %xmm7,%xmm5
movups %xmm4,0x0(%rbp,%rax,4)
movups %xmm5,0x10(%rbp,%rax,4)
movups 0x20(%r13,%rax,4),%xmm4
movups 0x30(%r13,%rax,4),%xmm5
subps  %xmm3,%xmm4
subps  %xmm2,%xmm5
mulps  %xmm8,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm8,%xmm5
addps  %xmm2,%xmm5
movups %xmm4,0x20(%rbp,%rax,4)
movups %xmm5,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    12f0 <s_update_var_mhe+0x1f0>
testb  $0x1,-0x30(%rsp)
je     139d <s_update_var_mhe+0x29d>
movups 0x0(%r13,%rax,4),%xmm2
movups 0x10(%r13,%rax,4),%xmm3
movups 0x0(%rbp,%rax,4),%xmm4
movups 0x10(%rbp,%rax,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,0x0(%rbp,%rax,4)
movups %xmm3,0x10(%rbp,%rax,4)
mov    -0x20(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
jne    1249 <s_update_var_mhe+0x149>
xchg   %ax,%ax
test   %edi,%edi
mov    %rbx,%r13
jle    16f0 <s_update_var_mhe+0x5f0>
mov    0x40(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x38(%rsp),%rcx
mov    (%rcx,%r15,8),%rbp
cmp    $0x8,%edi
jae    13e0 <s_update_var_mhe+0x2e0>
xor    %edx,%edx
jmp    14b0 <s_update_var_mhe+0x3b0>
nopl   0x0(%rax)
mov    %esi,%edi
mov    %r13,%rsi
mov    %r12,%r13
mov    %r9,%r12
mov    -0x78(%rsp),%rbx
lea    0x0(,%rbx,4),%rcx
add    %rbp,%rcx
mov    -0x10(%rsp),%r9
lea    (%rax,%r9,4),%rdx
cmp    %rdx,%rcx
jae    1433 <s_update_var_mhe+0x333>
lea    0x0(,%r9,4),%rcx
add    %rbp,%rcx
lea    (%rax,%rbx,4),%rdx
cmp    %rcx,%rdx
jae    1433 <s_update_var_mhe+0x333>
xor    %edx,%edx
mov    %r12,%r9
mov    %r13,%r12
mov    %rsi,%r13
mov    %edi,%esi
mov    -0x7c(%rsp),%edi
jmp    14b0 <s_update_var_mhe+0x3b0>
mov    -0x38(%rsp),%rdx
lea    0x0(,%rdx,4),%rcx
add    %rbp,%rcx
lea    (%rax,%rdx,4),%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rdx,%rbx,1),%xmm2
movups (%rdx,%rbx,1),%xmm3
movups -0x10(%rcx,%rbx,1),%xmm4
movups (%rcx,%rbx,1),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,-0x10(%rcx,%rbx,1)
movups %xmm3,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1450 <s_update_var_mhe+0x350>
mov    -0x68(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r10,%rcx
mov    %r12,%r9
mov    %r13,%r12
mov    %rsi,%r13
mov    %edi,%esi
mov    -0x7c(%rsp),%edi
je     1552 <s_update_var_mhe+0x452>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%r10b
je     14e5 <s_update_var_mhe+0x3e5>
mov    -0x78(%rsp),%rcx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0x0(%rbp,%rcx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r12,%rdx
je     1552 <s_update_var_mhe+0x452>
mov    -0x18(%rsp),%rdx
lea    (%rax,%rdx,4),%rax
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   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,%r10
jne    1510 <s_update_var_mhe+0x410>
test   %edi,%edi
jle    16f0 <s_update_var_mhe+0x5f0>
mov    0x70(%rsp),%rax
mov    (%rax,%r15,8),%rbp
mov    0x68(%rsp),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x8,%edi
jb     1592 <s_update_var_mhe+0x492>
lea    0x0(,%r10,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    1618 <s_update_var_mhe+0x518>
lea    (%rax,%r10,4),%rcx
cmp    %rcx,%rbp
jae    1618 <s_update_var_mhe+0x518>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r10b
je     15c0 <s_update_var_mhe+0x4c0>
movss  0x0(%rbp,%rdx,4),%xmm2
movss  (%rax,%rdx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rax,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r12,%rdx
je     16f0 <s_update_var_mhe+0x5f0>
nopl   0x0(%rax)
movss  0x0(%rbp,%rcx,4),%xmm2
movss  (%rax,%rcx,4),%xmm3
movss  0x4(%rax,%rcx,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rax,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    15d0 <s_update_var_mhe+0x4d0>
jmp    16f0 <s_update_var_mhe+0x5f0>
cmpq   $0x0,-0x40(%rsp)
je     17a8 <s_update_var_mhe+0x6a8>
mov    -0x60(%rsp),%rbx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
movups (%rax,%rdx,4),%xmm4
movups 0x10(%rax,%rdx,4),%xmm5
movups 0x20(%rax,%rdx,4),%xmm6
movups 0x30(%rax,%rdx,4),%xmm7
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rax,%rdx,4)
movups %xmm3,0x10(%rax,%rdx,4)
movups 0x20(%rbp,%rdx,4),%xmm2
movups 0x30(%rbp,%rdx,4),%xmm3
subps  %xmm6,%xmm2
subps  %xmm7,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm6,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm7,%xmm3
movups %xmm2,0x20(%rax,%rdx,4)
movups %xmm3,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    1630 <s_update_var_mhe+0x530>
testb  $0x1,-0x48(%rsp)
je     16d3 <s_update_var_mhe+0x5d3>
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
movups (%rax,%rdx,4),%xmm4
movups 0x10(%rax,%rdx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rax,%rdx,4)
movups %xmm3,0x10(%rax,%rdx,4)
mov    -0x68(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r10,%rcx
jne    1594 <s_update_var_mhe+0x494>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r13d,%r13d
jle    11f0 <s_update_var_mhe+0xf0>
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x58(%rsp),%rcx
mov    (%rcx,%r15,8),%rdx
mov    0x50(%rsp),%rcx
mov    (%rcx,%r15,8),%rbx
mov    0x48(%rsp),%rcx
mov    (%rcx,%r15,8),%rbp
xor    %ecx,%ecx
nop
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%rcx,4),%xmm2
movss  %xmm2,(%rdx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rdx,%rcx,4),%xmm2
movss  %xmm2,0x4(%rdx,%rcx,4)
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x0(%rbp,%rcx,4),%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rbp,%rcx,4),%xmm3
movss  %xmm3,0x4(%rbp,%rcx,4)
mulss  0x4(%rdx,%rcx,4),%xmm3
mulss  (%rdx,%rcx,4),%xmm2
addss  %xmm3,%xmm2
addss  %xmm2,%xmm9
add    $0x2,%rcx
cmp    %r14,%rcx
jl     1720 <s_update_var_mhe+0x620>
jmp    11f0 <s_update_var_mhe+0xf0>
xor    %eax,%eax
testb  $0x1,-0x30(%rsp)
jne    1369 <s_update_var_mhe+0x269>
jmp    139d <s_update_var_mhe+0x29d>
xor    %edx,%edx
testb  $0x1,-0x48(%rsp)
jne    16a3 <s_update_var_mhe+0x5a3>
jmp    16d3 <s_update_var_mhe+0x5d3>
xorps  %xmm9,%xmm9
movslq -0x6c(%rsp),%r8
test   %edi,%edi
jle    1abd <s_update_var_mhe+0x9bd>
mov    0x40(%rsp),%rax
mov    (%rax,%r8,8),%r9
mov    0x38(%rsp),%rax
mov    (%rax,%r8,8),%r11
cmp    $0x8,%edi
jae    17ee <s_update_var_mhe+0x6ee>
xor    %eax,%eax
mov    -0x78(%rsp),%r14
jmp    187f <s_update_var_mhe+0x77f>
mov    -0x78(%rsp),%r14
lea    (%r11,%r14,4),%rcx
lea    (%r14,%r10,1),%rax
lea    (%r9,%rax,4),%rdx
cmp    %rdx,%rcx
jae    1815 <s_update_var_mhe+0x715>
lea    (%r11,%rax,4),%rax
lea    (%r9,%r14,4),%rcx
cmp    %rax,%rcx
jae    1815 <s_update_var_mhe+0x715>
xor    %eax,%eax
jmp    187f <s_update_var_mhe+0x77f>
mov    %r10d,%eax
and    $0xfffffff8,%eax
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
lea    (%r11,%r14,4),%rcx
add    $0x10,%rcx
lea    (%r9,%r14,4),%rbx
add    $0x10,%rbx
lea    0x0(,%r10,4),%rbp
and    $0xffffffffffffffe0,%rbp
xor    %edx,%edx
movups -0x10(%rbx,%rdx,1),%xmm2
movups (%rbx,%rdx,1),%xmm4
movups -0x10(%rcx,%rdx,1),%xmm5
movups (%rcx,%rdx,1),%xmm6
subps  %xmm5,%xmm2
subps  %xmm6,%xmm4
mulps  %xmm3,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movups %xmm2,-0x10(%rcx,%rdx,1)
movups %xmm4,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1840 <s_update_var_mhe+0x740>
cmp    %r10,%rax
je     1912 <s_update_var_mhe+0x812>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r10b
je     18b1 <s_update_var_mhe+0x7b1>
lea    (%rax,%r14,1),%rdx
movss  (%r9,%rdx,4),%xmm2
movss  (%r11,%rdx,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%r11,%rdx,4)
or     $0x1,%rax
add    %r10,%rcx
je     1912 <s_update_var_mhe+0x812>
lea    (%r9,%r14,4),%rcx
add    $0x4,%rcx
lea    (%r11,%r14,4),%rdx
add    $0x4,%rdx
cs nopw 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,%r10
jne    18d0 <s_update_var_mhe+0x7d0>
test   %edi,%edi
jle    1abd <s_update_var_mhe+0x9bd>
mov    0x70(%rsp),%rax
mov    (%rax,%r8,8),%rcx
mov    0x68(%rsp),%rax
mov    (%rax,%r8,8),%rbp
cmp    $0x8,%edi
jb     1952 <s_update_var_mhe+0x852>
lea    (%rcx,%r10,4),%rax
cmp    %rax,%rbp
jae    19d9 <s_update_var_mhe+0x8d9>
lea    0x0(,%r10,4),%rax
add    %rbp,%rax
cmp    %rax,%rcx
jae    19d9 <s_update_var_mhe+0x8d9>
xor    %edi,%edi
mov    %rdi,%rax
not    %rax
test   $0x1,%r10b
je     1981 <s_update_var_mhe+0x881>
movss  (%rcx,%rdi,4),%xmm2
movss  0x0(%rbp,%rdi,4),%xmm3
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rdi,4)
or     $0x1,%rdi
add    %r10,%rax
je     1abd <s_update_var_mhe+0x9bd>
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdi,4),%xmm2
movss  0x0(%rbp,%rdi,4),%xmm3
movss  0x4(%rbp,%rdi,4),%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x0(%rbp,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm2
subss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rbp,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    1990 <s_update_var_mhe+0x890>
jmp    1abd <s_update_var_mhe+0x9bd>
mov    %r10d,%edi
and    $0xfffffff8,%edi
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
lea    -0x8(%rdi),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1b89 <s_update_var_mhe+0xa89>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movups (%rcx,%rdx,4),%xmm2
movups 0x10(%rcx,%rdx,4),%xmm4
movups 0x0(%rbp,%rdx,4),%xmm5
movups 0x10(%rbp,%rdx,4),%xmm6
movups 0x20(%rbp,%rdx,4),%xmm7
movups 0x30(%rbp,%rdx,4),%xmm3
subps  %xmm5,%xmm2
subps  %xmm6,%xmm4
mulps  %xmm8,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm4,0x10(%rbp,%rdx,4)
movups 0x20(%rcx,%rdx,4),%xmm2
movups 0x30(%rcx,%rdx,4),%xmm4
subps  %xmm7,%xmm2
subps  %xmm3,%xmm4
mulps  %xmm8,%xmm2
addps  %xmm7,%xmm2
mulps  %xmm8,%xmm4
addps  %xmm3,%xmm4
movups %xmm2,0x20(%rbp,%rdx,4)
movups %xmm4,0x30(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1a10 <s_update_var_mhe+0x910>
test   $0x1,%r9b
je     1ab4 <s_update_var_mhe+0x9b4>
movups (%rcx,%rdx,4),%xmm2
movups 0x10(%rcx,%rdx,4),%xmm3
movups 0x0(%rbp,%rdx,4),%xmm4
movups 0x10(%rbp,%rdx,4),%xmm5
subps  %xmm4,%xmm2
subps  %xmm5,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm3,0x10(%rbp,%rdx,4)
cmp    %r10,%rdi
jne    1954 <s_update_var_mhe+0x854>
add    %esi,%esi
add    %r13d,%r13d
cmp    %r13d,%esi
jge    1b6f <s_update_var_mhe+0xa6f>
mov    0x60(%rsp),%rax
mov    (%rax,%r8,8),%rax
mov    0x58(%rsp),%rcx
mov    (%rcx,%r8,8),%rdx
mov    0x50(%rsp),%rcx
mov    (%rcx,%r8,8),%rcx
mov    0x48(%rsp),%rdi
mov    (%rdi,%r8,8),%rdi
movslq %esi,%rsi
movslq %r13d,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%rsi,4),%xmm2
movss  %xmm2,(%rdx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rdx,%rsi,4),%xmm2
movss  %xmm2,0x4(%rdx,%rsi,4)
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdi,%rsi,4),%xmm2
movss  %xmm2,(%rdi,%rsi,4)
movss  0x4(%rcx,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rdi,%rsi,4),%xmm3
movss  %xmm3,0x4(%rdi,%rsi,4)
mulss  0x4(%rdx,%rsi,4),%xmm3
mulss  (%rdx,%rsi,4),%xmm2
addss  %xmm3,%xmm2
addss  %xmm2,%xmm9
add    $0x2,%rsi
cmp    %rbp,%rsi
jl     1b00 <s_update_var_mhe+0xa00>
mulss  %xmm0,%xmm9
mov    -0x58(%rsp),%rax
movss  %xmm9,(%rax)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r9b
jne    1a83 <s_update_var_mhe+0x983>
jmp    1ab4 <s_update_var_mhe+0x9b4>

LLVM IR (-O0):
define void @s_update_var_mhe(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, float* %5, float %6, float %7, float** %8, float** %9, float** %10, float** %11, float** %12, float** %13, float** %14, float** %15) {
%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* %33
br label %36
36: ; preds = %306, %16
%37 = load i32, i32* %33
%38 = load i32, i32* %19
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %309
40: ; preds = %36
store i32 0, i32* %34
br label %41
41: ; preds = %76, %40
%42 = load i32, i32* %34
%43 = load i32, i32* %18
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %79
45: ; preds = %41
%46 = load float, float* %24
%47 = load float**, float*** %26
%48 = load i32, i32* %33
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float*, float** %47, i64 %49
%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 = load float**, float*** %25
%57 = load i32, i32* %33
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float*, float** %56, i64 %58
%60 = load float*, float** %59
%61 = load i32, i32* %34
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
%65 = fsub float %55, %64
%66 = load float**, float*** %25
%67 = load i32, i32* %33
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float*, float** %66, i64 %68
%70 = load float*, float** %69
%71 = load i32, i32* %34
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = call float @llvm.fmuladd.f32(float %46, float %65, float %74)
store float %75, float* %73
br label %76
76: ; preds = %45
%77 = load i32, i32* %34
%78 = add nsw i32 %77, 1
store i32 %78, i32* %34
br label %41
79: ; preds = %41
store i32 0, i32* %34
br label %80
80: ; preds = %121, %79
%81 = load i32, i32* %34
%82 = load i32, i32* %17
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %124
84: ; preds = %80
%85 = load float, float* %24
%86 = load float**, float*** %26
%87 = load i32, i32* %33
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float*, float** %86, i64 %88
%90 = load float*, float** %89
%91 = load i32, i32* %18
%92 = load i32, i32* %34
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %90, i64 %94
%96 = load float, float* %95
%97 = load float**, float*** %25
%98 = load i32, i32* %33
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float*, float** %97, i64 %99
%101 = load float*, float** %100
%102 = load i32, i32* %18
%103 = load i32, i32* %34
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %101, i64 %105
%107 = load float, float* %106
%108 = fsub float %96, %107
%109 = load float**, float*** %25
%110 = load i32, i32* %33
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float*, float** %109, i64 %111
%113 = load float*, float** %112
%114 = load i32, i32* %18
%115 = load i32, i32* %34
%116 = add nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %113, i64 %117
%119 = load float, float* %118
%120 = call float @llvm.fmuladd.f32(float %85, float %108, float %119)
store float %120, float* %118
br label %121
121: ; preds = %84
%122 = load i32, i32* %34
%123 = add nsw i32 %122, 1
store i32 %123, i32* %34
br label %80
124: ; preds = %80
store i32 0, i32* %34
br label %125
125: ; preds = %160, %124
%126 = load i32, i32* %34
%127 = load i32, i32* %17
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %163
129: ; preds = %125
%130 = load float, float* %24
%131 = load float**, float*** %32
%132 = load i32, i32* %33
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float*, float** %131, i64 %133
%135 = load float*, float** %134
%136 = load i32, i32* %34
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
%140 = load float**, float*** %31
%141 = load i32, i32* %33
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float*, float** %140, i64 %142
%144 = load float*, float** %143
%145 = load i32, i32* %34
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = fsub float %139, %148
%150 = load float**, float*** %31
%151 = load i32, i32* %33
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float*, float** %150, i64 %152
%154 = load float*, float** %153
%155 = load i32, i32* %34
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %154, i64 %156
%158 = load float, float* %157
%159 = call float @llvm.fmuladd.f32(float %130, float %149, float %158)
store float %159, float* %157
br label %160
160: ; preds = %129
%161 = load i32, i32* %34
%162 = add nsw i32 %161, 1
store i32 %162, i32* %34
br label %125
163: ; preds = %125
store i32 0, i32* %34
br label %164
164: ; preds = %302, %163
%165 = load i32, i32* %34
%166 = load i32, i32* %20
%167 = mul nsw i32 2, %166
%168 = icmp slt i32 %165, %167
br i1 %168, label %169, label %305
169: ; preds = %164
%170 = load float, float* %24
%171 = load float**, float*** %30
%172 = load i32, i32* %33
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float*, float** %171, i64 %173
%175 = load float*, float** %174
%176 = load i32, i32* %34
%177 = add nsw i32 %176, 0
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %175, i64 %178
%180 = load float, float* %179
%181 = load float**, float*** %29
%182 = load i32, i32* %33
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds float*, float** %181, i64 %183
%185 = load float*, float** %184
%186 = load i32, i32* %34
%187 = add nsw i32 %186, 0
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %185, i64 %188
%190 = load float, float* %189
%191 = call float @llvm.fmuladd.f32(float %170, float %180, float %190)
store float %191, float* %189
%192 = load float, float* %24
%193 = load float**, float*** %30
%194 = load i32, i32* %33
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float*, float** %193, i64 %195
%197 = load float*, float** %196
%198 = load i32, i32* %34
%199 = add nsw i32 %198, 1
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %197, i64 %200
%202 = load float, float* %201
%203 = load float**, float*** %29
%204 = load i32, i32* %33
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float*, float** %203, i64 %205
%207 = load float*, float** %206
%208 = load i32, i32* %34
%209 = add nsw i32 %208, 1
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %207, i64 %210
%212 = load float, float* %211
%213 = call float @llvm.fmuladd.f32(float %192, float %202, float %212)
store float %213, float* %211
%214 = load float, float* %24
%215 = load float**, float*** %28
%216 = load i32, i32* %33
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float*, float** %215, i64 %217
%219 = load float*, float** %218
%220 = load i32, i32* %34
%221 = add nsw i32 %220, 0
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* %219, i64 %222
%224 = load float, float* %223
%225 = load float**, float*** %27
%226 = load i32, i32* %33
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float*, float** %225, i64 %227
%229 = load float*, float** %228
%230 = load i32, i32* %34
%231 = add nsw i32 %230, 0
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %229, i64 %232
%234 = load float, float* %233
%235 = call float @llvm.fmuladd.f32(float %214, float %224, float %234)
store float %235, float* %233
%236 = load float, float* %24
%237 = load float**, float*** %28
%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* %34
%243 = add nsw i32 %242, 1
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %241, i64 %244
%246 = load float, float* %245
%247 = load float**, float*** %27
%248 = load i32, i32* %33
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float*, float** %247, i64 %249
%251 = load float*, float** %250
%252 = load i32, i32* %34
%253 = add nsw i32 %252, 1
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds float, float* %251, i64 %254
%256 = load float, float* %255
%257 = call float @llvm.fmuladd.f32(float %236, float %246, float %256)
store float %257, float* %255
%258 = load float**, float*** %29
%259 = load i32, i32* %33
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds float*, float** %258, i64 %260
%262 = load float*, float** %261
%263 = load i32, i32* %34
%264 = add nsw i32 %263, 0
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %262, i64 %265
%267 = load float, float* %266
%268 = load float**, float*** %27
%269 = load i32, i32* %33
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float*, float** %268, i64 %270
%272 = load float*, float** %271
%273 = load i32, i32* %34
%274 = add nsw i32 %273, 0
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %272, i64 %275
%277 = load float, float* %276
%278 = load float**, float*** %29
%279 = load i32, i32* %33
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float*, float** %278, i64 %280
%282 = load float*, float** %281
%283 = load i32, i32* %34
%284 = add nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds float, float* %282, i64 %285
%287 = load float, float* %286
%288 = load float**, float*** %27
%289 = load i32, i32* %33
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float*, float** %288, i64 %290
%292 = load float*, float** %291
%293 = load i32, i32* %34
%294 = add nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds float, float* %292, i64 %295
%297 = load float, float* %296
%298 = fmul float %287, %297
%299 = call float @llvm.fmuladd.f32(float %267, float %277, float %298)
%300 = load float, float* %35
%301 = fadd float %300, %299
store float %301, float* %35
br label %302
302: ; preds = %169
%303 = load i32, i32* %34
%304 = add nsw i32 %303, 2
store i32 %304, i32* %34
br label %164
305: ; preds = %164
br label %306
306: ; preds = %305
%307 = load i32, i32* %33
%308 = add nsw i32 %307, 1
store i32 %308, i32* %33
br label %36
309: ; preds = %36
store i32 0, i32* %34
br label %310
310: ; preds = %351, %309
%311 = load i32, i32* %34
%312 = load i32, i32* %17
%313 = icmp slt i32 %311, %312
br i1 %313, label %314, label %354
314: ; preds = %310
%315 = load float, float* %24
%316 = load float**, float*** %26
%317 = load i32, i32* %19
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float*, float** %316, i64 %318
%320 = load float*, float** %319
%321 = load i32, i32* %18
%322 = load i32, i32* %34
%323 = add nsw i32 %321, %322
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %320, i64 %324
%326 = load float, float* %325
%327 = load float**, float*** %25
%328 = load i32, i32* %19
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float*, float** %327, i64 %329
%331 = load float*, float** %330
%332 = load i32, i32* %18
%333 = load i32, i32* %34
%334 = add nsw i32 %332, %333
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %331, i64 %335
%337 = load float, float* %336
%338 = fsub float %326, %337
%339 = load float**, float*** %25
%340 = load i32, i32* %19
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float*, float** %339, i64 %341
%343 = load float*, float** %342
%344 = load i32, i32* %18
%345 = load i32, i32* %34
%346 = add nsw i32 %344, %345
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %343, i64 %347
%349 = load float, float* %348
%350 = call float @llvm.fmuladd.f32(float %315, float %338, float %349)
store float %350, float* %348
br label %351
351: ; preds = %314
%352 = load i32, i32* %34
%353 = add nsw i32 %352, 1
store i32 %353, i32* %34
br label %310
354: ; preds = %310
store i32 0, i32* %34
br label %355
355: ; preds = %390, %354
%356 = load i32, i32* %34
%357 = load i32, i32* %17
%358 = icmp slt i32 %356, %357
br i1 %358, label %359, label %393
359: ; preds = %355
%360 = load float, float* %24
%361 = load float**, float*** %32
%362 = load i32, i32* %19
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float*, float** %361, i64 %363
%365 = load float*, float** %364
%366 = load i32, i32* %34
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %365, i64 %367
%369 = load float, float* %368
%370 = load float**, float*** %31
%371 = load i32, i32* %19
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float*, float** %370, i64 %372
%374 = load float*, float** %373
%375 = load i32, i32* %34
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds float, float* %374, i64 %376
%378 = load float, float* %377
%379 = fsub float %369, %378
%380 = load float**, float*** %31
%381 = load i32, i32* %19
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float*, float** %380, i64 %382
%384 = load float*, float** %383
%385 = load i32, i32* %34
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
%388 = load float, float* %387
%389 = call float @llvm.fmuladd.f32(float %360, float %379, float %388)
store float %389, float* %387
br label %390
390: ; preds = %359
%391 = load i32, i32* %34
%392 = add nsw i32 %391, 1
store i32 %392, i32* %34
br label %355
393: ; preds = %355
%394 = load i32, i32* %18
%395 = mul nsw i32 2, %394
store i32 %395, i32* %34
br label %396
396: ; preds = %534, %393
%397 = load i32, i32* %34
%398 = load i32, i32* %20
%399 = mul nsw i32 2, %398
%400 = icmp slt i32 %397, %399
br i1 %400, label %401, label %537
401: ; preds = %396
%402 = load float, float* %24
%403 = load float**, float*** %30
%404 = load i32, i32* %19
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float*, float** %403, i64 %405
%407 = load float*, float** %406
%408 = load i32, i32* %34
%409 = add nsw i32 %408, 0
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %407, i64 %410
%412 = load float, float* %411
%413 = load float**, float*** %29
%414 = load i32, i32* %19
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds float*, float** %413, i64 %415
%417 = load float*, float** %416
%418 = load i32, i32* %34
%419 = add nsw i32 %418, 0
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds float, float* %417, i64 %420
%422 = load float, float* %421
%423 = call float @llvm.fmuladd.f32(float %402, float %412, float %422)
store float %423, float* %421
%424 = load float, float* %24
%425 = load float**, float*** %30
%426 = load i32, i32* %19
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float*, float** %425, i64 %427
%429 = load float*, float** %428
%430 = load i32, i32* %34
%431 = add nsw i32 %430, 1
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float, float* %429, i64 %432
%434 = load float, float* %433
%435 = load float**, float*** %29
%436 = load i32, i32* %19
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds float*, float** %435, i64 %437
%439 = load float*, float** %438
%440 = load i32, i32* %34
%441 = add nsw i32 %440, 1
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds float, float* %439, i64 %442
%444 = load float, float* %443
%445 = call float @llvm.fmuladd.f32(float %424, float %434, float %444)
store float %445, float* %443
%446 = load float, float* %24
%447 = load float**, float*** %28
%448 = load i32, i32* %19
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds float*, float** %447, i64 %449
%451 = load float*, float** %450
%452 = load i32, i32* %34
%453 = add nsw i32 %452, 0
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds float, float* %451, i64 %454
%456 = load float, float* %455
%457 = load float**, float*** %27
%458 = load i32, i32* %19
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float*, float** %457, i64 %459
%461 = load float*, float** %460
%462 = load i32, i32* %34
%463 = add nsw i32 %462, 0
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float, float* %461, i64 %464
%466 = load float, float* %465
%467 = call float @llvm.fmuladd.f32(float %446, float %456, float %466)
store float %467, float* %465
%468 = load float, float* %24
%469 = load float**, float*** %28
%470 = load i32, i32* %19
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float*, float** %469, i64 %471
%473 = load float*, float** %472
%474 = load i32, i32* %34
%475 = add nsw i32 %474, 1
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds float, float* %473, i64 %476
%478 = load float, float* %477
%479 = load float**, float*** %27
%480 = load i32, i32* %19
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds float*, float** %479, i64 %481
%483 = load float*, float** %482
%484 = load i32, i32* %34
%485 = add nsw i32 %484, 1
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %483, i64 %486
%488 = load float, float* %487
%489 = call float @llvm.fmuladd.f32(float %468, float %478, float %488)
store float %489, float* %487
%490 = load float**, float*** %29
%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* %34
%496 = add nsw i32 %495, 0
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float, float* %494, i64 %497
%499 = load float, float* %498
%500 = load float**, float*** %27
%501 = load i32, i32* %19
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds float*, float** %500, i64 %502
%504 = load float*, float** %503
%505 = load i32, i32* %34
%506 = add nsw i32 %505, 0
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds float, float* %504, i64 %507
%509 = load float, float* %508
%510 = load float**, float*** %29
%511 = load i32, i32* %19
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds float*, float** %510, i64 %512
%514 = load float*, float** %513
%515 = load i32, i32* %34
%516 = add nsw i32 %515, 1
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds float, float* %514, i64 %517
%519 = load float, float* %518
%520 = load float**, float*** %27
%521 = load i32, i32* %19
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds float*, float** %520, i64 %522
%524 = load float*, float** %523
%525 = load i32, i32* %34
%526 = add nsw i32 %525, 1
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds float, float* %524, i64 %527
%529 = load float, float* %528
%530 = fmul float %519, %529
%531 = call float @llvm.fmuladd.f32(float %499, float %509, float %530)
%532 = load float, float* %35
%533 = fadd float %532, %531
store float %533, float* %35
br label %534
534: ; preds = %401
%535 = load i32, i32* %34
%536 = add nsw i32 %535, 2
store i32 %536, i32* %34
br label %396
537: ; preds = %396
%538 = load float, float* %23
%539 = load float, float* %35
%540 = fmul float %539, %538
store float %540, float* %35
%541 = load float, float* %35
%542 = load float*, float** %22
%543 = getelementptr inbounds float, float* %542, i64 0
store float %541, float* %543
ret void
}

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