#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 eucl_angle_direction(long double *a, long double *b,
                                 long double *c) {
  long double Ap[2];
  long double Cp[2];
  Ap[0] = a[0] - b[0];
  Ap[1] = a[1] - b[1];
  Cp[0] = c[0] - b[0];
  Cp[1] = c[1] - b[1];
  long double DAp = atan2l(Ap[1], Ap[0]);
  long double DCp = atan2l(Cp[1], Cp[0]);
  return DAp - DCp;
}


x86 assembly (clang, -O0):
<eucl_angle_direction>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
fldt   (%rax)
mov    -0x10(%rbp),%rax
fldt   (%rax)
fsubrp %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0x8(%rbp),%rax
fldt   0x10(%rax)
mov    -0x10(%rbp),%rax
fldt   0x10(%rax)
fsubrp %st,%st(1)
fstpt  -0x30(%rbp)
mov    -0x18(%rbp),%rax
fldt   (%rax)
mov    -0x10(%rbp),%rax
fldt   (%rax)
fsubrp %st,%st(1)
fstpt  -0x60(%rbp)
mov    -0x18(%rbp),%rax
fldt   0x10(%rax)
mov    -0x10(%rbp),%rax
fldt   0x10(%rax)
fsubrp %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x30(%rbp)
fldt   -0x40(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <atan2l@plt>
fstpt  -0x70(%rbp)
fldt   -0x50(%rbp)
fldt   -0x60(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1030 <atan2l@plt>
fstpt  -0x80(%rbp)
fldt   -0x70(%rbp)
fldt   -0x80(%rbp)
fsubrp %st,%st(1)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eucl_angle_direction>:
sub    $0x48,%rsp
fldt   (%rdi)
fldt   (%rsi)
fsubr  %st,%st(1)
fldt   0x10(%rdi)
fldt   0x10(%rsi)
fsubr  %st,%st(1)
fldt   (%rdx)
fsubp  %st,%st(3)
fxch   %st(2)
fstpt  0x3c(%rsp)
fldt   0x10(%rdx)
fsubp  %st,%st(2)
fxch   %st(1)
fstpt  0x30(%rsp)
fxch   %st(1)
fstpt  0x10(%rsp)
fstpt  (%rsp)
call   1030 <atan2l@plt>
fstpt  0x24(%rsp)
fldt   0x3c(%rsp)
fstpt  0x10(%rsp)
fldt   0x30(%rsp)
fstpt  (%rsp)
call   1030 <atan2l@plt>
fldt   0x24(%rsp)
fsubp  %st,%st(1)
add    $0x48,%rsp
ret

LLVM IR (-O0):
define x86_fp80 @eucl_angle_direction(x86_fp80* %0, x86_fp80* %1, x86_fp80* %2) {
%4 = alloca x86_fp80*
%5 = alloca x86_fp80*
%6 = alloca x86_fp80*
%7 = alloca [2 x x86_fp80]
%8 = alloca [2 x x86_fp80]
%9 = alloca x86_fp80
%10 = alloca x86_fp80
store x86_fp80* %0, x86_fp80** %4
store x86_fp80* %1, x86_fp80** %5
store x86_fp80* %2, x86_fp80** %6
%11 = load x86_fp80*, x86_fp80** %4
%12 = getelementptr inbounds x86_fp80, x86_fp80* %11, i64 0
%13 = load x86_fp80, x86_fp80* %12
%14 = load x86_fp80*, x86_fp80** %5
%15 = getelementptr inbounds x86_fp80, x86_fp80* %14, i64 0
%16 = load x86_fp80, x86_fp80* %15
%17 = fsub x86_fp80 %13, %16
%18 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %7, i64 0, i64 0
store x86_fp80 %17, x86_fp80* %18
%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 = load x86_fp80*, x86_fp80** %5
%23 = getelementptr inbounds x86_fp80, x86_fp80* %22, i64 1
%24 = load x86_fp80, x86_fp80* %23
%25 = fsub x86_fp80 %21, %24
%26 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %7, i64 0, i64 1
store x86_fp80 %25, x86_fp80* %26
%27 = load x86_fp80*, x86_fp80** %6
%28 = getelementptr inbounds x86_fp80, x86_fp80* %27, i64 0
%29 = load x86_fp80, x86_fp80* %28
%30 = load x86_fp80*, x86_fp80** %5
%31 = getelementptr inbounds x86_fp80, x86_fp80* %30, i64 0
%32 = load x86_fp80, x86_fp80* %31
%33 = fsub x86_fp80 %29, %32
%34 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %8, i64 0, i64 0
store x86_fp80 %33, x86_fp80* %34
%35 = load x86_fp80*, x86_fp80** %6
%36 = getelementptr inbounds x86_fp80, x86_fp80* %35, i64 1
%37 = load x86_fp80, x86_fp80* %36
%38 = load x86_fp80*, x86_fp80** %5
%39 = getelementptr inbounds x86_fp80, x86_fp80* %38, i64 1
%40 = load x86_fp80, x86_fp80* %39
%41 = fsub x86_fp80 %37, %40
%42 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %8, i64 0, i64 1
store x86_fp80 %41, x86_fp80* %42
%43 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %7, i64 0, i64 1
%44 = load x86_fp80, x86_fp80* %43
%45 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %7, i64 0, i64 0
%46 = load x86_fp80, x86_fp80* %45
%47 = call x86_fp80 @atan2l(x86_fp80 %44, x86_fp80 %46)
store x86_fp80 %47, x86_fp80* %9
%48 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %8, i64 0, i64 1
%49 = load x86_fp80, x86_fp80* %48
%50 = getelementptr inbounds [2 x x86_fp80], [2 x x86_fp80]* %8, i64 0, i64 0
%51 = load x86_fp80, x86_fp80* %50
%52 = call x86_fp80 @atan2l(x86_fp80 %49, x86_fp80 %51)
store x86_fp80 %52, x86_fp80* %10
%53 = load x86_fp80, x86_fp80* %9
%54 = load x86_fp80, x86_fp80* %10
%55 = fsub x86_fp80 %53, %54
ret x86_fp80 %55
}

LLVM IR (-O2):
define x86_fp80 @eucl_angle_direction(x86_fp80* nocapture %0, x86_fp80* nocapture %1, x86_fp80* nocapture %2) {
%4 = load x86_fp80, x86_fp80* %0
%5 = load x86_fp80, x86_fp80* %1
%6 = fsub x86_fp80 %4, %5
%7 = getelementptr inbounds x86_fp80, x86_fp80* %0, i64 1
%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 = fsub x86_fp80 %8, %10
%12 = load x86_fp80, x86_fp80* %2
%13 = fsub x86_fp80 %12, %5
%14 = getelementptr inbounds x86_fp80, x86_fp80* %2, i64 1
%15 = load x86_fp80, x86_fp80* %14
%16 = fsub x86_fp80 %15, %10
%17 = tail call x86_fp80 @atan2l(x86_fp80 %11, x86_fp80 %6)
%18 = tail call x86_fp80 @atan2l(x86_fp80 %16, x86_fp80 %13)
%19 = fsub x86_fp80 %17, %18
ret x86_fp80 %19
}