#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 */
typedef int uint8_t;

/* Variables and functions */
int sqrtf(float);
void R2Quaternion(float R[3][3], float q[4]) {
  float m[4], mag;
  uint8_t index, i;
  m[0] = 1 + R[0][0] + R[1][1] + R[2][2];
  m[1] = 1 + R[0][0] - R[1][1] - R[2][2];
  m[2] = 1 - R[0][0] + R[1][1] - R[2][2];
  m[3] = 1 - R[0][0] - R[1][1] + R[2][2];
  index = 0;
  mag = m[0];
  for (i = 1; i < 4; i++) {
    if (m[i] > mag) {
      mag = m[i];
      index = i;
    }
  }
  mag = 2 * sqrtf(mag);
  if (index == 0) {
    q[0] = mag / 4;
    q[1] = (R[1][2] - R[2][1]) / mag;
    q[2] = (R[2][0] - R[0][2]) / mag;
    q[3] = (R[0][1] - R[1][0]) / mag;
  } else if (index == 1) {
    q[1] = mag / 4;
    q[0] = (R[1][2] - R[2][1]) / mag;
    q[2] = (R[0][1] + R[1][0]) / mag;
    q[3] = (R[0][2] + R[2][0]) / mag;
  } else if (index == 2) {
    q[2] = mag / 4;
    q[0] = (R[2][0] - R[0][2]) / mag;
    q[1] = (R[0][1] + R[1][0]) / mag;
    q[3] = (R[1][2] + R[2][1]) / mag;
  } else {
    q[3] = mag / 4;
    q[0] = (R[0][1] - R[1][0]) / mag;
    q[1] = (R[0][2] + R[2][0]) / mag;
    q[2] = (R[1][2] + R[2][1]) / mag;
  }
  if (q[0] < 0) {
    q[0] = -q[0];
    q[1] = -q[1];
    q[2] = -q[2];
    q[3] = -q[3];
  }
}


x86 assembly (clang, -O0):
<R2Quaternion>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0xed4(%rip),%xmm0
addss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0xead(%rip),%xmm0
addss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x20(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xe86(%rip),%xmm0
subss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x20(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0xe5f(%rip),%xmm0
subss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
movl   $0x0,-0x28(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    121a <R2Quaternion+0x10a>
movslq -0x2c(%rbp),%rax
movss  -0x20(%rbp,%rax,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    1207 <R2Quaternion+0xf7>
movslq -0x2c(%rbp),%rax
movss  -0x20(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    120c <R2Quaternion+0xfc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d4 <R2Quaternion+0xc4>
movss  -0x24(%rbp),%xmm0
call   1030 <sqrtf@plt>
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x24(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    12b8 <R2Quaternion+0x1a8>
movss  -0x24(%rbp),%xmm0
movss  0xdbd(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x1c(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0xc(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    144b <R2Quaternion+0x33b>
cmpl   $0x1,-0x28(%rbp)
jne    1340 <R2Quaternion+0x230>
movss  -0x24(%rbp),%xmm0
movss  0xd35(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x1c(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x18(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1446 <R2Quaternion+0x336>
cmpl   $0x2,-0x28(%rbp)
jne    13c8 <R2Quaternion+0x2b8>
movss  -0x24(%rbp),%xmm0
movss  0xcad(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x1c(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1441 <R2Quaternion+0x331>
movss  -0x24(%rbp),%xmm0
movss  0xc2f(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0xc(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x18(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x1c(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1446 <R2Quaternion+0x336>
jmp    144b <R2Quaternion+0x33b>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
ucomiss (%rax),%xmm0
jbe    14d5 <R2Quaternion+0x3c5>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<R2Quaternion>:
push   %rbp
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
movss  (%rdi),%xmm2
movss  0x10(%rdi),%xmm3
movss  0xed5(%rip),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm4
addss  %xmm3,%xmm4
movss  0x20(%rdi),%xmm5
addss  %xmm5,%xmm4
subss  %xmm3,%xmm1
subss  %xmm5,%xmm1
subss  %xmm2,%xmm0
movaps %xmm0,%xmm2
addss  %xmm3,%xmm2
subss  %xmm5,%xmm2
subss  %xmm3,%xmm0
xor    %eax,%eax
ucomiss %xmm4,%xmm1
seta   %al
addss  %xmm5,%xmm0
maxss  %xmm4,%xmm1
ucomiss %xmm1,%xmm2
mov    $0x2,%ecx
cmovbe %eax,%ecx
maxss  %xmm1,%xmm2
ucomiss %xmm2,%xmm0
maxss  %xmm2,%xmm0
mov    $0x3,%ebp
cmovbe %ecx,%ebp
call   1030 <sqrtf@plt>
add    %eax,%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
cmp    $0x2,%ebp
je     11f7 <R2Quaternion+0xe7>
cmp    $0x1,%ebp
je     123c <R2Quaternion+0x12c>
test   %ebp,%ebp
jne    128d <R2Quaternion+0x17d>
movss  0xe4d(%rip),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r14)
movss  0x14(%rbx),%xmm1
subss  0x1c(%rbx),%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x18(%rbx),%xmm2
subss  0x8(%rbx),%xmm2
divss  %xmm3,%xmm2
movss  %xmm2,0x8(%r14)
movss  0x4(%rbx),%xmm5
subss  0xc(%rbx),%xmm5
jmp    127f <R2Quaternion+0x16f>
movss  0xe05(%rip),%xmm2
mulss  %xmm3,%xmm2
movss  %xmm2,0x8(%r14)
movss  0x18(%rbx),%xmm0
subss  0x8(%rbx),%xmm0
divss  %xmm3,%xmm0
movss  %xmm0,(%r14)
movss  0x4(%rbx),%xmm1
addss  0xc(%rbx),%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x14(%rbx),%xmm5
addss  0x1c(%rbx),%xmm5
jmp    127f <R2Quaternion+0x16f>
movss  0xdc0(%rip),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x14(%rbx),%xmm0
subss  0x1c(%rbx),%xmm0
divss  %xmm3,%xmm0
movss  %xmm0,(%r14)
movss  0x4(%rbx),%xmm2
addss  0xc(%rbx),%xmm2
divss  %xmm3,%xmm2
movss  %xmm2,0x8(%r14)
movss  0x8(%rbx),%xmm5
addss  0x18(%rbx),%xmm5
divss  %xmm3,%xmm5
mov    $0x3,%eax
movaps %xmm5,%xmm4
jmp    12dc <R2Quaternion+0x1cc>
movss  0xd6f(%rip),%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,0xc(%r14)
movss  0x4(%rbx),%xmm0
subss  0xc(%rbx),%xmm0
divss  %xmm3,%xmm0
movss  %xmm0,(%r14)
movss  0x8(%rbx),%xmm1
addss  0x18(%rbx),%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x14(%rbx),%xmm5
addss  0x1c(%rbx),%xmm5
divss  %xmm3,%xmm5
mov    $0x2,%eax
movaps %xmm5,%xmm2
movss  %xmm5,(%r14,%rax,4)
xorps  %xmm3,%xmm3
ucomiss %xmm0,%xmm3
jbe    130a <R2Quaternion+0x1fa>
movaps 0xd1f(%rip),%xmm3
xorps  %xmm3,%xmm0
xorps  %xmm3,%xmm2
xorps  %xmm3,%xmm4
unpcklps %xmm4,%xmm2
xorps  %xmm3,%xmm1
unpcklps %xmm1,%xmm0
movlhps %xmm2,%xmm0
movups %xmm0,(%r14)
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @R2Quaternion([3 x float]* %0, float* %1) {
%3 = alloca [3 x float]*
%4 = alloca float*
%5 = alloca [4 x float]
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
store [3 x float]* %0, [3 x float]** %3
store float* %1, float** %4
%9 = load [3 x float]*, [3 x float]** %3
%10 = getelementptr inbounds [3 x float], [3 x float]* %9, i64 0
%11 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 0
%12 = load float, float* %11
%13 = fadd float 1.000000e+00, %12
%14 = load [3 x float]*, [3 x float]** %3
%15 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 1
%16 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%17 = load float, float* %16
%18 = fadd float %13, %17
%19 = load [3 x float]*, [3 x float]** %3
%20 = getelementptr inbounds [3 x float], [3 x float]* %19, i64 2
%21 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%22 = load float, float* %21
%23 = fadd float %18, %22
%24 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
store float %23, float* %24
%25 = load [3 x float]*, [3 x float]** %3
%26 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0
%27 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%28 = load float, float* %27
%29 = fadd float 1.000000e+00, %28
%30 = load [3 x float]*, [3 x float]** %3
%31 = getelementptr inbounds [3 x float], [3 x float]* %30, i64 1
%32 = getelementptr inbounds [3 x float], [3 x float]* %31, i64 0, i64 1
%33 = load float, float* %32
%34 = fsub float %29, %33
%35 = load [3 x float]*, [3 x float]** %3
%36 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 2
%37 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%38 = load float, float* %37
%39 = fsub float %34, %38
%40 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
store float %39, float* %40
%41 = load [3 x float]*, [3 x float]** %3
%42 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 0
%43 = getelementptr inbounds [3 x float], [3 x float]* %42, i64 0, i64 0
%44 = load float, float* %43
%45 = fsub float 1.000000e+00, %44
%46 = load [3 x float]*, [3 x float]** %3
%47 = getelementptr inbounds [3 x float], [3 x float]* %46, i64 1
%48 = getelementptr inbounds [3 x float], [3 x float]* %47, i64 0, i64 1
%49 = load float, float* %48
%50 = fadd float %45, %49
%51 = load [3 x float]*, [3 x float]** %3
%52 = getelementptr inbounds [3 x float], [3 x float]* %51, i64 2
%53 = getelementptr inbounds [3 x float], [3 x float]* %52, i64 0, i64 2
%54 = load float, float* %53
%55 = fsub float %50, %54
%56 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
store float %55, float* %56
%57 = load [3 x float]*, [3 x float]** %3
%58 = getelementptr inbounds [3 x float], [3 x float]* %57, i64 0
%59 = getelementptr inbounds [3 x float], [3 x float]* %58, i64 0, i64 0
%60 = load float, float* %59
%61 = fsub float 1.000000e+00, %60
%62 = load [3 x float]*, [3 x float]** %3
%63 = getelementptr inbounds [3 x float], [3 x float]* %62, i64 1
%64 = getelementptr inbounds [3 x float], [3 x float]* %63, i64 0, i64 1
%65 = load float, float* %64
%66 = fsub float %61, %65
%67 = load [3 x float]*, [3 x float]** %3
%68 = getelementptr inbounds [3 x float], [3 x float]* %67, i64 2
%69 = getelementptr inbounds [3 x float], [3 x float]* %68, i64 0, i64 2
%70 = load float, float* %69
%71 = fadd float %66, %70
%72 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
store float %71, float* %72
store i32 0, i32* %7
%73 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%74 = load float, float* %73
store float %74, float* %6
store i32 1, i32* %8
br label %75
75: ; preds = %92, %2
%76 = load i32, i32* %8
%77 = icmp slt i32 %76, 4
br i1 %77, label %78, label %95
78: ; preds = %75
%79 = load i32, i32* %8
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 %80
%82 = load float, float* %81
%83 = load float, float* %6
%84 = fcmp ogt float %82, %83
br i1 %84, label %85, label %91
85: ; preds = %78
%86 = load i32, i32* %8
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 %87
%89 = load float, float* %88
store float %89, float* %6
%90 = load i32, i32* %8
store i32 %90, i32* %7
br label %91
91: ; preds = %85, %78
br label %92
92: ; preds = %91
%93 = load i32, i32* %8
%94 = add nsw i32 %93, 1
store i32 %94, i32* %8
br label %75
95: ; preds = %75
%96 = load float, float* %6
%97 = call i32 @sqrtf(float %96)
%98 = mul nsw i32 2, %97
%99 = sitofp i32 %98 to float
store float %99, float* %6
%100 = load i32, i32* %7
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %146
102: ; preds = %95
%103 = load float, float* %6
%104 = fdiv float %103, 4.000000e+00
%105 = load float*, float** %4
%106 = getelementptr inbounds float, float* %105, i64 0
store float %104, float* %106
%107 = load [3 x float]*, [3 x float]** %3
%108 = getelementptr inbounds [3 x float], [3 x float]* %107, i64 1
%109 = getelementptr inbounds [3 x float], [3 x float]* %108, i64 0, i64 2
%110 = load float, float* %109
%111 = load [3 x float]*, [3 x float]** %3
%112 = getelementptr inbounds [3 x float], [3 x float]* %111, i64 2
%113 = getelementptr inbounds [3 x float], [3 x float]* %112, i64 0, i64 1
%114 = load float, float* %113
%115 = fsub float %110, %114
%116 = load float, float* %6
%117 = fdiv float %115, %116
%118 = load float*, float** %4
%119 = getelementptr inbounds float, float* %118, i64 1
store float %117, float* %119
%120 = load [3 x float]*, [3 x float]** %3
%121 = getelementptr inbounds [3 x float], [3 x float]* %120, i64 2
%122 = getelementptr inbounds [3 x float], [3 x float]* %121, i64 0, i64 0
%123 = load float, float* %122
%124 = load [3 x float]*, [3 x float]** %3
%125 = getelementptr inbounds [3 x float], [3 x float]* %124, i64 0
%126 = getelementptr inbounds [3 x float], [3 x float]* %125, i64 0, i64 2
%127 = load float, float* %126
%128 = fsub float %123, %127
%129 = load float, float* %6
%130 = fdiv float %128, %129
%131 = load float*, float** %4
%132 = getelementptr inbounds float, float* %131, i64 2
store float %130, float* %132
%133 = load [3 x float]*, [3 x float]** %3
%134 = getelementptr inbounds [3 x float], [3 x float]* %133, i64 0
%135 = getelementptr inbounds [3 x float], [3 x float]* %134, i64 0, i64 1
%136 = load float, float* %135
%137 = load [3 x float]*, [3 x float]** %3
%138 = getelementptr inbounds [3 x float], [3 x float]* %137, i64 1
%139 = getelementptr inbounds [3 x float], [3 x float]* %138, i64 0, i64 0
%140 = load float, float* %139
%141 = fsub float %136, %140
%142 = load float, float* %6
%143 = fdiv float %141, %142
%144 = load float*, float** %4
%145 = getelementptr inbounds float, float* %144, i64 3
store float %143, float* %145
br label %286
146: ; preds = %95
%147 = load i32, i32* %7
%148 = icmp eq i32 %147, 1
br i1 %148, label %149, label %193
149: ; preds = %146
%150 = load float, float* %6
%151 = fdiv float %150, 4.000000e+00
%152 = load float*, float** %4
%153 = getelementptr inbounds float, float* %152, i64 1
store float %151, float* %153
%154 = load [3 x float]*, [3 x float]** %3
%155 = getelementptr inbounds [3 x float], [3 x float]* %154, i64 1
%156 = getelementptr inbounds [3 x float], [3 x float]* %155, i64 0, i64 2
%157 = load float, float* %156
%158 = load [3 x float]*, [3 x float]** %3
%159 = getelementptr inbounds [3 x float], [3 x float]* %158, i64 2
%160 = getelementptr inbounds [3 x float], [3 x float]* %159, i64 0, i64 1
%161 = load float, float* %160
%162 = fsub float %157, %161
%163 = load float, float* %6
%164 = fdiv float %162, %163
%165 = load float*, float** %4
%166 = getelementptr inbounds float, float* %165, i64 0
store float %164, float* %166
%167 = load [3 x float]*, [3 x float]** %3
%168 = getelementptr inbounds [3 x float], [3 x float]* %167, i64 0
%169 = getelementptr inbounds [3 x float], [3 x float]* %168, i64 0, i64 1
%170 = load float, float* %169
%171 = load [3 x float]*, [3 x float]** %3
%172 = getelementptr inbounds [3 x float], [3 x float]* %171, i64 1
%173 = getelementptr inbounds [3 x float], [3 x float]* %172, i64 0, i64 0
%174 = load float, float* %173
%175 = fadd float %170, %174
%176 = load float, float* %6
%177 = fdiv float %175, %176
%178 = load float*, float** %4
%179 = getelementptr inbounds float, float* %178, i64 2
store float %177, float* %179
%180 = load [3 x float]*, [3 x float]** %3
%181 = getelementptr inbounds [3 x float], [3 x float]* %180, i64 0
%182 = getelementptr inbounds [3 x float], [3 x float]* %181, i64 0, i64 2
%183 = load float, float* %182
%184 = load [3 x float]*, [3 x float]** %3
%185 = getelementptr inbounds [3 x float], [3 x float]* %184, i64 2
%186 = getelementptr inbounds [3 x float], [3 x float]* %185, i64 0, i64 0
%187 = load float, float* %186
%188 = fadd float %183, %187
%189 = load float, float* %6
%190 = fdiv float %188, %189
%191 = load float*, float** %4
%192 = getelementptr inbounds float, float* %191, i64 3
store float %190, float* %192
br label %285
193: ; preds = %146
%194 = load i32, i32* %7
%195 = icmp eq i32 %194, 2
br i1 %195, label %196, label %240
196: ; preds = %193
%197 = load float, float* %6
%198 = fdiv float %197, 4.000000e+00
%199 = load float*, float** %4
%200 = getelementptr inbounds float, float* %199, i64 2
store float %198, float* %200
%201 = load [3 x float]*, [3 x float]** %3
%202 = getelementptr inbounds [3 x float], [3 x float]* %201, i64 2
%203 = getelementptr inbounds [3 x float], [3 x float]* %202, i64 0, i64 0
%204 = load float, float* %203
%205 = load [3 x float]*, [3 x float]** %3
%206 = getelementptr inbounds [3 x float], [3 x float]* %205, i64 0
%207 = getelementptr inbounds [3 x float], [3 x float]* %206, i64 0, i64 2
%208 = load float, float* %207
%209 = fsub float %204, %208
%210 = load float, float* %6
%211 = fdiv float %209, %210
%212 = load float*, float** %4
%213 = getelementptr inbounds float, float* %212, i64 0
store float %211, float* %213
%214 = load [3 x float]*, [3 x float]** %3
%215 = getelementptr inbounds [3 x float], [3 x float]* %214, i64 0
%216 = getelementptr inbounds [3 x float], [3 x float]* %215, i64 0, i64 1
%217 = load float, float* %216
%218 = load [3 x float]*, [3 x float]** %3
%219 = getelementptr inbounds [3 x float], [3 x float]* %218, i64 1
%220 = getelementptr inbounds [3 x float], [3 x float]* %219, i64 0, i64 0
%221 = load float, float* %220
%222 = fadd float %217, %221
%223 = load float, float* %6
%224 = fdiv float %222, %223
%225 = load float*, float** %4
%226 = getelementptr inbounds float, float* %225, i64 1
store float %224, float* %226
%227 = load [3 x float]*, [3 x float]** %3
%228 = getelementptr inbounds [3 x float], [3 x float]* %227, i64 1
%229 = getelementptr inbounds [3 x float], [3 x float]* %228, i64 0, i64 2
%230 = load float, float* %229
%231 = load [3 x float]*, [3 x float]** %3
%232 = getelementptr inbounds [3 x float], [3 x float]* %231, i64 2
%233 = getelementptr inbounds [3 x float], [3 x float]* %232, i64 0, i64 1
%234 = load float, float* %233
%235 = fadd float %230, %234
%236 = load float, float* %6
%237 = fdiv float %235, %236
%238 = load float*, float** %4
%239 = getelementptr inbounds float, float* %238, i64 3
store float %237, float* %239
br label %284
240: ; preds = %193
%241 = load float, float* %6
%242 = fdiv float %241, 4.000000e+00
%243 = load float*, float** %4
%244 = getelementptr inbounds float, float* %243, i64 3
store float %242, float* %244
%245 = load [3 x float]*, [3 x float]** %3
%246 = getelementptr inbounds [3 x float], [3 x float]* %245, i64 0
%247 = getelementptr inbounds [3 x float], [3 x float]* %246, i64 0, i64 1
%248 = load float, float* %247
%249 = load [3 x float]*, [3 x float]** %3
%250 = getelementptr inbounds [3 x float], [3 x float]* %249, i64 1
%251 = getelementptr inbounds [3 x float], [3 x float]* %250, i64 0, i64 0
%252 = load float, float* %251
%253 = fsub float %248, %252
%254 = load float, float* %6
%255 = fdiv float %253, %254
%256 = load float*, float** %4
%257 = getelementptr inbounds float, float* %256, i64 0
store float %255, float* %257
%258 = load [3 x float]*, [3 x float]** %3
%259 = getelementptr inbounds [3 x float], [3 x float]* %258, i64 0
%260 = getelementptr inbounds [3 x float], [3 x float]* %259, i64 0, i64 2
%261 = load float, float* %260
%262 = load [3 x float]*, [3 x float]** %3
%263 = getelementptr inbounds [3 x float], [3 x float]* %262, i64 2
%264 = getelementptr inbounds [3 x float], [3 x float]* %263, i64 0, i64 0
%265 = load float, float* %264
%266 = fadd float %261, %265
%267 = load float, float* %6
%268 = fdiv float %266, %267
%269 = load float*, float** %4
%270 = getelementptr inbounds float, float* %269, i64 1
store float %268, float* %270
%271 = load [3 x float]*, [3 x float]** %3
%272 = getelementptr inbounds [3 x float], [3 x float]* %271, i64 1
%273 = getelementptr inbounds [3 x float], [3 x float]* %272, i64 0, i64 2
%274 = load float, float* %273
%275 = load [3 x float]*, [3 x float]** %3
%276 = getelementptr inbounds [3 x float], [3 x float]* %275, i64 2
%277 = getelementptr inbounds [3 x float], [3 x float]* %276, i64 0, i64 1
%278 = load float, float* %277
%279 = fadd float %274, %278
%280 = load float, float* %6
%281 = fdiv float %279, %280
%282 = load float*, float** %4
%283 = getelementptr inbounds float, float* %282, i64 2
store float %281, float* %283
br label %284
284: ; preds = %240, %196
br label %285
285: ; preds = %284, %149
br label %286
286: ; preds = %285, %102
%287 = load float*, float** %4
%288 = getelementptr inbounds float, float* %287, i64 0
%289 = load float, float* %288
%290 = fcmp olt float %289, 0.000000e+00
br i1 %290, label %291, label %316
291: ; preds = %286
%292 = load float*, float** %4
%293 = getelementptr inbounds float, float* %292, i64 0
%294 = load float, float* %293
%295 = fneg float %294
%296 = load float*, float** %4
%297 = getelementptr inbounds float, float* %296, i64 0
store float %295, float* %297
%298 = load float*, float** %4
%299 = getelementptr inbounds float, float* %298, i64 1
%300 = load float, float* %299
%301 = fneg float %300
%302 = load float*, float** %4
%303 = getelementptr inbounds float, float* %302, i64 1
store float %301, float* %303
%304 = load float*, float** %4
%305 = getelementptr inbounds float, float* %304, i64 2
%306 = load float, float* %305
%307 = fneg float %306
%308 = load float*, float** %4
%309 = getelementptr inbounds float, float* %308, i64 2
store float %307, float* %309
%310 = load float*, float** %4
%311 = getelementptr inbounds float, float* %310, i64 3
%312 = load float, float* %311
%313 = fneg float %312
%314 = load float*, float** %4
%315 = getelementptr inbounds float, float* %314, i64 3
store float %313, float* %315
br label %316
316: ; preds = %291, %286
ret void
}

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