void Mat4_RotateRByQuaternion(float mat[16], const float q[4]) {
  float qt[4], *v, buf[4];
  {
    (qt)[0] = -(q)[0];
    (qt)[1] = -(q)[1];
    (qt)[2] = -(q)[2];
    (qt)[3] = (q)[3];
  };
  v = mat + 0;
  {
    (buf)[0] =
        (q)[3] * (v)[0] + (q)[0] * (v)[3] + (q)[1] * (v)[2] - (q)[2] * (v)[1];
    (buf)[1] =
        (q)[3] * (v)[1] + (q)[1] * (v)[3] + (q)[2] * (v)[0] - (q)[0] * (v)[2];
    (buf)[2] =
        (q)[3] * (v)[2] + (q)[2] * (v)[3] + (q)[0] * (v)[1] - (q)[1] * (v)[0];
    (buf)[3] =
        (q)[3] * (v)[3] - (q)[0] * (v)[0] - (q)[1] * (v)[1] - (q)[2] * (v)[2];
  };
  {
    (v)[0] = (buf)[3] * (qt)[0] + (buf)[0] * (qt)[3] + (buf)[1] * (qt)[2] -
             (buf)[2] * (qt)[1];
    (v)[1] = (buf)[3] * (qt)[1] + (buf)[1] * (qt)[3] + (buf)[2] * (qt)[0] -
             (buf)[0] * (qt)[2];
    (v)[2] = (buf)[3] * (qt)[2] + (buf)[2] * (qt)[3] + (buf)[0] * (qt)[1] -
             (buf)[1] * (qt)[0];
    (v)[3] = (buf)[3] * (qt)[3] - (buf)[0] * (qt)[0] - (buf)[1] * (qt)[1] -
             (buf)[2] * (qt)[2];
  };
  mat[0 + 3] = 0.0f;
  v = mat + 4;
  {
    (buf)[0] =
        (q)[3] * (v)[0] + (q)[0] * (v)[3] + (q)[1] * (v)[2] - (q)[2] * (v)[1];
    (buf)[1] =
        (q)[3] * (v)[1] + (q)[1] * (v)[3] + (q)[2] * (v)[0] - (q)[0] * (v)[2];
    (buf)[2] =
        (q)[3] * (v)[2] + (q)[2] * (v)[3] + (q)[0] * (v)[1] - (q)[1] * (v)[0];
    (buf)[3] =
        (q)[3] * (v)[3] - (q)[0] * (v)[0] - (q)[1] * (v)[1] - (q)[2] * (v)[2];
  };
  {
    (v)[0] = (buf)[3] * (qt)[0] + (buf)[0] * (qt)[3] + (buf)[1] * (qt)[2] -
             (buf)[2] * (qt)[1];
    (v)[1] = (buf)[3] * (qt)[1] + (buf)[1] * (qt)[3] + (buf)[2] * (qt)[0] -
             (buf)[0] * (qt)[2];
    (v)[2] = (buf)[3] * (qt)[2] + (buf)[2] * (qt)[3] + (buf)[0] * (qt)[1] -
             (buf)[1] * (qt)[0];
    (v)[3] = (buf)[3] * (qt)[3] - (buf)[0] * (qt)[0] - (buf)[1] * (qt)[1] -
             (buf)[2] * (qt)[2];
  };
  mat[4 + 3] = 0.0f;
  v = mat + 8;
  {
    (buf)[0] =
        (q)[3] * (v)[0] + (q)[0] * (v)[3] + (q)[1] * (v)[2] - (q)[2] * (v)[1];
    (buf)[1] =
        (q)[3] * (v)[1] + (q)[1] * (v)[3] + (q)[2] * (v)[0] - (q)[0] * (v)[2];
    (buf)[2] =
        (q)[3] * (v)[2] + (q)[2] * (v)[3] + (q)[0] * (v)[1] - (q)[1] * (v)[0];
    (buf)[3] =
        (q)[3] * (v)[3] - (q)[0] * (v)[0] - (q)[1] * (v)[1] - (q)[2] * (v)[2];
  };
  {
    (v)[0] = (buf)[3] * (qt)[0] + (buf)[0] * (qt)[3] + (buf)[1] * (qt)[2] -
             (buf)[2] * (qt)[1];
    (v)[1] = (buf)[3] * (qt)[1] + (buf)[1] * (qt)[3] + (buf)[2] * (qt)[0] -
             (buf)[0] * (qt)[2];
    (v)[2] = (buf)[3] * (qt)[2] + (buf)[2] * (qt)[3] + (buf)[0] * (qt)[1] -
             (buf)[1] * (qt)[0];
    (v)[3] = (buf)[3] * (qt)[3] - (buf)[0] * (qt)[0] - (buf)[1] * (qt)[1] -
             (buf)[2] * (qt)[2];
  };
  mat[8 + 3] = 0.0f;
}


x86 assembly (clang, -O0):
<Mat4_RotateRByQuaternion>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mat4_RotateRByQuaternion>:
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm9
movss  0x8(%rsi),%xmm10
movss  0xc(%rsi),%xmm11
movss  0xc(%rdi),%xmm4
movaps %xmm8,%xmm2
mulss  %xmm4,%xmm2
movss  (%rdi),%xmm7
movss  0x4(%rdi),%xmm12
movaps %xmm11,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rdi),%xmm2
movaps %xmm9,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movaps %xmm10,%xmm3
mulss  %xmm12,%xmm3
subss  %xmm3,%xmm5
movaps %xmm9,%xmm3
mulss  %xmm4,%xmm3
movaps %xmm11,%xmm1
mulss  %xmm12,%xmm1
addss  %xmm3,%xmm1
movaps %xmm10,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm1,%xmm6
movaps %xmm8,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm6
movaps %xmm10,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm11,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movaps %xmm8,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm0,%xmm3
movaps %xmm9,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm8,%xmm7
mulss  %xmm11,%xmm4
subss  %xmm7,%xmm4
mulss  %xmm9,%xmm12
subss  %xmm12,%xmm4
mulss  %xmm10,%xmm2
subss  %xmm2,%xmm4
movaps %xmm11,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm4,%xmm1
mulss  %xmm8,%xmm1
subss  %xmm1,%xmm0
movaps %xmm6,%xmm1
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm0
movaps %xmm3,%xmm1
mulss  %xmm9,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi)
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm4,%xmm1
mulss  %xmm9,%xmm1
subss  %xmm1,%xmm0
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm8,%xmm3
movss  %xmm8,-0x4(%rsp)
subss  %xmm3,%xmm0
movaps %xmm5,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%rdi)
mulss  %xmm10,%xmm4
subss  %xmm4,%xmm1
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm1
mulss  %xmm8,%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,0x8(%rdi)
movl   $0x0,0xc(%rdi)
movss  0xc(%rsi),%xmm1
movss  0x10(%rdi),%xmm13
movss  0x1c(%rdi),%xmm15
movss  (%rsi),%xmm12
movss  0x4(%rsi),%xmm8
movaps %xmm12,%xmm2
movaps %xmm12,%xmm5
mulss  %xmm15,%xmm5
movaps %xmm1,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm5,%xmm6
movss  0x18(%rdi),%xmm3
movaps %xmm8,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm6,%xmm5
movss  0x8(%rsi),%xmm7
movss  0x14(%rdi),%xmm0
movaps %xmm7,%xmm6
mulss  %xmm0,%xmm6
subss  %xmm6,%xmm5
movaps %xmm15,%xmm6
mulss  %xmm8,%xmm6
movaps %xmm1,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm6,%xmm4
movaps %xmm7,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm4,%xmm6
movaps %xmm1,%xmm4
mulss  %xmm15,%xmm1
mulss  %xmm3,%xmm2
subss  %xmm2,%xmm6
movaps %xmm8,%xmm14
mulss  %xmm13,%xmm14
mulss  %xmm12,%xmm13
movaps %xmm12,%xmm2
mulss  %xmm7,%xmm15
mulss  %xmm3,%xmm4
addss  %xmm15,%xmm4
mulss  %xmm0,%xmm2
addss  %xmm4,%xmm2
subss  %xmm14,%xmm2
subss  %xmm13,%xmm1
mulss  %xmm0,%xmm8
subss  %xmm8,%xmm1
mulss  %xmm3,%xmm7
subss  %xmm7,%xmm1
movaps %xmm11,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm1,%xmm3
movss  -0x4(%rsp),%xmm4
mulss  %xmm4,%xmm3
subss  %xmm3,%xmm0
movaps %xmm6,%xmm3
mulss  %xmm10,%xmm3
subss  %xmm3,%xmm0
movaps %xmm2,%xmm3
mulss  %xmm9,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x10(%rdi)
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm1,%xmm3
mulss  %xmm9,%xmm3
subss  %xmm3,%xmm0
movaps %xmm11,%xmm3
mulss  %xmm2,%xmm3
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm0
movaps %xmm5,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x14(%rdi)
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm3
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm4,%xmm6
addss  %xmm3,%xmm6
movss  %xmm6,0x18(%rdi)
movl   $0x0,0x1c(%rdi)
movss  0xc(%rsi),%xmm1
movss  0x2c(%rdi),%xmm12
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm13
movaps %xmm8,%xmm14
movaps %xmm8,%xmm3
mulss  %xmm12,%xmm3
movss  0x20(%rdi),%xmm0
movss  0x24(%rdi),%xmm15
movaps %xmm1,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm3,%xmm6
movss  0x28(%rdi),%xmm3
movaps %xmm13,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm6,%xmm5
movss  0x8(%rsi),%xmm7
movaps %xmm7,%xmm6
mulss  %xmm15,%xmm6
subss  %xmm6,%xmm5
movaps %xmm12,%xmm6
mulss  %xmm13,%xmm6
movaps %xmm1,%xmm4
mulss  %xmm15,%xmm4
addss  %xmm6,%xmm4
movaps %xmm7,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm4,%xmm6
movaps %xmm1,%xmm4
mulss  %xmm12,%xmm1
mulss  %xmm3,%xmm14
subss  %xmm14,%xmm6
movaps %xmm13,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm8,%xmm0
mulss  %xmm7,%xmm12
mulss  %xmm3,%xmm4
addss  %xmm12,%xmm4
mulss  %xmm15,%xmm8
addss  %xmm4,%xmm8
subss  %xmm2,%xmm8
subss  %xmm0,%xmm1
mulss  %xmm15,%xmm13
subss  %xmm13,%xmm1
mulss  %xmm3,%xmm7
subss  %xmm7,%xmm1
movaps %xmm11,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm1,%xmm2
movss  -0x4(%rsp),%xmm3
mulss  %xmm3,%xmm2
subss  %xmm2,%xmm0
movaps %xmm6,%xmm2
mulss  %xmm10,%xmm2
subss  %xmm2,%xmm0
movaps %xmm8,%xmm2
mulss  %xmm9,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x20(%rdi)
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm9,%xmm2
subss  %xmm2,%xmm0
mulss  %xmm8,%xmm11
mulss  %xmm3,%xmm8
subss  %xmm8,%xmm0
movaps %xmm5,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x24(%rdi)
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm11
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm11
mulss  %xmm3,%xmm6
addss  %xmm11,%xmm6
movss  %xmm6,0x28(%rdi)
movl   $0x0,0x2c(%rdi)
ret

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

LLVM IR (-O2):
define void @Mat4_RotateRByQuaternion(float* nocapture %0, float* nocapture %1) {
%3 = load float, float* %1
%4 = fneg float %3
%5 = getelementptr inbounds float, float* %1, i64 1
%6 = load float, float* %5
%7 = fneg float %6
%8 = getelementptr inbounds float, float* %1, i64 2
%9 = load float, float* %8
%10 = fneg float %9
%11 = getelementptr inbounds float, float* %1, i64 3
%12 = load float, float* %11
%13 = load float, float* %0
%14 = getelementptr inbounds float, float* %0, i64 3
%15 = load float, float* %14
%16 = fmul float %3, %15
%17 = tail call float @llvm.fmuladd.f32(float %12, float %13, float %16)
%18 = getelementptr inbounds float, float* %0, i64 2
%19 = load float, float* %18
%20 = tail call float @llvm.fmuladd.f32(float %6, float %19, float %17)
%21 = getelementptr inbounds float, float* %0, i64 1
%22 = load float, float* %21
%23 = tail call float @llvm.fmuladd.f32(float %10, float %22, float %20)
%24 = fmul float %6, %15
%25 = tail call float @llvm.fmuladd.f32(float %12, float %22, float %24)
%26 = tail call float @llvm.fmuladd.f32(float %9, float %13, float %25)
%27 = tail call float @llvm.fmuladd.f32(float %4, float %19, float %26)
%28 = fmul float %9, %15
%29 = tail call float @llvm.fmuladd.f32(float %12, float %19, float %28)
%30 = tail call float @llvm.fmuladd.f32(float %3, float %22, float %29)
%31 = tail call float @llvm.fmuladd.f32(float %7, float %13, float %30)
%32 = fmul float %13, %4
%33 = tail call float @llvm.fmuladd.f32(float %12, float %15, float %32)
%34 = tail call float @llvm.fmuladd.f32(float %7, float %22, float %33)
%35 = tail call float @llvm.fmuladd.f32(float %10, float %19, float %34)
%36 = fmul float %12, %23
%37 = tail call float @llvm.fmuladd.f32(float %35, float %4, float %36)
%38 = tail call float @llvm.fmuladd.f32(float %27, float %10, float %37)
%39 = tail call float @llvm.fmuladd.f32(float %31, float %6, float %38)
store float %39, float* %0
%40 = fmul float %12, %27
%41 = tail call float @llvm.fmuladd.f32(float %35, float %7, float %40)
%42 = tail call float @llvm.fmuladd.f32(float %31, float %4, float %41)
%43 = tail call float @llvm.fmuladd.f32(float %23, float %9, float %42)
store float %43, float* %21
%44 = fmul float %12, %31
%45 = tail call float @llvm.fmuladd.f32(float %35, float %10, float %44)
%46 = tail call float @llvm.fmuladd.f32(float %23, float %7, float %45)
%47 = tail call float @llvm.fmuladd.f32(float %27, float %3, float %46)
store float %47, float* %18
store float 0.000000e+00, float* %14
%48 = getelementptr inbounds float, float* %0, i64 4
%49 = load float, float* %11
%50 = load float, float* %48
%51 = load float, float* %1
%52 = getelementptr inbounds float, float* %0, i64 7
%53 = load float, float* %52
%54 = fmul float %51, %53
%55 = tail call float @llvm.fmuladd.f32(float %49, float %50, float %54)
%56 = load float, float* %5
%57 = getelementptr inbounds float, float* %0, i64 6
%58 = load float, float* %57
%59 = tail call float @llvm.fmuladd.f32(float %56, float %58, float %55)
%60 = load float, float* %8
%61 = getelementptr inbounds float, float* %0, i64 5
%62 = load float, float* %61
%63 = fneg float %60
%64 = tail call float @llvm.fmuladd.f32(float %63, float %62, float %59)
%65 = fmul float %53, %56
%66 = tail call float @llvm.fmuladd.f32(float %49, float %62, float %65)
%67 = tail call float @llvm.fmuladd.f32(float %60, float %50, float %66)
%68 = fneg float %51
%69 = tail call float @llvm.fmuladd.f32(float %68, float %58, float %67)
%70 = fmul float %53, %60
%71 = tail call float @llvm.fmuladd.f32(float %49, float %58, float %70)
%72 = tail call float @llvm.fmuladd.f32(float %51, float %62, float %71)
%73 = fneg float %56
%74 = tail call float @llvm.fmuladd.f32(float %73, float %50, float %72)
%75 = fmul float %50, %68
%76 = tail call float @llvm.fmuladd.f32(float %49, float %53, float %75)
%77 = tail call float @llvm.fmuladd.f32(float %73, float %62, float %76)
%78 = tail call float @llvm.fmuladd.f32(float %63, float %58, float %77)
%79 = fmul float %12, %64
%80 = tail call float @llvm.fmuladd.f32(float %78, float %4, float %79)
%81 = tail call float @llvm.fmuladd.f32(float %69, float %10, float %80)
%82 = tail call float @llvm.fmuladd.f32(float %74, float %6, float %81)
store float %82, float* %48
%83 = fmul float %12, %69
%84 = tail call float @llvm.fmuladd.f32(float %78, float %7, float %83)
%85 = tail call float @llvm.fmuladd.f32(float %74, float %4, float %84)
%86 = tail call float @llvm.fmuladd.f32(float %64, float %9, float %85)
store float %86, float* %61
%87 = fmul float %12, %74
%88 = tail call float @llvm.fmuladd.f32(float %78, float %10, float %87)
%89 = tail call float @llvm.fmuladd.f32(float %64, float %7, float %88)
%90 = tail call float @llvm.fmuladd.f32(float %69, float %3, float %89)
store float %90, float* %57
store float 0.000000e+00, float* %52
%91 = getelementptr inbounds float, float* %0, i64 8
%92 = load float, float* %11
%93 = load float, float* %91
%94 = load float, float* %1
%95 = getelementptr inbounds float, float* %0, i64 11
%96 = load float, float* %95
%97 = fmul float %94, %96
%98 = tail call float @llvm.fmuladd.f32(float %92, float %93, float %97)
%99 = load float, float* %5
%100 = getelementptr inbounds float, float* %0, i64 10
%101 = load float, float* %100
%102 = tail call float @llvm.fmuladd.f32(float %99, float %101, float %98)
%103 = load float, float* %8
%104 = getelementptr inbounds float, float* %0, i64 9
%105 = load float, float* %104
%106 = fneg float %103
%107 = tail call float @llvm.fmuladd.f32(float %106, float %105, float %102)
%108 = fmul float %96, %99
%109 = tail call float @llvm.fmuladd.f32(float %92, float %105, float %108)
%110 = tail call float @llvm.fmuladd.f32(float %103, float %93, float %109)
%111 = fneg float %94
%112 = tail call float @llvm.fmuladd.f32(float %111, float %101, float %110)
%113 = fmul float %96, %103
%114 = tail call float @llvm.fmuladd.f32(float %92, float %101, float %113)
%115 = tail call float @llvm.fmuladd.f32(float %94, float %105, float %114)
%116 = fneg float %99
%117 = tail call float @llvm.fmuladd.f32(float %116, float %93, float %115)
%118 = fmul float %93, %111
%119 = tail call float @llvm.fmuladd.f32(float %92, float %96, float %118)
%120 = tail call float @llvm.fmuladd.f32(float %116, float %105, float %119)
%121 = tail call float @llvm.fmuladd.f32(float %106, float %101, float %120)
%122 = fmul float %12, %107
%123 = tail call float @llvm.fmuladd.f32(float %121, float %4, float %122)
%124 = tail call float @llvm.fmuladd.f32(float %112, float %10, float %123)
%125 = tail call float @llvm.fmuladd.f32(float %117, float %6, float %124)
store float %125, float* %91
%126 = fmul float %12, %112
%127 = tail call float @llvm.fmuladd.f32(float %121, float %7, float %126)
%128 = tail call float @llvm.fmuladd.f32(float %117, float %4, float %127)
%129 = tail call float @llvm.fmuladd.f32(float %107, float %9, float %128)
store float %129, float* %104
%130 = fmul float %12, %117
%131 = tail call float @llvm.fmuladd.f32(float %121, float %10, float %130)
%132 = tail call float @llvm.fmuladd.f32(float %107, float %7, float %131)
%133 = tail call float @llvm.fmuladd.f32(float %112, float %3, float %132)
store float %133, float* %100
store float 0.000000e+00, float* %95
ret void
}