#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 */
long double atan2l(long double, long double);
long double sqrtl(long double);
long double angle_betw_0pi(long double *a, long double *b) {
  long double cross_x = a[1] * b[2] - a[2] * b[1];
  long double cross_y = a[2] * b[0] - a[0] * b[2];
  long double cross_z = a[0] * b[1] - a[1] * b[0];
  long double fcross =
      sqrtl(cross_x * cross_x + cross_y * cross_y + cross_z * cross_z);
  long double fdot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
  return atan2l(fcross, fdot);
}


x86 assembly (clang, -O0):
<angle_betw_0pi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rcx
fldt   0x10(%rcx)
mov    -0x10(%rbp),%rax
fldt   0x20(%rax)
fldt   0x20(%rcx)
fldt   0x10(%rax)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
fsubp  %st,%st(1)
fstpt  -0x20(%rbp)
mov    -0x8(%rbp),%rcx
fldt   0x20(%rcx)
mov    -0x10(%rbp),%rax
fldt   (%rax)
fldt   (%rcx)
fldt   0x20(%rax)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
fsubp  %st,%st(1)
fstpt  -0x30(%rbp)
mov    -0x8(%rbp),%rcx
fldt   (%rcx)
mov    -0x10(%rbp),%rax
fldt   0x10(%rax)
fldt   0x10(%rcx)
fldt   (%rax)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
fsubp  %st,%st(1)
fstpt  -0x40(%rbp)
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
fmul   %st,%st(0)
fxch   %st(1)
fmul   %st,%st(0)
faddp  %st,%st(1)
fldt   -0x40(%rbp)
fmul   %st,%st(0)
faddp  %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
call   1030 <sqrtl@plt>
fstpt  -0x50(%rbp)
mov    -0x8(%rbp),%rcx
fldt   (%rcx)
mov    -0x10(%rbp),%rax
fldt   (%rax)
fldt   0x10(%rcx)
fldt   0x10(%rax)
fmulp  %st,%st(1)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldt   0x20(%rcx)
fldt   0x20(%rax)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpt  -0x60(%rbp)
fldt   -0x50(%rbp)
fldt   -0x60(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1040 <atan2l@plt>
fld    %st(0)
fstp   %st(0)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<angle_betw_0pi>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
fldt   0x10(%rdi)
fldt   0x20(%rsi)
fldt   0x20(%rdi)
fldt   0x10(%rsi)
fld    %st(0)
fmul   %st(2),%st
fld    %st(4)
fmul   %st(4),%st
fsubp  %st,%st(1)
fldt   (%rsi)
fldt   (%rdi)
fmul   %st,%st(5)
fxch   %st(4)
fmul   %st(1),%st
fsubp  %st,%st(5)
fmulp  %st,%st(5)
fxch   %st(2)
fmulp  %st,%st(1)
fsubp  %st,%st(3)
fxch   %st(1)
fmul   %st,%st(0)
fxch   %st(1)
fmul   %st,%st(0)
faddp  %st,%st(1)
fxch   %st(1)
fmul   %st,%st(0)
faddp  %st,%st(1)
fstpt  (%rsp)
call   1030 <sqrtl@plt>
fldt   (%rbx)
fldt   (%r14)
fmulp  %st,%st(1)
fldt   0x10(%rbx)
fldt   0x10(%r14)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fldt   0x20(%rbx)
fldt   0x20(%r14)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fxch   %st(1)
fstpt  (%rsp)
fstpt  0x10(%rsp)
call   1040 <atan2l@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define x86_fp80 @angle_betw_0pi(x86_fp80* %0, x86_fp80* %1) {
%3 = alloca x86_fp80*
%4 = alloca x86_fp80*
%5 = alloca x86_fp80
%6 = alloca x86_fp80
%7 = alloca x86_fp80
%8 = alloca x86_fp80
%9 = alloca x86_fp80
store x86_fp80* %0, x86_fp80** %3
store x86_fp80* %1, x86_fp80** %4
%10 = load x86_fp80*, x86_fp80** %3
%11 = getelementptr inbounds x86_fp80, x86_fp80* %10, i64 1
%12 = load x86_fp80, x86_fp80* %11
%13 = load x86_fp80*, x86_fp80** %4
%14 = getelementptr inbounds x86_fp80, x86_fp80* %13, i64 2
%15 = load x86_fp80, x86_fp80* %14
%16 = load x86_fp80*, x86_fp80** %3
%17 = getelementptr inbounds x86_fp80, x86_fp80* %16, i64 2
%18 = load x86_fp80, x86_fp80* %17
%19 = load x86_fp80*, x86_fp80** %4
%20 = getelementptr inbounds x86_fp80, x86_fp80* %19, i64 1
%21 = load x86_fp80, x86_fp80* %20
%22 = fmul x86_fp80 %18, %21
%23 = fneg x86_fp80 %22
%24 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %12, x86_fp80 %15, x86_fp80 %23)
store x86_fp80 %24, x86_fp80* %5
%25 = load x86_fp80*, x86_fp80** %3
%26 = getelementptr inbounds x86_fp80, x86_fp80* %25, i64 2
%27 = load x86_fp80, x86_fp80* %26
%28 = load x86_fp80*, x86_fp80** %4
%29 = getelementptr inbounds x86_fp80, x86_fp80* %28, i64 0
%30 = load x86_fp80, x86_fp80* %29
%31 = load x86_fp80*, x86_fp80** %3
%32 = getelementptr inbounds x86_fp80, x86_fp80* %31, i64 0
%33 = load x86_fp80, x86_fp80* %32
%34 = load x86_fp80*, x86_fp80** %4
%35 = getelementptr inbounds x86_fp80, x86_fp80* %34, i64 2
%36 = load x86_fp80, x86_fp80* %35
%37 = fmul x86_fp80 %33, %36
%38 = fneg x86_fp80 %37
%39 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %27, x86_fp80 %30, x86_fp80 %38)
store x86_fp80 %39, x86_fp80* %6
%40 = load x86_fp80*, x86_fp80** %3
%41 = getelementptr inbounds x86_fp80, x86_fp80* %40, i64 0
%42 = load x86_fp80, x86_fp80* %41
%43 = load x86_fp80*, x86_fp80** %4
%44 = getelementptr inbounds x86_fp80, x86_fp80* %43, i64 1
%45 = load x86_fp80, x86_fp80* %44
%46 = load x86_fp80*, x86_fp80** %3
%47 = getelementptr inbounds x86_fp80, x86_fp80* %46, i64 1
%48 = load x86_fp80, x86_fp80* %47
%49 = load x86_fp80*, x86_fp80** %4
%50 = getelementptr inbounds x86_fp80, x86_fp80* %49, i64 0
%51 = load x86_fp80, x86_fp80* %50
%52 = fmul x86_fp80 %48, %51
%53 = fneg x86_fp80 %52
%54 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %42, x86_fp80 %45, x86_fp80 %53)
store x86_fp80 %54, x86_fp80* %7
%55 = load x86_fp80, x86_fp80* %5
%56 = load x86_fp80, x86_fp80* %5
%57 = load x86_fp80, x86_fp80* %6
%58 = load x86_fp80, x86_fp80* %6
%59 = fmul x86_fp80 %57, %58
%60 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %55, x86_fp80 %56, x86_fp80 %59)
%61 = load x86_fp80, x86_fp80* %7
%62 = load x86_fp80, x86_fp80* %7
%63 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %61, x86_fp80 %62, x86_fp80 %60)
%64 = call x86_fp80 @sqrtl(x86_fp80 %63)
store x86_fp80 %64, x86_fp80* %8
%65 = load x86_fp80*, x86_fp80** %3
%66 = getelementptr inbounds x86_fp80, x86_fp80* %65, i64 0
%67 = load x86_fp80, x86_fp80* %66
%68 = load x86_fp80*, x86_fp80** %4
%69 = getelementptr inbounds x86_fp80, x86_fp80* %68, i64 0
%70 = load x86_fp80, x86_fp80* %69
%71 = load x86_fp80*, x86_fp80** %3
%72 = getelementptr inbounds x86_fp80, x86_fp80* %71, i64 1
%73 = load x86_fp80, x86_fp80* %72
%74 = load x86_fp80*, x86_fp80** %4
%75 = getelementptr inbounds x86_fp80, x86_fp80* %74, i64 1
%76 = load x86_fp80, x86_fp80* %75
%77 = fmul x86_fp80 %73, %76
%78 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %67, x86_fp80 %70, x86_fp80 %77)
%79 = load x86_fp80*, x86_fp80** %3
%80 = getelementptr inbounds x86_fp80, x86_fp80* %79, i64 2
%81 = load x86_fp80, x86_fp80* %80
%82 = load x86_fp80*, x86_fp80** %4
%83 = getelementptr inbounds x86_fp80, x86_fp80* %82, i64 2
%84 = load x86_fp80, x86_fp80* %83
%85 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %81, x86_fp80 %84, x86_fp80 %78)
store x86_fp80 %85, x86_fp80* %9
%86 = load x86_fp80, x86_fp80* %8
%87 = load x86_fp80, x86_fp80* %9
%88 = call x86_fp80 @atan2l(x86_fp80 %86, x86_fp80 %87)
ret x86_fp80 %88
}

LLVM IR (-O2):
define x86_fp80 @angle_betw_0pi(x86_fp80* nocapture %0, x86_fp80* nocapture %1) {
%3 = getelementptr inbounds x86_fp80, x86_fp80* %0, i64 1
%4 = load x86_fp80, x86_fp80* %3
%5 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 2
%6 = load x86_fp80, x86_fp80* %5
%7 = getelementptr inbounds x86_fp80, x86_fp80* %0, i64 2
%8 = load x86_fp80, x86_fp80* %7
%9 = getelementptr inbounds x86_fp80, x86_fp80* %1, i64 1
%10 = load x86_fp80, x86_fp80* %9
%11 = fneg x86_fp80 %8
%12 = fmul x86_fp80 %10, %11
%13 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %4, x86_fp80 %6, x86_fp80 %12)
%14 = load x86_fp80, x86_fp80* %1
%15 = load x86_fp80, x86_fp80* %0
%16 = fneg x86_fp80 %15
%17 = fmul x86_fp80 %6, %16
%18 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %8, x86_fp80 %14, x86_fp80 %17)
%19 = fneg x86_fp80 %4
%20 = fmul x86_fp80 %14, %19
%21 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %15, x86_fp80 %10, x86_fp80 %20)
%22 = fmul x86_fp80 %18, %18
%23 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %13, x86_fp80 %13, x86_fp80 %22)
%24 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %21, x86_fp80 %21, x86_fp80 %23)
%25 = tail call x86_fp80 @sqrtl(x86_fp80 %24)
%26 = load x86_fp80, x86_fp80* %0
%27 = load x86_fp80, x86_fp80* %1
%28 = load x86_fp80, x86_fp80* %3
%29 = load x86_fp80, x86_fp80* %9
%30 = fmul x86_fp80 %28, %29
%31 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %26, x86_fp80 %27, x86_fp80 %30)
%32 = load x86_fp80, x86_fp80* %7
%33 = load x86_fp80, x86_fp80* %5
%34 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %32, x86_fp80 %33, x86_fp80 %31)
%35 = tail call x86_fp80 @atan2l(x86_fp80 %25, x86_fp80 %34)
ret x86_fp80 %35
}