void mulMatMat(float m[16], float n[16], float r[16]) {
  float t[16];
  t[0] = m[0] * n[0] + m[4] * n[1] + m[8] * n[2] + m[12] * n[3];
  t[4] = m[0] * n[4] + m[4] * n[5] + m[8] * n[6] + m[12] * n[7];
  t[8] = m[0] * n[8] + m[4] * n[9] + m[8] * n[10] + m[12] * n[11];
  t[12] = m[0] * n[12] + m[4] * n[13] + m[8] * n[14] + m[12] * n[15];
  t[1] = m[1] * n[0] + m[5] * n[1] + m[9] * n[2] + m[13] * n[3];
  t[5] = m[1] * n[4] + m[5] * n[5] + m[9] * n[6] + m[13] * n[7];
  t[9] = m[1] * n[8] + m[5] * n[9] + m[9] * n[10] + m[13] * n[11];
  t[13] = m[1] * n[12] + m[5] * n[13] + m[9] * n[14] + m[13] * n[15];
  t[2] = m[2] * n[0] + m[6] * n[1] + m[10] * n[2] + m[14] * n[3];
  t[6] = m[2] * n[4] + m[6] * n[5] + m[10] * n[6] + m[14] * n[7];
  t[10] = m[2] * n[8] + m[6] * n[9] + m[10] * n[10] + m[14] * n[11];
  t[14] = m[2] * n[12] + m[6] * n[13] + m[10] * n[14] + m[14] * n[15];
  t[3] = m[3] * n[0] + m[7] * n[1] + m[11] * n[2] + m[15] * n[3];
  t[7] = m[3] * n[4] + m[7] * n[5] + m[11] * n[6] + m[15] * n[7];
  t[11] = m[3] * n[8] + m[7] * n[9] + m[11] * n[10] + m[15] * n[11];
  t[15] = m[3] * n[12] + m[7] * n[13] + m[11] * n[14] + m[15] * n[15];
  for (int i = 0; i < 15; i++)
    r[i] = t[i];
}


x86 assembly (clang, -O0):
<mulMatMat>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%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  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%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  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%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  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%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  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%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,-0x24(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0xf,-0x64(%rbp)
jge    178e <mulMatMat+0x68e>
movslq -0x64(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    175f <mulMatMat+0x65f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mulMatMat>:
movups (%rdi),%xmm12
movups 0x10(%rdi),%xmm14
movups 0x20(%rdi),%xmm11
movups 0x30(%rdi),%xmm4
movss  0x30(%rsi),%xmm8
movss  0x34(%rsi),%xmm9
movaps %xmm14,%xmm13
movss  0x4(%rsi),%xmm15
shufps $0x0,%xmm15,%xmm15
mulps  %xmm14,%xmm15
movss  0x14(%rsi),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm14,%xmm3
movaps %xmm14,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm12,%xmm5
movaps %xmm12,%xmm1
mulss  %xmm8,%xmm1
addss  %xmm0,%xmm1
movss  0x38(%rsi),%xmm2
movaps %xmm11,%xmm7
movaps %xmm11,%xmm6
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
movss  0x3c(%rsi),%xmm1
movaps %xmm4,%xmm0
movaps %xmm4,%xmm10
mulss  %xmm1,%xmm4
movss  %xmm1,-0x4(%rsp)
addss  %xmm6,%xmm4
movss  0x24(%rsi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm14,%xmm6
shufps $0x55,%xmm14,%xmm13
mulss  %xmm9,%xmm13
shufps $0x55,%xmm12,%xmm5
mulss  %xmm8,%xmm5
addss  %xmm13,%xmm5
movss  (%rsi),%xmm13
shufps $0x0,%xmm13,%xmm13
mulps  %xmm12,%xmm13
shufps $0x55,%xmm11,%xmm7
mulss  %xmm2,%xmm7
addss  %xmm5,%xmm7
movss  0x10(%rsi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm12,%xmm5
shufps $0x55,%xmm10,%xmm10
mulss  %xmm1,%xmm10
addss  %xmm7,%xmm10
movss  0x20(%rsi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm12,%xmm7
movhlps %xmm14,%xmm14
mulss  %xmm9,%xmm14
movss  0x8(%rsi),%xmm9
shufps $0x0,%xmm9,%xmm9
mulps  %xmm11,%xmm9
movhlps %xmm12,%xmm12
mulss  %xmm8,%xmm12
movss  0x18(%rsi),%xmm8
shufps $0x0,%xmm8,%xmm8
mulps  %xmm11,%xmm8
addss  %xmm14,%xmm12
movss  0x28(%rsi),%xmm14
shufps $0x0,%xmm14,%xmm14
mulps  %xmm11,%xmm14
movhlps %xmm11,%xmm11
mulss  %xmm2,%xmm11
movss  0xc(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm0,%xmm2
addss  %xmm12,%xmm11
movss  0x1c(%rsi),%xmm12
shufps $0x0,%xmm12,%xmm12
mulps  %xmm0,%xmm12
movss  0x2c(%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
movhlps %xmm0,%xmm0
mulss  -0x4(%rsp),%xmm0
addss  %xmm11,%xmm0
addps  %xmm15,%xmm13
addps  %xmm13,%xmm9
addps  %xmm9,%xmm2
addps  %xmm3,%xmm5
addps  %xmm5,%xmm8
addps  %xmm8,%xmm12
addps  %xmm6,%xmm7
addps  %xmm7,%xmm14
addps  %xmm14,%xmm1
movups %xmm2,(%rdx)
movups %xmm12,0x10(%rdx)
movups %xmm1,0x20(%rdx)
movss  %xmm4,0x30(%rdx)
movss  %xmm10,0x34(%rdx)
movss  %xmm0,0x38(%rdx)
ret

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

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