float *QuaternionRotateVector(const float quat[4], const float v[3],
                              float result[3]) {
  float temp, r_2[3][3];
  r_2[0][0] = quat[0] * quat[0];
  r_2[1][1] = quat[2] * quat[2];
  temp = quat[1] * quat[1];
  r_2[2][2] = 0.5 - temp - r_2[1][1];
  r_2[1][1] += r_2[0][0] - 0.5;
  r_2[0][0] += temp - 0.5;
  r_2[0][1] = quat[1] * quat[2];
  r_2[1][0] = r_2[0][1];
  temp = quat[0] * quat[3];
  r_2[1][0] += temp;
  r_2[0][1] -= temp;
  r_2[0][2] = quat[1] * quat[3];
  r_2[2][0] = r_2[0][2];
  temp = quat[0] * quat[2];
  r_2[2][0] -= temp;
  r_2[0][2] += temp;
  r_2[1][2] = quat[2] * quat[3];
  r_2[2][1] = r_2[1][2];
  temp = quat[0] * quat[1];
  r_2[2][1] += temp;
  r_2[1][2] -= temp;
  result[0] = r_2[0][0] * v[0] + r_2[0][1] * v[1] + r_2[0][2] * v[2];
  result[0] += result[0];
  result[1] = r_2[1][0] * v[0] + r_2[1][1] * v[1] + r_2[1][2] * v[2];
  result[1] += result[1];
  result[2] = r_2[2][0] * v[0] + r_2[2][1] * v[1] + r_2[2][2] * v[2];
  result[2] += result[2];
  return result;
}


x86 assembly (clang, -O0):
<QuaternionRotateVector>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe9c(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe71(%rip),%xmm0
subsd  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe46(%rip),%xmm0
subsd  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x28(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<QuaternionRotateVector>:
mov    %rdx,%rax
movss  (%rdi),%xmm10
movss  0x4(%rdi),%xmm9
movaps %xmm10,%xmm8
mulss  %xmm10,%xmm8
movss  0x8(%rdi),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm0,%xmm3
mulss  %xmm9,%xmm3
movaps %xmm9,%xmm6
movaps %xmm9,%xmm7
mulss  %xmm9,%xmm7
cvtss2sd %xmm7,%xmm7
movsd  0xebc(%rip),%xmm4
subsd  %xmm7,%xmm4
cvtss2sd %xmm1,%xmm2
subsd  %xmm2,%xmm4
cvtsd2ss %xmm4,%xmm11
xorps  %xmm4,%xmm4
cvtss2sd %xmm8,%xmm4
movsd  0xea2(%rip),%xmm8
addsd  %xmm8,%xmm7
addsd  %xmm4,%xmm7
addsd  %xmm8,%xmm4
addsd  %xmm2,%xmm4
xorps  %xmm8,%xmm8
cvtsd2ss %xmm4,%xmm8
movaps %xmm10,%xmm4
movaps %xmm10,%xmm1
mulss  %xmm9,%xmm10
cvtsd2ss %xmm7,%xmm7
movss  0xc(%rdi),%xmm2
mulss  %xmm2,%xmm4
movaps %xmm3,%xmm5
addss  %xmm4,%xmm5
subss  %xmm4,%xmm3
mulss  %xmm2,%xmm6
mulss  %xmm0,%xmm1
movaps %xmm6,%xmm4
subss  %xmm1,%xmm4
addss  %xmm6,%xmm1
mulss  %xmm2,%xmm0
movaps %xmm10,%xmm2
addss  %xmm0,%xmm2
subss  %xmm10,%xmm0
mulss  0x4(%rsi),%xmm3
mulss  (%rsi),%xmm7
mulss  0x8(%rsi),%xmm1
addss  %xmm3,%xmm7
addss  %xmm7,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%rdx)
mulss  0x4(%rsi),%xmm8
mulss  (%rsi),%xmm5
addss  %xmm8,%xmm5
mulss  0x8(%rsi),%xmm0
addss  %xmm5,%xmm0
addss  %xmm0,%xmm0
movss  %xmm0,0x4(%rdx)
mulss  0x4(%rsi),%xmm2
mulss  (%rsi),%xmm4
mulss  0x8(%rsi),%xmm11
addss  %xmm2,%xmm4
addss  %xmm4,%xmm11
addss  %xmm11,%xmm11
movss  %xmm11,0x8(%rdx)
ret

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

LLVM IR (-O2):
define float* @QuaternionRotateVector(float* nocapture %0, float* nocapture %1, float* returned writeonly %2) {
%4 = load float, float* %0
%5 = fmul float %4, %4
%6 = getelementptr inbounds float, float* %0, i64 2
%7 = load float, float* %6
%8 = fmul float %7, %7
%9 = getelementptr inbounds float, float* %0, i64 1
%10 = load float, float* %9
%11 = fmul float %10, %10
%12 = fpext float %11 to double
%13 = fsub double 5.000000e-01, %12
%14 = fpext float %8 to double
%15 = fsub double %13, %14
%16 = fptrunc double %15 to float
%17 = fpext float %5 to double
%18 = fadd double %17, -5.000000e-01
%19 = fadd double %18, %14
%20 = fptrunc double %19 to float
%21 = fadd double %12, -5.000000e-01
%22 = fadd double %21, %17
%23 = fptrunc double %22 to float
%24 = fmul float %7, %10
%25 = getelementptr inbounds float, float* %0, i64 3
%26 = load float, float* %25
%27 = fmul float %4, %26
%28 = fadd float %24, %27
%29 = fsub float %24, %27
%30 = fmul float %10, %26
%31 = fmul float %4, %7
%32 = fsub float %30, %31
%33 = fadd float %31, %30
%34 = fmul float %7, %26
%35 = fmul float %4, %10
%36 = fadd float %35, %34
%37 = fsub float %34, %35
%38 = load float, float* %1
%39 = getelementptr inbounds float, float* %1, i64 1
%40 = load float, float* %39
%41 = fmul float %29, %40
%42 = tail call float @llvm.fmuladd.f32(float %23, float %38, float %41)
%43 = getelementptr inbounds float, float* %1, i64 2
%44 = load float, float* %43
%45 = tail call float @llvm.fmuladd.f32(float %33, float %44, float %42)
%46 = fadd float %45, %45
store float %46, float* %2
%47 = load float, float* %1
%48 = load float, float* %39
%49 = fmul float %48, %20
%50 = tail call float @llvm.fmuladd.f32(float %28, float %47, float %49)
%51 = load float, float* %43
%52 = tail call float @llvm.fmuladd.f32(float %37, float %51, float %50)
%53 = getelementptr inbounds float, float* %2, i64 1
%54 = fadd float %52, %52
store float %54, float* %53
%55 = load float, float* %1
%56 = load float, float* %39
%57 = fmul float %36, %56
%58 = tail call float @llvm.fmuladd.f32(float %32, float %55, float %57)
%59 = load float, float* %43
%60 = tail call float @llvm.fmuladd.f32(float %16, float %59, float %58)
%61 = getelementptr inbounds float, float* %2, i64 2
%62 = fadd float %60, %60
store float %62, float* %61
ret float* %2
}