#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 */
float sqrtf(float);
void quaternion_fromMatrix(float out[4], const float matrix[16]) {
  float trace = matrix[0] + matrix[5] + matrix[10];
  if (trace > -1.0f) {
    float w4;
    out[3] = sqrtf(1.0f + trace) / 2.0f;
    w4 = 4.0f * out[3];
    out[0] = (matrix[6] - matrix[9]) / w4;
    out[1] = (matrix[8] - matrix[2]) / w4;
    out[2] = (matrix[1] - matrix[4]) / w4;
  } else {
    if (trace > 0.0f) {
      float s = 2.0f * sqrtf(1.0f + trace);
      out[3] = 0.25f * s;
      out[0] = (matrix[9] - matrix[6]) / s;
      out[1] = (matrix[2] - matrix[8]) / s;
      out[2] = (matrix[4] - matrix[1]) / s;
    } else {
      if (matrix[0] > matrix[5] && matrix[0] > matrix[10]) {
        float s = 2.0f * sqrtf(1.0f + matrix[0] - matrix[5] - matrix[10]);
        out[3] = (matrix[9] - matrix[6]) / s;
        out[0] = 0.25f * s;
        out[1] = (matrix[1] + matrix[4]) / s;
        out[2] = (matrix[2] + matrix[8]) / s;
      } else if (matrix[5] > matrix[10]) {
        float s = 2.0f * sqrtf(1.0f + matrix[5] - matrix[0] - matrix[10]);
        out[3] = (matrix[2] - matrix[8]) / s;
        out[0] = (matrix[1] + matrix[4]) / s;
        out[1] = 0.25f * s;
        out[2] = (matrix[6] + matrix[9]) / s;
      } else {
        float s = 2.0f * sqrtf(1.0f + matrix[10] - matrix[0] - matrix[5]);
        out[3] = (matrix[4] - matrix[1]) / s;
        out[0] = (matrix[2] + matrix[8]) / s;
        out[1] = (matrix[6] + matrix[9]) / s;
        out[2] = 0.25f * s;
      }
    }
  }
}


x86 assembly (clang, -O0):
<quaternion_fromMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x28(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
movss  0xeb4(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    11f6 <quaternion_fromMatrix+0xe6>
movss  0xeaf(%rip),%xmm0
addss  -0x14(%rbp),%xmm0
call   1030 <sqrtf@plt>
movss  0xe99(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  0xe88(%rip),%xmm0
mulss  0xc(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x24(%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x10(%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1513 <quaternion_fromMatrix+0x403>
movss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    12a7 <quaternion_fromMatrix+0x197>
movss  0xdfd(%rip),%xmm0
addss  -0x14(%rbp),%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xde4(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xdcf(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x18(%rax),%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x20(%rax),%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    150e <quaternion_fromMatrix+0x3fe>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x14(%rax),%xmm0
jbe    1388 <quaternion_fromMatrix+0x278>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x28(%rax),%xmm0
jbe    1388 <quaternion_fromMatrix+0x278>
mov    -0x10(%rbp),%rax
movss  0xd2d(%rip),%xmm0
addss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x28(%rax),%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xd03(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x18(%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  0xcce(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x10(%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x20(%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1509 <quaternion_fromMatrix+0x3f9>
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x28(%rax),%xmm0
jbe    1454 <quaternion_fromMatrix+0x344>
mov    -0x10(%rbp),%rax
movss  0xc61(%rip),%xmm0
addss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x28(%rax),%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xc37(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x20(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x10(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  0xbe3(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x24(%rax),%xmm0
divss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1504 <quaternion_fromMatrix+0x3f4>
mov    -0x10(%rbp),%rax
movss  0xbac(%rip),%xmm0
addss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x14(%rax),%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xb82(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
divss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x20(%rax),%xmm0
divss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
addss  0x24(%rax),%xmm0
divss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  0xb0e(%rip),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1509 <quaternion_fromMatrix+0x3f9>
jmp    150e <quaternion_fromMatrix+0x3fe>
jmp    1513 <quaternion_fromMatrix+0x403>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quaternion_fromMatrix>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
movss  (%rsi),%xmm1
movss  0x14(%rsi),%xmm0
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  0x28(%rsi),%xmm2
addss  %xmm2,%xmm3
ucomiss 0xec6(%rip),%xmm3
jbe    1155 <quaternion_fromMatrix+0x45>
addss  0xec0(%rip),%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jb     117a <quaternion_fromMatrix+0x6a>
xorps  %xmm1,%xmm1
sqrtss %xmm3,%xmm1
jmp    1185 <quaternion_fromMatrix+0x75>
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm3
jbe    11d5 <quaternion_fromMatrix+0xc5>
addss  0xe9f(%rip),%xmm3
ucomiss %xmm4,%xmm3
jb     1235 <quaternion_fromMatrix+0x125>
xorps  %xmm1,%xmm1
sqrtss %xmm3,%xmm1
jmp    1240 <quaternion_fromMatrix+0x130>
movaps %xmm3,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
mulss  0xe7f(%rip),%xmm1
movss  %xmm1,0xc(%r14)
mulss  0xe75(%rip),%xmm1
movss  0x18(%rbx),%xmm0
subss  0x24(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0x20(%rbx),%xmm0
subss  0x8(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x4(%rbx),%xmm0
subss  0x10(%rbx),%xmm0
divss  %xmm1,%xmm0
jmp    13b7 <quaternion_fromMatrix+0x2a7>
ucomiss %xmm0,%xmm1
jbe    1204 <quaternion_fromMatrix+0xf4>
ucomiss %xmm2,%xmm1
jbe    1204 <quaternion_fromMatrix+0xf4>
addss  0xe1d(%rip),%xmm1
subss  %xmm0,%xmm1
subss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jb     12b8 <quaternion_fromMatrix+0x1a8>
sqrtss %xmm1,%xmm1
jmp    12c3 <quaternion_fromMatrix+0x1b3>
ucomiss %xmm2,%xmm0
jbe    1290 <quaternion_fromMatrix+0x180>
addss  0xdef(%rip),%xmm0
subss  %xmm1,%xmm0
subss  %xmm2,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1313 <quaternion_fromMatrix+0x203>
xorps  %xmm1,%xmm1
sqrtss %xmm0,%xmm1
jmp    131b <quaternion_fromMatrix+0x20b>
movaps %xmm3,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
addss  %xmm1,%xmm1
movss  0xdbc(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
movss  0x24(%rbx),%xmm0
subss  0x18(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0x8(%rbx),%xmm0
subss  0x20(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x10(%rbx),%xmm0
subss  0x4(%rbx),%xmm0
divss  %xmm1,%xmm0
jmp    13b7 <quaternion_fromMatrix+0x2a7>
addss  0xd6c(%rip),%xmm2
subss  %xmm1,%xmm2
subss  %xmm0,%xmm2
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
jb     1368 <quaternion_fromMatrix+0x258>
xorps  %xmm0,%xmm0
sqrtss %xmm2,%xmm0
jmp    1370 <quaternion_fromMatrix+0x260>
movaps %xmm1,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
addss  %xmm1,%xmm1
movss  0x24(%rbx),%xmm0
subss  0x18(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
movss  0xd25(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0x4(%rbx),%xmm0
addss  0x10(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x8(%rbx),%xmm0
addss  0x20(%rbx),%xmm0
divss  %xmm1,%xmm0
jmp    13b7 <quaternion_fromMatrix+0x2a7>
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
addss  %xmm1,%xmm1
movss  0x8(%rbx),%xmm0
subss  0x20(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
movss  0x4(%rbx),%xmm0
addss  0x10(%rbx),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0xcba(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x18(%rbx),%xmm0
addss  0x24(%rbx),%xmm0
divss  %xmm1,%xmm0
jmp    13b7 <quaternion_fromMatrix+0x2a7>
movaps %xmm2,%xmm0
call   1030 <sqrtf@plt>
addss  %xmm0,%xmm0
movss  0x10(%rbx),%xmm1
subss  0x4(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%r14)
movss  0x8(%rbx),%xmm1
addss  0x20(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x18(%rbx),%xmm1
addss  0x24(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
mulss  0xc51(%rip),%xmm0
movss  %xmm0,0x8(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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