#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 */
double cos(double const);
double sin(double const);
void Glob_Star(const double x[3], const double nu, const double eps,
               const double psi, double xsi[3]) {
  double cnu = cos(nu), snu = sin(nu);
  double ceps = cos(eps), seps = sin(eps);
  double cpsi = cos(psi), spsi = sin(psi);
  double rot[3][3];
  rot[0][0] = cpsi * ceps;
  rot[0][1] = cpsi * seps * snu + spsi * cnu;
  rot[0][2] = -cpsi * seps * cnu + spsi * snu;
  rot[1][0] = -spsi * ceps;
  rot[1][1] = -spsi * seps * snu + cpsi * cnu;
  rot[1][2] = spsi * seps * cnu + cpsi * snu;
  rot[2][0] = seps;
  rot[2][1] = -ceps * snu;
  rot[2][2] = ceps * cnu;
  xsi[0] = x[0] * rot[0][0] + x[1] * rot[0][1] + x[2] * rot[0][2];
  xsi[1] = x[0] * rot[1][0] + x[1] * rot[1][1] + x[2] * rot[1][2];
  xsi[2] = x[0] * rot[2][0] + x[1] * rot[2][1] + x[2] * rot[2][2];
}


x86 assembly (clang, -O0):
<Glob_Star>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x18(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x18(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x70(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Glob_Star>:
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %rsi,%r14
movsd  %xmm2,0x18(%rsp)
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %rdi,%rbx
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x28(%rsp),%xmm6
movapd %xmm6,%xmm1
movsd  0x20(%rsp),%xmm11
mulsd  %xmm11,%xmm1
movsd  0x8(%rsp),%xmm10
movapd %xmm10,%xmm2
mulsd  %xmm11,%xmm2
movsd  0x30(%rsp),%xmm7
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm2,%xmm5
movsd  0x10(%rsp),%xmm4
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm2
subsd  %xmm2,%xmm3
movapd %xmm6,%xmm8
movapd %xmm6,%xmm9
mulsd  %xmm0,%xmm8
movapd %xmm7,%xmm2
mulsd  %xmm11,%xmm2
mulsd  %xmm10,%xmm0
movapd %xmm0,%xmm6
mulsd  %xmm4,%xmm6
subsd  %xmm6,%xmm2
mulsd  %xmm4,%xmm11
mulsd  %xmm7,%xmm0
mulsd  0x8(%rbx),%xmm5
addsd  %xmm11,%xmm0
mulsd  (%rbx),%xmm1
addsd  %xmm5,%xmm1
mulsd  0x10(%rbx),%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,(%r14)
mulsd  0x8(%rbx),%xmm2
mulsd  (%rbx),%xmm8
mulsd  %xmm9,%xmm4
subsd  %xmm8,%xmm2
mulsd  0x10(%rbx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%r14)
mulsd  0x8(%rbx),%xmm4
movapd %xmm7,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm10,%xmm1
mulsd  (%rbx),%xmm1
subsd  %xmm4,%xmm1
mulsd  0x10(%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @Glob_Star(double* %0, double %1, double %2, double %3, double* %4) {
%6 = alloca double*
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double*
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca [3 x [3 x double]]
store double* %0, double** %6
store double %1, double* %7
store double %2, double* %8
store double %3, double* %9
store double* %4, double** %10
%18 = load double, double* %7
%19 = call double @cos(double %18)
store double %19, double* %11
%20 = load double, double* %7
%21 = call double @sin(double %20)
store double %21, double* %12
%22 = load double, double* %8
%23 = call double @cos(double %22)
store double %23, double* %13
%24 = load double, double* %8
%25 = call double @sin(double %24)
store double %25, double* %14
%26 = load double, double* %9
%27 = call double @cos(double %26)
store double %27, double* %15
%28 = load double, double* %9
%29 = call double @sin(double %28)
store double %29, double* %16
%30 = load double, double* %15
%31 = load double, double* %13
%32 = fmul double %30, %31
%33 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%34 = getelementptr inbounds [3 x double], [3 x double]* %33, i64 0, i64 0
store double %32, double* %34
%35 = load double, double* %15
%36 = load double, double* %14
%37 = fmul double %35, %36
%38 = load double, double* %12
%39 = load double, double* %16
%40 = load double, double* %11
%41 = fmul double %39, %40
%42 = call double @llvm.fmuladd.f64(double %37, double %38, double %41)
%43 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%44 = getelementptr inbounds [3 x double], [3 x double]* %43, i64 0, i64 1
store double %42, double* %44
%45 = load double, double* %15
%46 = fneg double %45
%47 = load double, double* %14
%48 = fmul double %46, %47
%49 = load double, double* %11
%50 = load double, double* %16
%51 = load double, double* %12
%52 = fmul double %50, %51
%53 = call double @llvm.fmuladd.f64(double %48, double %49, double %52)
%54 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%55 = getelementptr inbounds [3 x double], [3 x double]* %54, i64 0, i64 2
store double %53, double* %55
%56 = load double, double* %16
%57 = fneg double %56
%58 = load double, double* %13
%59 = fmul double %57, %58
%60 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%61 = getelementptr inbounds [3 x double], [3 x double]* %60, i64 0, i64 0
store double %59, double* %61
%62 = load double, double* %16
%63 = fneg double %62
%64 = load double, double* %14
%65 = fmul double %63, %64
%66 = load double, double* %12
%67 = load double, double* %15
%68 = load double, double* %11
%69 = fmul double %67, %68
%70 = call double @llvm.fmuladd.f64(double %65, double %66, double %69)
%71 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%72 = getelementptr inbounds [3 x double], [3 x double]* %71, i64 0, i64 1
store double %70, double* %72
%73 = load double, double* %16
%74 = load double, double* %14
%75 = fmul double %73, %74
%76 = load double, double* %11
%77 = load double, double* %15
%78 = load double, double* %12
%79 = fmul double %77, %78
%80 = call double @llvm.fmuladd.f64(double %75, double %76, double %79)
%81 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%82 = getelementptr inbounds [3 x double], [3 x double]* %81, i64 0, i64 2
store double %80, double* %82
%83 = load double, double* %14
%84 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%85 = getelementptr inbounds [3 x double], [3 x double]* %84, i64 0, i64 0
store double %83, double* %85
%86 = load double, double* %13
%87 = fneg double %86
%88 = load double, double* %12
%89 = fmul double %87, %88
%90 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%91 = getelementptr inbounds [3 x double], [3 x double]* %90, i64 0, i64 1
store double %89, double* %91
%92 = load double, double* %13
%93 = load double, double* %11
%94 = fmul double %92, %93
%95 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%96 = getelementptr inbounds [3 x double], [3 x double]* %95, i64 0, i64 2
store double %94, double* %96
%97 = load double*, double** %6
%98 = getelementptr inbounds double, double* %97, i64 0
%99 = load double, double* %98
%100 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%101 = getelementptr inbounds [3 x double], [3 x double]* %100, i64 0, i64 0
%102 = load double, double* %101
%103 = load double*, double** %6
%104 = getelementptr inbounds double, double* %103, i64 1
%105 = load double, double* %104
%106 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%107 = getelementptr inbounds [3 x double], [3 x double]* %106, i64 0, i64 1
%108 = load double, double* %107
%109 = fmul double %105, %108
%110 = call double @llvm.fmuladd.f64(double %99, double %102, double %109)
%111 = load double*, double** %6
%112 = getelementptr inbounds double, double* %111, i64 2
%113 = load double, double* %112
%114 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 0
%115 = getelementptr inbounds [3 x double], [3 x double]* %114, i64 0, i64 2
%116 = load double, double* %115
%117 = call double @llvm.fmuladd.f64(double %113, double %116, double %110)
%118 = load double*, double** %10
%119 = getelementptr inbounds double, double* %118, i64 0
store double %117, double* %119
%120 = load double*, double** %6
%121 = getelementptr inbounds double, double* %120, i64 0
%122 = load double, double* %121
%123 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%124 = getelementptr inbounds [3 x double], [3 x double]* %123, i64 0, i64 0
%125 = load double, double* %124
%126 = load double*, double** %6
%127 = getelementptr inbounds double, double* %126, i64 1
%128 = load double, double* %127
%129 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%130 = getelementptr inbounds [3 x double], [3 x double]* %129, i64 0, i64 1
%131 = load double, double* %130
%132 = fmul double %128, %131
%133 = call double @llvm.fmuladd.f64(double %122, double %125, double %132)
%134 = load double*, double** %6
%135 = getelementptr inbounds double, double* %134, i64 2
%136 = load double, double* %135
%137 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 1
%138 = getelementptr inbounds [3 x double], [3 x double]* %137, i64 0, i64 2
%139 = load double, double* %138
%140 = call double @llvm.fmuladd.f64(double %136, double %139, double %133)
%141 = load double*, double** %10
%142 = getelementptr inbounds double, double* %141, i64 1
store double %140, double* %142
%143 = load double*, double** %6
%144 = getelementptr inbounds double, double* %143, i64 0
%145 = load double, double* %144
%146 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%147 = getelementptr inbounds [3 x double], [3 x double]* %146, i64 0, i64 0
%148 = load double, double* %147
%149 = load double*, double** %6
%150 = getelementptr inbounds double, double* %149, i64 1
%151 = load double, double* %150
%152 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%153 = getelementptr inbounds [3 x double], [3 x double]* %152, i64 0, i64 1
%154 = load double, double* %153
%155 = fmul double %151, %154
%156 = call double @llvm.fmuladd.f64(double %145, double %148, double %155)
%157 = load double*, double** %6
%158 = getelementptr inbounds double, double* %157, i64 2
%159 = load double, double* %158
%160 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %17, i64 0, i64 2
%161 = getelementptr inbounds [3 x double], [3 x double]* %160, i64 0, i64 2
%162 = load double, double* %161
%163 = call double @llvm.fmuladd.f64(double %159, double %162, double %156)
%164 = load double*, double** %10
%165 = getelementptr inbounds double, double* %164, i64 2
store double %163, double* %165
ret void
}

LLVM IR (-O2):
define void @Glob_Star(double* nocapture %0, double %1, double %2, double %3, double* nocapture writeonly %4) {
%6 = tail call double @cos(double %1)
%7 = tail call double @sin(double %1)
%8 = tail call double @cos(double %2)
%9 = tail call double @sin(double %2)
%10 = tail call double @cos(double %3)
%11 = tail call double @sin(double %3)
%12 = fmul double %8, %10
%13 = fmul double %9, %10
%14 = fmul double %6, %11
%15 = tail call double @llvm.fmuladd.f64(double %13, double %7, double %14)
%16 = fneg double %10
%17 = fmul double %9, %16
%18 = fmul double %7, %11
%19 = tail call double @llvm.fmuladd.f64(double %17, double %6, double %18)
%20 = fneg double %11
%21 = fmul double %8, %20
%22 = fmul double %9, %20
%23 = fmul double %6, %10
%24 = tail call double @llvm.fmuladd.f64(double %22, double %7, double %23)
%25 = fmul double %9, %11
%26 = fmul double %7, %10
%27 = tail call double @llvm.fmuladd.f64(double %25, double %6, double %26)
%28 = fneg double %8
%29 = fmul double %7, %28
%30 = fmul double %6, %8
%31 = load double, double* %0
%32 = getelementptr inbounds double, double* %0, i64 1
%33 = load double, double* %32
%34 = fmul double %33, %15
%35 = tail call double @llvm.fmuladd.f64(double %31, double %12, double %34)
%36 = getelementptr inbounds double, double* %0, i64 2
%37 = load double, double* %36
%38 = tail call double @llvm.fmuladd.f64(double %37, double %19, double %35)
store double %38, double* %4
%39 = load double, double* %0
%40 = load double, double* %32
%41 = fmul double %24, %40
%42 = tail call double @llvm.fmuladd.f64(double %39, double %21, double %41)
%43 = load double, double* %36
%44 = tail call double @llvm.fmuladd.f64(double %43, double %27, double %42)
%45 = getelementptr inbounds double, double* %4, i64 1
store double %44, double* %45
%46 = load double, double* %0
%47 = load double, double* %32
%48 = fmul double %29, %47
%49 = tail call double @llvm.fmuladd.f64(double %46, double %9, double %48)
%50 = load double, double* %36
%51 = tail call double @llvm.fmuladd.f64(double %50, double %30, double %49)
%52 = getelementptr inbounds double, double* %4, i64 2
store double %51, double* %52
ret void
}