float *mat4_multiply(float *result, float *a, float *b) {
  float multiplied[16];
  multiplied[0] = a[0] * b[0] + a[4] * b[1] + a[8] * b[2] + a[12] * b[3];
  multiplied[1] = a[1] * b[0] + a[5] * b[1] + a[9] * b[2] + a[13] * b[3];
  multiplied[2] = a[2] * b[0] + a[6] * b[1] + a[10] * b[2] + a[14] * b[3];
  multiplied[3] = a[3] * b[0] + a[7] * b[1] + a[11] * b[2] + a[15] * b[3];
  multiplied[4] = a[0] * b[4] + a[4] * b[5] + a[8] * b[6] + a[12] * b[7];
  multiplied[5] = a[1] * b[4] + a[5] * b[5] + a[9] * b[6] + a[13] * b[7];
  multiplied[6] = a[2] * b[4] + a[6] * b[5] + a[10] * b[6] + a[14] * b[7];
  multiplied[7] = a[3] * b[4] + a[7] * b[5] + a[11] * b[6] + a[15] * b[7];
  multiplied[8] = a[0] * b[8] + a[4] * b[9] + a[8] * b[10] + a[12] * b[11];
  multiplied[9] = a[1] * b[8] + a[5] * b[9] + a[9] * b[10] + a[13] * b[11];
  multiplied[10] = a[2] * b[8] + a[6] * b[9] + a[10] * b[10] + a[14] * b[11];
  multiplied[11] = a[3] * b[8] + a[7] * b[9] + a[11] * b[10] + a[15] * b[11];
  multiplied[12] = a[0] * b[12] + a[4] * b[13] + a[8] * b[14] + a[12] * b[15];
  multiplied[13] = a[1] * b[12] + a[5] * b[13] + a[9] * b[14] + a[13] * b[15];
  multiplied[14] = a[2] * b[12] + a[6] * b[13] + a[10] * b[14] + a[14] * b[15];
  multiplied[15] = a[3] * b[12] + a[7] * b[13] + a[11] * b[14] + a[15] * b[15];
  result[0] = multiplied[0];
  result[1] = multiplied[1];
  result[2] = multiplied[2];
  result[3] = multiplied[3];
  result[4] = multiplied[4];
  result[5] = multiplied[5];
  result[6] = multiplied[6];
  result[7] = multiplied[7];
  result[8] = multiplied[8];
  result[9] = multiplied[9];
  result[10] = multiplied[10];
  result[11] = multiplied[11];
  result[12] = multiplied[12];
  result[13] = multiplied[13];
  result[14] = multiplied[14];
  result[15] = multiplied[15];
  return result;
}


x86 assembly (clang, -O0):
<mat4_multiply>:
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  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%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  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%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  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%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  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%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  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%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
movss  %xmm0,-0x24(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

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

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

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