void mult4x4(float (*a)[4], float (*b)[4], float (*c)[4]) {
  a[0][0] = b[0][0] * c[0][0] + b[0][1] * c[1][0] + b[0][2] * c[2][0] +
            b[0][3] * c[3][0];
  a[0][1] = b[0][0] * c[0][1] + b[0][1] * c[1][1] + b[0][2] * c[2][1] +
            b[0][3] * c[3][1];
  a[0][2] = b[0][0] * c[0][2] + b[0][1] * c[1][2] + b[0][2] * c[2][2] +
            b[0][3] * c[3][2];
  a[0][3] = b[0][0] * c[0][3] + b[0][1] * c[1][3] + b[0][2] * c[2][3] +
            b[0][3] * c[3][3];
  a[1][0] = b[1][0] * c[0][0] + b[1][1] * c[1][0] + b[1][2] * c[2][0] +
            b[1][3] * c[3][0];
  a[1][1] = b[1][0] * c[0][1] + b[1][1] * c[1][1] + b[1][2] * c[2][1] +
            b[1][3] * c[3][1];
  a[1][2] = b[1][0] * c[0][2] + b[1][1] * c[1][2] + b[1][2] * c[2][2] +
            b[1][3] * c[3][2];
  a[1][3] = b[1][0] * c[0][3] + b[1][1] * c[1][3] + b[1][2] * c[2][3] +
            b[1][3] * c[3][3];
  a[2][0] = b[2][0] * c[0][0] + b[2][1] * c[1][0] + b[2][2] * c[2][0] +
            b[2][3] * c[3][0];
  a[2][1] = b[2][0] * c[0][1] + b[2][1] * c[1][1] + b[2][2] * c[2][1] +
            b[2][3] * c[3][1];
  a[2][2] = b[2][0] * c[0][2] + b[2][1] * c[1][2] + b[2][2] * c[2][2] +
            b[2][3] * c[3][2];
  a[2][3] = b[2][0] * c[0][3] + b[2][1] * c[1][3] + b[2][2] * c[2][3] +
            b[2][3] * c[3][3];
  a[3][0] = b[3][0] * c[0][0] + b[3][1] * c[1][0] + b[3][2] * c[2][0] +
            b[3][3] * c[3][0];
  a[3][1] = b[3][0] * c[0][1] + b[3][1] * c[1][1] + b[3][2] * c[2][1] +
            b[3][3] * c[3][1];
  a[3][2] = b[3][0] * c[0][2] + b[3][1] * c[1][2] + b[3][2] * c[2][2] +
            b[3][3] * c[3][2];
  a[3][3] = b[3][0] * c[0][3] + b[3][1] * c[1][3] + b[3][2] * c[2][3] +
            b[3][3] * c[3][3];
}


x86 assembly (clang, -O0):
<mult4x4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mult4x4>:
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm1
mulss  0x10(%rdx),%xmm1
mulss  (%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm1
mulss  0x20(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rsi),%xmm0
mulss  0x30(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdi)
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm1
mulss  0x14(%rdx),%xmm1
mulss  0x4(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm1
mulss  0x24(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rsi),%xmm0
mulss  0x34(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rdi)
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm1
mulss  0x18(%rdx),%xmm1
mulss  0x8(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm1
mulss  0x28(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rsi),%xmm0
mulss  0x38(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rdi)
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm1
mulss  0x1c(%rdx),%xmm1
mulss  0xc(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm1
mulss  0x2c(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rsi),%xmm0
mulss  0x3c(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rdi)
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm1
mulss  0x10(%rdx),%xmm1
mulss  (%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x18(%rsi),%xmm1
mulss  0x20(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x1c(%rsi),%xmm0
mulss  0x30(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rdi)
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm1
mulss  0x14(%rdx),%xmm1
mulss  0x4(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x18(%rsi),%xmm1
mulss  0x24(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x1c(%rsi),%xmm0
mulss  0x34(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rdi)
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm1
mulss  0x18(%rdx),%xmm1
mulss  0x8(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x18(%rsi),%xmm1
mulss  0x28(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x1c(%rsi),%xmm0
mulss  0x38(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x18(%rdi)
movss  0x10(%rsi),%xmm0
movss  0x14(%rsi),%xmm1
mulss  0x1c(%rdx),%xmm1
mulss  0xc(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x18(%rsi),%xmm1
mulss  0x2c(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x1c(%rsi),%xmm0
mulss  0x3c(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rdi)
movss  0x20(%rsi),%xmm0
movss  0x24(%rsi),%xmm1
mulss  0x10(%rdx),%xmm1
mulss  (%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm1
mulss  0x20(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x2c(%rsi),%xmm0
mulss  0x30(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rdi)
movss  0x20(%rsi),%xmm0
movss  0x24(%rsi),%xmm1
mulss  0x14(%rdx),%xmm1
mulss  0x4(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm1
mulss  0x24(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x2c(%rsi),%xmm0
mulss  0x34(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x24(%rdi)
movss  0x20(%rsi),%xmm0
movss  0x24(%rsi),%xmm1
mulss  0x18(%rdx),%xmm1
mulss  0x8(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm1
mulss  0x28(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x2c(%rsi),%xmm0
mulss  0x38(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x28(%rdi)
movss  0x20(%rsi),%xmm0
movss  0x24(%rsi),%xmm1
mulss  0x1c(%rdx),%xmm1
mulss  0xc(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%rsi),%xmm1
mulss  0x2c(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x2c(%rsi),%xmm0
mulss  0x3c(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x2c(%rdi)
movss  0x30(%rsi),%xmm0
movss  0x34(%rsi),%xmm1
mulss  0x10(%rdx),%xmm1
mulss  (%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm1
mulss  0x20(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x3c(%rsi),%xmm0
mulss  0x30(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x30(%rdi)
movss  0x30(%rsi),%xmm0
movss  0x34(%rsi),%xmm1
mulss  0x14(%rdx),%xmm1
mulss  0x4(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm1
mulss  0x24(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x3c(%rsi),%xmm0
mulss  0x34(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x34(%rdi)
movss  0x30(%rsi),%xmm0
movss  0x34(%rsi),%xmm1
mulss  0x18(%rdx),%xmm1
mulss  0x8(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm1
mulss  0x28(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x3c(%rsi),%xmm0
mulss  0x38(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x38(%rdi)
movss  0x30(%rsi),%xmm0
movss  0x34(%rsi),%xmm1
mulss  0x1c(%rdx),%xmm1
mulss  0xc(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  0x38(%rsi),%xmm1
mulss  0x2c(%rdx),%xmm1
addss  %xmm0,%xmm1
movss  0x3c(%rsi),%xmm0
mulss  0x3c(%rdx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3c(%rdi)
ret

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

LLVM IR (-O2):
define void @mult4x4([4 x float]* nocapture writeonly %0, [4 x float]* nocapture %1, [4 x float]* nocapture %2) {
%4 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 0
%5 = load float, float* %4
%6 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 0
%7 = load float, float* %6
%8 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 1
%9 = load float, float* %8
%10 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 1, i64 0
%11 = load float, float* %10
%12 = fmul float %9, %11
%13 = tail call float @llvm.fmuladd.f32(float %5, float %7, float %12)
%14 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 2
%15 = load float, float* %14
%16 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 2, i64 0
%17 = load float, float* %16
%18 = tail call float @llvm.fmuladd.f32(float %15, float %17, float %13)
%19 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 3
%20 = load float, float* %19
%21 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 3, i64 0
%22 = load float, float* %21
%23 = tail call float @llvm.fmuladd.f32(float %20, float %22, float %18)
%24 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 0
store float %23, float* %24
%25 = load float, float* %4
%26 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 1
%27 = load float, float* %26
%28 = load float, float* %8
%29 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 1, i64 1
%30 = load float, float* %29
%31 = fmul float %28, %30
%32 = tail call float @llvm.fmuladd.f32(float %25, float %27, float %31)
%33 = load float, float* %14
%34 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 2, i64 1
%35 = load float, float* %34
%36 = tail call float @llvm.fmuladd.f32(float %33, float %35, float %32)
%37 = load float, float* %19
%38 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 3, i64 1
%39 = load float, float* %38
%40 = tail call float @llvm.fmuladd.f32(float %37, float %39, float %36)
%41 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 1
store float %40, float* %41
%42 = load float, float* %4
%43 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 2
%44 = load float, float* %43
%45 = load float, float* %8
%46 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 1, i64 2
%47 = load float, float* %46
%48 = fmul float %45, %47
%49 = tail call float @llvm.fmuladd.f32(float %42, float %44, float %48)
%50 = load float, float* %14
%51 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 2, i64 2
%52 = load float, float* %51
%53 = tail call float @llvm.fmuladd.f32(float %50, float %52, float %49)
%54 = load float, float* %19
%55 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 3, i64 2
%56 = load float, float* %55
%57 = tail call float @llvm.fmuladd.f32(float %54, float %56, float %53)
%58 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 2
store float %57, float* %58
%59 = load float, float* %4
%60 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 3
%61 = load float, float* %60
%62 = load float, float* %8
%63 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 1, i64 3
%64 = load float, float* %63
%65 = fmul float %62, %64
%66 = tail call float @llvm.fmuladd.f32(float %59, float %61, float %65)
%67 = load float, float* %14
%68 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 2, i64 3
%69 = load float, float* %68
%70 = tail call float @llvm.fmuladd.f32(float %67, float %69, float %66)
%71 = load float, float* %19
%72 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 3, i64 3
%73 = load float, float* %72
%74 = tail call float @llvm.fmuladd.f32(float %71, float %73, float %70)
%75 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 3
store float %74, float* %75
%76 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 0
%77 = load float, float* %76
%78 = load float, float* %6
%79 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 1
%80 = load float, float* %79
%81 = load float, float* %10
%82 = fmul float %80, %81
%83 = tail call float @llvm.fmuladd.f32(float %77, float %78, float %82)
%84 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 2
%85 = load float, float* %84
%86 = load float, float* %16
%87 = tail call float @llvm.fmuladd.f32(float %85, float %86, float %83)
%88 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 3
%89 = load float, float* %88
%90 = load float, float* %21
%91 = tail call float @llvm.fmuladd.f32(float %89, float %90, float %87)
%92 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 0
store float %91, float* %92
%93 = load float, float* %76
%94 = load float, float* %26
%95 = load float, float* %79
%96 = load float, float* %29
%97 = fmul float %95, %96
%98 = tail call float @llvm.fmuladd.f32(float %93, float %94, float %97)
%99 = load float, float* %84
%100 = load float, float* %34
%101 = tail call float @llvm.fmuladd.f32(float %99, float %100, float %98)
%102 = load float, float* %88
%103 = load float, float* %38
%104 = tail call float @llvm.fmuladd.f32(float %102, float %103, float %101)
%105 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 1
store float %104, float* %105
%106 = load float, float* %76
%107 = load float, float* %43
%108 = load float, float* %79
%109 = load float, float* %46
%110 = fmul float %108, %109
%111 = tail call float @llvm.fmuladd.f32(float %106, float %107, float %110)
%112 = load float, float* %84
%113 = load float, float* %51
%114 = tail call float @llvm.fmuladd.f32(float %112, float %113, float %111)
%115 = load float, float* %88
%116 = load float, float* %55
%117 = tail call float @llvm.fmuladd.f32(float %115, float %116, float %114)
%118 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 2
store float %117, float* %118
%119 = load float, float* %76
%120 = load float, float* %60
%121 = load float, float* %79
%122 = load float, float* %63
%123 = fmul float %121, %122
%124 = tail call float @llvm.fmuladd.f32(float %119, float %120, float %123)
%125 = load float, float* %84
%126 = load float, float* %68
%127 = tail call float @llvm.fmuladd.f32(float %125, float %126, float %124)
%128 = load float, float* %88
%129 = load float, float* %72
%130 = tail call float @llvm.fmuladd.f32(float %128, float %129, float %127)
%131 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 3
store float %130, float* %131
%132 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 0
%133 = load float, float* %132
%134 = load float, float* %6
%135 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 1
%136 = load float, float* %135
%137 = load float, float* %10
%138 = fmul float %136, %137
%139 = tail call float @llvm.fmuladd.f32(float %133, float %134, float %138)
%140 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 2
%141 = load float, float* %140
%142 = load float, float* %16
%143 = tail call float @llvm.fmuladd.f32(float %141, float %142, float %139)
%144 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 3
%145 = load float, float* %144
%146 = load float, float* %21
%147 = tail call float @llvm.fmuladd.f32(float %145, float %146, float %143)
%148 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 0
store float %147, float* %148
%149 = load float, float* %132
%150 = load float, float* %26
%151 = load float, float* %135
%152 = load float, float* %29
%153 = fmul float %151, %152
%154 = tail call float @llvm.fmuladd.f32(float %149, float %150, float %153)
%155 = load float, float* %140
%156 = load float, float* %34
%157 = tail call float @llvm.fmuladd.f32(float %155, float %156, float %154)
%158 = load float, float* %144
%159 = load float, float* %38
%160 = tail call float @llvm.fmuladd.f32(float %158, float %159, float %157)
%161 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 1
store float %160, float* %161
%162 = load float, float* %132
%163 = load float, float* %43
%164 = load float, float* %135
%165 = load float, float* %46
%166 = fmul float %164, %165
%167 = tail call float @llvm.fmuladd.f32(float %162, float %163, float %166)
%168 = load float, float* %140
%169 = load float, float* %51
%170 = tail call float @llvm.fmuladd.f32(float %168, float %169, float %167)
%171 = load float, float* %144
%172 = load float, float* %55
%173 = tail call float @llvm.fmuladd.f32(float %171, float %172, float %170)
%174 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 2
store float %173, float* %174
%175 = load float, float* %132
%176 = load float, float* %60
%177 = load float, float* %135
%178 = load float, float* %63
%179 = fmul float %177, %178
%180 = tail call float @llvm.fmuladd.f32(float %175, float %176, float %179)
%181 = load float, float* %140
%182 = load float, float* %68
%183 = tail call float @llvm.fmuladd.f32(float %181, float %182, float %180)
%184 = load float, float* %144
%185 = load float, float* %72
%186 = tail call float @llvm.fmuladd.f32(float %184, float %185, float %183)
%187 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 3
store float %186, float* %187
%188 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 0
%189 = load float, float* %188
%190 = load float, float* %6
%191 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 1
%192 = load float, float* %191
%193 = load float, float* %10
%194 = fmul float %192, %193
%195 = tail call float @llvm.fmuladd.f32(float %189, float %190, float %194)
%196 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 2
%197 = load float, float* %196
%198 = load float, float* %16
%199 = tail call float @llvm.fmuladd.f32(float %197, float %198, float %195)
%200 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 3
%201 = load float, float* %200
%202 = load float, float* %21
%203 = tail call float @llvm.fmuladd.f32(float %201, float %202, float %199)
%204 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 0
store float %203, float* %204
%205 = load float, float* %188
%206 = load float, float* %26
%207 = load float, float* %191
%208 = load float, float* %29
%209 = fmul float %207, %208
%210 = tail call float @llvm.fmuladd.f32(float %205, float %206, float %209)
%211 = load float, float* %196
%212 = load float, float* %34
%213 = tail call float @llvm.fmuladd.f32(float %211, float %212, float %210)
%214 = load float, float* %200
%215 = load float, float* %38
%216 = tail call float @llvm.fmuladd.f32(float %214, float %215, float %213)
%217 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 1
store float %216, float* %217
%218 = load float, float* %188
%219 = load float, float* %43
%220 = load float, float* %191
%221 = load float, float* %46
%222 = fmul float %220, %221
%223 = tail call float @llvm.fmuladd.f32(float %218, float %219, float %222)
%224 = load float, float* %196
%225 = load float, float* %51
%226 = tail call float @llvm.fmuladd.f32(float %224, float %225, float %223)
%227 = load float, float* %200
%228 = load float, float* %55
%229 = tail call float @llvm.fmuladd.f32(float %227, float %228, float %226)
%230 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 2
store float %229, float* %230
%231 = load float, float* %188
%232 = load float, float* %60
%233 = load float, float* %191
%234 = load float, float* %63
%235 = fmul float %233, %234
%236 = tail call float @llvm.fmuladd.f32(float %231, float %232, float %235)
%237 = load float, float* %196
%238 = load float, float* %68
%239 = tail call float @llvm.fmuladd.f32(float %237, float %238, float %236)
%240 = load float, float* %200
%241 = load float, float* %72
%242 = tail call float @llvm.fmuladd.f32(float %240, float %241, float %239)
%243 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 3
store float %242, float* %243
ret void
}