void s_compute_alpha_box_mpc(int N, int k0, int k1, int kmax, float *ptr_alpha,
                             float **t, float **dt, float **lam, float **dlam,
                             float **lamt, float **dux, float **db) {
  const int bs = 4;
  float alpha = ptr_alpha[0];
  int kna = ((k1 + bs - 1) / bs) * bs;
  int jj, ll;
  ll = 0;
  for (; ll < k0; ll += 2) {
    dt[0][ll + 0] = dux[0][ll / 2] - db[0][ll + 0] - t[0][ll + 0];
    dt[0][ll + 1] = -dux[0][ll / 2] - db[0][ll + 1] - t[0][ll + 1];
    dlam[0][ll + 0] -= lamt[0][ll + 0] * dt[0][ll + 0] + lam[0][ll + 0];
    dlam[0][ll + 1] -= lamt[0][ll + 1] * dt[0][ll + 1] + lam[0][ll + 1];
    if (-alpha * dlam[0][ll + 0] > lam[0][ll + 0]) {
      alpha = -lam[0][ll + 0] / dlam[0][ll + 0];
    }
    if (-alpha * dlam[0][ll + 1] > lam[0][ll + 1]) {
      alpha = -lam[0][ll + 1] / dlam[0][ll + 1];
    }
    if (-alpha * dt[0][ll + 0] > t[0][ll + 0]) {
      alpha = -t[0][ll + 0] / dt[0][ll + 0];
    }
    if (-alpha * dt[0][ll + 1] > t[0][ll + 1]) {
      alpha = -t[0][ll + 1] / dt[0][ll + 1];
    }
  }
  for (jj = 1; jj < N; jj++) {
    ll = 0;
    for (; ll < kmax; ll += 2) {
      dt[jj][ll + 0] = dux[jj][ll / 2] - db[jj][ll + 0] - t[jj][ll + 0];
      dt[jj][ll + 1] = -dux[jj][ll / 2] - db[jj][ll + 1] - t[jj][ll + 1];
      dlam[jj][ll + 0] -= lamt[jj][ll + 0] * dt[jj][ll + 0] + lam[jj][ll + 0];
      dlam[jj][ll + 1] -= lamt[jj][ll + 1] * dt[jj][ll + 1] + lam[jj][ll + 1];
      if (-alpha * dlam[jj][ll + 0] > lam[jj][ll + 0]) {
        alpha = -lam[jj][ll + 0] / dlam[jj][ll + 0];
      }
      if (-alpha * dlam[jj][ll + 1] > lam[jj][ll + 1]) {
        alpha = -lam[jj][ll + 1] / dlam[jj][ll + 1];
      }
      if (-alpha * dt[jj][ll + 0] > t[jj][ll + 0]) {
        alpha = -t[jj][ll + 0] / dt[jj][ll + 0];
      }
      if (-alpha * dt[jj][ll + 1] > t[jj][ll + 1]) {
        alpha = -t[jj][ll + 1] / dt[jj][ll + 1];
      }
    }
  }
  ll = k1;
  for (; ll < kmax; ll += 2) {
    dt[N][ll + 0] = dux[N][ll / 2] - db[N][ll + 0] - t[N][ll + 0];
    dt[N][ll + 1] = -dux[N][ll / 2] - db[N][ll + 1] - t[N][ll + 1];
    dlam[N][ll + 0] -= lamt[N][ll + 0] * dt[N][ll + 0] + lam[N][ll + 0];
    dlam[N][ll + 1] -= lamt[N][ll + 1] * dt[N][ll + 1] + lam[N][ll + 1];
    if (-alpha * dlam[N][ll + 0] > lam[N][ll + 0]) {
      alpha = -lam[N][ll + 0] / dlam[N][ll + 0];
    }
    if (-alpha * dlam[N][ll + 1] > lam[N][ll + 1]) {
      alpha = -lam[N][ll + 1] / dlam[N][ll + 1];
    }
    if (-alpha * dt[N][ll + 0] > t[N][ll + 0]) {
      alpha = -t[N][ll + 0] / dt[N][ll + 0];
    }
    if (-alpha * dt[N][ll + 1] > t[N][ll + 1]) {
      alpha = -t[N][ll + 1] / dt[N][ll + 1];
    }
  }
  ptr_alpha[0] = alpha;
  return;
}


x86 assembly (clang, -O0):
<s_compute_alpha_box_mpc>:
push   %rbp
mov    %rsp,%rbp
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    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movl   $0x4,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
shl    $0x2,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1512 <s_compute_alpha_box_mpc+0x412>
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1388 <s_compute_alpha_box_mpc+0x288>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1405 <s_compute_alpha_box_mpc+0x305>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1482 <s_compute_alpha_box_mpc+0x382>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    14ff <s_compute_alpha_box_mpc+0x3ff>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    1504 <s_compute_alpha_box_mpc+0x404>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1162 <s_compute_alpha_box_mpc+0x62>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    198f <s_compute_alpha_box_mpc+0x88f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    197c <s_compute_alpha_box_mpc+0x87c>
mov    0x30(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    17b6 <s_compute_alpha_box_mpc+0x6b6>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1847 <s_compute_alpha_box_mpc+0x747>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    18d8 <s_compute_alpha_box_mpc+0x7d8>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1969 <s_compute_alpha_box_mpc+0x869>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    196e <s_compute_alpha_box_mpc+0x86e>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    152c <s_compute_alpha_box_mpc+0x42c>
jmp    1981 <s_compute_alpha_box_mpc+0x881>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1519 <s_compute_alpha_box_mpc+0x419>
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1de5 <s_compute_alpha_box_mpc+0xce5>
mov    0x30(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x38(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1c1f <s_compute_alpha_box_mpc+0xb1f>
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1cb0 <s_compute_alpha_box_mpc+0xbb0>
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1d41 <s_compute_alpha_box_mpc+0xc41>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1dd2 <s_compute_alpha_box_mpc+0xcd2>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    1dd7 <s_compute_alpha_box_mpc+0xcd7>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1995 <s_compute_alpha_box_mpc+0x895>
movss  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_compute_alpha_box_mpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,-0x14(%rsp)
mov    %edx,-0xc(%rsp)
mov    0x60(%rsp),%rbx
mov    0x58(%rsp),%rax
mov    0x50(%rsp),%r14
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%rdx
mov    0x38(%rsp),%rcx
mov    %r8,-0x8(%rsp)
movss  (%r8),%xmm0
test   %esi,%esi
jle    1285 <s_compute_alpha_box_mpc+0x185>
mov    (%rax),%r10
mov    (%rbx),%rbp
mov    (%r9),%rbx
mov    %rcx,%r15
mov    (%rcx),%rax
mov    (%r14),%r8
mov    (%rdx),%rdx
mov    (%r11),%r11
mov    %esi,%r14d
xor    %esi,%esi
movaps 0xe9a(%rip),%xmm1
jmp    117d <s_compute_alpha_box_mpc+0x7d>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rsi
cmp    %r14,%rsi
jae    1288 <s_compute_alpha_box_mpc+0x188>
movss  (%r10,%rsi,2),%xmm2
subss  0x0(%rbp,%rsi,4),%xmm2
subss  (%rbx,%rsi,4),%xmm2
movss  %xmm2,(%rax,%rsi,4)
movss  (%r10,%rsi,2),%xmm3
xorps  %xmm1,%xmm3
subss  0x4(%rbp,%rsi,4),%xmm3
subss  0x4(%rbx,%rsi,4),%xmm3
movss  %xmm3,0x4(%rax,%rsi,4)
mulss  (%r8,%rsi,4),%xmm2
addss  (%rdx,%rsi,4),%xmm2
movss  (%r11,%rsi,4),%xmm4
subss  %xmm2,%xmm4
movss  0x4(%r11,%rsi,4),%xmm3
movss  %xmm4,(%r11,%rsi,4)
movss  0x4(%r8,%rsi,4),%xmm2
mulss  0x4(%rax,%rsi,4),%xmm2
addss  0x4(%rdx,%rsi,4),%xmm2
subss  %xmm2,%xmm3
movss  %xmm3,0x4(%r11,%rsi,4)
movaps %xmm0,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
movss  (%rdx,%rsi,4),%xmm5
ucomiss %xmm5,%xmm6
jbe    1215 <s_compute_alpha_box_mpc+0x115>
xorps  %xmm1,%xmm5
divss  %xmm4,%xmm5
movaps %xmm5,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm5,%xmm0
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
movss  0x4(%rdx,%rsi,4),%xmm4
ucomiss %xmm4,%xmm5
jbe    1237 <s_compute_alpha_box_mpc+0x137>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm0
movss  (%rax,%rsi,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
movss  (%rbx,%rsi,4),%xmm3
ucomiss %xmm3,%xmm5
jbe    125d <s_compute_alpha_box_mpc+0x15d>
xorps  %xmm1,%xmm3
divss  %xmm4,%xmm3
movaps %xmm3,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm3,%xmm0
movss  0x4(%rax,%rsi,4),%xmm3
mulss  %xmm3,%xmm2
movss  0x4(%rbx,%rsi,4),%xmm4
ucomiss %xmm4,%xmm2
jbe    1170 <s_compute_alpha_box_mpc+0x70>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm0
jmp    1170 <s_compute_alpha_box_mpc+0x70>
mov    %rcx,%r15
movslq -0x14(%rsp),%r11
cmp    $0x2,%edi
mov    %edi,-0x10(%rsp)
jl     1441 <s_compute_alpha_box_mpc+0x341>
mov    %edi,%r8d
mov    $0x1,%r10d
movaps 0xd56(%rip),%xmm1
mov    0x50(%rsp),%rbp
mov    %r15,%rcx
mov    %r9,%rdi
jmp    12d0 <s_compute_alpha_box_mpc+0x1d0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r8,%r10
mov    %rdi,%r9
je     1449 <s_compute_alpha_box_mpc+0x349>
cmpl   $0x0,-0x14(%rsp)
jle    12c0 <s_compute_alpha_box_mpc+0x1c0>
mov    0x58(%rsp),%rax
mov    (%rax,%r10,8),%r13
mov    0x60(%rsp),%rax
mov    (%rax,%r10,8),%rdx
mov    (%r9,%r10,8),%rax
mov    (%rcx,%r10,8),%rsi
mov    0x0(%rbp,%r10,8),%rbx
mov    0x40(%rsp),%rbp
mov    0x0(%rbp,%r10,8),%r14
mov    0x48(%rsp),%rbp
mov    0x0(%rbp,%r10,8),%r15
mov    0x50(%rsp),%rbp
xor    %r12d,%r12d
jmp    1329 <s_compute_alpha_box_mpc+0x229>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%r12
cmp    %r11,%r12
jge    12c0 <s_compute_alpha_box_mpc+0x1c0>
movss  0x0(%r13,%r12,2),%xmm2
subss  (%rdx,%r12,4),%xmm2
subss  (%rax,%r12,4),%xmm2
movss  %xmm2,(%rsi,%r12,4)
movss  0x0(%r13,%r12,2),%xmm3
xorps  %xmm1,%xmm3
subss  0x4(%rdx,%r12,4),%xmm3
subss  0x4(%rax,%r12,4),%xmm3
movss  %xmm3,0x4(%rsi,%r12,4)
mulss  (%rbx,%r12,4),%xmm2
addss  (%r14,%r12,4),%xmm2
movss  (%r15,%r12,4),%xmm4
subss  %xmm2,%xmm4
movss  0x4(%r15,%r12,4),%xmm3
movss  %xmm4,(%r15,%r12,4)
movss  0x4(%rbx,%r12,4),%xmm2
mulss  0x4(%rsi,%r12,4),%xmm2
addss  0x4(%r14,%r12,4),%xmm2
subss  %xmm2,%xmm3
movss  %xmm3,0x4(%r15,%r12,4)
movaps %xmm0,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
movss  (%r14,%r12,4),%xmm5
ucomiss %xmm5,%xmm6
jbe    13cc <s_compute_alpha_box_mpc+0x2cc>
xorps  %xmm1,%xmm5
divss  %xmm4,%xmm5
movaps %xmm5,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm5,%xmm0
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
movss  0x4(%r14,%r12,4),%xmm4
ucomiss %xmm4,%xmm5
jbe    13ef <s_compute_alpha_box_mpc+0x2ef>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm0
movss  (%rsi,%r12,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
movss  (%rax,%r12,4),%xmm3
ucomiss %xmm3,%xmm5
jbe    1417 <s_compute_alpha_box_mpc+0x317>
xorps  %xmm1,%xmm3
divss  %xmm4,%xmm3
movaps %xmm3,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm3,%xmm0
movss  0x4(%rsi,%r12,4),%xmm3
mulss  %xmm3,%xmm2
movss  0x4(%rax,%r12,4),%xmm4
ucomiss %xmm4,%xmm2
jbe    1320 <s_compute_alpha_box_mpc+0x220>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm0
jmp    1320 <s_compute_alpha_box_mpc+0x220>
mov    0x50(%rsp),%rbp
mov    %r15,%rcx
mov    -0xc(%rsp),%esi
cmp    -0x14(%rsp),%esi
jge    15ea <s_compute_alpha_box_mpc+0x4ea>
movslq -0x10(%rsp),%rdx
movslq %esi,%r10
mov    %rcx,%rax
lea    0x4(,%r10,4),%rdi
mov    0x60(%rsp),%rcx
mov    (%rcx,%rdx,8),%r13
add    %rdi,%r13
mov    (%r9,%rdx,8),%rbx
add    %rdi,%rbx
mov    (%rax,%rdx,8),%rcx
add    %rdi,%rcx
mov    0x0(%rbp,%rdx,8),%r9
add    %rdi,%r9
mov    0x40(%rsp),%rax
mov    (%rax,%rdx,8),%rax
add    %rdi,%rax
mov    0x48(%rsp),%rbp
add    0x0(%rbp,%rdx,8),%rdi
mov    0x58(%rsp),%rbp
mov    0x0(%rbp,%rdx,8),%r14
mov    %esi,%r8d
xor    %edx,%edx
movaps 0xb48(%rip),%xmm1
jmp    14d5 <s_compute_alpha_box_mpc+0x3d5>
nopw   0x0(%rax,%rax,1)
lea    (%r10,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    %r11,%rsi
jge    15ea <s_compute_alpha_box_mpc+0x4ea>
lea    (%r8,%rdx,1),%ebp
mov    %ebp,%esi
shr    $0x1f,%esi
add    %ebp,%esi
sar    %esi
movslq %esi,%rsi
movss  (%r14,%rsi,4),%xmm2
subss  -0x4(%r13,%rdx,4),%xmm2
subss  -0x4(%rbx,%rdx,4),%xmm2
movss  %xmm2,-0x4(%rcx,%rdx,4)
movss  (%r14,%rsi,4),%xmm3
xorps  %xmm1,%xmm3
subss  0x0(%r13,%rdx,4),%xmm3
subss  (%rbx,%rdx,4),%xmm3
movss  %xmm3,(%rcx,%rdx,4)
mulss  -0x4(%r9,%rdx,4),%xmm2
addss  -0x4(%rax,%rdx,4),%xmm2
movss  -0x4(%rdi,%rdx,4),%xmm4
subss  %xmm2,%xmm4
movss  (%rdi,%rdx,4),%xmm3
movss  %xmm4,-0x4(%rdi,%rdx,4)
movss  (%r9,%rdx,4),%xmm2
mulss  (%rcx,%rdx,4),%xmm2
addss  (%rax,%rdx,4),%xmm2
subss  %xmm2,%xmm3
movss  %xmm3,(%rdi,%rdx,4)
movaps %xmm0,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
movss  -0x4(%rax,%rdx,4),%xmm5
ucomiss %xmm5,%xmm6
jbe    157b <s_compute_alpha_box_mpc+0x47b>
xorps  %xmm1,%xmm5
divss  %xmm4,%xmm5
movaps %xmm5,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm5,%xmm0
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
movss  (%rax,%rdx,4),%xmm4
ucomiss %xmm4,%xmm5
jbe    159c <s_compute_alpha_box_mpc+0x49c>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm4,%xmm0
movss  -0x4(%rcx,%rdx,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
movss  -0x4(%rbx,%rdx,4),%xmm3
ucomiss %xmm3,%xmm5
jbe    15c4 <s_compute_alpha_box_mpc+0x4c4>
xorps  %xmm1,%xmm3
divss  %xmm4,%xmm3
movaps %xmm3,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm3,%xmm0
movss  (%rcx,%rdx,4),%xmm3
mulss  %xmm3,%xmm2
movss  (%rbx,%rdx,4),%xmm4
ucomiss %xmm4,%xmm2
jbe    14c0 <s_compute_alpha_box_mpc+0x3c0>
xorps  %xmm1,%xmm4
divss  %xmm3,%xmm4
movaps %xmm4,%xmm0
jmp    14c0 <s_compute_alpha_box_mpc+0x3c0>
mov    -0x8(%rsp),%rax
movss  %xmm0,(%rax)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @s_compute_alpha_box_mpc(i32 %0, i32 %1, i32 %2, i32 %3, float* nocapture %4, float** nocapture %5, float** nocapture %6, float** nocapture %7, float** nocapture %8, float** nocapture %9, float** nocapture %10, float** nocapture %11) {
%13 = load float, float* %4
%14 = icmp sgt i32 %1, 0
br i1 %14, label %15, label %24
15: ; preds = %12
%16 = load float*, float** %10
%17 = load float*, float** %11
%18 = load float*, float** %5
%19 = load float*, float** %6
%20 = load float*, float** %9
%21 = load float*, float** %7
%22 = load float*, float** %8
%23 = zext i32 %1 to i64
br label %31
24: ; preds = %110, %12
%25 = phi float [ %13, %12 ], [ %111, %110 ]
%26 = icmp sgt i32 %0, 1
br i1 %26, label %27, label %132
27: ; preds = %24
%28 = icmp sgt i32 %3, 0
%29 = sext i32 %3 to i64
%30 = zext i32 %0 to i64
br label %114
31: ; preds = %15, %110
%32 = phi i64 [ 0, %15 ], [ %112, %110 ]
%33 = phi float [ %13, %15 ], [ %111, %110 ]
%34 = lshr exact i64 %32, 1
%35 = getelementptr inbounds float, float* %16, i64 %34
%36 = load float, float* %35
%37 = getelementptr inbounds float, float* %17, i64 %32
%38 = load float, float* %37
%39 = fsub float %36, %38
%40 = getelementptr inbounds float, float* %18, i64 %32
%41 = load float, float* %40
%42 = fsub float %39, %41
%43 = getelementptr inbounds float, float* %19, i64 %32
store float %42, float* %43
%44 = load float, float* %35
%45 = fneg float %44
%46 = or i64 %32, 1
%47 = getelementptr inbounds float, float* %17, i64 %46
%48 = load float, float* %47
%49 = fsub float %45, %48
%50 = getelementptr inbounds float, float* %18, i64 %46
%51 = load float, float* %50
%52 = fsub float %49, %51
%53 = getelementptr inbounds float, float* %19, i64 %46
store float %52, float* %53
%54 = getelementptr inbounds float, float* %20, i64 %32
%55 = load float, float* %54
%56 = getelementptr inbounds float, float* %21, i64 %32
%57 = load float, float* %56
%58 = tail call float @llvm.fmuladd.f32(float %55, float %42, float %57)
%59 = getelementptr inbounds float, float* %22, i64 %32
%60 = load float, float* %59
%61 = fsub float %60, %58
store float %61, float* %59
%62 = getelementptr inbounds float, float* %20, i64 %46
%63 = load float, float* %62
%64 = load float, float* %53
%65 = getelementptr inbounds float, float* %21, i64 %46
%66 = load float, float* %65
%67 = tail call float @llvm.fmuladd.f32(float %63, float %64, float %66)
%68 = getelementptr inbounds float, float* %22, i64 %46
%69 = load float, float* %68
%70 = fsub float %69, %67
store float %70, float* %68
%71 = fneg float %33
%72 = fmul float %61, %71
%73 = load float, float* %56
%74 = fcmp ogt float %72, %73
br i1 %74, label %75, label %79
75: ; preds = %31
%76 = fneg float %73
%77 = fdiv float %76, %61
%78 = fneg float %77
br label %79
79: ; preds = %75, %31
%80 = phi float [ %78, %75 ], [ %71, %31 ]
%81 = phi float [ %77, %75 ], [ %33, %31 ]
%82 = fmul float %70, %80
%83 = load float, float* %65
%84 = fcmp ogt float %82, %83
br i1 %84, label %85, label %89
85: ; preds = %79
%86 = fneg float %83
%87 = fdiv float %86, %70
%88 = fneg float %87
br label %89
89: ; preds = %85, %79
%90 = phi float [ %88, %85 ], [ %80, %79 ]
%91 = phi float [ %87, %85 ], [ %81, %79 ]
%92 = load float, float* %43
%93 = fmul float %92, %90
%94 = load float, float* %40
%95 = fcmp ogt float %93, %94
br i1 %95, label %96, label %100
96: ; preds = %89
%97 = fneg float %94
%98 = fdiv float %97, %92
%99 = fneg float %98
br label %100
100: ; preds = %96, %89
%101 = phi float [ %99, %96 ], [ %90, %89 ]
%102 = phi float [ %98, %96 ], [ %91, %89 ]
%103 = load float, float* %53
%104 = fmul float %103, %101
%105 = load float, float* %50
%106 = fcmp ogt float %104, %105
br i1 %106, label %107, label %110
107: ; preds = %100
%108 = fneg float %105
%109 = fdiv float %108, %103
br label %110
110: ; preds = %100, %107
%111 = phi float [ %109, %107 ], [ %102, %100 ]
%112 = add nuw nsw i64 %32, 2
%113 = icmp ult i64 %112, %23
br i1 %113, label %31, label %24
114: ; preds = %27, %236
%115 = phi i64 [ 1, %27 ], [ %238, %236 ]
%116 = phi float [ %25, %27 ], [ %237, %236 ]
br i1 %28, label %117, label %236
117: ; preds = %114
%118 = getelementptr inbounds float*, float** %10, i64 %115
%119 = load float*, float** %118
%120 = getelementptr inbounds float*, float** %11, i64 %115
%121 = load float*, float** %120
%122 = getelementptr inbounds float*, float** %5, i64 %115
%123 = load float*, float** %122
%124 = getelementptr inbounds float*, float** %6, i64 %115
%125 = load float*, float** %124
%126 = getelementptr inbounds float*, float** %9, i64 %115
%127 = load float*, float** %126
%128 = getelementptr inbounds float*, float** %7, i64 %115
%129 = load float*, float** %128
%130 = getelementptr inbounds float*, float** %8, i64 %115
%131 = load float*, float** %130
br label %153
132: ; preds = %236, %24
%133 = phi float [ %25, %24 ], [ %237, %236 ]
%134 = icmp slt i32 %2, %3
br i1 %134, label %135, label %325
135: ; preds = %132
%136 = sext i32 %0 to i64
%137 = getelementptr inbounds float*, float** %10, i64 %136
%138 = load float*, float** %137
%139 = getelementptr inbounds float*, float** %11, i64 %136
%140 = load float*, float** %139
%141 = getelementptr inbounds float*, float** %5, i64 %136
%142 = load float*, float** %141
%143 = getelementptr inbounds float*, float** %6, i64 %136
%144 = load float*, float** %143
%145 = getelementptr inbounds float*, float** %9, i64 %136
%146 = load float*, float** %145
%147 = getelementptr inbounds float*, float** %7, i64 %136
%148 = load float*, float** %147
%149 = getelementptr inbounds float*, float** %8, i64 %136
%150 = load float*, float** %149
%151 = sext i32 %2 to i64
%152 = sext i32 %3 to i64
br label %240
153: ; preds = %117, %232
%154 = phi i64 [ 0, %117 ], [ %234, %232 ]
%155 = phi float [ %116, %117 ], [ %233, %232 ]
%156 = lshr exact i64 %154, 1
%157 = getelementptr inbounds float, float* %119, i64 %156
%158 = load float, float* %157
%159 = getelementptr inbounds float, float* %121, i64 %154
%160 = load float, float* %159
%161 = fsub float %158, %160
%162 = getelementptr inbounds float, float* %123, i64 %154
%163 = load float, float* %162
%164 = fsub float %161, %163
%165 = getelementptr inbounds float, float* %125, i64 %154
store float %164, float* %165
%166 = load float, float* %157
%167 = fneg float %166
%168 = or i64 %154, 1
%169 = getelementptr inbounds float, float* %121, i64 %168
%170 = load float, float* %169
%171 = fsub float %167, %170
%172 = getelementptr inbounds float, float* %123, i64 %168
%173 = load float, float* %172
%174 = fsub float %171, %173
%175 = getelementptr inbounds float, float* %125, i64 %168
store float %174, float* %175
%176 = getelementptr inbounds float, float* %127, i64 %154
%177 = load float, float* %176
%178 = getelementptr inbounds float, float* %129, i64 %154
%179 = load float, float* %178
%180 = tail call float @llvm.fmuladd.f32(float %177, float %164, float %179)
%181 = getelementptr inbounds float, float* %131, i64 %154
%182 = load float, float* %181
%183 = fsub float %182, %180
store float %183, float* %181
%184 = getelementptr inbounds float, float* %127, i64 %168
%185 = load float, float* %184
%186 = load float, float* %175
%187 = getelementptr inbounds float, float* %129, i64 %168
%188 = load float, float* %187
%189 = tail call float @llvm.fmuladd.f32(float %185, float %186, float %188)
%190 = getelementptr inbounds float, float* %131, i64 %168
%191 = load float, float* %190
%192 = fsub float %191, %189
store float %192, float* %190
%193 = fneg float %155
%194 = fmul float %183, %193
%195 = load float, float* %178
%196 = fcmp ogt float %194, %195
br i1 %196, label %197, label %201
197: ; preds = %153
%198 = fneg float %195
%199 = fdiv float %198, %183
%200 = fneg float %199
br label %201
201: ; preds = %197, %153
%202 = phi float [ %200, %197 ], [ %193, %153 ]
%203 = phi float [ %199, %197 ], [ %155, %153 ]
%204 = fmul float %192, %202
%205 = load float, float* %187
%206 = fcmp ogt float %204, %205
br i1 %206, label %207, label %211
207: ; preds = %201
%208 = fneg float %205
%209 = fdiv float %208, %192
%210 = fneg float %209
br label %211
211: ; preds = %207, %201
%212 = phi float [ %210, %207 ], [ %202, %201 ]
%213 = phi float [ %209, %207 ], [ %203, %201 ]
%214 = load float, float* %165
%215 = fmul float %214, %212
%216 = load float, float* %162
%217 = fcmp ogt float %215, %216
br i1 %217, label %218, label %222
218: ; preds = %211
%219 = fneg float %216
%220 = fdiv float %219, %214
%221 = fneg float %220
br label %222
222: ; preds = %218, %211
%223 = phi float [ %221, %218 ], [ %212, %211 ]
%224 = phi float [ %220, %218 ], [ %213, %211 ]
%225 = load float, float* %175
%226 = fmul float %225, %223
%227 = load float, float* %172
%228 = fcmp ogt float %226, %227
br i1 %228, label %229, label %232
229: ; preds = %222
%230 = fneg float %227
%231 = fdiv float %230, %225
br label %232
232: ; preds = %222, %229
%233 = phi float [ %231, %229 ], [ %224, %222 ]
%234 = add nuw nsw i64 %154, 2
%235 = icmp slt i64 %234, %29
br i1 %235, label %153, label %236
236: ; preds = %232, %114
%237 = phi float [ %116, %114 ], [ %233, %232 ]
%238 = add nuw nsw i64 %115, 1
%239 = icmp eq i64 %238, %30
br i1 %239, label %132, label %114
240: ; preds = %135, %321
%241 = phi i64 [ %151, %135 ], [ %323, %321 ]
%242 = phi float [ %133, %135 ], [ %322, %321 ]
%243 = trunc i64 %241 to i32
%244 = sdiv i32 %243, 2
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %138, i64 %245
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %140, i64 %241
%249 = load float, float* %248
%250 = fsub float %247, %249
%251 = getelementptr inbounds float, float* %142, i64 %241
%252 = load float, float* %251
%253 = fsub float %250, %252
%254 = getelementptr inbounds float, float* %144, i64 %241
store float %253, float* %254
%255 = load float, float* %246
%256 = fneg float %255
%257 = add nsw i64 %241, 1
%258 = getelementptr inbounds float, float* %140, i64 %257
%259 = load float, float* %258
%260 = fsub float %256, %259
%261 = getelementptr inbounds float, float* %142, i64 %257
%262 = load float, float* %261
%263 = fsub float %260, %262
%264 = getelementptr inbounds float, float* %144, i64 %257
store float %263, float* %264
%265 = getelementptr inbounds float, float* %146, i64 %241
%266 = load float, float* %265
%267 = getelementptr inbounds float, float* %148, i64 %241
%268 = load float, float* %267
%269 = tail call float @llvm.fmuladd.f32(float %266, float %253, float %268)
%270 = getelementptr inbounds float, float* %150, i64 %241
%271 = load float, float* %270
%272 = fsub float %271, %269
store float %272, float* %270
%273 = getelementptr inbounds float, float* %146, i64 %257
%274 = load float, float* %273
%275 = load float, float* %264
%276 = getelementptr inbounds float, float* %148, i64 %257
%277 = load float, float* %276
%278 = tail call float @llvm.fmuladd.f32(float %274, float %275, float %277)
%279 = getelementptr inbounds float, float* %150, i64 %257
%280 = load float, float* %279
%281 = fsub float %280, %278
store float %281, float* %279
%282 = fneg float %242
%283 = fmul float %272, %282
%284 = load float, float* %267
%285 = fcmp ogt float %283, %284
br i1 %285, label %286, label %290
286: ; preds = %240
%287 = fneg float %284
%288 = fdiv float %287, %272
%289 = fneg float %288
br label %290
290: ; preds = %286, %240
%291 = phi float [ %289, %286 ], [ %282, %240 ]
%292 = phi float [ %288, %286 ], [ %242, %240 ]
%293 = fmul float %281, %291
%294 = load float, float* %276
%295 = fcmp ogt float %293, %294
br i1 %295, label %296, label %300
296: ; preds = %290
%297 = fneg float %294
%298 = fdiv float %297, %281
%299 = fneg float %298
br label %300
300: ; preds = %296, %290
%301 = phi float [ %299, %296 ], [ %291, %290 ]
%302 = phi float [ %298, %296 ], [ %292, %290 ]
%303 = load float, float* %254
%304 = fmul float %303, %301
%305 = load float, float* %251
%306 = fcmp ogt float %304, %305
br i1 %306, label %307, label %311
307: ; preds = %300
%308 = fneg float %305
%309 = fdiv float %308, %303
%310 = fneg float %309
br label %311
311: ; preds = %307, %300
%312 = phi float [ %310, %307 ], [ %301, %300 ]
%313 = phi float [ %309, %307 ], [ %302, %300 ]
%314 = load float, float* %264
%315 = fmul float %314, %312
%316 = load float, float* %261
%317 = fcmp ogt float %315, %316
br i1 %317, label %318, label %321
318: ; preds = %311
%319 = fneg float %316
%320 = fdiv float %319, %314
br label %321
321: ; preds = %311, %318
%322 = phi float [ %320, %318 ], [ %313, %311 ]
%323 = add nsw i64 %241, 2
%324 = icmp slt i64 %323, %152
br i1 %324, label %240, label %325
325: ; preds = %321, %132
%326 = phi float [ %133, %132 ], [ %322, %321 ]
store float %326, float* %4
ret void
}