#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);
double sin(double);
void Precess(double mjd, double *target) {
  double dt;
  double dt2, dt3;
  double zeta, z, theta;
  double a[9];
  double targ[3];
  targ[0] = target[0];
  targ[1] = target[1];
  targ[2] = target[2];
  dt = (mjd - (51544.5)) / 36525.;
  dt2 = dt * dt;
  dt3 = dt * dt * dt;
  zeta = 2306.2181 * dt + 0.30188 * dt2 + 0.017998 * dt3;
  z = 2306.2181 * dt + 1.09468 * dt2 + 0.018203 * dt3;
  theta = 2004.3109 * dt - 0.42665 * dt2 - 0.041833 * dt3;
  zeta *= (3.1415926535897932384626433 / (180. * 3600.));
  z *= (3.1415926535897932384626433 / (180. * 3600.));
  theta *= (3.1415926535897932384626433 / (180. * 3600.));
  a[0] = cos(z) * cos(theta) * cos(zeta) - sin(z) * sin(zeta);
  a[1] = -cos(z) * cos(theta) * sin(zeta) - sin(z) * cos(zeta);
  a[2] = -cos(z) * sin(theta);
  a[3] = sin(z) * cos(theta) * cos(zeta) + cos(z) * sin(zeta);
  a[4] = -sin(z) * cos(theta) * sin(zeta) + cos(z) * cos(zeta);
  a[5] = -sin(z) * sin(theta);
  a[6] = sin(theta) * cos(zeta);
  a[7] = -sin(theta) * sin(zeta);
  a[8] = cos(theta);
  target[0] = a[0] * targ[0] + a[1] * targ[1] + a[2] * targ[2];
  target[1] = a[3] * targ[0] + a[4] * targ[1] + a[5] * targ[2];
  target[2] = a[6] * targ[0] + a[7] * targ[1] + a[8] * targ[2];
}


x86 assembly (clang, -O0):
<Precess>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  0xedd(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xec9(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xe88(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  0xe63(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0xe5e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xe3c(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  0xe27(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0xe0a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xde8(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xdbc(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0xd9f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xd82(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xd70(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd5e(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x150(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x118(%rbp),%xmm0
ff
mulsd  %xmm3,%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  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Precess>:
push   %rbx
sub    $0x120,%rsp
mov    %rdi,%rbx
movapd %xmm0,%xmm2
movsd  (%rdi),%xmm0
movaps %xmm0,0x100(%rsp)
movsd  0x8(%rdi),%xmm0
movaps %xmm0,0xf0(%rsp)
movsd  0x10(%rdi),%xmm0
movaps %xmm0,0x110(%rsp)
addsd  0xea3(%rip),%xmm2
divsd  0xea3(%rip),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm0
movapd %xmm2,%xmm4
mulsd  %xmm1,%xmm0
movsd  0xe8f(%rip),%xmm2
mulsd  %xmm1,%xmm2
movsd  0xe8b(%rip),%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
movsd  0xe83(%rip),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm2,%xmm5
movsd  0xe7b(%rip),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  0xe73(%rip),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mulsd  0xe6b(%rip),%xmm1
mulsd  0xe6b(%rip),%xmm4
addsd  %xmm1,%xmm4
mulsd  0xe67(%rip),%xmm0
addsd  %xmm0,%xmm4
movsd  0xe63(%rip),%xmm0
mulsd  %xmm0,%xmm5
movsd  %xmm5,0x10(%rsp)
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x8(%rsp)
mulsd  %xmm0,%xmm4
movsd  %xmm4,0x18(%rsp)
movapd %xmm3,%xmm0
call   1040 <cos@plt>
movapd %xmm0,0x70(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x80(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0xa0(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0xc0(%rsp)
movaps 0x20(%rsp),%xmm0
xorps  0xdf1(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x30(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x90(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0xe0(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0x50(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0xd0(%rsp)
movaps 0x50(%rsp),%xmm0
xorps  0xd87(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x40(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0xb0(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0x60(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0x70(%rsp),%xmm2
unpcklpd 0x60(%rsp),%xmm2
movapd 0x80(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x80(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x70(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x60(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0xc0(%rsp),%xmm2
unpcklpd 0x60(%rsp),%xmm2
movapd 0x20(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm2,%xmm1
movapd 0xa0(%rsp),%xmm0
unpcklpd 0x70(%rsp),%xmm0
mulpd  0x80(%rsp),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,0xa0(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x30(%rsp),%xmm1
movlhps %xmm0,%xmm1
movaps %xmm1,0x30(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0x90(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x30(%rsp),%xmm1
movapd %xmm1,0x90(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movaps %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0xd0(%rsp),%xmm2
unpcklpd 0x20(%rsp),%xmm2
movapd 0x50(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm2,%xmm1
movapd 0xe0(%rsp),%xmm0
unpcklpd 0x30(%rsp),%xmm0
mulpd  0x90(%rsp),%xmm0
subpd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x40(%rsp),%xmm1
movlhps %xmm0,%xmm1
movaps %xmm1,0x40(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0xb0(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x40(%rsp),%xmm1
movapd %xmm1,0xb0(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <cos@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0xf0(%rsp),%xmm2
movapd %xmm2,%xmm1
unpcklpd %xmm2,%xmm1
mulpd  0x50(%rsp),%xmm1
movapd 0x100(%rsp),%xmm3
movsd  0x8(%rsp),%xmm4
mulsd  %xmm3,%xmm4
unpcklpd %xmm3,%xmm3
mulpd  0xa0(%rsp),%xmm3
addpd  %xmm1,%xmm3
movapd 0x110(%rsp),%xmm1
mulsd  %xmm1,%xmm0
unpcklpd %xmm1,%xmm1
mulpd  0xb0(%rsp),%xmm1
subpd  %xmm1,%xmm3
movupd %xmm3,(%rbx)
movsd  0x10(%rsp),%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm4,%xmm1
subsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx)
add    $0x120,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @Precess(double %0, double* %1) {
%3 = alloca double
%4 = alloca double*
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca [9 x double]
%12 = alloca [3 x double]
store double %0, double* %3
store double* %1, double** %4
%13 = load double*, double** %4
%14 = getelementptr inbounds double, double* %13, i64 0
%15 = load double, double* %14
%16 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
store double %15, double* %16
%17 = load double*, double** %4
%18 = getelementptr inbounds double, double* %17, i64 1
%19 = load double, double* %18
%20 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
store double %19, double* %20
%21 = load double*, double** %4
%22 = getelementptr inbounds double, double* %21, i64 2
%23 = load double, double* %22
%24 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
store double %23, double* %24
%25 = load double, double* %3
%26 = fsub double %25, 5.154450e+04
%27 = fdiv double %26, 3.652500e+04
store double %27, double* %5
%28 = load double, double* %5
%29 = load double, double* %5
%30 = fmul double %28, %29
store double %30, double* %6
%31 = load double, double* %5
%32 = load double, double* %5
%33 = fmul double %31, %32
%34 = load double, double* %5
%35 = fmul double %33, %34
store double %35, double* %7
%36 = load double, double* %5
%37 = load double, double* %6
%38 = fmul double 3.018800e-01, %37
%39 = call double @llvm.fmuladd.f64(double 0x40A2046FAACD9E84, double %36, double %38)
%40 = load double, double* %7
%41 = call double @llvm.fmuladd.f64(double 1.799800e-02, double %40, double %39)
store double %41, double* %8
%42 = load double, double* %5
%43 = load double, double* %6
%44 = fmul double 1.094680e+00, %43
%45 = call double @llvm.fmuladd.f64(double 0x40A2046FAACD9E84, double %42, double %44)
%46 = load double, double* %7
%47 = call double @llvm.fmuladd.f64(double 1.820300e-02, double %46, double %45)
store double %47, double* %9
%48 = load double, double* %5
%49 = load double, double* %6
%50 = fmul double 4.266500e-01, %49
%51 = fneg double %50
%52 = call double @llvm.fmuladd.f64(double 0x409F513E5C91D14E, double %48, double %51)
%53 = load double, double* %7
%54 = call double @llvm.fmuladd.f64(double -4.183300e-02, double %53, double %52)
store double %54, double* %10
%55 = load double, double* %8
%56 = fmul double %55, 0x3ED455A5B2FF8F9D
store double %56, double* %8
%57 = load double, double* %9
%58 = fmul double %57, 0x3ED455A5B2FF8F9D
store double %58, double* %9
%59 = load double, double* %10
%60 = fmul double %59, 0x3ED455A5B2FF8F9D
store double %60, double* %10
%61 = load double, double* %9
%62 = call double @cos(double %61)
%63 = load double, double* %10
%64 = call double @cos(double %63)
%65 = fmul double %62, %64
%66 = load double, double* %8
%67 = call double @cos(double %66)
%68 = load double, double* %9
%69 = call double @sin(double %68)
%70 = load double, double* %8
%71 = call double @sin(double %70)
%72 = fmul double %69, %71
%73 = fneg double %72
%74 = call double @llvm.fmuladd.f64(double %65, double %67, double %73)
%75 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 0
store double %74, double* %75
%76 = load double, double* %9
%77 = call double @cos(double %76)
%78 = fneg double %77
%79 = load double, double* %10
%80 = call double @cos(double %79)
%81 = fmul double %78, %80
%82 = load double, double* %8
%83 = call double @sin(double %82)
%84 = load double, double* %9
%85 = call double @sin(double %84)
%86 = load double, double* %8
%87 = call double @cos(double %86)
%88 = fmul double %85, %87
%89 = fneg double %88
%90 = call double @llvm.fmuladd.f64(double %81, double %83, double %89)
%91 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 1
store double %90, double* %91
%92 = load double, double* %9
%93 = call double @cos(double %92)
%94 = fneg double %93
%95 = load double, double* %10
%96 = call double @sin(double %95)
%97 = fmul double %94, %96
%98 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 2
store double %97, double* %98
%99 = load double, double* %9
%100 = call double @sin(double %99)
%101 = load double, double* %10
%102 = call double @cos(double %101)
%103 = fmul double %100, %102
%104 = load double, double* %8
%105 = call double @cos(double %104)
%106 = load double, double* %9
%107 = call double @cos(double %106)
%108 = load double, double* %8
%109 = call double @sin(double %108)
%110 = fmul double %107, %109
%111 = call double @llvm.fmuladd.f64(double %103, double %105, double %110)
%112 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 3
store double %111, double* %112
%113 = load double, double* %9
%114 = call double @sin(double %113)
%115 = fneg double %114
%116 = load double, double* %10
%117 = call double @cos(double %116)
%118 = fmul double %115, %117
%119 = load double, double* %8
%120 = call double @sin(double %119)
%121 = load double, double* %9
%122 = call double @cos(double %121)
%123 = load double, double* %8
%124 = call double @cos(double %123)
%125 = fmul double %122, %124
%126 = call double @llvm.fmuladd.f64(double %118, double %120, double %125)
%127 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 4
store double %126, double* %127
%128 = load double, double* %9
%129 = call double @sin(double %128)
%130 = fneg double %129
%131 = load double, double* %10
%132 = call double @sin(double %131)
%133 = fmul double %130, %132
%134 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 5
store double %133, double* %134
%135 = load double, double* %10
%136 = call double @sin(double %135)
%137 = load double, double* %8
%138 = call double @cos(double %137)
%139 = fmul double %136, %138
%140 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 6
store double %139, double* %140
%141 = load double, double* %10
%142 = call double @sin(double %141)
%143 = fneg double %142
%144 = load double, double* %8
%145 = call double @sin(double %144)
%146 = fmul double %143, %145
%147 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 7
store double %146, double* %147
%148 = load double, double* %10
%149 = call double @cos(double %148)
%150 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 8
store double %149, double* %150
%151 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 0
%152 = load double, double* %151
%153 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%154 = load double, double* %153
%155 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 1
%156 = load double, double* %155
%157 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%158 = load double, double* %157
%159 = fmul double %156, %158
%160 = call double @llvm.fmuladd.f64(double %152, double %154, double %159)
%161 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 2
%162 = load double, double* %161
%163 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%164 = load double, double* %163
%165 = call double @llvm.fmuladd.f64(double %162, double %164, double %160)
%166 = load double*, double** %4
%167 = getelementptr inbounds double, double* %166, i64 0
store double %165, double* %167
%168 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 3
%169 = load double, double* %168
%170 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%171 = load double, double* %170
%172 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 4
%173 = load double, double* %172
%174 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%175 = load double, double* %174
%176 = fmul double %173, %175
%177 = call double @llvm.fmuladd.f64(double %169, double %171, double %176)
%178 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 5
%179 = load double, double* %178
%180 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%181 = load double, double* %180
%182 = call double @llvm.fmuladd.f64(double %179, double %181, double %177)
%183 = load double*, double** %4
%184 = getelementptr inbounds double, double* %183, i64 1
store double %182, double* %184
%185 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 6
%186 = load double, double* %185
%187 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%188 = load double, double* %187
%189 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 7
%190 = load double, double* %189
%191 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%192 = load double, double* %191
%193 = fmul double %190, %192
%194 = call double @llvm.fmuladd.f64(double %186, double %188, double %193)
%195 = getelementptr inbounds [9 x double], [9 x double]* %11, i64 0, i64 8
%196 = load double, double* %195
%197 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%198 = load double, double* %197
%199 = call double @llvm.fmuladd.f64(double %196, double %198, double %194)
%200 = load double*, double** %4
%201 = getelementptr inbounds double, double* %200, i64 2
store double %199, double* %201
ret void
}

LLVM IR (-O2):
define void @Precess(double %0, double* nocapture %1) {
%3 = load double, double* %1
%4 = getelementptr inbounds double, double* %1, i64 1
%5 = load double, double* %4
%6 = getelementptr inbounds double, double* %1, i64 2
%7 = load double, double* %6
%8 = fadd double %0, -5.154450e+04
%9 = fdiv double %8, 3.652500e+04
%10 = fmul double %9, %9
%11 = fmul double %9, %10
%12 = fmul double %10, 3.018800e-01
%13 = tail call double @llvm.fmuladd.f64(double %9, double 0x40A2046FAACD9E84, double %12)
%14 = tail call double @llvm.fmuladd.f64(double %11, double 1.799800e-02, double %13)
%15 = fmul double %10, 1.094680e+00
%16 = tail call double @llvm.fmuladd.f64(double %9, double 0x40A2046FAACD9E84, double %15)
%17 = tail call double @llvm.fmuladd.f64(double %11, double 1.820300e-02, double %16)
%18 = fmul double %10, -4.266500e-01
%19 = tail call double @llvm.fmuladd.f64(double %9, double 0x409F513E5C91D14E, double %18)
%20 = tail call double @llvm.fmuladd.f64(double %11, double -4.183300e-02, double %19)
%21 = fmul double %14, 0x3ED455A5B2FF8F9D
%22 = fmul double %17, 0x3ED455A5B2FF8F9D
%23 = fmul double %20, 0x3ED455A5B2FF8F9D
%24 = tail call double @cos(double %22)
%25 = tail call double @cos(double %23)
%26 = tail call double @cos(double %21)
%27 = tail call double @sin(double %22)
%28 = tail call double @sin(double %21)
%29 = fneg double %27
%30 = tail call double @cos(double %22)
%31 = tail call double @cos(double %23)
%32 = tail call double @sin(double %21)
%33 = tail call double @sin(double %22)
%34 = tail call double @cos(double %21)
%35 = fneg double %33
%36 = tail call double @cos(double %22)
%37 = tail call double @sin(double %23)
%38 = tail call double @sin(double %22)
%39 = tail call double @cos(double %23)
%40 = insertelement <2 x double> poison, double %24, i64 0
%41 = insertelement <2 x double> %40, double %38, i64 1
%42 = insertelement <2 x double> poison, double %25, i64 0
%43 = insertelement <2 x double> %42, double %39, i64 1
%44 = fmul <2 x double> %41, %43
%45 = tail call double @cos(double %21)
%46 = tail call double @cos(double %22)
%47 = tail call double @sin(double %21)
%48 = insertelement <2 x double> poison, double %28, i64 0
%49 = insertelement <2 x double> %48, double %46, i64 1
%50 = insertelement <2 x double> poison, double %29, i64 0
%51 = insertelement <2 x double> %50, double %47, i64 1
%52 = fmul <2 x double> %49, %51
%53 = insertelement <2 x double> poison, double %26, i64 0
%54 = insertelement <2 x double> %53, double %45, i64 1
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> %54, <2 x double> %52)
%56 = tail call double @sin(double %22)
%57 = insertelement <2 x double> poison, double %30, i64 0
%58 = insertelement <2 x double> %57, double %56, i64 1
%59 = fneg <2 x double> %58
%60 = tail call double @cos(double %23)
%61 = insertelement <2 x double> poison, double %31, i64 0
%62 = insertelement <2 x double> %61, double %60, i64 1
%63 = fmul <2 x double> %62, %59
%64 = tail call double @sin(double %21)
%65 = tail call double @cos(double %22)
%66 = tail call double @cos(double %21)
%67 = insertelement <2 x double> poison, double %34, i64 0
%68 = insertelement <2 x double> %67, double %65, i64 1
%69 = insertelement <2 x double> poison, double %35, i64 0
%70 = insertelement <2 x double> %69, double %66, i64 1
%71 = fmul <2 x double> %68, %70
%72 = insertelement <2 x double> poison, double %32, i64 0
%73 = insertelement <2 x double> %72, double %64, i64 1
%74 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %63, <2 x double> %73, <2 x double> %71)
%75 = tail call double @sin(double %22)
%76 = insertelement <2 x double> poison, double %36, i64 0
%77 = insertelement <2 x double> %76, double %75, i64 1
%78 = fneg <2 x double> %77
%79 = tail call double @sin(double %23)
%80 = insertelement <2 x double> poison, double %37, i64 0
%81 = insertelement <2 x double> %80, double %79, i64 1
%82 = fmul <2 x double> %81, %78
%83 = tail call double @sin(double %23)
%84 = tail call double @cos(double %21)
%85 = fmul double %83, %84
%86 = tail call double @sin(double %23)
%87 = fneg double %86
%88 = tail call double @sin(double %21)
%89 = fmul double %88, %87
%90 = tail call double @cos(double %23)
%91 = insertelement <2 x double> poison, double %5, i64 0
%92 = shufflevector <2 x double> %91, <2 x double> poison, <2 x i32> zeroinitializer
%93 = fmul <2 x double> %92, %74
%94 = insertelement <2 x double> poison, double %3, i64 0
%95 = shufflevector <2 x double> %94, <2 x double> poison, <2 x i32> zeroinitializer
%96 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %55, <2 x double> %95, <2 x double> %93)
%97 = insertelement <2 x double> poison, double %7, i64 0
%98 = shufflevector <2 x double> %97, <2 x double> poison, <2 x i32> zeroinitializer
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %98, <2 x double> %96)
%100 = bitcast double* %1 to <2 x double>*
store <2 x double> %99, <2 x double>* %100
%101 = fmul double %5, %89
%102 = tail call double @llvm.fmuladd.f64(double %85, double %3, double %101)
%103 = tail call double @llvm.fmuladd.f64(double %90, double %7, double %102)
store double %103, double* %6
ret void
}