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


x86 assembly (clang, -O0):
<s_compute_mu_mpc>:
push   %rbp
mov    %rsp,%rbp
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)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    124e <s_compute_mu_mpc+0x14e>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm2
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
movss  -0x20(%rbp),%xmm3
mov    0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%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    113d <s_compute_mu_mpc+0x3d>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b4 <s_compute_mu_mpc+0x2b4>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    13a1 <s_compute_mu_mpc+0x2a1>
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),%xmm1
movss  -0x20(%rbp),%xmm0
mov    0x10(%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
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%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
movss  -0x20(%rbp),%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),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
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),%xmm3
movss  -0x20(%rbp),%xmm1
mov    0x10(%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),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mov    0x18(%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),%xmm4
movss  -0x20(%rbp),%xmm3
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),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%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    1268 <s_compute_mu_mpc+0x168>
jmp    13a6 <s_compute_mu_mpc+0x2a6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1255 <s_compute_mu_mpc+0x155>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    14f6 <s_compute_mu_mpc+0x3f6>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x20(%rbp),%xmm2
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mov    0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
movss  -0x20(%rbp),%xmm3
mov    0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%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    13bd <s_compute_mu_mpc+0x2bd>
movss  -0x1c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<s_compute_mu_mpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x38(%rsp),%r15
test   %esi,%esi
jle    119a <s_compute_mu_mpc+0x9a>
add    %esi,%esi
mov    (%r9),%r14
mov    (%r15),%rbp
mov    (%r11),%rax
mov    (%r10),%rbx
movslq %esi,%r12
xorps  %xmm2,%xmm2
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%r14,%rsi,4),%xmm3
movss  (%rbx,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  (%rax,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
movss  0x4(%rbp,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%r14,%rsi,4),%xmm3
movss  0x4(%rbx,%rsi,4),%xmm5
mulss  %xmm1,%xmm5
addss  0x4(%rax,%rsi,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
addss  %xmm5,%xmm2
add    $0x2,%rsi
cmp    %r12,%rsi
jl     1140 <s_compute_mu_mpc+0x40>
jmp    119d <s_compute_mu_mpc+0x9d>
xorps  %xmm2,%xmm2
lea    (%rcx,%rcx,1),%esi
mov    %esi,%eax
movslq %esi,%rsi
cmp    $0x2,%edi
mov    %r8,-0x8(%rsp)
mov    %edi,-0xc(%rsp)
jl     1250 <s_compute_mu_mpc+0x150>
mov    %edi,%r12d
mov    $0x1,%r13d
mov    %eax,%edi
jmp    11d9 <s_compute_mu_mpc+0xd9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
cmp    %r12,%r13
je     1252 <s_compute_mu_mpc+0x152>
test   %ecx,%ecx
jle    11d0 <s_compute_mu_mpc+0xd0>
mov    (%r9,%r13,8),%rax
mov    (%r15,%r13,8),%rbx
mov    (%r11,%r13,8),%rbp
mov    (%r10,%r13,8),%r14
xor    %r8d,%r8d
movss  (%rbx,%r8,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%rax,%r8,4),%xmm3
movss  (%r14,%r8,4),%xmm4
mulss  %xmm1,%xmm4
addss  0x0(%rbp,%r8,4),%xmm4
mulss  %xmm3,%xmm4
movss  0x4(%rbx,%r8,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rax,%r8,4),%xmm3
movss  0x4(%r14,%r8,4),%xmm5
mulss  %xmm1,%xmm5
addss  0x4(%rbp,%r8,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
addss  %xmm5,%xmm2
add    $0x2,%r8
cmp    %rsi,%r8
jl     11f0 <s_compute_mu_mpc+0xf0>
jmp    11d0 <s_compute_mu_mpc+0xd0>
mov    %eax,%edi
add    %edx,%edx
cmp    %edi,%edx
jge    12d8 <s_compute_mu_mpc+0x1d8>
movslq -0xc(%rsp),%rbp
mov    (%r9,%rbp,8),%rax
mov    (%r15,%rbp,8),%rcx
mov    (%r11,%rbp,8),%rdi
mov    (%r10,%rbp,8),%rbp
movslq %edx,%rdx
mov    -0x8(%rsp),%rbx
nopl   0x0(%rax)
movss  (%rcx,%rdx,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%rax,%rdx,4),%xmm3
movss  0x0(%rbp,%rdx,4),%xmm4
mulss  %xmm1,%xmm4
addss  (%rdi,%rdx,4),%xmm4
mulss  %xmm3,%xmm4
movss  0x4(%rcx,%rdx,4),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rax,%rdx,4),%xmm3
movss  0x4(%rbp,%rdx,4),%xmm5
mulss  %xmm1,%xmm5
addss  0x4(%rdi,%rdx,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
addss  %xmm5,%xmm2
add    $0x2,%rdx
cmp    %rsi,%rdx
jl     1280 <s_compute_mu_mpc+0x180>
jmp    12dd <s_compute_mu_mpc+0x1dd>
mov    -0x8(%rsp),%rbx
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @s_compute_mu_mpc(i32 %0, i32 %1, i32 %2, i32 %3, float* nocapture writeonly %4, float %5, float %6, float** nocapture %7, float** nocapture %8, float** nocapture %9, float** nocapture %10) {
%12 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %20
13: ; preds = %11
%14 = shl nuw nsw i32 %1, 1
%15 = load float*, float** %7
%16 = load float*, float** %8
%17 = load float*, float** %9
%18 = load float*, float** %10
%19 = sext i32 %14 to i64
br label %28
20: ; preds = %28, %11
%21 = phi float [ 0.000000e+00, %11 ], [ %54, %28 ]
%22 = icmp sgt i32 %0, 1
%23 = shl nsw i32 %3, 1
br i1 %22, label %24, label %102
24: ; preds = %20
%25 = icmp sgt i32 %3, 0
%26 = sext i32 %23 to i64
%27 = zext i32 %0 to i64
br label %57
28: ; preds = %13, %28
%29 = phi i64 [ 0, %13 ], [ %55, %28 ]
%30 = phi float [ 0.000000e+00, %13 ], [ %54, %28 ]
%31 = getelementptr inbounds float, float* %15, i64 %29
%32 = load float, float* %31
%33 = getelementptr inbounds float, float* %16, i64 %29
%34 = load float, float* %33
%35 = tail call float @llvm.fmuladd.f32(float %6, float %34, float %32)
%36 = getelementptr inbounds float, float* %17, i64 %29
%37 = load float, float* %36
%38 = getelementptr inbounds float, float* %18, i64 %29
%39 = load float, float* %38
%40 = tail call float @llvm.fmuladd.f32(float %6, float %39, float %37)
%41 = or i64 %29, 1
%42 = getelementptr inbounds float, float* %15, i64 %41
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %16, i64 %41
%45 = load float, float* %44
%46 = tail call float @llvm.fmuladd.f32(float %6, float %45, float %43)
%47 = getelementptr inbounds float, float* %17, i64 %41
%48 = load float, float* %47
%49 = getelementptr inbounds float, float* %18, i64 %41
%50 = load float, float* %49
%51 = tail call float @llvm.fmuladd.f32(float %6, float %50, float %48)
%52 = fmul float %46, %51
%53 = tail call float @llvm.fmuladd.f32(float %35, float %40, float %52)
%54 = fadd float %30, %53
%55 = add nuw nsw i64 %29, 2
%56 = icmp slt i64 %55, %19
br i1 %56, label %28, label %20
57: ; preds = %24, %98
%58 = phi i64 [ 1, %24 ], [ %100, %98 ]
%59 = phi float [ %21, %24 ], [ %99, %98 ]
br i1 %25, label %60, label %98
60: ; preds = %57
%61 = getelementptr inbounds float*, float** %7, i64 %58
%62 = load float*, float** %61
%63 = getelementptr inbounds float*, float** %8, i64 %58
%64 = load float*, float** %63
%65 = getelementptr inbounds float*, float** %9, i64 %58
%66 = load float*, float** %65
%67 = getelementptr inbounds float*, float** %10, i64 %58
%68 = load float*, float** %67
br label %69
69: ; preds = %60, %69
%70 = phi i64 [ 0, %60 ], [ %96, %69 ]
%71 = phi float [ %59, %60 ], [ %95, %69 ]
%72 = getelementptr inbounds float, float* %62, i64 %70
%73 = load float, float* %72
%74 = getelementptr inbounds float, float* %64, i64 %70
%75 = load float, float* %74
%76 = tail call float @llvm.fmuladd.f32(float %6, float %75, float %73)
%77 = getelementptr inbounds float, float* %66, i64 %70
%78 = load float, float* %77
%79 = getelementptr inbounds float, float* %68, i64 %70
%80 = load float, float* %79
%81 = tail call float @llvm.fmuladd.f32(float %6, float %80, float %78)
%82 = or i64 %70, 1
%83 = getelementptr inbounds float, float* %62, i64 %82
%84 = load float, float* %83
%85 = getelementptr inbounds float, float* %64, i64 %82
%86 = load float, float* %85
%87 = tail call float @llvm.fmuladd.f32(float %6, float %86, float %84)
%88 = getelementptr inbounds float, float* %66, i64 %82
%89 = load float, float* %88
%90 = getelementptr inbounds float, float* %68, i64 %82
%91 = load float, float* %90
%92 = tail call float @llvm.fmuladd.f32(float %6, float %91, float %89)
%93 = fmul float %87, %92
%94 = tail call float @llvm.fmuladd.f32(float %76, float %81, float %93)
%95 = fadd float %71, %94
%96 = add nuw nsw i64 %70, 2
%97 = icmp slt i64 %96, %26
br i1 %97, label %69, label %98
98: ; preds = %69, %57
%99 = phi float [ %59, %57 ], [ %95, %69 ]
%100 = add nuw nsw i64 %58, 1
%101 = icmp eq i64 %100, %27
br i1 %101, label %102, label %57
102: ; preds = %98, %20
%103 = phi float [ %21, %20 ], [ %99, %98 ]
%104 = shl i32 %2, 1
%105 = icmp slt i32 %104, %23
br i1 %105, label %106, label %147
106: ; preds = %102
%107 = sext i32 %0 to i64
%108 = getelementptr inbounds float*, float** %7, i64 %107
%109 = load float*, float** %108
%110 = getelementptr inbounds float*, float** %8, i64 %107
%111 = load float*, float** %110
%112 = getelementptr inbounds float*, float** %9, i64 %107
%113 = load float*, float** %112
%114 = getelementptr inbounds float*, float** %10, i64 %107
%115 = load float*, float** %114
%116 = sext i32 %104 to i64
%117 = sext i32 %23 to i64
br label %118
118: ; preds = %106, %118
%119 = phi i64 [ %116, %106 ], [ %145, %118 ]
%120 = phi float [ %103, %106 ], [ %144, %118 ]
%121 = getelementptr inbounds float, float* %109, i64 %119
%122 = load float, float* %121
%123 = getelementptr inbounds float, float* %111, i64 %119
%124 = load float, float* %123
%125 = tail call float @llvm.fmuladd.f32(float %6, float %124, float %122)
%126 = getelementptr inbounds float, float* %113, i64 %119
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %115, i64 %119
%129 = load float, float* %128
%130 = tail call float @llvm.fmuladd.f32(float %6, float %129, float %127)
%131 = or i64 %119, 1
%132 = getelementptr inbounds float, float* %109, i64 %131
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %111, i64 %131
%135 = load float, float* %134
%136 = tail call float @llvm.fmuladd.f32(float %6, float %135, float %133)
%137 = getelementptr inbounds float, float* %113, i64 %131
%138 = load float, float* %137
%139 = getelementptr inbounds float, float* %115, i64 %131
%140 = load float, float* %139
%141 = tail call float @llvm.fmuladd.f32(float %6, float %140, float %138)
%142 = fmul float %136, %141
%143 = tail call float @llvm.fmuladd.f32(float %125, float %130, float %142)
%144 = fadd float %120, %143
%145 = add nsw i64 %119, 2
%146 = icmp slt i64 %145, %117
br i1 %146, label %118, label %147
147: ; preds = %118, %102
%148 = phi float [ %103, %102 ], [ %144, %118 ]
%149 = fmul float %148, %5
store float %149, float* %4
ret void
}