void esmMultiply(float *M, float *M2) {
  float a00 = M[0], a01 = M[1], a02 = M[2], a03 = M[3], a10 = M[4], a11 = M[5],
        a12 = M[6], a13 = M[7], a20 = M[8], a21 = M[9], a22 = M[10],
        a23 = M[11], a30 = M[12], a31 = M[13], a32 = M[14], a33 = M[15],
        b00 = M2[0], b01 = M2[1], b02 = M2[2], b03 = M2[3], b10 = M2[4],
        b11 = M2[5], b12 = M2[6], b13 = M2[7], b20 = M2[8], b21 = M2[9],
        b22 = M2[10], b23 = M2[11], b30 = M2[12], b31 = M2[13], b32 = M2[14],
        b33 = M2[15];
  M[0] = b00 * a00 + b01 * a10 + b02 * a20 + b03 * a30;
  M[1] = b00 * a01 + b01 * a11 + b02 * a21 + b03 * a31;
  M[2] = b00 * a02 + b01 * a12 + b02 * a22 + b03 * a32;
  M[3] = b00 * a03 + b01 * a13 + b02 * a23 + b03 * a33;
  M[4] = b10 * a00 + b11 * a10 + b12 * a20 + b13 * a30;
  M[5] = b10 * a01 + b11 * a11 + b12 * a21 + b13 * a31;
  M[6] = b10 * a02 + b11 * a12 + b12 * a22 + b13 * a32;
  M[7] = b10 * a03 + b11 * a13 + b12 * a23 + b13 * a33;
  M[8] = b20 * a00 + b21 * a10 + b22 * a20 + b23 * a30;
  M[9] = b20 * a01 + b21 * a11 + b22 * a21 + b23 * a31;
  M[10] = b20 * a02 + b21 * a12 + b22 * a22 + b23 * a32;
  M[11] = b20 * a03 + b21 * a13 + b22 * a23 + b23 * a33;
  M[12] = b30 * a00 + b31 * a10 + b32 * a20 + b33 * a30;
  M[13] = b30 * a01 + b31 * a11 + b32 * a21 + b33 * a31;
  M[14] = b30 * a02 + b31 * a12 + b32 * a22 + b33 * a32;
  M[15] = b30 * a03 + b31 * a13 + b32 * a23 + b33 * a33;
}


x86 assembly (clang, -O0):
<esmMultiply>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x74(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x74(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x74(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x74(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x14(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x18(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x1c(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x20(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
add    $0x10,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
define void @esmMultiply(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
store float* %0, float** %3
store float* %1, float** %4
%37 = load float*, float** %3
%38 = getelementptr inbounds float, float* %37, i64 0
%39 = load float, float* %38
store float %39, float* %5
%40 = load float*, float** %3
%41 = getelementptr inbounds float, float* %40, i64 1
%42 = load float, float* %41
store float %42, float* %6
%43 = load float*, float** %3
%44 = getelementptr inbounds float, float* %43, i64 2
%45 = load float, float* %44
store float %45, float* %7
%46 = load float*, float** %3
%47 = getelementptr inbounds float, float* %46, i64 3
%48 = load float, float* %47
store float %48, float* %8
%49 = load float*, float** %3
%50 = getelementptr inbounds float, float* %49, i64 4
%51 = load float, float* %50
store float %51, float* %9
%52 = load float*, float** %3
%53 = getelementptr inbounds float, float* %52, i64 5
%54 = load float, float* %53
store float %54, float* %10
%55 = load float*, float** %3
%56 = getelementptr inbounds float, float* %55, i64 6
%57 = load float, float* %56
store float %57, float* %11
%58 = load float*, float** %3
%59 = getelementptr inbounds float, float* %58, i64 7
%60 = load float, float* %59
store float %60, float* %12
%61 = load float*, float** %3
%62 = getelementptr inbounds float, float* %61, i64 8
%63 = load float, float* %62
store float %63, float* %13
%64 = load float*, float** %3
%65 = getelementptr inbounds float, float* %64, i64 9
%66 = load float, float* %65
store float %66, float* %14
%67 = load float*, float** %3
%68 = getelementptr inbounds float, float* %67, i64 10
%69 = load float, float* %68
store float %69, float* %15
%70 = load float*, float** %3
%71 = getelementptr inbounds float, float* %70, i64 11
%72 = load float, float* %71
store float %72, float* %16
%73 = load float*, float** %3
%74 = getelementptr inbounds float, float* %73, i64 12
%75 = load float, float* %74
store float %75, float* %17
%76 = load float*, float** %3
%77 = getelementptr inbounds float, float* %76, i64 13
%78 = load float, float* %77
store float %78, float* %18
%79 = load float*, float** %3
%80 = getelementptr inbounds float, float* %79, i64 14
%81 = load float, float* %80
store float %81, float* %19
%82 = load float*, float** %3
%83 = getelementptr inbounds float, float* %82, i64 15
%84 = load float, float* %83
store float %84, float* %20
%85 = load float*, float** %4
%86 = getelementptr inbounds float, float* %85, i64 0
%87 = load float, float* %86
store float %87, float* %21
%88 = load float*, float** %4
%89 = getelementptr inbounds float, float* %88, i64 1
%90 = load float, float* %89
store float %90, float* %22
%91 = load float*, float** %4
%92 = getelementptr inbounds float, float* %91, i64 2
%93 = load float, float* %92
store float %93, float* %23
%94 = load float*, float** %4
%95 = getelementptr inbounds float, float* %94, i64 3
%96 = load float, float* %95
store float %96, float* %24
%97 = load float*, float** %4
%98 = getelementptr inbounds float, float* %97, i64 4
%99 = load float, float* %98
store float %99, float* %25
%100 = load float*, float** %4
%101 = getelementptr inbounds float, float* %100, i64 5
%102 = load float, float* %101
store float %102, float* %26
%103 = load float*, float** %4
%104 = getelementptr inbounds float, float* %103, i64 6
%105 = load float, float* %104
store float %105, float* %27
%106 = load float*, float** %4
%107 = getelementptr inbounds float, float* %106, i64 7
%108 = load float, float* %107
store float %108, float* %28
%109 = load float*, float** %4
%110 = getelementptr inbounds float, float* %109, i64 8
%111 = load float, float* %110
store float %111, float* %29
%112 = load float*, float** %4
%113 = getelementptr inbounds float, float* %112, i64 9
%114 = load float, float* %113
store float %114, float* %30
%115 = load float*, float** %4
%116 = getelementptr inbounds float, float* %115, i64 10
%117 = load float, float* %116
store float %117, float* %31
%118 = load float*, float** %4
%119 = getelementptr inbounds float, float* %118, i64 11
%120 = load float, float* %119
store float %120, float* %32
%121 = load float*, float** %4
%122 = getelementptr inbounds float, float* %121, i64 12
%123 = load float, float* %122
store float %123, float* %33
%124 = load float*, float** %4
%125 = getelementptr inbounds float, float* %124, i64 13
%126 = load float, float* %125
store float %126, float* %34
%127 = load float*, float** %4
%128 = getelementptr inbounds float, float* %127, i64 14
%129 = load float, float* %128
store float %129, float* %35
%130 = load float*, float** %4
%131 = getelementptr inbounds float, float* %130, i64 15
%132 = load float, float* %131
store float %132, float* %36
%133 = load float, float* %21
%134 = load float, float* %5
%135 = load float, float* %22
%136 = load float, float* %9
%137 = fmul float %135, %136
%138 = call float @llvm.fmuladd.f32(float %133, float %134, float %137)
%139 = load float, float* %23
%140 = load float, float* %13
%141 = call float @llvm.fmuladd.f32(float %139, float %140, float %138)
%142 = load float, float* %24
%143 = load float, float* %17
%144 = call float @llvm.fmuladd.f32(float %142, float %143, float %141)
%145 = load float*, float** %3
%146 = getelementptr inbounds float, float* %145, i64 0
store float %144, float* %146
%147 = load float, float* %21
%148 = load float, float* %6
%149 = load float, float* %22
%150 = load float, float* %10
%151 = fmul float %149, %150
%152 = call float @llvm.fmuladd.f32(float %147, float %148, float %151)
%153 = load float, float* %23
%154 = load float, float* %14
%155 = call float @llvm.fmuladd.f32(float %153, float %154, float %152)
%156 = load float, float* %24
%157 = load float, float* %18
%158 = call float @llvm.fmuladd.f32(float %156, float %157, float %155)
%159 = load float*, float** %3
%160 = getelementptr inbounds float, float* %159, i64 1
store float %158, float* %160
%161 = load float, float* %21
%162 = load float, float* %7
%163 = load float, float* %22
%164 = load float, float* %11
%165 = fmul float %163, %164
%166 = call float @llvm.fmuladd.f32(float %161, float %162, float %165)
%167 = load float, float* %23
%168 = load float, float* %15
%169 = call float @llvm.fmuladd.f32(float %167, float %168, float %166)
%170 = load float, float* %24
%171 = load float, float* %19
%172 = call float @llvm.fmuladd.f32(float %170, float %171, float %169)
%173 = load float*, float** %3
%174 = getelementptr inbounds float, float* %173, i64 2
store float %172, float* %174
%175 = load float, float* %21
%176 = load float, float* %8
%177 = load float, float* %22
%178 = load float, float* %12
%179 = fmul float %177, %178
%180 = call float @llvm.fmuladd.f32(float %175, float %176, float %179)
%181 = load float, float* %23
%182 = load float, float* %16
%183 = call float @llvm.fmuladd.f32(float %181, float %182, float %180)
%184 = load float, float* %24
%185 = load float, float* %20
%186 = call float @llvm.fmuladd.f32(float %184, float %185, float %183)
%187 = load float*, float** %3
%188 = getelementptr inbounds float, float* %187, i64 3
store float %186, float* %188
%189 = load float, float* %25
%190 = load float, float* %5
%191 = load float, float* %26
%192 = load float, float* %9
%193 = fmul float %191, %192
%194 = call float @llvm.fmuladd.f32(float %189, float %190, float %193)
%195 = load float, float* %27
%196 = load float, float* %13
%197 = call float @llvm.fmuladd.f32(float %195, float %196, float %194)
%198 = load float, float* %28
%199 = load float, float* %17
%200 = call float @llvm.fmuladd.f32(float %198, float %199, float %197)
%201 = load float*, float** %3
%202 = getelementptr inbounds float, float* %201, i64 4
store float %200, float* %202
%203 = load float, float* %25
%204 = load float, float* %6
%205 = load float, float* %26
%206 = load float, float* %10
%207 = fmul float %205, %206
%208 = call float @llvm.fmuladd.f32(float %203, float %204, float %207)
%209 = load float, float* %27
%210 = load float, float* %14
%211 = call float @llvm.fmuladd.f32(float %209, float %210, float %208)
%212 = load float, float* %28
%213 = load float, float* %18
%214 = call float @llvm.fmuladd.f32(float %212, float %213, float %211)
%215 = load float*, float** %3
%216 = getelementptr inbounds float, float* %215, i64 5
store float %214, float* %216
%217 = load float, float* %25
%218 = load float, float* %7
%219 = load float, float* %26
%220 = load float, float* %11
%221 = fmul float %219, %220
%222 = call float @llvm.fmuladd.f32(float %217, float %218, float %221)
%223 = load float, float* %27
%224 = load float, float* %15
%225 = call float @llvm.fmuladd.f32(float %223, float %224, float %222)
%226 = load float, float* %28
%227 = load float, float* %19
%228 = call float @llvm.fmuladd.f32(float %226, float %227, float %225)
%229 = load float*, float** %3
%230 = getelementptr inbounds float, float* %229, i64 6
store float %228, float* %230
%231 = load float, float* %25
%232 = load float, float* %8
%233 = load float, float* %26
%234 = load float, float* %12
%235 = fmul float %233, %234
%236 = call float @llvm.fmuladd.f32(float %231, float %232, float %235)
%237 = load float, float* %27
%238 = load float, float* %16
%239 = call float @llvm.fmuladd.f32(float %237, float %238, float %236)
%240 = load float, float* %28
%241 = load float, float* %20
%242 = call float @llvm.fmuladd.f32(float %240, float %241, float %239)
%243 = load float*, float** %3
%244 = getelementptr inbounds float, float* %243, i64 7
store float %242, float* %244
%245 = load float, float* %29
%246 = load float, float* %5
%247 = load float, float* %30
%248 = load float, float* %9
%249 = fmul float %247, %248
%250 = call float @llvm.fmuladd.f32(float %245, float %246, float %249)
%251 = load float, float* %31
%252 = load float, float* %13
%253 = call float @llvm.fmuladd.f32(float %251, float %252, float %250)
%254 = load float, float* %32
%255 = load float, float* %17
%256 = call float @llvm.fmuladd.f32(float %254, float %255, float %253)
%257 = load float*, float** %3
%258 = getelementptr inbounds float, float* %257, i64 8
store float %256, float* %258
%259 = load float, float* %29
%260 = load float, float* %6
%261 = load float, float* %30
%262 = load float, float* %10
%263 = fmul float %261, %262
%264 = call float @llvm.fmuladd.f32(float %259, float %260, float %263)
%265 = load float, float* %31
%266 = load float, float* %14
%267 = call float @llvm.fmuladd.f32(float %265, float %266, float %264)
%268 = load float, float* %32
%269 = load float, float* %18
%270 = call float @llvm.fmuladd.f32(float %268, float %269, float %267)
%271 = load float*, float** %3
%272 = getelementptr inbounds float, float* %271, i64 9
store float %270, float* %272
%273 = load float, float* %29
%274 = load float, float* %7
%275 = load float, float* %30
%276 = load float, float* %11
%277 = fmul float %275, %276
%278 = call float @llvm.fmuladd.f32(float %273, float %274, float %277)
%279 = load float, float* %31
%280 = load float, float* %15
%281 = call float @llvm.fmuladd.f32(float %279, float %280, float %278)
%282 = load float, float* %32
%283 = load float, float* %19
%284 = call float @llvm.fmuladd.f32(float %282, float %283, float %281)
%285 = load float*, float** %3
%286 = getelementptr inbounds float, float* %285, i64 10
store float %284, float* %286
%287 = load float, float* %29
%288 = load float, float* %8
%289 = load float, float* %30
%290 = load float, float* %12
%291 = fmul float %289, %290
%292 = call float @llvm.fmuladd.f32(float %287, float %288, float %291)
%293 = load float, float* %31
%294 = load float, float* %16
%295 = call float @llvm.fmuladd.f32(float %293, float %294, float %292)
%296 = load float, float* %32
%297 = load float, float* %20
%298 = call float @llvm.fmuladd.f32(float %296, float %297, float %295)
%299 = load float*, float** %3
%300 = getelementptr inbounds float, float* %299, i64 11
store float %298, float* %300
%301 = load float, float* %33
%302 = load float, float* %5
%303 = load float, float* %34
%304 = load float, float* %9
%305 = fmul float %303, %304
%306 = call float @llvm.fmuladd.f32(float %301, float %302, float %305)
%307 = load float, float* %35
%308 = load float, float* %13
%309 = call float @llvm.fmuladd.f32(float %307, float %308, float %306)
%310 = load float, float* %36
%311 = load float, float* %17
%312 = call float @llvm.fmuladd.f32(float %310, float %311, float %309)
%313 = load float*, float** %3
%314 = getelementptr inbounds float, float* %313, i64 12
store float %312, float* %314
%315 = load float, float* %33
%316 = load float, float* %6
%317 = load float, float* %34
%318 = load float, float* %10
%319 = fmul float %317, %318
%320 = call float @llvm.fmuladd.f32(float %315, float %316, float %319)
%321 = load float, float* %35
%322 = load float, float* %14
%323 = call float @llvm.fmuladd.f32(float %321, float %322, float %320)
%324 = load float, float* %36
%325 = load float, float* %18
%326 = call float @llvm.fmuladd.f32(float %324, float %325, float %323)
%327 = load float*, float** %3
%328 = getelementptr inbounds float, float* %327, i64 13
store float %326, float* %328
%329 = load float, float* %33
%330 = load float, float* %7
%331 = load float, float* %34
%332 = load float, float* %11
%333 = fmul float %331, %332
%334 = call float @llvm.fmuladd.f32(float %329, float %330, float %333)
%335 = load float, float* %35
%336 = load float, float* %15
%337 = call float @llvm.fmuladd.f32(float %335, float %336, float %334)
%338 = load float, float* %36
%339 = load float, float* %19
%340 = call float @llvm.fmuladd.f32(float %338, float %339, float %337)
%341 = load float*, float** %3
%342 = getelementptr inbounds float, float* %341, i64 14
store float %340, float* %342
%343 = load float, float* %33
%344 = load float, float* %8
%345 = load float, float* %34
%346 = load float, float* %12
%347 = fmul float %345, %346
%348 = call float @llvm.fmuladd.f32(float %343, float %344, float %347)
%349 = load float, float* %35
%350 = load float, float* %16
%351 = call float @llvm.fmuladd.f32(float %349, float %350, float %348)
%352 = load float, float* %36
%353 = load float, float* %20
%354 = call float @llvm.fmuladd.f32(float %352, float %353, float %351)
%355 = load float*, float** %3
%356 = getelementptr inbounds float, float* %355, i64 15
store float %354, float* %356
ret void
}

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