#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ Quaternion_FromRotationMatrix(float *, float *);
float getSqrt(float *, int);
float sqrtf(float);
void Quaternion_From6AxisData(float *q, float *accel, float *mag) {
  float norma, normx, normy;
  float R[9];
  R[2] = accel[0];
  R[5] = accel[1];
  R[8] = accel[2];
  R[0] = mag[0];
  R[3] = mag[1];
  R[6] = mag[2];
  R[1] = R[5] * R[6] - R[8] * R[3];
  R[4] = R[8] * R[0] - R[2] * R[6];
  R[7] = R[2] * R[3] - R[5] * R[0];
  R[0] = R[4] * R[8] - R[7] * R[5];
  R[3] = R[7] * R[2] - R[1] * R[8];
  R[6] = R[1] * R[5] - R[4] * R[2];
  norma = getSqrt(accel, 3);
  normx = sqrtf(R[0] * R[0] + R[3] * R[3] + R[6] * R[6]);
  normy = sqrtf(R[1] * R[1] + R[4] * R[4] + R[7] * R[7]);
  R[0] /= normx;
  R[3] /= normx;
  R[6] /= normx;
  R[1] /= normy;
  R[4] /= normy;
  R[7] /= normy;
  R[2] /= norma;
  R[5] /= norma;
  R[8] /= norma;
  Quaternion_FromRotationMatrix(R, q);
}


x86 assembly (clang, -O0):
<Quaternion_From6AxisData>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    $0x3,%esi
call   1050 <getSqrt@plt>
movss  %xmm0,-0x1c(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
movss  %xmm0,-0x20(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <sqrtf@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x20(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x20(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <Quaternion_FromRotationMatrix@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Quaternion_From6AxisData>:
push   %rbx
sub    $0xd0,%rsp
mov    %rdi,%rbx
movss  (%rsi),%xmm5
movss  0x4(%rsi),%xmm8
movss  0x8(%rsi),%xmm0
movss  (%rdx),%xmm1
movss  0x4(%rdx),%xmm2
movss  0x8(%rdx),%xmm3
movaps %xmm0,%xmm4
unpcklps %xmm3,%xmm4
mulss  %xmm5,%xmm3
movaps %xmm0,%xmm7
mulss  %xmm1,%xmm7
subss  %xmm3,%xmm7
mulss  %xmm8,%xmm1
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
subss  %xmm1,%xmm6
movaps %xmm6,%xmm1
unpcklps %xmm0,%xmm1
movaps %xmm8,%xmm3
unpcklps %xmm2,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm7,%xmm1
unpcklps %xmm8,%xmm1
movaps %xmm1,0x70(%rsp)
mulps  %xmm1,%xmm4
subps  %xmm3,%xmm4
movaps %xmm4,0x40(%rsp)
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
movaps %xmm0,0x90(%rsp)
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm6,0x30(%rsp)
mulss  %xmm5,%xmm6
subss  %xmm1,%xmm6
movaps %xmm6,0x10(%rsp)
movaps %xmm5,0x80(%rsp)
movaps %xmm5,%xmm1
movaps %xmm7,(%rsp)
mulss  %xmm7,%xmm1
movaps %xmm2,0x50(%rsp)
mulss  %xmm8,%xmm2
subss  %xmm1,%xmm2
movaps %xmm2,0x20(%rsp)
mov    %rsi,%rdi
mov    $0x3,%esi
call   1050 <getSqrt@plt>
movaps %xmm0,0x60(%rsp)
movaps 0x10(%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps 0x40(%rsp),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movaps 0x20(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
jb     1238 <Quaternion_From6AxisData+0x108>
xorps  %xmm5,%xmm5
sqrtss %xmm0,%xmm5
jmp    1243 <Quaternion_From6AxisData+0x113>
call   1040 <sqrtf@plt>
xorps  %xmm2,%xmm2
movaps %xmm0,%xmm5
movaps (%rsp),%xmm0
mulss  %xmm0,%xmm0
movaps 0x50(%rsp),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movaps 0x30(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm2,%xmm0
jb     1270 <Quaternion_From6AxisData+0x140>
sqrtss %xmm0,%xmm0
jmp    127d <Quaternion_From6AxisData+0x14d>
movaps %xmm5,(%rsp)
call   1040 <sqrtf@plt>
movaps (%rsp),%xmm5
movaps 0x10(%rsp),%xmm1
unpcklpd 0x80(%rsp),%xmm1
movaps 0x40(%rsp),%xmm3
shufps $0x24,%xmm1,%xmm3
movaps 0x60(%rsp),%xmm4
movaps %xmm4,%xmm1
unpcklps %xmm5,%xmm1
unpcklps %xmm0,%xmm5
movaps %xmm5,%xmm2
movlhps %xmm1,%xmm2
divps  %xmm2,%xmm3
movaps %xmm3,0xa0(%rsp)
movaps 0x20(%rsp),%xmm2
unpcklps 0x30(%rsp),%xmm2
movaps 0x70(%rsp),%xmm1
movlhps %xmm2,%xmm1
unpcklps %xmm4,%xmm0
movlhps %xmm5,%xmm0
divps  %xmm0,%xmm1
movaps %xmm1,0xb0(%rsp)
movaps 0x90(%rsp),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,0xc0(%rsp)
lea    0xa0(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <Quaternion_FromRotationMatrix@plt>
add    $0xd0,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @Quaternion_From6AxisData(float* %0, float* %1, float* %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca [9 x float]
store float* %0, float** %4
store float* %1, float** %5
store float* %2, float** %6
%11 = load float*, float** %5
%12 = getelementptr inbounds float, float* %11, i64 0
%13 = load float, float* %12
%14 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
store float %13, float* %14
%15 = load float*, float** %5
%16 = getelementptr inbounds float, float* %15, i64 1
%17 = load float, float* %16
%18 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
store float %17, float* %18
%19 = load float*, float** %5
%20 = getelementptr inbounds float, float* %19, i64 2
%21 = load float, float* %20
%22 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
store float %21, float* %22
%23 = load float*, float** %6
%24 = getelementptr inbounds float, float* %23, i64 0
%25 = load float, float* %24
%26 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
store float %25, float* %26
%27 = load float*, float** %6
%28 = getelementptr inbounds float, float* %27, i64 1
%29 = load float, float* %28
%30 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
store float %29, float* %30
%31 = load float*, float** %6
%32 = getelementptr inbounds float, float* %31, i64 2
%33 = load float, float* %32
%34 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
store float %33, float* %34
%35 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
%36 = load float, float* %35
%37 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
%38 = load float, float* %37
%39 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
%40 = load float, float* %39
%41 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
%42 = load float, float* %41
%43 = fmul float %40, %42
%44 = fneg float %43
%45 = call float @llvm.fmuladd.f32(float %36, float %38, float %44)
%46 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
store float %45, float* %46
%47 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
%48 = load float, float* %47
%49 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%50 = load float, float* %49
%51 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
%52 = load float, float* %51
%53 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
%54 = load float, float* %53
%55 = fmul float %52, %54
%56 = fneg float %55
%57 = call float @llvm.fmuladd.f32(float %48, float %50, float %56)
%58 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
store float %57, float* %58
%59 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
%60 = load float, float* %59
%61 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
%62 = load float, float* %61
%63 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
%64 = load float, float* %63
%65 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%66 = load float, float* %65
%67 = fmul float %64, %66
%68 = fneg float %67
%69 = call float @llvm.fmuladd.f32(float %60, float %62, float %68)
%70 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
store float %69, float* %70
%71 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
%72 = load float, float* %71
%73 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
%74 = load float, float* %73
%75 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
%76 = load float, float* %75
%77 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
%78 = load float, float* %77
%79 = fmul float %76, %78
%80 = fneg float %79
%81 = call float @llvm.fmuladd.f32(float %72, float %74, float %80)
%82 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
store float %81, float* %82
%83 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
%84 = load float, float* %83
%85 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
%86 = load float, float* %85
%87 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
%88 = load float, float* %87
%89 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
%90 = load float, float* %89
%91 = fmul float %88, %90
%92 = fneg float %91
%93 = call float @llvm.fmuladd.f32(float %84, float %86, float %92)
%94 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
store float %93, float* %94
%95 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
%96 = load float, float* %95
%97 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
%98 = load float, float* %97
%99 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
%100 = load float, float* %99
%101 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
%102 = load float, float* %101
%103 = fmul float %100, %102
%104 = fneg float %103
%105 = call float @llvm.fmuladd.f32(float %96, float %98, float %104)
%106 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
store float %105, float* %106
%107 = load float*, float** %5
%108 = call float @getSqrt(float* %107, i32 3)
store float %108, float* %7
%109 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%110 = load float, float* %109
%111 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%112 = load float, float* %111
%113 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
%114 = load float, float* %113
%115 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
%116 = load float, float* %115
%117 = fmul float %114, %116
%118 = call float @llvm.fmuladd.f32(float %110, float %112, float %117)
%119 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
%120 = load float, float* %119
%121 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
%122 = load float, float* %121
%123 = call float @llvm.fmuladd.f32(float %120, float %122, float %118)
%124 = call float @sqrtf(float %123)
store float %124, float* %8
%125 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
%126 = load float, float* %125
%127 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
%128 = load float, float* %127
%129 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
%130 = load float, float* %129
%131 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
%132 = load float, float* %131
%133 = fmul float %130, %132
%134 = call float @llvm.fmuladd.f32(float %126, float %128, float %133)
%135 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
%136 = load float, float* %135
%137 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
%138 = load float, float* %137
%139 = call float @llvm.fmuladd.f32(float %136, float %138, float %134)
%140 = call float @sqrtf(float %139)
store float %140, float* %9
%141 = load float, float* %8
%142 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%143 = load float, float* %142
%144 = fdiv float %143, %141
store float %144, float* %142
%145 = load float, float* %8
%146 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 3
%147 = load float, float* %146
%148 = fdiv float %147, %145
store float %148, float* %146
%149 = load float, float* %8
%150 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 6
%151 = load float, float* %150
%152 = fdiv float %151, %149
store float %152, float* %150
%153 = load float, float* %9
%154 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 1
%155 = load float, float* %154
%156 = fdiv float %155, %153
store float %156, float* %154
%157 = load float, float* %9
%158 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 4
%159 = load float, float* %158
%160 = fdiv float %159, %157
store float %160, float* %158
%161 = load float, float* %9
%162 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 7
%163 = load float, float* %162
%164 = fdiv float %163, %161
store float %164, float* %162
%165 = load float, float* %7
%166 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 2
%167 = load float, float* %166
%168 = fdiv float %167, %165
store float %168, float* %166
%169 = load float, float* %7
%170 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 5
%171 = load float, float* %170
%172 = fdiv float %171, %169
store float %172, float* %170
%173 = load float, float* %7
%174 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 8
%175 = load float, float* %174
%176 = fdiv float %175, %173
store float %176, float* %174
%177 = getelementptr inbounds [9 x float], [9 x float]* %10, i64 0, i64 0
%178 = load float*, float** %4
%179 = call i32 @Quaternion_FromRotationMatrix(float* %177, float* %178)
ret void
}

LLVM IR (-O2):
define void @Quaternion_From6AxisData(float* %0, float* %1, float* nocapture %2) {
%4 = alloca [9 x float]
%5 = bitcast [9 x float]* %4 to i8*
%6 = load float, float* %1
%7 = getelementptr inbounds float, float* %1, i64 1
%8 = load float, float* %7
%9 = getelementptr inbounds float, float* %1, i64 2
%10 = load float, float* %9
%11 = getelementptr inbounds [9 x float], [9 x float]* %4, i64 0, i64 8
%12 = load float, float* %2
%13 = getelementptr inbounds [9 x float], [9 x float]* %4, i64 0, i64 0
%14 = getelementptr inbounds float, float* %2, i64 1
%15 = load float, float* %14
%16 = getelementptr inbounds float, float* %2, i64 2
%17 = load float, float* %16
%18 = fneg float %6
%19 = fmul float %17, %18
%20 = tail call float @llvm.fmuladd.f32(float %10, float %12, float %19)
%21 = getelementptr inbounds [9 x float], [9 x float]* %4, i64 0, i64 4
%22 = fneg float %8
%23 = fmul float %12, %22
%24 = tail call float @llvm.fmuladd.f32(float %6, float %15, float %23)
%25 = insertelement <2 x float> poison, float %24, i64 0
%26 = insertelement <2 x float> %25, float %10, i64 1
%27 = fneg <2 x float> %26
%28 = insertelement <2 x float> poison, float %8, i64 0
%29 = insertelement <2 x float> %28, float %15, i64 1
%30 = fmul <2 x float> %29, %27
%31 = insertelement <2 x float> poison, float %20, i64 0
%32 = insertelement <2 x float> %31, float %8, i64 1
%33 = insertelement <2 x float> poison, float %10, i64 0
%34 = insertelement <2 x float> %33, float %17, i64 1
%35 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> %34, <2 x float> %30)
%36 = extractelement <2 x float> %35, i64 1
%37 = fneg float %36
%38 = fmul float %10, %37
%39 = tail call float @llvm.fmuladd.f32(float %24, float %6, float %38)
%40 = fneg float %20
%41 = fmul float %6, %40
%42 = tail call float @llvm.fmuladd.f32(float %36, float %8, float %41)
%43 = tail call float @getSqrt(float* %1, i32 3)
%44 = fmul float %39, %39
%45 = extractelement <2 x float> %35, i64 0
%46 = tail call float @llvm.fmuladd.f32(float %45, float %45, float %44)
%47 = tail call float @llvm.fmuladd.f32(float %42, float %42, float %46)
%48 = tail call float @sqrtf(float %47)
%49 = fmul float %20, %20
%50 = tail call float @llvm.fmuladd.f32(float %36, float %36, float %49)
%51 = tail call float @llvm.fmuladd.f32(float %24, float %24, float %50)
%52 = tail call float @sqrtf(float %51)
%53 = shufflevector <2 x float> %35, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%54 = insertelement <4 x float> %53, float %6, i64 2
%55 = insertelement <4 x float> %54, float %39, i64 3
%56 = insertelement <4 x float> poison, float %48, i64 0
%57 = insertelement <4 x float> %56, float %52, i64 1
%58 = insertelement <4 x float> %57, float %43, i64 2
%59 = insertelement <4 x float> %58, float %48, i64 3
%60 = fdiv <4 x float> %55, %59
%61 = bitcast [9 x float]* %4 to <4 x float>*
store <4 x float> %60, <4 x float>* %61
%62 = insertelement <4 x float> poison, float %20, i64 0
%63 = insertelement <4 x float> %62, float %8, i64 1
%64 = insertelement <4 x float> %63, float %42, i64 2
%65 = insertelement <4 x float> %64, float %24, i64 3
%66 = insertelement <4 x float> poison, float %52, i64 0
%67 = insertelement <4 x float> %66, float %43, i64 1
%68 = insertelement <4 x float> %67, float %48, i64 2
%69 = insertelement <4 x float> %68, float %52, i64 3
%70 = fdiv <4 x float> %65, %69
%71 = bitcast float* %21 to <4 x float>*
store <4 x float> %70, <4 x float>* %71
%72 = fdiv float %10, %43
store float %72, float* %11
%73 = call i32 @Quaternion_FromRotationMatrix(float* %13, float* %0)
ret void
}