#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 _norm(long double *);
int _cross_prod(long double *B, long double *C, long double *A) {
  A[0] = B[1] * C[2] - B[2] * C[1];
  A[1] = B[2] * C[0] - B[0] * C[2];
  A[2] = B[0] * C[1] - B[1] * C[0];
  long double N = _norm(A);
  A[0] = A[0] / N;
  A[1] = A[1] / N;
  A[2] = A[2] / N;
  return 1;
}


x86 assembly (clang, -O0):
<_cross_prod>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%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)
mov    -0x18(%rbp),%rax
fstpt  (%rax)
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)
mov    -0x18(%rbp),%rax
fstpt  0x10(%rax)
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)
mov    -0x18(%rbp),%rax
fstpt  0x20(%rax)
mov    -0x18(%rbp),%rdi
call   1030 <_norm@plt>
fstpt  -0x30(%rbp)
mov    -0x18(%rbp),%rax
fldt   (%rax)
fldt   -0x30(%rbp)
fdivrp %st,%st(1)
fstpt  (%rax)
mov    -0x18(%rbp),%rax
fldt   0x10(%rax)
fldt   -0x30(%rbp)
fdivrp %st,%st(1)
fstpt  0x10(%rax)
mov    -0x18(%rbp),%rax
fldt   0x20(%rax)
fldt   -0x30(%rbp)
fdivrp %st,%st(1)
fstpt  0x20(%rax)
mov    $0x1,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_cross_prod>:
push   %rbx
mov    %rdx,%rbx
fldt   0x10(%rdi)
fldt   0x20(%rsi)
fmulp  %st,%st(1)
fldt   0x20(%rdi)
fldt   0x10(%rsi)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  (%rdx)
fldt   0x20(%rdi)
fldt   (%rsi)
fmulp  %st,%st(1)
fldt   (%rdi)
fldt   0x20(%rsi)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  0x10(%rdx)
fldt   (%rdi)
fldt   0x10(%rsi)
fmulp  %st,%st(1)
fldt   0x10(%rdi)
fldt   (%rsi)
fmulp  %st,%st(1)
fsubrp %st,%st(1)
fstpt  0x20(%rdx)
mov    %rdx,%rdi
call   1030 <_norm@plt>
fldt   (%rbx)
fdiv   %st(1),%st
fstpt  (%rbx)
fldt   0x10(%rbx)
fdiv   %st(1),%st
fstpt  0x10(%rbx)
fldt   0x20(%rbx)
fdivp  %st,%st(1)
fstpt  0x20(%rbx)
mov    $0x1,%eax
pop    %rbx
ret

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

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