#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 pow(int /*<<< orphan*/, int);
int /*<<< orphan*/ sqrt(double const);
float sqrtf(float);
void vbapf_circumcircle(float const x1, float const y1, float const z1,
                        float const x2, float const y2, float const z2,
                        float const x3, float const y3, float const z3,
                        float *xr, float *yr, float *zr, float *l) {
  const double mx1 = (double)x2 - (double)x1, my1 = (double)y2 - (double)y1,
               mz1 = (double)z2 - (double)z1;
  const double mx2 = (double)x3 - (double)x1, my2 = (double)y3 - (double)y1,
               mz2 = (double)z3 - (double)z1;
  const double crx1 = my1 * mz2 - mz1 * my2, cry1 = mz1 * mx2 - mx1 * mz2,
               crz1 = mx1 * my2 - my1 * mx2;
  const double l1 = pow(sqrt(crx1 * crx1 + cry1 * cry1 + crz1 * crz1), 2.) * 2.;
  const double l2 = pow(sqrt(mx1 * mx1 + my1 * my1 + mz1 * mz1), 2.);
  const double l3 = pow(sqrt(mx2 * mx2 + my2 * my2 + mz2 * mz2), 2.);
  const double crx2 = (cry1 * mz1 - crz1 * my1) * l3,
               cry2 = (crz1 * mx1 - crx1 * mz1) * l3,
               crz2 = (crx1 * my1 - cry1 * mx1) * l3;
  const double crx3 = (my2 * crz1 - mz2 * cry1) * l2,
               cry3 = (mz2 * crx1 - mx2 * crz1) * l2,
               crz3 = (mx2 * cry1 - my2 * crx1) * l2;
  *xr = (float)((crx2 + crx3) / l1);
  *yr = (float)((cry2 + cry3) / l1);
  *zr = (float)((crz2 + crz3) / l1);
  *l = sqrtf(*xr * *xr + *yr * *yr + *zr * *zr);
  *xr += x1;
  *yr += y1;
  *zr += z1;
}


x86 assembly (clang, -O0):
<vbapf_circumcircle>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  %xmm4,-0x14(%rbp)
movss  %xmm5,-0x18(%rbp)
movss  %xmm6,-0x1c(%rbp)
movss  %xmm7,-0x20(%rbp)
mov    %rdi,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x4(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  0xce9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mulss  (%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x8(%rbp),%xmm0
mov    -0x30(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0xc(%rbp),%xmm0
mov    -0x38(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vbapf_circumcircle>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r12
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
movss  0x90(%rsp),%xmm8
cvtss2sd %xmm3,%xmm9
movss  %xmm0,0x4(%rsp)
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm9
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movss  %xmm1,0x8(%rsp)
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
subsd  %xmm4,%xmm3
movapd %xmm3,%xmm10
movsd  %xmm3,0x10(%rsp)
cvtss2sd %xmm5,%xmm5
movss  %xmm2,0xc(%rsp)
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
subsd  %xmm3,%xmm5
movsd  %xmm5,0x18(%rsp)
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
subsd  %xmm4,%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm8,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,0x30(%rsp)
movapd %xmm2,%xmm0
movapd %xmm2,%xmm3
movsd  %xmm2,0x28(%rsp)
mulsd  %xmm5,%xmm0
movapd %xmm10,%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm6
movsd  %xmm2,0x50(%rsp)
movapd %xmm4,%xmm0
movsd  %xmm9,0x20(%rsp)
mulsd  %xmm9,%xmm0
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x58(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm3,%xmm9
subsd  %xmm0,%xmm9
movsd  %xmm9,0x48(%rsp)
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm9,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x10(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x28(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    %eax,%edi
mov    $0x2,%esi
call   1040 <pow@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x50(%rsp),%xmm3
movapd %xmm3,%xmm0
movsd  0x10(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x48(%rsp),%xmm6
mulsd  %xmm6,%xmm2
movapd %xmm2,%xmm5
movsd  0x58(%rsp),%xmm7
movapd %xmm7,%xmm2
movsd  0x18(%rsp),%xmm4
mulsd  %xmm4,%xmm2
subsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm4
movapd %xmm4,%xmm8
movapd %xmm3,%xmm11
movapd %xmm6,%xmm3
movsd  0x20(%rsp),%xmm4
mulsd  %xmm4,%xmm3
subsd  %xmm8,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
movapd %xmm7,%xmm9
movsd  0x30(%rsp),%xmm7
mulsd  %xmm7,%xmm1
movsd  0x28(%rsp),%xmm8
movapd %xmm8,%xmm4
mulsd  %xmm6,%xmm4
subsd  %xmm1,%xmm4
movsd  0x40(%rsp),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
movsd  0x38(%rsp),%xmm10
mulsd  %xmm10,%xmm6
movapd %xmm7,%xmm1
mulsd  %xmm11,%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm8,%xmm11
movapd %xmm9,%xmm3
mulsd  %xmm10,%xmm3
subsd  %xmm11,%xmm3
mulsd  %xmm5,%xmm3
movsd  0x60(%rsp),%xmm5
divsd  %xmm5,%xmm4
xorps  %xmm1,%xmm1
cvtsd2ss %xmm4,%xmm1
addsd  %xmm0,%xmm3
divsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,(%rbx)
divsd  %xmm5,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
movss  %xmm2,(%r15)
movss  %xmm0,(%r14)
movss  (%rbx),%xmm1
movss  (%r15),%xmm2
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     143e <vbapf_circumcircle+0x30e>
sqrtss %xmm0,%xmm0
jmp    1443 <vbapf_circumcircle+0x313>
call   1030 <sqrtf@plt>
movss  %xmm0,(%r12)
movss  0x4(%rsp),%xmm0
addss  (%rbx),%xmm0
movss  %xmm0,(%rbx)
movss  0x8(%rsp),%xmm0
addss  (%r15),%xmm0
movss  %xmm0,(%r15)
movss  0xc(%rsp),%xmm0
addss  (%r14),%xmm0
movss  %xmm0,(%r14)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @vbapf_circumcircle(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float* nocapture %9, float* nocapture %10, float* nocapture %11, float* nocapture writeonly %12) {
%14 = fpext float %3 to double
%15 = fpext float %0 to double
%16 = fsub double %14, %15
%17 = fpext float %4 to double
%18 = fpext float %1 to double
%19 = fsub double %17, %18
%20 = fpext float %5 to double
%21 = fpext float %2 to double
%22 = fsub double %20, %21
%23 = fpext float %6 to double
%24 = fsub double %23, %15
%25 = fpext float %7 to double
%26 = fsub double %25, %18
%27 = fpext float %8 to double
%28 = fsub double %27, %21
%29 = fneg double %22
%30 = fmul double %26, %29
%31 = tail call double @llvm.fmuladd.f64(double %19, double %28, double %30)
%32 = fneg double %16
%33 = fmul double %28, %32
%34 = tail call double @llvm.fmuladd.f64(double %22, double %24, double %33)
%35 = fneg double %19
%36 = fmul double %24, %35
%37 = tail call double @llvm.fmuladd.f64(double %16, double %26, double %36)
%38 = fmul double %34, %34
%39 = tail call double @llvm.fmuladd.f64(double %31, double %31, double %38)
%40 = tail call double @llvm.fmuladd.f64(double %37, double %37, double %39)
%41 = tail call i32 @sqrt(double %40)
%42 = tail call i32 @pow(i32 %41, i32 2)
%43 = sitofp i32 %42 to double
%44 = fmul double %43, 2.000000e+00
%45 = fmul double %19, %19
%46 = tail call double @llvm.fmuladd.f64(double %16, double %16, double %45)
%47 = tail call double @llvm.fmuladd.f64(double %22, double %22, double %46)
%48 = tail call i32 @sqrt(double %47)
%49 = tail call i32 @pow(i32 %48, i32 2)
%50 = sitofp i32 %49 to double
%51 = fmul double %26, %26
%52 = tail call double @llvm.fmuladd.f64(double %24, double %24, double %51)
%53 = tail call double @llvm.fmuladd.f64(double %28, double %28, double %52)
%54 = tail call i32 @sqrt(double %53)
%55 = tail call i32 @pow(i32 %54, i32 2)
%56 = sitofp i32 %55 to double
%57 = fneg double %37
%58 = fmul double %19, %57
%59 = tail call double @llvm.fmuladd.f64(double %34, double %22, double %58)
%60 = fmul double %59, %56
%61 = fneg double %31
%62 = fmul double %22, %61
%63 = tail call double @llvm.fmuladd.f64(double %37, double %16, double %62)
%64 = fmul double %63, %56
%65 = fneg double %34
%66 = fmul double %16, %65
%67 = tail call double @llvm.fmuladd.f64(double %31, double %19, double %66)
%68 = fmul double %67, %56
%69 = fneg double %28
%70 = fmul double %34, %69
%71 = tail call double @llvm.fmuladd.f64(double %26, double %37, double %70)
%72 = fmul double %71, %50
%73 = fneg double %24
%74 = fmul double %37, %73
%75 = tail call double @llvm.fmuladd.f64(double %28, double %31, double %74)
%76 = fmul double %75, %50
%77 = fneg double %26
%78 = fmul double %31, %77
%79 = tail call double @llvm.fmuladd.f64(double %24, double %34, double %78)
%80 = fmul double %79, %50
%81 = fadd double %72, %60
%82 = fdiv double %81, %44
%83 = fptrunc double %82 to float
store float %83, float* %9
%84 = fadd double %76, %64
%85 = fdiv double %84, %44
%86 = fptrunc double %85 to float
store float %86, float* %10
%87 = fadd double %80, %68
%88 = fdiv double %87, %44
%89 = fptrunc double %88 to float
store float %89, float* %11
%90 = load float, float* %9
%91 = load float, float* %10
%92 = fmul float %91, %91
%93 = tail call float @llvm.fmuladd.f32(float %90, float %90, float %92)
%94 = tail call float @llvm.fmuladd.f32(float %89, float %89, float %93)
%95 = tail call float @sqrtf(float %94)
store float %95, float* %12
%96 = load float, float* %9
%97 = fadd float %96, %0
store float %97, float* %9
%98 = load float, float* %10
%99 = fadd float %98, %1
store float %99, float* %10
%100 = load float, float* %11
%101 = fadd float %100, %2
store float %101, float* %11
ret void
}