void mul_mtx44(float *a, const float *b) {
  float res[16];
  res[0] =
      (a[0]) * (b[0]) + (a[1]) * (b[4]) + (a[2]) * (b[8]) + (a[3]) * (b[12]);
  res[1] =
      (a[0]) * (b[1]) + (a[1]) * (b[5]) + (a[2]) * (b[9]) + (a[3]) * (b[13]);
  res[2] =
      (a[0]) * (b[2]) + (a[1]) * (b[6]) + (a[2]) * (b[10]) + (a[3]) * (b[14]);
  res[3] =
      (a[0]) * (b[3]) + (a[1]) * (b[7]) + (a[2]) * (b[11]) + (a[3]) * (b[15]);
  res[4] =
      (a[4]) * (b[0]) + (a[5]) * (b[4]) + (a[6]) * (b[8]) + (a[7]) * (b[12]);
  res[5] =
      (a[4]) * (b[1]) + (a[5]) * (b[5]) + (a[6]) * (b[9]) + (a[7]) * (b[13]);
  res[6] =
      (a[4]) * (b[2]) + (a[5]) * (b[6]) + (a[6]) * (b[10]) + (a[7]) * (b[14]);
  res[7] =
      (a[4]) * (b[3]) + (a[5]) * (b[7]) + (a[6]) * (b[11]) + (a[7]) * (b[15]);
  res[8] =
      (a[8]) * (b[0]) + (a[9]) * (b[3]) + (a[10]) * (b[8]) + (a[11]) * (b[12]);
  res[9] =
      (a[8]) * (b[1]) + (a[9]) * (b[4]) + (a[10]) * (b[9]) + (a[11]) * (b[13]);
  res[10] =
      (a[8]) * (b[2]) + (a[9]) * (b[5]) + (a[10]) * (b[10]) + (a[11]) * (b[14]);
  res[11] =
      (a[8]) * (b[3]) + (a[9]) * (b[6]) + (a[10]) * (b[11]) + (a[11]) * (b[15]);
  res[12] = (a[12]) * (b[0]) + (a[13]) * (b[3]) + (a[14]) * (b[8]) +
            (a[15]) * (b[12]);
  res[13] = (a[12]) * (b[1]) + (a[13]) * (b[4]) + (a[14]) * (b[9]) +
            (a[15]) * (b[13]);
  res[14] = (a[12]) * (b[2]) + (a[13]) * (b[5]) + (a[14]) * (b[10]) +
            (a[15]) * (b[14]);
  res[15] = (a[12]) * (b[3]) + (a[13]) * (b[6]) + (a[14]) * (b[11]) +
            (a[15]) * (b[15]);
  memcpy(a, &res, 9 * sizeof(float));
}


x86 assembly (clang, -O0):
<mul_mtx44>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mul_mtx44>:
movss  (%rdi),%xmm4
movss  0x4(%rdi),%xmm5
movss  0x8(%rdi),%xmm6
movss  0xc(%rdi),%xmm0
shufps $0x0,%xmm5,%xmm5
movups (%rsi),%xmm3
movups 0x10(%rsi),%xmm7
movups 0x20(%rsi),%xmm2
movups 0x30(%rsi),%xmm1
mulps  %xmm7,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm3,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm2,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm6,%xmm0
movss  0x14(%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm7,%xmm4
movss  0x10(%rdi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
addps  %xmm4,%xmm5
movss  0x18(%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movss  0x1c(%rdi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm4,%xmm5
movaps %xmm3,%xmm4
shufps $0xff,%xmm3,%xmm4
mulss  0x24(%rdi),%xmm4
mulss  0x20(%rdi),%xmm3
mulss  0x28(%rdi),%xmm2
addss  %xmm4,%xmm3
addss  %xmm3,%xmm2
mulss  0x2c(%rdi),%xmm1
addss  %xmm2,%xmm1
movups %xmm0,(%rdi)
movups %xmm5,0x10(%rdi)
movss  %xmm1,0x20(%rdi)
ret

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

LLVM IR (-O2):
define void @mul_mtx44(float* nocapture %0, float* nocapture %1) {
%3 = load float, float* %0
%4 = getelementptr inbounds float, float* %0, i64 1
%5 = load float, float* %4
%6 = getelementptr inbounds float, float* %1, i64 4
%7 = getelementptr inbounds float, float* %0, i64 2
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %1, i64 8
%10 = getelementptr inbounds float, float* %0, i64 3
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %1, i64 12
%13 = bitcast float* %1 to <4 x float>*
%14 = load <4 x float>, <4 x float>* %13
%15 = bitcast float* %6 to <4 x float>*
%16 = load <4 x float>, <4 x float>* %15
%17 = insertelement <4 x float> poison, float %5, i64 0
%18 = shufflevector <4 x float> %17, <4 x float> poison, <4 x i32> zeroinitializer
%19 = fmul <4 x float> %18, %16
%20 = insertelement <4 x float> poison, float %3, i64 0
%21 = shufflevector <4 x float> %20, <4 x float> poison, <4 x i32> zeroinitializer
%22 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %21, <4 x float> %14, <4 x float> %19)
%23 = bitcast float* %9 to <4 x float>*
%24 = load <4 x float>, <4 x float>* %23
%25 = insertelement <4 x float> poison, float %8, i64 0
%26 = shufflevector <4 x float> %25, <4 x float> poison, <4 x i32> zeroinitializer
%27 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %26, <4 x float> %24, <4 x float> %22)
%28 = bitcast float* %12 to <4 x float>*
%29 = load <4 x float>, <4 x float>* %28
%30 = insertelement <4 x float> poison, float %11, i64 0
%31 = shufflevector <4 x float> %30, <4 x float> poison, <4 x i32> zeroinitializer
%32 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %31, <4 x float> %29, <4 x float> %27)
%33 = getelementptr inbounds float, float* %0, i64 4
%34 = load float, float* %33
%35 = getelementptr inbounds float, float* %0, i64 5
%36 = load float, float* %35
%37 = getelementptr inbounds float, float* %0, i64 6
%38 = load float, float* %37
%39 = getelementptr inbounds float, float* %0, i64 7
%40 = load float, float* %39
%41 = insertelement <4 x float> poison, float %36, i64 0
%42 = shufflevector <4 x float> %41, <4 x float> poison, <4 x i32> zeroinitializer
%43 = fmul <4 x float> %16, %42
%44 = insertelement <4 x float> poison, float %34, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%46 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %45, <4 x float> %14, <4 x float> %43)
%47 = insertelement <4 x float> poison, float %38, i64 0
%48 = shufflevector <4 x float> %47, <4 x float> poison, <4 x i32> zeroinitializer
%49 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %48, <4 x float> %24, <4 x float> %46)
%50 = insertelement <4 x float> poison, float %40, i64 0
%51 = shufflevector <4 x float> %50, <4 x float> poison, <4 x i32> zeroinitializer
%52 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %51, <4 x float> %29, <4 x float> %49)
%53 = getelementptr inbounds float, float* %0, i64 8
%54 = load float, float* %53
%55 = getelementptr inbounds float, float* %0, i64 9
%56 = load float, float* %55
%57 = extractelement <4 x float> %14, i64 3
%58 = fmul float %57, %56
%59 = extractelement <4 x float> %14, i64 0
%60 = tail call float @llvm.fmuladd.f32(float %54, float %59, float %58)
%61 = getelementptr inbounds float, float* %0, i64 10
%62 = load float, float* %61
%63 = extractelement <4 x float> %24, i64 0
%64 = tail call float @llvm.fmuladd.f32(float %62, float %63, float %60)
%65 = getelementptr inbounds float, float* %0, i64 11
%66 = load float, float* %65
%67 = extractelement <4 x float> %29, i64 0
%68 = tail call float @llvm.fmuladd.f32(float %66, float %67, float %64)
%69 = bitcast float* %0 to <4 x float>*
store <4 x float> %32, <4 x float>* %69
%70 = bitcast float* %33 to <4 x float>*
store <4 x float> %52, <4 x float>* %70
store float %68, float* %53
ret void
}