calc_mean_and_covariance2(weights, velocities, weighted_size, mean,
                          covariance) float weights[21][21],
    velocities[21][21][2];
float mean[2], covariance[2][2];
int weighted_size;
{
  int i, j, k, Q, fdr, a, b;
  float vx, vy, w_sum;
  w_sum = vx = vy = 0.0;
  for (i = 0; i < weighted_size; i++)
    for (j = 0; j < weighted_size; j++) {
      if (velocities[i][j][0] != 100.0 && velocities[i][j][1] != 100.0) {
        w_sum += weights[i][j];
        vx += weights[i][j] * velocities[i][j][0];
        vy += weights[i][j] * velocities[i][j][1];
      }
    }
  mean[0] = vx;
  mean[1] = vy;
  for (i = 0; i < 2; i++)
    for (j = 0; j < 2; j++)
      covariance[i][j] = 0.0;
  for (i = 0; i < weighted_size; i++)
    for (j = 0; j < weighted_size; j++) {
      if (velocities[i][j][0] != 100.0 && velocities[i][j][1] != 100.0) {
        covariance[0][0] += (velocities[i][j][0] - vx) *
                            (velocities[i][j][0] - vx) * weights[i][j];
        covariance[1][1] += (velocities[i][j][1] - vy) *
                            (velocities[i][j][1] - vy) * weights[i][j];
        covariance[0][1] += (velocities[i][j][0] - vx) *
                            (velocities[i][j][1] - vy) * weights[i][j];
      }
    }
  covariance[0][0] /= w_sum;
  covariance[0][1] /= w_sum;
  covariance[1][1] /= w_sum;
  covariance[1][0] = covariance[0][1];
}


x86 assembly (clang, -O0):
<calc_mean_and_covariance2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12a1 <calc_mean_and_covariance2+0x1a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128e <calc_mean_and_covariance2+0x18e>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe84(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1191 <calc_mean_and_covariance2+0x91>
jp     1191 <calc_mean_and_covariance2+0x91>
jmp    127b <calc_mean_and_covariance2+0x17b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe47(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    11ce <calc_mean_and_covariance2+0xce>
jp     11ce <calc_mean_and_covariance2+0xce>
jmp    127b <calc_mean_and_covariance2+0x17b>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1280 <calc_mean_and_covariance2+0x180>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1149 <calc_mean_and_covariance2+0x49>
jmp    1293 <calc_mean_and_covariance2+0x193>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1136 <calc_mean_and_covariance2+0x36>
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x0,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jge    131a <calc_mean_and_covariance2+0x21a>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1307 <calc_mean_and_covariance2+0x207>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d4 <calc_mean_and_covariance2+0x1d4>
jmp    130c <calc_mean_and_covariance2+0x20c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c3 <calc_mean_and_covariance2+0x1c3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1536 <calc_mean_and_covariance2+0x436>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1523 <calc_mean_and_covariance2+0x423>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc99(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    137c <calc_mean_and_covariance2+0x27c>
jp     137c <calc_mean_and_covariance2+0x27c>
jmp    1510 <calc_mean_and_covariance2+0x410>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc5c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13b9 <calc_mean_and_covariance2+0x2b9>
jp     13b9 <calc_mean_and_covariance2+0x2b9>
jmp    1510 <calc_mean_and_covariance2+0x410>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm1
subss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm1
subss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm1
subss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x54,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
jmp    1515 <calc_mean_and_covariance2+0x415>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1334 <calc_mean_and_covariance2+0x234>
jmp    1528 <calc_mean_and_covariance2+0x428>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1321 <calc_mean_and_covariance2+0x221>
movss  -0x58(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  0xc(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_mean_and_covariance2>:
push   %rbx
test   %edx,%edx
jle    125a <calc_mean_and_covariance2+0x15a>
mov    %edx,%r9d
lea    0x4(%rsi),%rax
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
xor    %r10d,%r10d
movss  0xedf(%rip),%xmm2
mov    %rdi,%r11
jmp    1143 <calc_mean_and_covariance2+0x43>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x54,%r11
add    $0xa8,%rax
cmp    %r9,%r10
je     118b <calc_mean_and_covariance2+0x8b>
xor    %ebx,%ebx
jmp    1159 <calc_mean_and_covariance2+0x59>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r9
je     1130 <calc_mean_and_covariance2+0x30>
movss  -0x4(%rax,%rbx,8),%xmm3
ucomiss %xmm2,%xmm3
jne    1166 <calc_mean_and_covariance2+0x66>
jnp    1150 <calc_mean_and_covariance2+0x50>
movss  (%rax,%rbx,8),%xmm4
ucomiss %xmm2,%xmm4
jne    1172 <calc_mean_and_covariance2+0x72>
jnp    1150 <calc_mean_and_covariance2+0x50>
movss  (%r11,%rbx,4),%xmm5
addss  %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm5
unpcklps %xmm4,%xmm3
mulps  %xmm5,%xmm3
addps  %xmm3,%xmm1
jmp    1150 <calc_mean_and_covariance2+0x50>
movss  %xmm1,(%rcx)
movaps %xmm1,%xmm8
shufps $0x55,%xmm1,%xmm8
movss  %xmm8,0x4(%rcx)
xorps  %xmm3,%xmm3
movups %xmm3,(%r8)
test   %edx,%edx
jle    1264 <calc_mean_and_covariance2+0x164>
add    $0x4,%rsi
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xorps  %xmm4,%xmm4
xorps  %xmm6,%xmm6
jmp    11d8 <calc_mean_and_covariance2+0xd8>
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x54,%rdi
add    $0xa8,%rsi
cmp    %r9,%rcx
je     126d <calc_mean_and_covariance2+0x16d>
xor    %eax,%eax
jmp    11e9 <calc_mean_and_covariance2+0xe9>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%r9
je     11c0 <calc_mean_and_covariance2+0xc0>
movss  -0x4(%rsi,%rax,8),%xmm7
ucomiss %xmm2,%xmm7
jne    11f6 <calc_mean_and_covariance2+0xf6>
jnp    11e0 <calc_mean_and_covariance2+0xe0>
movss  (%rsi,%rax,8),%xmm5
ucomiss %xmm2,%xmm5
jne    1202 <calc_mean_and_covariance2+0x102>
jnp    11e0 <calc_mean_and_covariance2+0xe0>
subss  %xmm1,%xmm7
mulss  %xmm7,%xmm7
mulss  (%rdi,%rax,4),%xmm7
addss  %xmm7,%xmm6
movss  %xmm6,(%r8)
movss  (%rsi,%rax,8),%xmm5
subss  %xmm8,%xmm5
mulss  %xmm5,%xmm5
mulss  (%rdi,%rax,4),%xmm5
addss  %xmm5,%xmm4
movss  %xmm4,0xc(%r8)
movsd  -0x4(%rsi,%rax,8),%xmm5
subps  %xmm1,%xmm5
movaps %xmm5,%xmm7
shufps $0x55,%xmm5,%xmm7
mulss  %xmm5,%xmm7
mulss  (%rdi,%rax,4),%xmm7
addss  %xmm7,%xmm3
movss  %xmm3,0x4(%r8)
jmp    11e0 <calc_mean_and_covariance2+0xe0>
movq   $0x0,(%rcx)
xorps  %xmm0,%xmm0
xorps  %xmm4,%xmm4
xorps  %xmm3,%xmm3
xorps  %xmm6,%xmm6
divss  %xmm0,%xmm6
movss  %xmm6,(%r8)
divss  %xmm0,%xmm3
movss  %xmm3,0x4(%r8)
divss  %xmm0,%xmm4
movss  %xmm4,0xc(%r8)
movss  %xmm3,0x8(%r8)
pop    %rbx
ret

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

LLVM IR (-O2):
define i32 @calc_mean_and_covariance2([21 x float]* nocapture %0, [21 x [2 x float]]* nocapture %1, i32 %2, float* nocapture writeonly %3, [2 x float]* nocapture %4) {
%6 = bitcast [2 x float]* %4 to i8*
%7 = icmp sgt i32 %2, 0
br i1 %7, label %10, label %8
8: ; preds = %5
store float 0.000000e+00, float* %3
%9 = getelementptr inbounds float, float* %3, i64 1
store float 0.000000e+00, float* %9
br label %98
10: ; preds = %5
%11 = zext i32 %2 to i64
br label %12
12: ; preds = %41, %10
%13 = phi i64 [ 0, %10 ], [ %42, %41 ]
%14 = phi float [ 0.000000e+00, %10 ], [ %37, %41 ]
%15 = phi <2 x float> [ zeroinitializer, %10 ], [ %38, %41 ]
br label %16
16: ; preds = %12, %36
%17 = phi i64 [ 0, %12 ], [ %39, %36 ]
%18 = phi float [ %14, %12 ], [ %37, %36 ]
%19 = phi <2 x float> [ %15, %12 ], [ %38, %36 ]
%20 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %13, i64 %17, i64 0
%21 = load float, float* %20
%22 = fcmp une float %21, 1.000000e+02
br i1 %22, label %23, label %36
23: ; preds = %16
%24 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %13, i64 %17, i64 1
%25 = load float, float* %24
%26 = fcmp une float %25, 1.000000e+02
br i1 %26, label %27, label %36
27: ; preds = %23
%28 = getelementptr inbounds [21 x float], [21 x float]* %0, i64 %13, i64 %17
%29 = load float, float* %28
%30 = fadd float %18, %29
%31 = insertelement <2 x float> poison, float %29, i64 0
%32 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> zeroinitializer
%33 = insertelement <2 x float> poison, float %21, i64 0
%34 = insertelement <2 x float> %33, float %25, i64 1
%35 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> %34, <2 x float> %19)
br label %36
36: ; preds = %16, %23, %27
%37 = phi float [ %30, %27 ], [ %18, %23 ], [ %18, %16 ]
%38 = phi <2 x float> [ %35, %27 ], [ %19, %23 ], [ %19, %16 ]
%39 = add nuw nsw i64 %17, 1
%40 = icmp eq i64 %39, %11
br i1 %40, label %41, label %16
41: ; preds = %36
%42 = add nuw nsw i64 %13, 1
%43 = icmp eq i64 %42, %11
br i1 %43, label %44, label %12
44: ; preds = %41
%45 = extractelement <2 x float> %38, i64 0
store float %45, float* %3
%46 = getelementptr inbounds float, float* %3, i64 1
%47 = extractelement <2 x float> %38, i64 1
store float %47, float* %46
br i1 %7, label %48, label %98
48: ; preds = %44
%49 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 0
%50 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 1
%51 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 1
%52 = zext i32 %2 to i64
br label %53
53: ; preds = %95, %48
%54 = phi float [ 0.000000e+00, %48 ], [ %90, %95 ]
%55 = phi float [ 0.000000e+00, %48 ], [ %91, %95 ]
%56 = phi float [ 0.000000e+00, %48 ], [ %92, %95 ]
%57 = phi i64 [ 0, %48 ], [ %96, %95 ]
br label %58
58: ; preds = %53, %89
%59 = phi float [ %54, %53 ], [ %90, %89 ]
%60 = phi float [ %55, %53 ], [ %91, %89 ]
%61 = phi float [ %56, %53 ], [ %92, %89 ]
%62 = phi i64 [ 0, %53 ], [ %93, %89 ]
%63 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %57, i64 %62, i64 0
%64 = load float, float* %63
%65 = fcmp une float %64, 1.000000e+02
br i1 %65, label %66, label %89
66: ; preds = %58
%67 = getelementptr inbounds [21 x [2 x float]], [21 x [2 x float]]* %1, i64 %57, i64 %62, i64 1
%68 = load float, float* %67
%69 = fcmp une float %68, 1.000000e+02
br i1 %69, label %70, label %89
70: ; preds = %66
%71 = fsub float %64, %45
%72 = fmul float %71, %71
%73 = getelementptr inbounds [21 x float], [21 x float]* %0, i64 %57, i64 %62
%74 = load float, float* %73
%75 = tail call float @llvm.fmuladd.f32(float %72, float %74, float %61)
store float %75, float* %49
%76 = load float, float* %67
%77 = fsub float %76, %47
%78 = fmul float %77, %77
%79 = load float, float* %73
%80 = tail call float @llvm.fmuladd.f32(float %78, float %79, float %60)
store float %80, float* %50
%81 = bitcast float* %63 to <2 x float>*
%82 = load <2 x float>, <2 x float>* %81
%83 = fsub <2 x float> %82, %38
%84 = shufflevector <2 x float> %83, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%85 = fmul <2 x float> %83, %84
%86 = extractelement <2 x float> %85, i64 0
%87 = load float, float* %73
%88 = tail call float @llvm.fmuladd.f32(float %86, float %87, float %59)
store float %88, float* %51
br label %89
89: ; preds = %58, %66, %70
%90 = phi float [ %59, %58 ], [ %59, %66 ], [ %88, %70 ]
%91 = phi float [ %60, %58 ], [ %60, %66 ], [ %80, %70 ]
%92 = phi float [ %61, %58 ], [ %61, %66 ], [ %75, %70 ]
%93 = add nuw nsw i64 %62, 1
%94 = icmp eq i64 %93, %52
br i1 %94, label %95, label %58
95: ; preds = %89
%96 = add nuw nsw i64 %57, 1
%97 = icmp eq i64 %96, %52
br i1 %97, label %98, label %53
98: ; preds = %95, %8, %44
%99 = phi float [ %37, %44 ], [ 0.000000e+00, %8 ], [ %37, %95 ]
%100 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %91, %95 ]
%101 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %90, %95 ]
%102 = phi float [ 0.000000e+00, %44 ], [ 0.000000e+00, %8 ], [ %92, %95 ]
%103 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 0
%104 = fdiv float %102, %99
store float %104, float* %103
%105 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 0, i64 1
%106 = fdiv float %101, %99
store float %106, float* %105
%107 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 1
%108 = fdiv float %100, %99
store float %108, float* %107
%109 = getelementptr inbounds [2 x float], [2 x float]* %4, i64 1, i64 0
store float %106, float* %109
ret i32 undef
}