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] = r_2[0][0];
  r_2[2][2] = r_2[0][0];
  r_2[0][0] += quat[1] * quat[1] - 0.5;
  r_2[1][1] += quat[2] * quat[2] - 0.5;
  r_2[2][2] += quat[3] * quat[3] - 0.5;
  r_2[1][0] = quat[0] * quat[3];
  r_2[0][1] = -r_2[1][0];
  temp = quat[1] * quat[2];
  r_2[1][0] += temp;
  r_2[0][1] += temp;
  r_2[0][2] = quat[0] * quat[2];
  r_2[2][0] = -r_2[0][2];
  temp = quat[1] * quat[3];
  r_2[0][2] += temp;
  r_2[2][0] += temp;
  r_2[2][1] = quat[0] * quat[1];
  r_2[1][2] = -r_2[2][1];
  temp = quat[2] * quat[3];
  r_2[2][1] += temp;
  r_2[1][2] += temp;
  result[0] = 2.0 * (r_2[0][0] * v[0] + r_2[0][1] * v[1] + r_2[0][2] * v[2]);
  result[1] = 2.0 * (r_2[1][0] * v[0] + r_2[1][1] * v[1] + r_2[1][2] * v[2]);
  result[2] = 2.0 * (r_2[2][0] * v[0] + r_2[2][1] * v[1] + r_2[2][2] * v[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)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeb1(%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  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe79(%rip),%xmm0
subsd  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe41(%rip),%xmm0
subsd  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x2c(%rbp),%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
cvtss2sd %xmm0,%xmm1
movsd  0xcb4(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
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
cvtss2sd %xmm0,%xmm1
movsd  0xc5f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
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
cvtss2sd %xmm0,%xmm1
movsd  0xc09(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
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),%xmm7
movaps %xmm10,%xmm1
mulss  %xmm10,%xmm1
movaps %xmm7,%xmm3
mulss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
movsd  0xed6(%rip),%xmm8
addsd  %xmm8,%xmm3
cvtss2sd %xmm1,%xmm5
addsd  %xmm5,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  0x8(%rdi),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm8,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm9
movss  0xc(%rdi),%xmm4
movaps %xmm10,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm7,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm10,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm7,%xmm10
mulss  %xmm4,%xmm7
mulss  %xmm4,%xmm1
mulss  %xmm4,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm8,%xmm4
addsd  %xmm5,%xmm4
xorps  %xmm5,%xmm5
cvtsd2ss %xmm4,%xmm5
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
subss  %xmm2,%xmm0
movaps %xmm6,%xmm2
addss  %xmm7,%xmm2
subss  %xmm6,%xmm7
movaps %xmm10,%xmm6
addss  %xmm1,%xmm6
subss  %xmm10,%xmm1
mulss  0x4(%rsi),%xmm0
mulss  (%rsi),%xmm3
mulss  0x8(%rsi),%xmm2
addss  %xmm0,%xmm3
addss  %xmm3,%xmm2
addss  %xmm2,%xmm2
movss  %xmm2,(%rdx)
mulss  0x4(%rsi),%xmm9
mulss  (%rsi),%xmm4
addss  %xmm9,%xmm4
mulss  0x8(%rsi),%xmm1
addss  %xmm4,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,0x4(%rdx)
mulss  0x4(%rsi),%xmm6
mulss  (%rsi),%xmm7
mulss  0x8(%rsi),%xmm5
addss  %xmm6,%xmm7
addss  %xmm7,%xmm5
addss  %xmm5,%xmm5
movss  %xmm5,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 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%19 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 0
%20 = load float, float* %19
%21 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%22 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %20, float* %22
%23 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%24 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%25 = load float, float* %24
%26 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%27 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
store float %25, float* %27
%28 = load float*, float** %4
%29 = getelementptr inbounds float, float* %28, i64 1
%30 = load float, float* %29
%31 = load float*, float** %4
%32 = getelementptr inbounds float, float* %31, i64 1
%33 = load float, float* %32
%34 = fmul float %30, %33
%35 = fpext float %34 to double
%36 = fsub double %35, 5.000000e-01
%37 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%38 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%39 = load float, float* %38
%40 = fpext float %39 to double
%41 = fadd double %40, %36
%42 = fptrunc double %41 to float
store float %42, float* %38
%43 = load float*, float** %4
%44 = getelementptr inbounds float, float* %43, i64 2
%45 = load float, float* %44
%46 = load float*, float** %4
%47 = getelementptr inbounds float, float* %46, i64 2
%48 = load float, float* %47
%49 = fmul float %45, %48
%50 = fpext float %49 to double
%51 = fsub double %50, 5.000000e-01
%52 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%53 = getelementptr inbounds [3 x float], [3 x float]* %52, i64 0, i64 1
%54 = load float, float* %53
%55 = fpext float %54 to double
%56 = fadd double %55, %51
%57 = fptrunc double %56 to float
store float %57, float* %53
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i64 3
%60 = load float, float* %59
%61 = load float*, float** %4
%62 = getelementptr inbounds float, float* %61, i64 3
%63 = load float, float* %62
%64 = fmul float %60, %63
%65 = fpext float %64 to double
%66 = fsub double %65, 5.000000e-01
%67 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%68 = getelementptr inbounds [3 x float], [3 x float]* %67, i64 0, i64 2
%69 = load float, float* %68
%70 = fpext float %69 to double
%71 = fadd double %70, %66
%72 = fptrunc double %71 to float
store float %72, float* %68
%73 = load float*, float** %4
%74 = getelementptr inbounds float, float* %73, i64 0
%75 = load float, float* %74
%76 = load float*, float** %4
%77 = getelementptr inbounds float, float* %76, i64 3
%78 = load float, float* %77
%79 = fmul float %75, %78
%80 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%81 = getelementptr inbounds [3 x float], [3 x float]* %80, i64 0, i64 0
store float %79, float* %81
%82 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%83 = getelementptr inbounds [3 x float], [3 x float]* %82, i64 0, i64 0
%84 = load float, float* %83
%85 = fneg float %84
%86 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%87 = getelementptr inbounds [3 x float], [3 x float]* %86, i64 0, i64 1
store float %85, float* %87
%88 = load float*, float** %4
%89 = getelementptr inbounds float, float* %88, i64 1
%90 = load float, float* %89
%91 = load float*, float** %4
%92 = getelementptr inbounds float, float* %91, i64 2
%93 = load float, float* %92
%94 = fmul float %90, %93
store float %94, float* %7
%95 = load float, float* %7
%96 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%97 = getelementptr inbounds [3 x float], [3 x float]* %96, i64 0, i64 0
%98 = load float, float* %97
%99 = fadd float %98, %95
store float %99, float* %97
%100 = load float, float* %7
%101 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%102 = getelementptr inbounds [3 x float], [3 x float]* %101, i64 0, i64 1
%103 = load float, float* %102
%104 = fadd float %103, %100
store float %104, float* %102
%105 = load float*, float** %4
%106 = getelementptr inbounds float, float* %105, i64 0
%107 = load float, float* %106
%108 = load float*, float** %4
%109 = getelementptr inbounds float, float* %108, i64 2
%110 = load float, float* %109
%111 = fmul float %107, %110
%112 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%113 = getelementptr inbounds [3 x float], [3 x float]* %112, i64 0, i64 2
store float %111, float* %113
%114 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%115 = getelementptr inbounds [3 x float], [3 x float]* %114, i64 0, i64 2
%116 = load float, float* %115
%117 = fneg float %116
%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
store float %117, float* %119
%120 = load float*, float** %4
%121 = getelementptr inbounds float, float* %120, i64 1
%122 = load float, float* %121
%123 = load float*, float** %4
%124 = getelementptr inbounds float, float* %123, i64 3
%125 = load float, float* %124
%126 = fmul float %122, %125
store float %126, float* %7
%127 = load float, float* %7
%128 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%129 = getelementptr inbounds [3 x float], [3 x float]* %128, i64 0, i64 2
%130 = load float, float* %129
%131 = fadd float %130, %127
store float %131, float* %129
%132 = load float, float* %7
%133 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%134 = getelementptr inbounds [3 x float], [3 x float]* %133, i64 0, i64 0
%135 = load float, float* %134
%136 = fadd float %135, %132
store float %136, float* %134
%137 = load float*, float** %4
%138 = getelementptr inbounds float, float* %137, i64 0
%139 = load float, float* %138
%140 = load float*, float** %4
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %141
%143 = fmul float %139, %142
%144 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%145 = getelementptr inbounds [3 x float], [3 x float]* %144, i64 0, i64 1
store float %143, float* %145
%146 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%147 = getelementptr inbounds [3 x float], [3 x float]* %146, i64 0, i64 1
%148 = load float, float* %147
%149 = fneg float %148
%150 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%151 = getelementptr inbounds [3 x float], [3 x float]* %150, i64 0, i64 2
store float %149, float* %151
%152 = load float*, float** %4
%153 = getelementptr inbounds float, float* %152, i64 2
%154 = load float, float* %153
%155 = load float*, float** %4
%156 = getelementptr inbounds float, float* %155, i64 3
%157 = load float, float* %156
%158 = fmul float %154, %157
store float %158, float* %7
%159 = load float, float* %7
%160 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%161 = getelementptr inbounds [3 x float], [3 x float]* %160, i64 0, i64 1
%162 = load float, float* %161
%163 = fadd float %162, %159
store float %163, float* %161
%164 = load float, float* %7
%165 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%166 = getelementptr inbounds [3 x float], [3 x float]* %165, i64 0, i64 2
%167 = load float, float* %166
%168 = fadd float %167, %164
store float %168, float* %166
%169 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%170 = getelementptr inbounds [3 x float], [3 x float]* %169, i64 0, i64 0
%171 = load float, float* %170
%172 = load float*, float** %5
%173 = getelementptr inbounds float, float* %172, i64 0
%174 = load float, float* %173
%175 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%176 = getelementptr inbounds [3 x float], [3 x float]* %175, i64 0, i64 1
%177 = load float, float* %176
%178 = load float*, float** %5
%179 = getelementptr inbounds float, float* %178, i64 1
%180 = load float, float* %179
%181 = fmul float %177, %180
%182 = call float @llvm.fmuladd.f32(float %171, float %174, float %181)
%183 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 0
%184 = getelementptr inbounds [3 x float], [3 x float]* %183, i64 0, i64 2
%185 = load float, float* %184
%186 = load float*, float** %5
%187 = getelementptr inbounds float, float* %186, i64 2
%188 = load float, float* %187
%189 = call float @llvm.fmuladd.f32(float %185, float %188, float %182)
%190 = fpext float %189 to double
%191 = fmul double 2.000000e+00, %190
%192 = fptrunc double %191 to float
%193 = load float*, float** %6
%194 = getelementptr inbounds float, float* %193, i64 0
store float %192, float* %194
%195 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%196 = getelementptr inbounds [3 x float], [3 x float]* %195, i64 0, i64 0
%197 = load float, float* %196
%198 = load float*, float** %5
%199 = getelementptr inbounds float, float* %198, i64 0
%200 = load float, float* %199
%201 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%202 = getelementptr inbounds [3 x float], [3 x float]* %201, i64 0, i64 1
%203 = load float, float* %202
%204 = load float*, float** %5
%205 = getelementptr inbounds float, float* %204, i64 1
%206 = load float, float* %205
%207 = fmul float %203, %206
%208 = call float @llvm.fmuladd.f32(float %197, float %200, float %207)
%209 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 1
%210 = getelementptr inbounds [3 x float], [3 x float]* %209, i64 0, i64 2
%211 = load float, float* %210
%212 = load float*, float** %5
%213 = getelementptr inbounds float, float* %212, i64 2
%214 = load float, float* %213
%215 = call float @llvm.fmuladd.f32(float %211, float %214, float %208)
%216 = fpext float %215 to double
%217 = fmul double 2.000000e+00, %216
%218 = fptrunc double %217 to float
%219 = load float*, float** %6
%220 = getelementptr inbounds float, float* %219, i64 1
store float %218, float* %220
%221 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%222 = getelementptr inbounds [3 x float], [3 x float]* %221, i64 0, i64 0
%223 = load float, float* %222
%224 = load float*, float** %5
%225 = getelementptr inbounds float, float* %224, i64 0
%226 = load float, float* %225
%227 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%228 = getelementptr inbounds [3 x float], [3 x float]* %227, i64 0, i64 1
%229 = load float, float* %228
%230 = load float*, float** %5
%231 = getelementptr inbounds float, float* %230, i64 1
%232 = load float, float* %231
%233 = fmul float %229, %232
%234 = call float @llvm.fmuladd.f32(float %223, float %226, float %233)
%235 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %8, i64 0, i64 2
%236 = getelementptr inbounds [3 x float], [3 x float]* %235, i64 0, i64 2
%237 = load float, float* %236
%238 = load float*, float** %5
%239 = getelementptr inbounds float, float* %238, i64 2
%240 = load float, float* %239
%241 = call float @llvm.fmuladd.f32(float %237, float %240, float %234)
%242 = fpext float %241 to double
%243 = fmul double 2.000000e+00, %242
%244 = fptrunc double %243 to float
%245 = load float*, float** %6
%246 = getelementptr inbounds float, float* %245, i64 2
store float %244, float* %246
%247 = load float*, float** %6
ret float* %247
}

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