void u3d_matrixMultiplicationInRawData(float dst_raw_data[16],
                                       float left_raw_data[16],
                                       float right_raw_data[16]) {
  dst_raw_data[0] = left_raw_data[0] * right_raw_data[0] +
                    left_raw_data[1] * right_raw_data[4] +
                    left_raw_data[2] * right_raw_data[8] +
                    left_raw_data[3] * right_raw_data[12];
  dst_raw_data[1] = left_raw_data[0] * right_raw_data[1] +
                    left_raw_data[1] * right_raw_data[5] +
                    left_raw_data[2] * right_raw_data[9] +
                    left_raw_data[3] * right_raw_data[13];
  dst_raw_data[2] = left_raw_data[0] * right_raw_data[2] +
                    left_raw_data[1] * right_raw_data[6] +
                    left_raw_data[2] * right_raw_data[10] +
                    left_raw_data[3] * right_raw_data[14];
  dst_raw_data[3] = left_raw_data[0] * right_raw_data[3] +
                    left_raw_data[1] * right_raw_data[7] +
                    left_raw_data[2] * right_raw_data[11] +
                    left_raw_data[3] * right_raw_data[15];
  dst_raw_data[4] = left_raw_data[4] * right_raw_data[0] +
                    left_raw_data[5] * right_raw_data[4] +
                    left_raw_data[6] * right_raw_data[8] +
                    left_raw_data[7] * right_raw_data[12];
  dst_raw_data[5] = left_raw_data[4] * right_raw_data[1] +
                    left_raw_data[5] * right_raw_data[5] +
                    left_raw_data[6] * right_raw_data[9] +
                    left_raw_data[7] * right_raw_data[13];
  dst_raw_data[6] = left_raw_data[4] * right_raw_data[2] +
                    left_raw_data[5] * right_raw_data[6] +
                    left_raw_data[6] * right_raw_data[10] +
                    left_raw_data[7] * right_raw_data[14];
  dst_raw_data[7] = left_raw_data[4] * right_raw_data[3] +
                    left_raw_data[5] * right_raw_data[7] +
                    left_raw_data[6] * right_raw_data[11] +
                    left_raw_data[7] * right_raw_data[15];
  dst_raw_data[8] = left_raw_data[8] * right_raw_data[0] +
                    left_raw_data[9] * right_raw_data[4] +
                    left_raw_data[10] * right_raw_data[8] +
                    left_raw_data[11] * right_raw_data[12];
  dst_raw_data[9] = left_raw_data[8] * right_raw_data[1] +
                    left_raw_data[9] * right_raw_data[5] +
                    left_raw_data[10] * right_raw_data[9] +
                    left_raw_data[11] * right_raw_data[13];
  dst_raw_data[10] = left_raw_data[8] * right_raw_data[2] +
                     left_raw_data[9] * right_raw_data[6] +
                     left_raw_data[10] * right_raw_data[10] +
                     left_raw_data[11] * right_raw_data[14];
  dst_raw_data[11] = left_raw_data[8] * right_raw_data[3] +
                     left_raw_data[9] * right_raw_data[7] +
                     left_raw_data[10] * right_raw_data[11] +
                     left_raw_data[11] * right_raw_data[15];
  dst_raw_data[12] = left_raw_data[12] * right_raw_data[0] +
                     left_raw_data[13] * right_raw_data[4] +
                     left_raw_data[14] * right_raw_data[8] +
                     left_raw_data[15] * right_raw_data[12];
  dst_raw_data[13] = left_raw_data[12] * right_raw_data[1] +
                     left_raw_data[13] * right_raw_data[5] +
                     left_raw_data[14] * right_raw_data[9] +
                     left_raw_data[15] * right_raw_data[13];
  dst_raw_data[14] = left_raw_data[12] * right_raw_data[2] +
                     left_raw_data[13] * right_raw_data[6] +
                     left_raw_data[14] * right_raw_data[10] +
                     left_raw_data[15] * right_raw_data[14];
  dst_raw_data[15] = left_raw_data[12] * right_raw_data[3] +
                     left_raw_data[13] * right_raw_data[7] +
                     left_raw_data[14] * right_raw_data[11] +
                     left_raw_data[15] * right_raw_data[15];
}


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

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