void matrixMatrixMult(float mat1[4][4], float mat2[4][4], float out[4][4]) {
  float temp[4][4];
  temp[0][0] = mat1[0][0] * mat2[0][0] + mat1[0][1] * mat2[1][0] +
               mat1[0][2] * mat2[2][0] + mat1[0][3] * mat2[3][0];
  temp[0][1] = mat1[0][0] * mat2[0][1] + mat1[0][1] * mat2[1][1] +
               mat1[0][2] * mat2[2][1] + mat1[0][3] * mat2[3][1];
  temp[0][2] = mat1[0][0] * mat2[0][2] + mat1[0][1] * mat2[1][2] +
               mat1[0][2] * mat2[2][2] + mat1[0][3] * mat2[3][2];
  temp[0][3] = mat1[0][0] * mat2[0][3] + mat1[0][1] * mat2[1][3] +
               mat1[0][2] * mat2[2][3] + mat1[0][3] * mat2[3][3];
  temp[1][0] = mat1[1][0] * mat2[0][0] + mat1[1][1] * mat2[1][0] +
               mat1[1][2] * mat2[2][0] + mat1[1][3] * mat2[3][0];
  temp[1][1] = mat1[1][0] * mat2[0][1] + mat1[1][1] * mat2[1][1] +
               mat1[1][2] * mat2[2][1] + mat1[1][3] * mat2[3][1];
  temp[1][2] = mat1[1][0] * mat2[0][2] + mat1[1][1] * mat2[1][2] +
               mat1[1][2] * mat2[2][2] + mat1[1][3] * mat2[3][2];
  temp[1][3] = mat1[1][0] * mat2[0][3] + mat1[1][1] * mat2[1][3] +
               mat1[1][2] * mat2[2][3] + mat1[1][3] * mat2[3][3];
  temp[2][0] = mat1[2][0] * mat2[0][0] + mat1[2][1] * mat2[1][0] +
               mat1[2][2] * mat2[2][0] + mat1[2][3] * mat2[3][0];
  temp[2][1] = mat1[2][0] * mat2[0][1] + mat1[2][1] * mat2[1][1] +
               mat1[2][2] * mat2[2][1] + mat1[2][3] * mat2[3][1];
  temp[2][2] = mat1[2][0] * mat2[0][2] + mat1[2][1] * mat2[1][2] +
               mat1[2][2] * mat2[2][2] + mat1[2][3] * mat2[3][2];
  temp[2][3] = mat1[2][0] * mat2[0][3] + mat1[2][1] * mat2[1][3] +
               mat1[2][2] * mat2[2][3] + mat1[2][3] * mat2[3][3];
  temp[3][0] = mat1[3][0] * mat2[0][0] + mat1[3][1] * mat2[1][0] +
               mat1[3][2] * mat2[2][0] + mat1[3][3] * mat2[3][0];
  temp[3][1] = mat1[3][0] * mat2[0][1] + mat1[3][1] * mat2[1][1] +
               mat1[3][2] * mat2[2][1] + mat1[3][3] * mat2[3][1];
  temp[3][2] = mat1[3][0] * mat2[0][2] + mat1[3][1] * mat2[1][2] +
               mat1[3][2] * mat2[2][2] + mat1[3][3] * mat2[3][2];
  temp[3][3] = mat1[3][0] * mat2[0][3] + mat1[3][1] * mat2[1][3] +
               mat1[3][2] * mat2[2][3] + mat1[3][3] * mat2[3][3];
  memcpy(out, temp, 4 * 4 * sizeof(float));
}


x86 assembly (clang, -O0):
<matrixMatrixMult>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
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  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,-0x60(%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,-0x5c(%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,-0x58(%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,-0x54(%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,-0x50(%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,-0x4c(%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,-0x48(%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,-0x44(%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  0x10(%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,-0x40(%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  0x14(%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,-0x3c(%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  0x18(%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,-0x38(%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  0x1c(%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,-0x34(%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  0x10(%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,-0x30(%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  0x14(%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,-0x2c(%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  0x18(%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,-0x28(%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  0x1c(%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,-0x24(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrixMatrixMult>:
movss  (%rdi),%xmm5
movss  0x4(%rdi),%xmm6
movss  0x8(%rdi),%xmm7
movss  0xc(%rdi),%xmm0
shufps $0x0,%xmm6,%xmm6
movups (%rsi),%xmm3
movups 0x10(%rsi),%xmm4
movups 0x20(%rsi),%xmm2
movups 0x30(%rsi),%xmm8
mulps  %xmm4,%xmm6
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
addps  %xmm6,%xmm5
shufps $0x0,%xmm7,%xmm7
mulps  %xmm2,%xmm7
addps  %xmm5,%xmm7
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
addps  %xmm7,%xmm0
movss  0x14(%rdi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
movss  0x10(%rdi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
movss  0x18(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm2,%xmm7
addps  %xmm6,%xmm7
movss  0x1c(%rdi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm8,%xmm5
addps  %xmm7,%xmm5
movss  0x24(%rdi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm4,%xmm6
movss  0x20(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movss  0x28(%rdi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm7,%xmm1
movss  0x2c(%rdi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm8,%xmm6
addps  %xmm1,%xmm6
movss  0x34(%rdi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
movss  0x30(%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm3,%xmm4
addps  %xmm1,%xmm4
movss  0x38(%rdi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm4,%xmm1
movss  0x3c(%rdi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
addps  %xmm1,%xmm2
movups %xmm0,(%rdx)
movups %xmm5,0x10(%rdx)
movups %xmm6,0x20(%rdx)
movups %xmm2,0x30(%rdx)
ret

LLVM IR (-O0):
define void @matrixMatrixMult([4 x float]* %0, [4 x float]* %1, [4 x float]* %2) {
%4 = alloca [4 x float]*
%5 = alloca [4 x float]*
%6 = alloca [4 x float]*
%7 = alloca [4 x [4 x float]]
store [4 x float]* %0, [4 x float]** %4
store [4 x float]* %1, [4 x float]** %5
store [4 x float]* %2, [4 x float]** %6
%8 = load [4 x float]*, [4 x float]** %4
%9 = getelementptr inbounds [4 x float], [4 x float]* %8, i64 0
%10 = getelementptr inbounds [4 x float], [4 x float]* %9, i64 0, i64 0
%11 = load float, float* %10
%12 = load [4 x float]*, [4 x float]** %5
%13 = getelementptr inbounds [4 x float], [4 x float]* %12, i64 0
%14 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%15 = load float, float* %14
%16 = load [4 x float]*, [4 x float]** %4
%17 = getelementptr inbounds [4 x float], [4 x float]* %16, i64 0
%18 = getelementptr inbounds [4 x float], [4 x float]* %17, i64 0, i64 1
%19 = load float, float* %18
%20 = load [4 x float]*, [4 x float]** %5
%21 = getelementptr inbounds [4 x float], [4 x float]* %20, i64 1
%22 = getelementptr inbounds [4 x float], [4 x float]* %21, i64 0, i64 0
%23 = load float, float* %22
%24 = fmul float %19, %23
%25 = call float @llvm.fmuladd.f32(float %11, float %15, float %24)
%26 = load [4 x float]*, [4 x float]** %4
%27 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0
%28 = getelementptr inbounds [4 x float], [4 x float]* %27, i64 0, i64 2
%29 = load float, float* %28
%30 = load [4 x float]*, [4 x float]** %5
%31 = getelementptr inbounds [4 x float], [4 x float]* %30, i64 2
%32 = getelementptr inbounds [4 x float], [4 x float]* %31, i64 0, i64 0
%33 = load float, float* %32
%34 = call float @llvm.fmuladd.f32(float %29, float %33, float %25)
%35 = load [4 x float]*, [4 x float]** %4
%36 = getelementptr inbounds [4 x float], [4 x float]* %35, i64 0
%37 = getelementptr inbounds [4 x float], [4 x float]* %36, i64 0, i64 3
%38 = load float, float* %37
%39 = load [4 x float]*, [4 x float]** %5
%40 = getelementptr inbounds [4 x float], [4 x float]* %39, i64 3
%41 = getelementptr inbounds [4 x float], [4 x float]* %40, i64 0, i64 0
%42 = load float, float* %41
%43 = call float @llvm.fmuladd.f32(float %38, float %42, float %34)
%44 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%45 = getelementptr inbounds [4 x float], [4 x float]* %44, i64 0, i64 0
store float %43, float* %45
%46 = load [4 x float]*, [4 x float]** %4
%47 = getelementptr inbounds [4 x float], [4 x float]* %46, i64 0
%48 = getelementptr inbounds [4 x float], [4 x float]* %47, i64 0, i64 0
%49 = load float, float* %48
%50 = load [4 x float]*, [4 x float]** %5
%51 = getelementptr inbounds [4 x float], [4 x float]* %50, i64 0
%52 = getelementptr inbounds [4 x float], [4 x float]* %51, i64 0, i64 1
%53 = load float, float* %52
%54 = load [4 x float]*, [4 x float]** %4
%55 = getelementptr inbounds [4 x float], [4 x float]* %54, i64 0
%56 = getelementptr inbounds [4 x float], [4 x float]* %55, i64 0, i64 1
%57 = load float, float* %56
%58 = load [4 x float]*, [4 x float]** %5
%59 = getelementptr inbounds [4 x float], [4 x float]* %58, i64 1
%60 = getelementptr inbounds [4 x float], [4 x float]* %59, i64 0, i64 1
%61 = load float, float* %60
%62 = fmul float %57, %61
%63 = call float @llvm.fmuladd.f32(float %49, float %53, float %62)
%64 = load [4 x float]*, [4 x float]** %4
%65 = getelementptr inbounds [4 x float], [4 x float]* %64, i64 0
%66 = getelementptr inbounds [4 x float], [4 x float]* %65, i64 0, i64 2
%67 = load float, float* %66
%68 = load [4 x float]*, [4 x float]** %5
%69 = getelementptr inbounds [4 x float], [4 x float]* %68, i64 2
%70 = getelementptr inbounds [4 x float], [4 x float]* %69, i64 0, i64 1
%71 = load float, float* %70
%72 = call float @llvm.fmuladd.f32(float %67, float %71, float %63)
%73 = load [4 x float]*, [4 x float]** %4
%74 = getelementptr inbounds [4 x float], [4 x float]* %73, i64 0
%75 = getelementptr inbounds [4 x float], [4 x float]* %74, i64 0, i64 3
%76 = load float, float* %75
%77 = load [4 x float]*, [4 x float]** %5
%78 = getelementptr inbounds [4 x float], [4 x float]* %77, i64 3
%79 = getelementptr inbounds [4 x float], [4 x float]* %78, i64 0, i64 1
%80 = load float, float* %79
%81 = call float @llvm.fmuladd.f32(float %76, float %80, float %72)
%82 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%83 = getelementptr inbounds [4 x float], [4 x float]* %82, i64 0, i64 1
store float %81, float* %83
%84 = load [4 x float]*, [4 x float]** %4
%85 = getelementptr inbounds [4 x float], [4 x float]* %84, i64 0
%86 = getelementptr inbounds [4 x float], [4 x float]* %85, i64 0, i64 0
%87 = load float, float* %86
%88 = load [4 x float]*, [4 x float]** %5
%89 = getelementptr inbounds [4 x float], [4 x float]* %88, i64 0
%90 = getelementptr inbounds [4 x float], [4 x float]* %89, i64 0, i64 2
%91 = load float, float* %90
%92 = load [4 x float]*, [4 x float]** %4
%93 = getelementptr inbounds [4 x float], [4 x float]* %92, i64 0
%94 = getelementptr inbounds [4 x float], [4 x float]* %93, i64 0, i64 1
%95 = load float, float* %94
%96 = load [4 x float]*, [4 x float]** %5
%97 = getelementptr inbounds [4 x float], [4 x float]* %96, i64 1
%98 = getelementptr inbounds [4 x float], [4 x float]* %97, i64 0, i64 2
%99 = load float, float* %98
%100 = fmul float %95, %99
%101 = call float @llvm.fmuladd.f32(float %87, float %91, float %100)
%102 = load [4 x float]*, [4 x float]** %4
%103 = getelementptr inbounds [4 x float], [4 x float]* %102, i64 0
%104 = getelementptr inbounds [4 x float], [4 x float]* %103, i64 0, i64 2
%105 = load float, float* %104
%106 = load [4 x float]*, [4 x float]** %5
%107 = getelementptr inbounds [4 x float], [4 x float]* %106, i64 2
%108 = getelementptr inbounds [4 x float], [4 x float]* %107, i64 0, i64 2
%109 = load float, float* %108
%110 = call float @llvm.fmuladd.f32(float %105, float %109, float %101)
%111 = load [4 x float]*, [4 x float]** %4
%112 = getelementptr inbounds [4 x float], [4 x float]* %111, i64 0
%113 = getelementptr inbounds [4 x float], [4 x float]* %112, i64 0, i64 3
%114 = load float, float* %113
%115 = load [4 x float]*, [4 x float]** %5
%116 = getelementptr inbounds [4 x float], [4 x float]* %115, i64 3
%117 = getelementptr inbounds [4 x float], [4 x float]* %116, i64 0, i64 2
%118 = load float, float* %117
%119 = call float @llvm.fmuladd.f32(float %114, float %118, float %110)
%120 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%121 = getelementptr inbounds [4 x float], [4 x float]* %120, i64 0, i64 2
store float %119, float* %121
%122 = load [4 x float]*, [4 x float]** %4
%123 = getelementptr inbounds [4 x float], [4 x float]* %122, i64 0
%124 = getelementptr inbounds [4 x float], [4 x float]* %123, i64 0, i64 0
%125 = load float, float* %124
%126 = load [4 x float]*, [4 x float]** %5
%127 = getelementptr inbounds [4 x float], [4 x float]* %126, i64 0
%128 = getelementptr inbounds [4 x float], [4 x float]* %127, i64 0, i64 3
%129 = load float, float* %128
%130 = load [4 x float]*, [4 x float]** %4
%131 = getelementptr inbounds [4 x float], [4 x float]* %130, i64 0
%132 = getelementptr inbounds [4 x float], [4 x float]* %131, i64 0, i64 1
%133 = load float, float* %132
%134 = load [4 x float]*, [4 x float]** %5
%135 = getelementptr inbounds [4 x float], [4 x float]* %134, i64 1
%136 = getelementptr inbounds [4 x float], [4 x float]* %135, i64 0, i64 3
%137 = load float, float* %136
%138 = fmul float %133, %137
%139 = call float @llvm.fmuladd.f32(float %125, float %129, float %138)
%140 = load [4 x float]*, [4 x float]** %4
%141 = getelementptr inbounds [4 x float], [4 x float]* %140, i64 0
%142 = getelementptr inbounds [4 x float], [4 x float]* %141, i64 0, i64 2
%143 = load float, float* %142
%144 = load [4 x float]*, [4 x float]** %5
%145 = getelementptr inbounds [4 x float], [4 x float]* %144, i64 2
%146 = getelementptr inbounds [4 x float], [4 x float]* %145, i64 0, i64 3
%147 = load float, float* %146
%148 = call float @llvm.fmuladd.f32(float %143, float %147, float %139)
%149 = load [4 x float]*, [4 x float]** %4
%150 = getelementptr inbounds [4 x float], [4 x float]* %149, i64 0
%151 = getelementptr inbounds [4 x float], [4 x float]* %150, i64 0, i64 3
%152 = load float, float* %151
%153 = load [4 x float]*, [4 x float]** %5
%154 = getelementptr inbounds [4 x float], [4 x float]* %153, i64 3
%155 = getelementptr inbounds [4 x float], [4 x float]* %154, i64 0, i64 3
%156 = load float, float* %155
%157 = call float @llvm.fmuladd.f32(float %152, float %156, float %148)
%158 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%159 = getelementptr inbounds [4 x float], [4 x float]* %158, i64 0, i64 3
store float %157, float* %159
%160 = load [4 x float]*, [4 x float]** %4
%161 = getelementptr inbounds [4 x float], [4 x float]* %160, i64 1
%162 = getelementptr inbounds [4 x float], [4 x float]* %161, i64 0, i64 0
%163 = load float, float* %162
%164 = load [4 x float]*, [4 x float]** %5
%165 = getelementptr inbounds [4 x float], [4 x float]* %164, i64 0
%166 = getelementptr inbounds [4 x float], [4 x float]* %165, i64 0, i64 0
%167 = load float, float* %166
%168 = load [4 x float]*, [4 x float]** %4
%169 = getelementptr inbounds [4 x float], [4 x float]* %168, i64 1
%170 = getelementptr inbounds [4 x float], [4 x float]* %169, i64 0, i64 1
%171 = load float, float* %170
%172 = load [4 x float]*, [4 x float]** %5
%173 = getelementptr inbounds [4 x float], [4 x float]* %172, i64 1
%174 = getelementptr inbounds [4 x float], [4 x float]* %173, i64 0, i64 0
%175 = load float, float* %174
%176 = fmul float %171, %175
%177 = call float @llvm.fmuladd.f32(float %163, float %167, float %176)
%178 = load [4 x float]*, [4 x float]** %4
%179 = getelementptr inbounds [4 x float], [4 x float]* %178, i64 1
%180 = getelementptr inbounds [4 x float], [4 x float]* %179, i64 0, i64 2
%181 = load float, float* %180
%182 = load [4 x float]*, [4 x float]** %5
%183 = getelementptr inbounds [4 x float], [4 x float]* %182, i64 2
%184 = getelementptr inbounds [4 x float], [4 x float]* %183, i64 0, i64 0
%185 = load float, float* %184
%186 = call float @llvm.fmuladd.f32(float %181, float %185, float %177)
%187 = load [4 x float]*, [4 x float]** %4
%188 = getelementptr inbounds [4 x float], [4 x float]* %187, i64 1
%189 = getelementptr inbounds [4 x float], [4 x float]* %188, i64 0, i64 3
%190 = load float, float* %189
%191 = load [4 x float]*, [4 x float]** %5
%192 = getelementptr inbounds [4 x float], [4 x float]* %191, i64 3
%193 = getelementptr inbounds [4 x float], [4 x float]* %192, i64 0, i64 0
%194 = load float, float* %193
%195 = call float @llvm.fmuladd.f32(float %190, float %194, float %186)
%196 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1
%197 = getelementptr inbounds [4 x float], [4 x float]* %196, i64 0, i64 0
store float %195, float* %197
%198 = load [4 x float]*, [4 x float]** %4
%199 = getelementptr inbounds [4 x float], [4 x float]* %198, i64 1
%200 = getelementptr inbounds [4 x float], [4 x float]* %199, i64 0, i64 0
%201 = load float, float* %200
%202 = load [4 x float]*, [4 x float]** %5
%203 = getelementptr inbounds [4 x float], [4 x float]* %202, i64 0
%204 = getelementptr inbounds [4 x float], [4 x float]* %203, i64 0, i64 1
%205 = load float, float* %204
%206 = load [4 x float]*, [4 x float]** %4
%207 = getelementptr inbounds [4 x float], [4 x float]* %206, i64 1
%208 = getelementptr inbounds [4 x float], [4 x float]* %207, i64 0, i64 1
%209 = load float, float* %208
%210 = load [4 x float]*, [4 x float]** %5
%211 = getelementptr inbounds [4 x float], [4 x float]* %210, i64 1
%212 = getelementptr inbounds [4 x float], [4 x float]* %211, i64 0, i64 1
%213 = load float, float* %212
%214 = fmul float %209, %213
%215 = call float @llvm.fmuladd.f32(float %201, float %205, float %214)
%216 = load [4 x float]*, [4 x float]** %4
%217 = getelementptr inbounds [4 x float], [4 x float]* %216, i64 1
%218 = getelementptr inbounds [4 x float], [4 x float]* %217, i64 0, i64 2
%219 = load float, float* %218
%220 = load [4 x float]*, [4 x float]** %5
%221 = getelementptr inbounds [4 x float], [4 x float]* %220, i64 2
%222 = getelementptr inbounds [4 x float], [4 x float]* %221, i64 0, i64 1
%223 = load float, float* %222
%224 = call float @llvm.fmuladd.f32(float %219, float %223, float %215)
%225 = load [4 x float]*, [4 x float]** %4
%226 = getelementptr inbounds [4 x float], [4 x float]* %225, i64 1
%227 = getelementptr inbounds [4 x float], [4 x float]* %226, i64 0, i64 3
%228 = load float, float* %227
%229 = load [4 x float]*, [4 x float]** %5
%230 = getelementptr inbounds [4 x float], [4 x float]* %229, i64 3
%231 = getelementptr inbounds [4 x float], [4 x float]* %230, i64 0, i64 1
%232 = load float, float* %231
%233 = call float @llvm.fmuladd.f32(float %228, float %232, float %224)
%234 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1
%235 = getelementptr inbounds [4 x float], [4 x float]* %234, i64 0, i64 1
store float %233, float* %235
%236 = load [4 x float]*, [4 x float]** %4
%237 = getelementptr inbounds [4 x float], [4 x float]* %236, i64 1
%238 = getelementptr inbounds [4 x float], [4 x float]* %237, i64 0, i64 0
%239 = load float, float* %238
%240 = load [4 x float]*, [4 x float]** %5
%241 = getelementptr inbounds [4 x float], [4 x float]* %240, i64 0
%242 = getelementptr inbounds [4 x float], [4 x float]* %241, i64 0, i64 2
%243 = load float, float* %242
%244 = load [4 x float]*, [4 x float]** %4
%245 = getelementptr inbounds [4 x float], [4 x float]* %244, i64 1
%246 = getelementptr inbounds [4 x float], [4 x float]* %245, i64 0, i64 1
%247 = load float, float* %246
%248 = load [4 x float]*, [4 x float]** %5
%249 = getelementptr inbounds [4 x float], [4 x float]* %248, i64 1
%250 = getelementptr inbounds [4 x float], [4 x float]* %249, i64 0, i64 2
%251 = load float, float* %250
%252 = fmul float %247, %251
%253 = call float @llvm.fmuladd.f32(float %239, float %243, float %252)
%254 = load [4 x float]*, [4 x float]** %4
%255 = getelementptr inbounds [4 x float], [4 x float]* %254, i64 1
%256 = getelementptr inbounds [4 x float], [4 x float]* %255, i64 0, i64 2
%257 = load float, float* %256
%258 = load [4 x float]*, [4 x float]** %5
%259 = getelementptr inbounds [4 x float], [4 x float]* %258, i64 2
%260 = getelementptr inbounds [4 x float], [4 x float]* %259, i64 0, i64 2
%261 = load float, float* %260
%262 = call float @llvm.fmuladd.f32(float %257, float %261, float %253)
%263 = load [4 x float]*, [4 x float]** %4
%264 = getelementptr inbounds [4 x float], [4 x float]* %263, i64 1
%265 = getelementptr inbounds [4 x float], [4 x float]* %264, i64 0, i64 3
%266 = load float, float* %265
%267 = load [4 x float]*, [4 x float]** %5
%268 = getelementptr inbounds [4 x float], [4 x float]* %267, i64 3
%269 = getelementptr inbounds [4 x float], [4 x float]* %268, i64 0, i64 2
%270 = load float, float* %269
%271 = call float @llvm.fmuladd.f32(float %266, float %270, float %262)
%272 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1
%273 = getelementptr inbounds [4 x float], [4 x float]* %272, i64 0, i64 2
store float %271, float* %273
%274 = load [4 x float]*, [4 x float]** %4
%275 = getelementptr inbounds [4 x float], [4 x float]* %274, i64 1
%276 = getelementptr inbounds [4 x float], [4 x float]* %275, i64 0, i64 0
%277 = load float, float* %276
%278 = load [4 x float]*, [4 x float]** %5
%279 = getelementptr inbounds [4 x float], [4 x float]* %278, i64 0
%280 = getelementptr inbounds [4 x float], [4 x float]* %279, i64 0, i64 3
%281 = load float, float* %280
%282 = load [4 x float]*, [4 x float]** %4
%283 = getelementptr inbounds [4 x float], [4 x float]* %282, i64 1
%284 = getelementptr inbounds [4 x float], [4 x float]* %283, i64 0, i64 1
%285 = load float, float* %284
%286 = load [4 x float]*, [4 x float]** %5
%287 = getelementptr inbounds [4 x float], [4 x float]* %286, i64 1
%288 = getelementptr inbounds [4 x float], [4 x float]* %287, i64 0, i64 3
%289 = load float, float* %288
%290 = fmul float %285, %289
%291 = call float @llvm.fmuladd.f32(float %277, float %281, float %290)
%292 = load [4 x float]*, [4 x float]** %4
%293 = getelementptr inbounds [4 x float], [4 x float]* %292, i64 1
%294 = getelementptr inbounds [4 x float], [4 x float]* %293, i64 0, i64 2
%295 = load float, float* %294
%296 = load [4 x float]*, [4 x float]** %5
%297 = getelementptr inbounds [4 x float], [4 x float]* %296, i64 2
%298 = getelementptr inbounds [4 x float], [4 x float]* %297, i64 0, i64 3
%299 = load float, float* %298
%300 = call float @llvm.fmuladd.f32(float %295, float %299, float %291)
%301 = load [4 x float]*, [4 x float]** %4
%302 = getelementptr inbounds [4 x float], [4 x float]* %301, i64 1
%303 = getelementptr inbounds [4 x float], [4 x float]* %302, i64 0, i64 3
%304 = load float, float* %303
%305 = load [4 x float]*, [4 x float]** %5
%306 = getelementptr inbounds [4 x float], [4 x float]* %305, i64 3
%307 = getelementptr inbounds [4 x float], [4 x float]* %306, i64 0, i64 3
%308 = load float, float* %307
%309 = call float @llvm.fmuladd.f32(float %304, float %308, float %300)
%310 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1
%311 = getelementptr inbounds [4 x float], [4 x float]* %310, i64 0, i64 3
store float %309, float* %311
%312 = load [4 x float]*, [4 x float]** %4
%313 = getelementptr inbounds [4 x float], [4 x float]* %312, i64 2
%314 = getelementptr inbounds [4 x float], [4 x float]* %313, i64 0, i64 0
%315 = load float, float* %314
%316 = load [4 x float]*, [4 x float]** %5
%317 = getelementptr inbounds [4 x float], [4 x float]* %316, i64 0
%318 = getelementptr inbounds [4 x float], [4 x float]* %317, i64 0, i64 0
%319 = load float, float* %318
%320 = load [4 x float]*, [4 x float]** %4
%321 = getelementptr inbounds [4 x float], [4 x float]* %320, i64 2
%322 = getelementptr inbounds [4 x float], [4 x float]* %321, i64 0, i64 1
%323 = load float, float* %322
%324 = load [4 x float]*, [4 x float]** %5
%325 = getelementptr inbounds [4 x float], [4 x float]* %324, i64 1
%326 = getelementptr inbounds [4 x float], [4 x float]* %325, i64 0, i64 0
%327 = load float, float* %326
%328 = fmul float %323, %327
%329 = call float @llvm.fmuladd.f32(float %315, float %319, float %328)
%330 = load [4 x float]*, [4 x float]** %4
%331 = getelementptr inbounds [4 x float], [4 x float]* %330, i64 2
%332 = getelementptr inbounds [4 x float], [4 x float]* %331, i64 0, i64 2
%333 = load float, float* %332
%334 = load [4 x float]*, [4 x float]** %5
%335 = getelementptr inbounds [4 x float], [4 x float]* %334, i64 2
%336 = getelementptr inbounds [4 x float], [4 x float]* %335, i64 0, i64 0
%337 = load float, float* %336
%338 = call float @llvm.fmuladd.f32(float %333, float %337, float %329)
%339 = load [4 x float]*, [4 x float]** %4
%340 = getelementptr inbounds [4 x float], [4 x float]* %339, i64 2
%341 = getelementptr inbounds [4 x float], [4 x float]* %340, i64 0, i64 3
%342 = load float, float* %341
%343 = load [4 x float]*, [4 x float]** %5
%344 = getelementptr inbounds [4 x float], [4 x float]* %343, i64 3
%345 = getelementptr inbounds [4 x float], [4 x float]* %344, i64 0, i64 0
%346 = load float, float* %345
%347 = call float @llvm.fmuladd.f32(float %342, float %346, float %338)
%348 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2
%349 = getelementptr inbounds [4 x float], [4 x float]* %348, i64 0, i64 0
store float %347, float* %349
%350 = load [4 x float]*, [4 x float]** %4
%351 = getelementptr inbounds [4 x float], [4 x float]* %350, i64 2
%352 = getelementptr inbounds [4 x float], [4 x float]* %351, i64 0, i64 0
%353 = load float, float* %352
%354 = load [4 x float]*, [4 x float]** %5
%355 = getelementptr inbounds [4 x float], [4 x float]* %354, i64 0
%356 = getelementptr inbounds [4 x float], [4 x float]* %355, i64 0, i64 1
%357 = load float, float* %356
%358 = load [4 x float]*, [4 x float]** %4
%359 = getelementptr inbounds [4 x float], [4 x float]* %358, i64 2
%360 = getelementptr inbounds [4 x float], [4 x float]* %359, i64 0, i64 1
%361 = load float, float* %360
%362 = load [4 x float]*, [4 x float]** %5
%363 = getelementptr inbounds [4 x float], [4 x float]* %362, i64 1
%364 = getelementptr inbounds [4 x float], [4 x float]* %363, i64 0, i64 1
%365 = load float, float* %364
%366 = fmul float %361, %365
%367 = call float @llvm.fmuladd.f32(float %353, float %357, float %366)
%368 = load [4 x float]*, [4 x float]** %4
%369 = getelementptr inbounds [4 x float], [4 x float]* %368, i64 2
%370 = getelementptr inbounds [4 x float], [4 x float]* %369, i64 0, i64 2
%371 = load float, float* %370
%372 = load [4 x float]*, [4 x float]** %5
%373 = getelementptr inbounds [4 x float], [4 x float]* %372, i64 2
%374 = getelementptr inbounds [4 x float], [4 x float]* %373, i64 0, i64 1
%375 = load float, float* %374
%376 = call float @llvm.fmuladd.f32(float %371, float %375, float %367)
%377 = load [4 x float]*, [4 x float]** %4
%378 = getelementptr inbounds [4 x float], [4 x float]* %377, i64 2
%379 = getelementptr inbounds [4 x float], [4 x float]* %378, i64 0, i64 3
%380 = load float, float* %379
%381 = load [4 x float]*, [4 x float]** %5
%382 = getelementptr inbounds [4 x float], [4 x float]* %381, i64 3
%383 = getelementptr inbounds [4 x float], [4 x float]* %382, i64 0, i64 1
%384 = load float, float* %383
%385 = call float @llvm.fmuladd.f32(float %380, float %384, float %376)
%386 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2
%387 = getelementptr inbounds [4 x float], [4 x float]* %386, i64 0, i64 1
store float %385, float* %387
%388 = load [4 x float]*, [4 x float]** %4
%389 = getelementptr inbounds [4 x float], [4 x float]* %388, i64 2
%390 = getelementptr inbounds [4 x float], [4 x float]* %389, i64 0, i64 0
%391 = load float, float* %390
%392 = load [4 x float]*, [4 x float]** %5
%393 = getelementptr inbounds [4 x float], [4 x float]* %392, i64 0
%394 = getelementptr inbounds [4 x float], [4 x float]* %393, i64 0, i64 2
%395 = load float, float* %394
%396 = load [4 x float]*, [4 x float]** %4
%397 = getelementptr inbounds [4 x float], [4 x float]* %396, i64 2
%398 = getelementptr inbounds [4 x float], [4 x float]* %397, i64 0, i64 1
%399 = load float, float* %398
%400 = load [4 x float]*, [4 x float]** %5
%401 = getelementptr inbounds [4 x float], [4 x float]* %400, i64 1
%402 = getelementptr inbounds [4 x float], [4 x float]* %401, i64 0, i64 2
%403 = load float, float* %402
%404 = fmul float %399, %403
%405 = call float @llvm.fmuladd.f32(float %391, float %395, float %404)
%406 = load [4 x float]*, [4 x float]** %4
%407 = getelementptr inbounds [4 x float], [4 x float]* %406, i64 2
%408 = getelementptr inbounds [4 x float], [4 x float]* %407, i64 0, i64 2
%409 = load float, float* %408
%410 = load [4 x float]*, [4 x float]** %5
%411 = getelementptr inbounds [4 x float], [4 x float]* %410, i64 2
%412 = getelementptr inbounds [4 x float], [4 x float]* %411, i64 0, i64 2
%413 = load float, float* %412
%414 = call float @llvm.fmuladd.f32(float %409, float %413, float %405)
%415 = load [4 x float]*, [4 x float]** %4
%416 = getelementptr inbounds [4 x float], [4 x float]* %415, i64 2
%417 = getelementptr inbounds [4 x float], [4 x float]* %416, i64 0, i64 3
%418 = load float, float* %417
%419 = load [4 x float]*, [4 x float]** %5
%420 = getelementptr inbounds [4 x float], [4 x float]* %419, i64 3
%421 = getelementptr inbounds [4 x float], [4 x float]* %420, i64 0, i64 2
%422 = load float, float* %421
%423 = call float @llvm.fmuladd.f32(float %418, float %422, float %414)
%424 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2
%425 = getelementptr inbounds [4 x float], [4 x float]* %424, i64 0, i64 2
store float %423, float* %425
%426 = load [4 x float]*, [4 x float]** %4
%427 = getelementptr inbounds [4 x float], [4 x float]* %426, i64 2
%428 = getelementptr inbounds [4 x float], [4 x float]* %427, i64 0, i64 0
%429 = load float, float* %428
%430 = load [4 x float]*, [4 x float]** %5
%431 = getelementptr inbounds [4 x float], [4 x float]* %430, i64 0
%432 = getelementptr inbounds [4 x float], [4 x float]* %431, i64 0, i64 3
%433 = load float, float* %432
%434 = load [4 x float]*, [4 x float]** %4
%435 = getelementptr inbounds [4 x float], [4 x float]* %434, i64 2
%436 = getelementptr inbounds [4 x float], [4 x float]* %435, i64 0, i64 1
%437 = load float, float* %436
%438 = load [4 x float]*, [4 x float]** %5
%439 = getelementptr inbounds [4 x float], [4 x float]* %438, i64 1
%440 = getelementptr inbounds [4 x float], [4 x float]* %439, i64 0, i64 3
%441 = load float, float* %440
%442 = fmul float %437, %441
%443 = call float @llvm.fmuladd.f32(float %429, float %433, float %442)
%444 = load [4 x float]*, [4 x float]** %4
%445 = getelementptr inbounds [4 x float], [4 x float]* %444, i64 2
%446 = getelementptr inbounds [4 x float], [4 x float]* %445, i64 0, i64 2
%447 = load float, float* %446
%448 = load [4 x float]*, [4 x float]** %5
%449 = getelementptr inbounds [4 x float], [4 x float]* %448, i64 2
%450 = getelementptr inbounds [4 x float], [4 x float]* %449, i64 0, i64 3
%451 = load float, float* %450
%452 = call float @llvm.fmuladd.f32(float %447, float %451, float %443)
%453 = load [4 x float]*, [4 x float]** %4
%454 = getelementptr inbounds [4 x float], [4 x float]* %453, i64 2
%455 = getelementptr inbounds [4 x float], [4 x float]* %454, i64 0, i64 3
%456 = load float, float* %455
%457 = load [4 x float]*, [4 x float]** %5
%458 = getelementptr inbounds [4 x float], [4 x float]* %457, i64 3
%459 = getelementptr inbounds [4 x float], [4 x float]* %458, i64 0, i64 3
%460 = load float, float* %459
%461 = call float @llvm.fmuladd.f32(float %456, float %460, float %452)
%462 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2
%463 = getelementptr inbounds [4 x float], [4 x float]* %462, i64 0, i64 3
store float %461, float* %463
%464 = load [4 x float]*, [4 x float]** %4
%465 = getelementptr inbounds [4 x float], [4 x float]* %464, i64 3
%466 = getelementptr inbounds [4 x float], [4 x float]* %465, i64 0, i64 0
%467 = load float, float* %466
%468 = load [4 x float]*, [4 x float]** %5
%469 = getelementptr inbounds [4 x float], [4 x float]* %468, i64 0
%470 = getelementptr inbounds [4 x float], [4 x float]* %469, i64 0, i64 0
%471 = load float, float* %470
%472 = load [4 x float]*, [4 x float]** %4
%473 = getelementptr inbounds [4 x float], [4 x float]* %472, i64 3
%474 = getelementptr inbounds [4 x float], [4 x float]* %473, i64 0, i64 1
%475 = load float, float* %474
%476 = load [4 x float]*, [4 x float]** %5
%477 = getelementptr inbounds [4 x float], [4 x float]* %476, i64 1
%478 = getelementptr inbounds [4 x float], [4 x float]* %477, i64 0, i64 0
%479 = load float, float* %478
%480 = fmul float %475, %479
%481 = call float @llvm.fmuladd.f32(float %467, float %471, float %480)
%482 = load [4 x float]*, [4 x float]** %4
%483 = getelementptr inbounds [4 x float], [4 x float]* %482, i64 3
%484 = getelementptr inbounds [4 x float], [4 x float]* %483, i64 0, i64 2
%485 = load float, float* %484
%486 = load [4 x float]*, [4 x float]** %5
%487 = getelementptr inbounds [4 x float], [4 x float]* %486, i64 2
%488 = getelementptr inbounds [4 x float], [4 x float]* %487, i64 0, i64 0
%489 = load float, float* %488
%490 = call float @llvm.fmuladd.f32(float %485, float %489, float %481)
%491 = load [4 x float]*, [4 x float]** %4
%492 = getelementptr inbounds [4 x float], [4 x float]* %491, i64 3
%493 = getelementptr inbounds [4 x float], [4 x float]* %492, i64 0, i64 3
%494 = load float, float* %493
%495 = load [4 x float]*, [4 x float]** %5
%496 = getelementptr inbounds [4 x float], [4 x float]* %495, i64 3
%497 = getelementptr inbounds [4 x float], [4 x float]* %496, i64 0, i64 0
%498 = load float, float* %497
%499 = call float @llvm.fmuladd.f32(float %494, float %498, float %490)
%500 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 3
%501 = getelementptr inbounds [4 x float], [4 x float]* %500, i64 0, i64 0
store float %499, float* %501
%502 = load [4 x float]*, [4 x float]** %4
%503 = getelementptr inbounds [4 x float], [4 x float]* %502, i64 3
%504 = getelementptr inbounds [4 x float], [4 x float]* %503, i64 0, i64 0
%505 = load float, float* %504
%506 = load [4 x float]*, [4 x float]** %5
%507 = getelementptr inbounds [4 x float], [4 x float]* %506, i64 0
%508 = getelementptr inbounds [4 x float], [4 x float]* %507, i64 0, i64 1
%509 = load float, float* %508
%510 = load [4 x float]*, [4 x float]** %4
%511 = getelementptr inbounds [4 x float], [4 x float]* %510, i64 3
%512 = getelementptr inbounds [4 x float], [4 x float]* %511, i64 0, i64 1
%513 = load float, float* %512
%514 = load [4 x float]*, [4 x float]** %5
%515 = getelementptr inbounds [4 x float], [4 x float]* %514, i64 1
%516 = getelementptr inbounds [4 x float], [4 x float]* %515, i64 0, i64 1
%517 = load float, float* %516
%518 = fmul float %513, %517
%519 = call float @llvm.fmuladd.f32(float %505, float %509, float %518)
%520 = load [4 x float]*, [4 x float]** %4
%521 = getelementptr inbounds [4 x float], [4 x float]* %520, i64 3
%522 = getelementptr inbounds [4 x float], [4 x float]* %521, i64 0, i64 2
%523 = load float, float* %522
%524 = load [4 x float]*, [4 x float]** %5
%525 = getelementptr inbounds [4 x float], [4 x float]* %524, i64 2
%526 = getelementptr inbounds [4 x float], [4 x float]* %525, i64 0, i64 1
%527 = load float, float* %526
%528 = call float @llvm.fmuladd.f32(float %523, float %527, float %519)
%529 = load [4 x float]*, [4 x float]** %4
%530 = getelementptr inbounds [4 x float], [4 x float]* %529, i64 3
%531 = getelementptr inbounds [4 x float], [4 x float]* %530, i64 0, i64 3
%532 = load float, float* %531
%533 = load [4 x float]*, [4 x float]** %5
%534 = getelementptr inbounds [4 x float], [4 x float]* %533, i64 3
%535 = getelementptr inbounds [4 x float], [4 x float]* %534, i64 0, i64 1
%536 = load float, float* %535
%537 = call float @llvm.fmuladd.f32(float %532, float %536, float %528)
%538 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 3
%539 = getelementptr inbounds [4 x float], [4 x float]* %538, i64 0, i64 1
store float %537, float* %539
%540 = load [4 x float]*, [4 x float]** %4
%541 = getelementptr inbounds [4 x float], [4 x float]* %540, i64 3
%542 = getelementptr inbounds [4 x float], [4 x float]* %541, i64 0, i64 0
%543 = load float, float* %542
%544 = load [4 x float]*, [4 x float]** %5
%545 = getelementptr inbounds [4 x float], [4 x float]* %544, i64 0
%546 = getelementptr inbounds [4 x float], [4 x float]* %545, i64 0, i64 2
%547 = load float, float* %546
%548 = load [4 x float]*, [4 x float]** %4
%549 = getelementptr inbounds [4 x float], [4 x float]* %548, i64 3
%550 = getelementptr inbounds [4 x float], [4 x float]* %549, i64 0, i64 1
%551 = load float, float* %550
%552 = load [4 x float]*, [4 x float]** %5
%553 = getelementptr inbounds [4 x float], [4 x float]* %552, i64 1
%554 = getelementptr inbounds [4 x float], [4 x float]* %553, i64 0, i64 2
%555 = load float, float* %554
%556 = fmul float %551, %555
%557 = call float @llvm.fmuladd.f32(float %543, float %547, float %556)
%558 = load [4 x float]*, [4 x float]** %4
%559 = getelementptr inbounds [4 x float], [4 x float]* %558, i64 3
%560 = getelementptr inbounds [4 x float], [4 x float]* %559, i64 0, i64 2
%561 = load float, float* %560
%562 = load [4 x float]*, [4 x float]** %5
%563 = getelementptr inbounds [4 x float], [4 x float]* %562, i64 2
%564 = getelementptr inbounds [4 x float], [4 x float]* %563, i64 0, i64 2
%565 = load float, float* %564
%566 = call float @llvm.fmuladd.f32(float %561, float %565, float %557)
%567 = load [4 x float]*, [4 x float]** %4
%568 = getelementptr inbounds [4 x float], [4 x float]* %567, i64 3
%569 = getelementptr inbounds [4 x float], [4 x float]* %568, i64 0, i64 3
%570 = load float, float* %569
%571 = load [4 x float]*, [4 x float]** %5
%572 = getelementptr inbounds [4 x float], [4 x float]* %571, i64 3
%573 = getelementptr inbounds [4 x float], [4 x float]* %572, i64 0, i64 2
%574 = load float, float* %573
%575 = call float @llvm.fmuladd.f32(float %570, float %574, float %566)
%576 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 3
%577 = getelementptr inbounds [4 x float], [4 x float]* %576, i64 0, i64 2
store float %575, float* %577
%578 = load [4 x float]*, [4 x float]** %4
%579 = getelementptr inbounds [4 x float], [4 x float]* %578, i64 3
%580 = getelementptr inbounds [4 x float], [4 x float]* %579, i64 0, i64 0
%581 = load float, float* %580
%582 = load [4 x float]*, [4 x float]** %5
%583 = getelementptr inbounds [4 x float], [4 x float]* %582, i64 0
%584 = getelementptr inbounds [4 x float], [4 x float]* %583, i64 0, i64 3
%585 = load float, float* %584
%586 = load [4 x float]*, [4 x float]** %4
%587 = getelementptr inbounds [4 x float], [4 x float]* %586, i64 3
%588 = getelementptr inbounds [4 x float], [4 x float]* %587, i64 0, i64 1
%589 = load float, float* %588
%590 = load [4 x float]*, [4 x float]** %5
%591 = getelementptr inbounds [4 x float], [4 x float]* %590, i64 1
%592 = getelementptr inbounds [4 x float], [4 x float]* %591, i64 0, i64 3
%593 = load float, float* %592
%594 = fmul float %589, %593
%595 = call float @llvm.fmuladd.f32(float %581, float %585, float %594)
%596 = load [4 x float]*, [4 x float]** %4
%597 = getelementptr inbounds [4 x float], [4 x float]* %596, i64 3
%598 = getelementptr inbounds [4 x float], [4 x float]* %597, i64 0, i64 2
%599 = load float, float* %598
%600 = load [4 x float]*, [4 x float]** %5
%601 = getelementptr inbounds [4 x float], [4 x float]* %600, i64 2
%602 = getelementptr inbounds [4 x float], [4 x float]* %601, i64 0, i64 3
%603 = load float, float* %602
%604 = call float @llvm.fmuladd.f32(float %599, float %603, float %595)
%605 = load [4 x float]*, [4 x float]** %4
%606 = getelementptr inbounds [4 x float], [4 x float]* %605, i64 3
%607 = getelementptr inbounds [4 x float], [4 x float]* %606, i64 0, i64 3
%608 = load float, float* %607
%609 = load [4 x float]*, [4 x float]** %5
%610 = getelementptr inbounds [4 x float], [4 x float]* %609, i64 3
%611 = getelementptr inbounds [4 x float], [4 x float]* %610, i64 0, i64 3
%612 = load float, float* %611
%613 = call float @llvm.fmuladd.f32(float %608, float %612, float %604)
%614 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 3
%615 = getelementptr inbounds [4 x float], [4 x float]* %614, i64 0, i64 3
store float %613, float* %615
%616 = load [4 x float]*, [4 x float]** %6
%617 = bitcast [4 x float]* %616 to i8*
%618 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%619 = bitcast [4 x float]* %618 to i8*
ret void
}

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