#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*/ fabs(float);
float getSqrt(float *, int);
float sqrtf(int /*<<< orphan*/);
void Quaternion_FromRotationMatrix(float *R, float *Q) {
  float fq0sq;
  float recip4q0;
  float fmag;
  fq0sq = 0.25f * (1.0f + R[0] + R[4] + R[8]);
  Q[0] = (float)sqrtf(fabs(fq0sq));
  if (Q[0] > 0.01F) {
    recip4q0 = 0.25F / Q[0];
    Q[1] = recip4q0 * (R[5] - R[7]);
    Q[2] = recip4q0 * (R[6] - R[2]);
    Q[3] = recip4q0 * (R[1] - R[3]);
  } else {
    Q[1] = sqrtf(fabs(0.5f * (1.0f + R[0]) - fq0sq));
    Q[2] = sqrtf(fabs(0.5f * (1.0f + R[4]) - fq0sq));
    Q[3] = sqrtf(fabs(0.5f * (1.0f + R[8]) - fq0sq));
    if ((R[1] + R[3]) < 0.0f) {
      Q[2] = -Q[2];
      if ((R[5] + R[7]) > 0.0f) {
        Q[3] = -Q[3];
      }
    } else if ((R[1] + R[3]) > 0.0f) {
      if ((R[5] + R[7]) < 0.0f) {
        Q[3] = -Q[3];
      }
    }
    if ((R[5] - R[7]) < 0.0f) {
      Q[1] = -Q[1];
      Q[2] = -Q[2];
      Q[3] = -Q[3];
    }
  }
  fmag = getSqrt(Q, 4);
  Q[0] /= fmag;
  Q[1] /= fmag;
  Q[2] /= fmag;
  Q[3] /= fmag;
}


x86 assembly (clang, -O0):
<Quaternion_FromRotationMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0xebc(%rip),%xmm1
addss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
addss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
addss  0x20(%rax),%xmm1
movss  0xe9a(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  0xe64(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    122b <Quaternion_FromRotationMatrix+0xfb>
mov    -0x10(%rbp),%rax
movss  0xe53(%rip),%xmm0
divss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
subss  0x1c(%rax),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
subss  0xc(%rax),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1466 <Quaternion_FromRotationMatrix+0x336>
mov    -0x8(%rbp),%rax
movss  0xdd1(%rip),%xmm0
addss  (%rax),%xmm0
movss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xdb7(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0xd8a(%rip),%xmm0
addss  0x10(%rax),%xmm0
movss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xd6f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0xd42(%rip),%xmm0
addss  0x20(%rax),%xmm0
movss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xd27(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
addss  0xc(%rax),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    1381 <Quaternion_FromRotationMatrix+0x251>
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    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x1c(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    137c <Quaternion_FromRotationMatrix+0x24c>
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)
jmp    13e6 <Quaternion_FromRotationMatrix+0x2b6>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0xc(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    13e1 <Quaternion_FromRotationMatrix+0x2b1>
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
addss  0x1c(%rax),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    13dc <Quaternion_FromRotationMatrix+0x2ac>
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)
jmp    13e1 <Quaternion_FromRotationMatrix+0x2b1>
jmp    13e6 <Quaternion_FromRotationMatrix+0x2b6>
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
subss  0x1c(%rax),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    1461 <Quaternion_FromRotationMatrix+0x331>
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)
jmp    1466 <Quaternion_FromRotationMatrix+0x336>
mov    -0x10(%rbp),%rdi
mov    $0x4,%esi
call   1050 <getSqrt@plt>
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Quaternion_FromRotationMatrix>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
movss  (%rdi),%xmm0
addss  0xeba(%rip),%xmm0
addss  0x10(%rdi),%xmm0
addss  0x20(%rdi),%xmm0
mulss  0xeac(%rip),%xmm0
movss  %xmm0,0x4(%rsp)
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
movss  %xmm0,(%r14)
ucomiss 0xe92(%rip),%xmm0
jbe    11bf <Quaternion_FromRotationMatrix+0x8f>
movss  0xe84(%rip),%xmm1
divss  %xmm0,%xmm1
movss  0x14(%rbx),%xmm0
subss  0x1c(%rbx),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x18(%rbx),%xmm0
subss  0x8(%rbx),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x8(%r14)
movss  0x4(%rbx),%xmm0
subss  0xc(%rbx),%xmm0
mulss  %xmm1,%xmm0
jmp    12dc <Quaternion_FromRotationMatrix+0x1ac>
movss  (%rbx),%xmm0
addss  0xe35(%rip),%xmm0
mulss  0xe39(%rip),%xmm0
subss  0x4(%rsp),%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
movss  %xmm0,0x4(%r14)
movss  0x10(%rbx),%xmm0
addss  0xe08(%rip),%xmm0
mulss  0xe0c(%rip),%xmm0
subss  0x4(%rsp),%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
movss  %xmm0,0x8(%r14)
movss  0xde0(%rip),%xmm0
addss  0x20(%rbx),%xmm0
mulss  0xddf(%rip),%xmm0
subss  0x4(%rsp),%xmm0
call   1030 <fabs@plt>
mov    %eax,%edi
call   1040 <sqrtf@plt>
movss  %xmm0,0xc(%r14)
movss  0x4(%rbx),%xmm2
addss  0xc(%rbx),%xmm2
xorps  %xmm1,%xmm1
ucomiss %xmm2,%xmm1
jbe    127b <Quaternion_FromRotationMatrix+0x14b>
movss  0x8(%r14),%xmm2
xorps  0xdac(%rip),%xmm2
movss  %xmm2,0x8(%r14)
movss  0x14(%rbx),%xmm2
addss  0x1c(%rbx),%xmm2
ucomiss %xmm1,%xmm2
ja     1292 <Quaternion_FromRotationMatrix+0x162>
jmp    12a2 <Quaternion_FromRotationMatrix+0x172>
ucomiss %xmm1,%xmm2
jbe    12a2 <Quaternion_FromRotationMatrix+0x172>
movss  0x14(%rbx),%xmm1
addss  0x1c(%rbx),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm1,%xmm2
jbe    12a2 <Quaternion_FromRotationMatrix+0x172>
movaps 0xd77(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
movss  0x14(%rbx),%xmm1
subss  0x1c(%rbx),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm1,%xmm2
jbe    12e2 <Quaternion_FromRotationMatrix+0x1b2>
movaps 0xd55(%rip),%xmm1
movss  0x4(%r14),%xmm2
movss  0x8(%r14),%xmm3
xorps  %xmm1,%xmm2
movss  %xmm2,0x4(%r14)
xorps  %xmm1,%xmm3
movss  %xmm3,0x8(%r14)
xorps  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
mov    %r14,%rdi
mov    $0x4,%esi
call   1050 <getSqrt@plt>
movups (%r14),%xmm1
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm1
movups %xmm1,(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @Quaternion_FromRotationMatrix(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca float
%6 = alloca float
%7 = alloca float
store float* %0, float** %3
store float* %1, float** %4
%8 = load float*, float** %3
%9 = getelementptr inbounds float, float* %8, i64 0
%10 = load float, float* %9
%11 = fadd float 1.000000e+00, %10
%12 = load float*, float** %3
%13 = getelementptr inbounds float, float* %12, i64 4
%14 = load float, float* %13
%15 = fadd float %11, %14
%16 = load float*, float** %3
%17 = getelementptr inbounds float, float* %16, i64 8
%18 = load float, float* %17
%19 = fadd float %15, %18
%20 = fmul float 2.500000e-01, %19
store float %20, float* %5
%21 = load float, float* %5
%22 = call i32 @fabs(float %21)
%23 = call float @sqrtf(i32 %22)
%24 = load float*, float** %4
%25 = getelementptr inbounds float, float* %24, i64 0
store float %23, float* %25
%26 = load float*, float** %4
%27 = getelementptr inbounds float, float* %26, i64 0
%28 = load float, float* %27
%29 = fcmp ogt float %28, 0x3F847AE140000000
br i1 %29, label %30, label %68
30: ; preds = %2
%31 = load float*, float** %4
%32 = getelementptr inbounds float, float* %31, i64 0
%33 = load float, float* %32
%34 = fdiv float 2.500000e-01, %33
store float %34, float* %6
%35 = load float, float* %6
%36 = load float*, float** %3
%37 = getelementptr inbounds float, float* %36, i64 5
%38 = load float, float* %37
%39 = load float*, float** %3
%40 = getelementptr inbounds float, float* %39, i64 7
%41 = load float, float* %40
%42 = fsub float %38, %41
%43 = fmul float %35, %42
%44 = load float*, float** %4
%45 = getelementptr inbounds float, float* %44, i64 1
store float %43, float* %45
%46 = load float, float* %6
%47 = load float*, float** %3
%48 = getelementptr inbounds float, float* %47, i64 6
%49 = load float, float* %48
%50 = load float*, float** %3
%51 = getelementptr inbounds float, float* %50, i64 2
%52 = load float, float* %51
%53 = fsub float %49, %52
%54 = fmul float %46, %53
%55 = load float*, float** %4
%56 = getelementptr inbounds float, float* %55, i64 2
store float %54, float* %56
%57 = load float, float* %6
%58 = load float*, float** %3
%59 = getelementptr inbounds float, float* %58, i64 1
%60 = load float, float* %59
%61 = load float*, float** %3
%62 = getelementptr inbounds float, float* %61, i64 3
%63 = load float, float* %62
%64 = fsub float %60, %63
%65 = fmul float %57, %64
%66 = load float*, float** %4
%67 = getelementptr inbounds float, float* %66, i64 3
store float %65, float* %67
br label %189
68: ; preds = %2
%69 = load float*, float** %3
%70 = getelementptr inbounds float, float* %69, i64 0
%71 = load float, float* %70
%72 = fadd float 1.000000e+00, %71
%73 = load float, float* %5
%74 = fneg float %73
%75 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %72, float %74)
%76 = call i32 @fabs(float %75)
%77 = call float @sqrtf(i32 %76)
%78 = load float*, float** %4
%79 = getelementptr inbounds float, float* %78, i64 1
store float %77, float* %79
%80 = load float*, float** %3
%81 = getelementptr inbounds float, float* %80, i64 4
%82 = load float, float* %81
%83 = fadd float 1.000000e+00, %82
%84 = load float, float* %5
%85 = fneg float %84
%86 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %83, float %85)
%87 = call i32 @fabs(float %86)
%88 = call float @sqrtf(i32 %87)
%89 = load float*, float** %4
%90 = getelementptr inbounds float, float* %89, i64 2
store float %88, float* %90
%91 = load float*, float** %3
%92 = getelementptr inbounds float, float* %91, i64 8
%93 = load float, float* %92
%94 = fadd float 1.000000e+00, %93
%95 = load float, float* %5
%96 = fneg float %95
%97 = call float @llvm.fmuladd.f32(float 5.000000e-01, float %94, float %96)
%98 = call i32 @fabs(float %97)
%99 = call float @sqrtf(i32 %98)
%100 = load float*, float** %4
%101 = getelementptr inbounds float, float* %100, i64 3
store float %99, float* %101
%102 = load float*, float** %3
%103 = getelementptr inbounds float, float* %102, i64 1
%104 = load float, float* %103
%105 = load float*, float** %3
%106 = getelementptr inbounds float, float* %105, i64 3
%107 = load float, float* %106
%108 = fadd float %104, %107
%109 = fcmp olt float %108, 0.000000e+00
br i1 %109, label %110, label %133
110: ; preds = %68
%111 = load float*, float** %4
%112 = getelementptr inbounds float, float* %111, i64 2
%113 = load float, float* %112
%114 = fneg float %113
%115 = load float*, float** %4
%116 = getelementptr inbounds float, float* %115, i64 2
store float %114, float* %116
%117 = load float*, float** %3
%118 = getelementptr inbounds float, float* %117, i64 5
%119 = load float, float* %118
%120 = load float*, float** %3
%121 = getelementptr inbounds float, float* %120, i64 7
%122 = load float, float* %121
%123 = fadd float %119, %122
%124 = fcmp ogt float %123, 0.000000e+00
br i1 %124, label %125, label %132
125: ; preds = %110
%126 = load float*, float** %4
%127 = getelementptr inbounds float, float* %126, i64 3
%128 = load float, float* %127
%129 = fneg float %128
%130 = load float*, float** %4
%131 = getelementptr inbounds float, float* %130, i64 3
store float %129, float* %131
br label %132
132: ; preds = %125, %110
br label %160
133: ; preds = %68
%134 = load float*, float** %3
%135 = getelementptr inbounds float, float* %134, i64 1
%136 = load float, float* %135
%137 = load float*, float** %3
%138 = getelementptr inbounds float, float* %137, i64 3
%139 = load float, float* %138
%140 = fadd float %136, %139
%141 = fcmp ogt float %140, 0.000000e+00
br i1 %141, label %142, label %159
142: ; preds = %133
%143 = load float*, float** %3
%144 = getelementptr inbounds float, float* %143, i64 5
%145 = load float, float* %144
%146 = load float*, float** %3
%147 = getelementptr inbounds float, float* %146, i64 7
%148 = load float, float* %147
%149 = fadd float %145, %148
%150 = fcmp olt float %149, 0.000000e+00
br i1 %150, label %151, label %158
151: ; preds = %142
%152 = load float*, float** %4
%153 = getelementptr inbounds float, float* %152, i64 3
%154 = load float, float* %153
%155 = fneg float %154
%156 = load float*, float** %4
%157 = getelementptr inbounds float, float* %156, i64 3
store float %155, float* %157
br label %158
158: ; preds = %151, %142
br label %159
159: ; preds = %158, %133
br label %160
160: ; preds = %159, %132
%161 = load float*, float** %3
%162 = getelementptr inbounds float, float* %161, i64 5
%163 = load float, float* %162
%164 = load float*, float** %3
%165 = getelementptr inbounds float, float* %164, i64 7
%166 = load float, float* %165
%167 = fsub float %163, %166
%168 = fcmp olt float %167, 0.000000e+00
br i1 %168, label %169, label %188
169: ; preds = %160
%170 = load float*, float** %4
%171 = getelementptr inbounds float, float* %170, i64 1
%172 = load float, float* %171
%173 = fneg float %172
%174 = load float*, float** %4
%175 = getelementptr inbounds float, float* %174, i64 1
store float %173, float* %175
%176 = load float*, float** %4
%177 = getelementptr inbounds float, float* %176, i64 2
%178 = load float, float* %177
%179 = fneg float %178
%180 = load float*, float** %4
%181 = getelementptr inbounds float, float* %180, i64 2
store float %179, float* %181
%182 = load float*, float** %4
%183 = getelementptr inbounds float, float* %182, i64 3
%184 = load float, float* %183
%185 = fneg float %184
%186 = load float*, float** %4
%187 = getelementptr inbounds float, float* %186, i64 3
store float %185, float* %187
br label %188
188: ; preds = %169, %160
br label %189
189: ; preds = %188, %30
%190 = load float*, float** %4
%191 = call float @getSqrt(float* %190, i32 4)
store float %191, float* %7
%192 = load float, float* %7
%193 = load float*, float** %4
%194 = getelementptr inbounds float, float* %193, i64 0
%195 = load float, float* %194
%196 = fdiv float %195, %192
store float %196, float* %194
%197 = load float, float* %7
%198 = load float*, float** %4
%199 = getelementptr inbounds float, float* %198, i64 1
%200 = load float, float* %199
%201 = fdiv float %200, %197
store float %201, float* %199
%202 = load float, float* %7
%203 = load float*, float** %4
%204 = getelementptr inbounds float, float* %203, i64 2
%205 = load float, float* %204
%206 = fdiv float %205, %202
store float %206, float* %204
%207 = load float, float* %7
%208 = load float*, float** %4
%209 = getelementptr inbounds float, float* %208, i64 3
%210 = load float, float* %209
%211 = fdiv float %210, %207
store float %211, float* %209
ret void
}

LLVM IR (-O2):
define void @Quaternion_FromRotationMatrix(float* nocapture %0, float* %1) {
%3 = load float, float* %0
%4 = fadd float %3, 1.000000e+00
%5 = getelementptr inbounds float, float* %0, i64 4
%6 = load float, float* %5
%7 = fadd float %4, %6
%8 = getelementptr inbounds float, float* %0, i64 8
%9 = load float, float* %8
%10 = fadd float %7, %9
%11 = fmul float %10, 2.500000e-01
%12 = tail call i32 @fabs(float %11)
%13 = tail call float @sqrtf(i32 %12)
store float %13, float* %1
%14 = fcmp ogt float %13, 0x3F847AE140000000
br i1 %14, label %15, label %38
15: ; preds = %2
%16 = fdiv float 2.500000e-01, %13
%17 = getelementptr inbounds float, float* %0, i64 5
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %0, i64 7
%20 = load float, float* %19
%21 = fsub float %18, %20
%22 = fmul float %16, %21
%23 = getelementptr inbounds float, float* %1, i64 1
store float %22, float* %23
%24 = getelementptr inbounds float, float* %0, i64 6
%25 = load float, float* %24
%26 = getelementptr inbounds float, float* %0, i64 2
%27 = load float, float* %26
%28 = fsub float %25, %27
%29 = fmul float %16, %28
%30 = getelementptr inbounds float, float* %1, i64 2
store float %29, float* %30
%31 = getelementptr inbounds float, float* %0, i64 1
%32 = load float, float* %31
%33 = getelementptr inbounds float, float* %0, i64 3
%34 = load float, float* %33
%35 = fsub float %32, %34
%36 = fmul float %16, %35
%37 = getelementptr inbounds float, float* %1, i64 3
store float %36, float* %37
br label %98
38: ; preds = %2
%39 = load float, float* %0
%40 = fadd float %39, 1.000000e+00
%41 = fneg float %11
%42 = tail call float @llvm.fmuladd.f32(float %40, float 5.000000e-01, float %41)
%43 = tail call i32 @fabs(float %42)
%44 = tail call float @sqrtf(i32 %43)
%45 = getelementptr inbounds float, float* %1, i64 1
store float %44, float* %45
%46 = load float, float* %5
%47 = fadd float %46, 1.000000e+00
%48 = tail call float @llvm.fmuladd.f32(float %47, float 5.000000e-01, float %41)
%49 = tail call i32 @fabs(float %48)
%50 = tail call float @sqrtf(i32 %49)
%51 = getelementptr inbounds float, float* %1, i64 2
store float %50, float* %51
%52 = load float, float* %8
%53 = fadd float %52, 1.000000e+00
%54 = tail call float @llvm.fmuladd.f32(float %53, float 5.000000e-01, float %41)
%55 = tail call i32 @fabs(float %54)
%56 = tail call float @sqrtf(i32 %55)
%57 = getelementptr inbounds float, float* %1, i64 3
store float %56, float* %57
%58 = getelementptr inbounds float, float* %0, i64 1
%59 = load float, float* %58
%60 = getelementptr inbounds float, float* %0, i64 3
%61 = load float, float* %60
%62 = fadd float %59, %61
%63 = fcmp olt float %62, 0.000000e+00
br i1 %63, label %64, label %73
64: ; preds = %38
%65 = load float, float* %51
%66 = fneg float %65
store float %66, float* %51
%67 = getelementptr inbounds float, float* %0, i64 5
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %0, i64 7
%70 = load float, float* %69
%71 = fadd float %68, %70
%72 = fcmp ogt float %71, 0.000000e+00
br i1 %72, label %82, label %84
73: ; preds = %38
%74 = fcmp ogt float %62, 0.000000e+00
br i1 %74, label %75, label %84
75: ; preds = %73
%76 = getelementptr inbounds float, float* %0, i64 5
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %0, i64 7
%79 = load float, float* %78
%80 = fadd float %77, %79
%81 = fcmp olt float %80, 0.000000e+00
br i1 %81, label %82, label %84
82: ; preds = %75, %64
%83 = fneg float %56
store float %83, float* %57
br label %84
84: ; preds = %82, %73, %75, %64
%85 = phi float [ %56, %73 ], [ %56, %75 ], [ %56, %64 ], [ %83, %82 ]
%86 = getelementptr inbounds float, float* %0, i64 5
%87 = load float, float* %86
%88 = getelementptr inbounds float, float* %0, i64 7
%89 = load float, float* %88
%90 = fsub float %87, %89
%91 = fcmp olt float %90, 0.000000e+00
br i1 %91, label %92, label %98
92: ; preds = %84
%93 = load float, float* %45
%94 = fneg float %93
store float %94, float* %45
%95 = load float, float* %51
%96 = fneg float %95
store float %96, float* %51
%97 = fneg float %85
store float %97, float* %57
br label %98
98: ; preds = %84, %92, %15
%99 = tail call float @getSqrt(float* %1, i32 4)
%100 = bitcast float* %1 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = insertelement <4 x float> poison, float %99, i64 0
%103 = shufflevector <4 x float> %102, <4 x float> poison, <4 x i32> zeroinitializer
%104 = fdiv <4 x float> %101, %103
%105 = bitcast float* %1 to <4 x float>*
store <4 x float> %104, <4 x float>* %105
ret void
}