#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 */
int factorial(int);
float sin(int ang) {
  float angrad =
      3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989 /
      180 * ang;
  int angf3 = factorial(3);
  int angf5 = factorial(5);
  int angf7 = factorial(7);
  int angf9 = factorial(9);
  int angf11 = factorial(11);
  int angf13 = factorial(13);
  int angf15 = factorial(15);
  float ang3 = angrad * angrad * angrad;
  float ang5 = ang3 * angrad * angrad;
  float ang7 = ang5 * angrad * angrad;
  float ang9 = ang7 * angrad * angrad;
  float ang11 = ang9 * angrad * angrad;
  float ang13 = ang11 * angrad * angrad;
  float ang15 = ang13 * angrad * angrad;
  float ang33 = ang3 / angf3;
  float ang55 = ang5 / angf5;
  float ang77 = ang7 / angf7;
  float ang99 = ang9 / angf9;
  float ang111 = ang11 / angf11;
  float ang133 = ang13 / angf13;
  float ang155 = ang15 / angf15;
  float sin = angrad - ang33 + ang55 - ang77 + ang99 - ang111 + ang133 - ang155;
  return sin;
}


x86 assembly (clang, -O0):
<sin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xed8(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8(%rbp)
mov    $0x3,%edi
call   1030 <factorial@plt>
mov    %eax,-0xc(%rbp)
mov    $0x5,%edi
call   1030 <factorial@plt>
mov    %eax,-0x10(%rbp)
mov    $0x7,%edi
call   1030 <factorial@plt>
mov    %eax,-0x14(%rbp)
mov    $0x9,%edi
call   1030 <factorial@plt>
mov    %eax,-0x18(%rbp)
mov    $0xb,%edi
call   1030 <factorial@plt>
mov    %eax,-0x1c(%rbp)
mov    $0xd,%edi
call   1030 <factorial@plt>
mov    %eax,-0x20(%rbp)
mov    $0xf,%edi
call   1030 <factorial@plt>
mov    %eax,-0x24(%rbp)
movss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x28(%rbp),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x34(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0x20(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x40(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x8(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cvtsi2sd %edi,%xmm0
mulsd  0xed9(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
mov    $0x3,%edi
call   1030 <factorial@plt>
mov    %eax,%r14d
mov    $0x5,%edi
call   1030 <factorial@plt>
mov    %eax,%r15d
mov    $0x7,%edi
call   1030 <factorial@plt>
mov    %eax,%r12d
mov    $0x9,%edi
call   1030 <factorial@plt>
mov    %eax,%r13d
mov    $0xb,%edi
call   1030 <factorial@plt>
mov    %eax,%ebx
mov    $0xd,%edi
call   1030 <factorial@plt>
mov    %eax,%ebp
mov    $0xf,%edi
call   1030 <factorial@plt>
movss  0x4(%rsp),%xmm0
movaps %xmm0,%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm0,%xmm7
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm1,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm0,%xmm2
unpcklps %xmm2,%xmm1
mulss  %xmm0,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm0,%xmm3
unpcklps %xmm3,%xmm2
mulss  %xmm0,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm3,%xmm4
mulss  %xmm0,%xmm4
cvtsi2ss %r14d,%xmm5
mulss  %xmm0,%xmm4
divss  %xmm5,%xmm7
movd   %r15d,%xmm5
movd   %r12d,%xmm6
punpckldq %xmm6,%xmm5
cvtdq2ps %xmm5,%xmm5
divps  %xmm5,%xmm1
movd   %r13d,%xmm5
movd   %ebx,%xmm6
punpckldq %xmm6,%xmm5
cvtdq2ps %xmm5,%xmm5
divps  %xmm5,%xmm2
movd   %ebp,%xmm5
movd   %eax,%xmm6
punpckldq %xmm6,%xmm5
cvtdq2ps %xmm5,%xmm5
unpcklps %xmm4,%xmm3
divps  %xmm5,%xmm3
subss  %xmm7,%xmm0
addss  %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm1
subss  %xmm1,%xmm0
addss  %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm2
subss  %xmm2,%xmm0
addss  %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm3
subss  %xmm3,%xmm0
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float @sin(i32 %0) {
%2 = alloca i32
%3 = alloca float
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
store i32 %0, i32* %2
%26 = load i32, i32* %2
%27 = sitofp i32 %26 to double
%28 = fmul double 0x3F91DF46A2529D39, %27
%29 = fptrunc double %28 to float
store float %29, float* %3
%30 = call i32 @factorial(i32 3)
store i32 %30, i32* %4
%31 = call i32 @factorial(i32 5)
store i32 %31, i32* %5
%32 = call i32 @factorial(i32 7)
store i32 %32, i32* %6
%33 = call i32 @factorial(i32 9)
store i32 %33, i32* %7
%34 = call i32 @factorial(i32 11)
store i32 %34, i32* %8
%35 = call i32 @factorial(i32 13)
store i32 %35, i32* %9
%36 = call i32 @factorial(i32 15)
store i32 %36, i32* %10
%37 = load float, float* %3
%38 = load float, float* %3
%39 = fmul float %37, %38
%40 = load float, float* %3
%41 = fmul float %39, %40
store float %41, float* %11
%42 = load float, float* %11
%43 = load float, float* %3
%44 = fmul float %42, %43
%45 = load float, float* %3
%46 = fmul float %44, %45
store float %46, float* %12
%47 = load float, float* %12
%48 = load float, float* %3
%49 = fmul float %47, %48
%50 = load float, float* %3
%51 = fmul float %49, %50
store float %51, float* %13
%52 = load float, float* %13
%53 = load float, float* %3
%54 = fmul float %52, %53
%55 = load float, float* %3
%56 = fmul float %54, %55
store float %56, float* %14
%57 = load float, float* %14
%58 = load float, float* %3
%59 = fmul float %57, %58
%60 = load float, float* %3
%61 = fmul float %59, %60
store float %61, float* %15
%62 = load float, float* %15
%63 = load float, float* %3
%64 = fmul float %62, %63
%65 = load float, float* %3
%66 = fmul float %64, %65
store float %66, float* %16
%67 = load float, float* %16
%68 = load float, float* %3
%69 = fmul float %67, %68
%70 = load float, float* %3
%71 = fmul float %69, %70
store float %71, float* %17
%72 = load float, float* %11
%73 = load i32, i32* %4
%74 = sitofp i32 %73 to float
%75 = fdiv float %72, %74
store float %75, float* %18
%76 = load float, float* %12
%77 = load i32, i32* %5
%78 = sitofp i32 %77 to float
%79 = fdiv float %76, %78
store float %79, float* %19
%80 = load float, float* %13
%81 = load i32, i32* %6
%82 = sitofp i32 %81 to float
%83 = fdiv float %80, %82
store float %83, float* %20
%84 = load float, float* %14
%85 = load i32, i32* %7
%86 = sitofp i32 %85 to float
%87 = fdiv float %84, %86
store float %87, float* %21
%88 = load float, float* %15
%89 = load i32, i32* %8
%90 = sitofp i32 %89 to float
%91 = fdiv float %88, %90
store float %91, float* %22
%92 = load float, float* %16
%93 = load i32, i32* %9
%94 = sitofp i32 %93 to float
%95 = fdiv float %92, %94
store float %95, float* %23
%96 = load float, float* %17
%97 = load i32, i32* %10
%98 = sitofp i32 %97 to float
%99 = fdiv float %96, %98
store float %99, float* %24
%100 = load float, float* %3
%101 = load float, float* %18
%102 = fsub float %100, %101
%103 = load float, float* %19
%104 = fadd float %102, %103
%105 = load float, float* %20
%106 = fsub float %104, %105
%107 = load float, float* %21
%108 = fadd float %106, %107
%109 = load float, float* %22
%110 = fsub float %108, %109
%111 = load float, float* %23
%112 = fadd float %110, %111
%113 = load float, float* %24
%114 = fsub float %112, %113
store float %114, float* %25
%115 = load float, float* %25
ret float %115
}

LLVM IR (-O2):
define float @sin(i32 %0) {
%2 = sitofp i32 %0 to double
%3 = fmul double %2, 0x3F91DF46A2529D39
%4 = fptrunc double %3 to float
%5 = tail call i32 @factorial(i32 3)
%6 = tail call i32 @factorial(i32 5)
%7 = tail call i32 @factorial(i32 7)
%8 = tail call i32 @factorial(i32 9)
%9 = tail call i32 @factorial(i32 11)
%10 = tail call i32 @factorial(i32 13)
%11 = tail call i32 @factorial(i32 15)
%12 = fmul float %4, %4
%13 = fmul float %12, %4
%14 = fmul float %13, %4
%15 = fmul float %14, %4
%16 = fmul float %15, %4
%17 = fmul float %16, %4
%18 = fmul float %17, %4
%19 = fmul float %18, %4
%20 = fmul float %19, %4
%21 = fmul float %20, %4
%22 = fmul float %21, %4
%23 = fmul float %22, %4
%24 = fmul float %23, %4
%25 = fmul float %24, %4
%26 = sitofp i32 %5 to float
%27 = fdiv float %13, %26
%28 = insertelement <2 x i32> poison, i32 %6, i64 0
%29 = insertelement <2 x i32> %28, i32 %7, i64 1
%30 = sitofp <2 x i32> %29 to <2 x float>
%31 = insertelement <2 x float> poison, float %15, i64 0
%32 = insertelement <2 x float> %31, float %17, i64 1
%33 = fdiv <2 x float> %32, %30
%34 = insertelement <2 x i32> poison, i32 %8, i64 0
%35 = insertelement <2 x i32> %34, i32 %9, i64 1
%36 = sitofp <2 x i32> %35 to <2 x float>
%37 = insertelement <2 x float> poison, float %19, i64 0
%38 = insertelement <2 x float> %37, float %21, i64 1
%39 = fdiv <2 x float> %38, %36
%40 = insertelement <2 x i32> poison, i32 %10, i64 0
%41 = insertelement <2 x i32> %40, i32 %11, i64 1
%42 = sitofp <2 x i32> %41 to <2 x float>
%43 = insertelement <2 x float> poison, float %23, i64 0
%44 = insertelement <2 x float> %43, float %25, i64 1
%45 = fdiv <2 x float> %44, %42
%46 = fsub float %4, %27
%47 = extractelement <2 x float> %33, i64 0
%48 = fadd float %46, %47
%49 = extractelement <2 x float> %33, i64 1
%50 = fsub float %48, %49
%51 = extractelement <2 x float> %39, i64 0
%52 = fadd float %50, %51
%53 = extractelement <2 x float> %39, i64 1
%54 = fsub float %52, %53
%55 = extractelement <2 x float> %45, i64 0
%56 = fadd float %54, %55
%57 = extractelement <2 x float> %45, i64 1
%58 = fsub float %56, %57
ret float %58
}