#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 M_PI;
float cos(float);
int /*<<< orphan*/ free(float *);
float *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
float sin(float);
int main(int argc, char *argv[]) {
  int i;
  float *xa = malloc((1 + 16) * sizeof(float));
  float *sx = malloc((1 + 16) * sizeof(float));
  float *cx = malloc((1 + 16) * sizeof(float));
  for (i = 0; i <= 16; ++i)
    xa[i] = i * 2 * M_PI / 16;
  for (i = 0; i <= 16; ++i)
    sx[i] = sin(xa[i]);
  for (i = 0; i <= 16; ++i)
    cx[i] = cos(xa[i]);
  for (i = 0; i < 16; ++i)
    printf("%2.4f/%2.4f/%2.4f ", xa[i], sx[i], cx[i]);
  printf("\n");
  free(xa);
  free(sx);
  free(cx);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x44,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    $0x44,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    $0x44,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jg     11d8 <main+0x88>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    0x2e3a(%rip),%rcx
imul   (%rcx),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1197 <main+0x47>
movl   $0x0,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jg     1216 <main+0xc6>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <sin@plt>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11df <main+0x8f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jg     1254 <main+0x104>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1070 <cos@plt>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    121d <main+0xcd>
movl   $0x0,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    12b4 <main+0x164>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xd61(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    125b <main+0x10b>
lea    0xd58(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    $0x44,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    $0x44,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    $0x44,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    0x2e52(%rip),%rax
mov    (%rax),%eax
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xe57(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
movdqa 0xe56(%rip),%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
movdqa %xmm2,%xmm1
psrad  $0x1f,%xmm1
psrld  $0x1c,%xmm1
paddd  %xmm2,%xmm1
psrad  $0x4,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm1,(%rbx)
movdqa 0xe34(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
movdqa 0xe33(%rip),%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
movdqa %xmm2,%xmm1
psrad  $0x1f,%xmm1
psrld  $0x1c,%xmm1
paddd  %xmm2,%xmm1
psrad  $0x4,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm1,0x10(%rbx)
movdqa 0xe10(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
movdqa 0xe0f(%rip),%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
movdqa %xmm2,%xmm1
psrad  $0x1f,%xmm1
psrld  $0x1c,%xmm1
paddd  %xmm2,%xmm1
psrad  $0x4,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm1,0x20(%rbx)
movdqa 0xdec(%rip),%xmm1
pmuludq %xmm0,%xmm1
pmuludq 0xdf0(%rip),%xmm0
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrad  $0x1f,%xmm1
psrld  $0x1c,%xmm1
paddd  %xmm0,%xmm1
psrad  $0x4,%xmm1
shl    $0x5,%eax
sar    $0x4,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
cvtdq2ps %xmm1,%xmm1
movups %xmm1,0x30(%rbx)
movss  %xmm0,0x40(%rbx)
movss  (%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,(%r14)
movss  0x4(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x4(%r14)
movss  0x8(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x8(%r14)
movss  0xc(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0xc(%r14)
movss  0x10(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x10(%r14)
movss  0x14(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x14(%r14)
movss  0x18(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x18(%r14)
movss  0x1c(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x1c(%r14)
movss  0x20(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x20(%r14)
movss  0x24(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x24(%r14)
movss  0x28(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x28(%r14)
movss  0x2c(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x2c(%r14)
movss  0x30(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x30(%r14)
movss  0x34(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x34(%r14)
movss  0x38(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x38(%r14)
movss  0x3c(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x3c(%r14)
movss  0x40(%rbx),%xmm0
call   1060 <sin@plt>
movss  %xmm0,0x40(%r14)
movss  (%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,(%r15)
movss  0x4(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x4(%r15)
movss  0x8(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x8(%r15)
movss  0xc(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0xc(%r15)
movss  0x10(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x10(%r15)
movss  0x14(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x14(%r15)
movss  0x18(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x18(%r15)
movss  0x1c(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x1c(%r15)
movss  0x20(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x20(%r15)
movss  0x24(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x24(%r15)
movss  0x28(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x28(%r15)
movss  0x2c(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x2c(%r15)
movss  0x30(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x30(%r15)
movss  0x34(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x34(%r15)
movss  0x38(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x38(%r15)
movss  0x3c(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x3c(%r15)
movss  0x40(%rbx),%xmm0
call   1080 <cos@plt>
movss  %xmm0,0x40(%r15)
movss  (%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  (%r15),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xb85(%rip),%r12
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x4(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x4(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x8(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x8(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x8(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0xc(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0xc(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0xc(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x10(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x10(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x10(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x14(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x14(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x14(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x18(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x18(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x18(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x1c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x1c(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x1c(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x20(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x20(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x20(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x24(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x24(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x24(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x28(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x28(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x28(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x2c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2c(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x2c(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x30(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x30(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x30(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x34(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x34(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x34(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x38(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x38(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x38(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
movss  0x3c(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x3c(%r14),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x3c(%r15),%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r12,%rdi
mov    $0x3,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@M_PI = global i32 0
@.str = [19 x i8] c"%2.4f/%2.4f/%2.4f \00"
@.str.1 = [2 x i8] c"\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%10 = call float* @malloc(i32 68)
store float* %10, float** %7
%11 = call float* @malloc(i32 68)
store float* %11, float** %8
%12 = call float* @malloc(i32 68)
store float* %12, float** %9
store i32 0, i32* %6
br label %13
13: ; preds = %27, %2
%14 = load i32, i32* %6
%15 = icmp sle i32 %14, 16
br i1 %15, label %16, label %30
16: ; preds = %13
%17 = load i32, i32* %6
%18 = mul nsw i32 %17, 2
%19 = load i32, i32* @M_PI
%20 = mul nsw i32 %18, %19
%21 = sdiv i32 %20, 16
%22 = sitofp i32 %21 to float
%23 = load float*, float** %7
%24 = load i32, i32* %6
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds float, float* %23, i64 %25
store float %22, float* %26
br label %27
27: ; preds = %16
%28 = load i32, i32* %6
%29 = add nsw i32 %28, 1
store i32 %29, i32* %6
br label %13
30: ; preds = %13
store i32 0, i32* %6
br label %31
31: ; preds = %45, %30
%32 = load i32, i32* %6
%33 = icmp sle i32 %32, 16
br i1 %33, label %34, label %48
34: ; preds = %31
%35 = load float*, float** %7
%36 = load i32, i32* %6
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
%40 = call float @sin(float %39)
%41 = load float*, float** %8
%42 = load i32, i32* %6
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
store float %40, float* %44
br label %45
45: ; preds = %34
%46 = load i32, i32* %6
%47 = add nsw i32 %46, 1
store i32 %47, i32* %6
br label %31
48: ; preds = %31
store i32 0, i32* %6
br label %49
49: ; preds = %63, %48
%50 = load i32, i32* %6
%51 = icmp sle i32 %50, 16
br i1 %51, label %52, label %66
52: ; preds = %49
%53 = load float*, float** %7
%54 = load i32, i32* %6
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
%57 = load float, float* %56
%58 = call float @cos(float %57)
%59 = load float*, float** %9
%60 = load i32, i32* %6
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float %58, float* %62
br label %63
63: ; preds = %52
%64 = load i32, i32* %6
%65 = add nsw i32 %64, 1
store i32 %65, i32* %6
br label %49
66: ; preds = %49
store i32 0, i32* %6
br label %67
67: ; preds = %90, %66
%68 = load i32, i32* %6
%69 = icmp slt i32 %68, 16
br i1 %69, label %70, label %93
70: ; preds = %67
%71 = load float*, float** %7
%72 = load i32, i32* %6
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = load float*, float** %8
%78 = load i32, i32* %6
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %77, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = load float*, float** %9
%84 = load i32, i32* %6
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
%87 = load float, float* %86
%88 = fpext float %87 to double
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %76, double %82, double %88)
br label %90
90: ; preds = %70
%91 = load i32, i32* %6
%92 = add nsw i32 %91, 1
store i32 %92, i32* %6
br label %67
93: ; preds = %67
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%95 = load float*, float** %7
%96 = call i32 @free(float* %95)
%97 = load float*, float** %8
%98 = call i32 @free(float* %97)
%99 = load float*, float** %9
%100 = call i32 @free(float* %99)
ret i32 0
}

LLVM IR (-O2):
@M_PI = global i32 0
@.str = [19 x i8] c"%2.4f/%2.4f/%2.4f \00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call float* @malloc(i32 68)
%4 = tail call float* @malloc(i32 68)
%5 = tail call float* @malloc(i32 68)
%6 = load i32, i32* @M_PI
%7 = insertelement <4 x i32> poison, i32 %6, i64 0
%8 = shufflevector <4 x i32> %7, <4 x i32> poison, <4 x i32> zeroinitializer
%9 = mul <4 x i32> %8, <i32 0, i32 2, i32 4, i32 6>
%10 = sdiv <4 x i32> %9, <i32 16, i32 16, i32 16, i32 16>
%11 = sitofp <4 x i32> %10 to <4 x float>
%12 = bitcast float* %3 to <4 x float>*
store <4 x float> %11, <4 x float>* %12
%13 = mul <4 x i32> %8, <i32 8, i32 10, i32 12, i32 14>
%14 = sdiv <4 x i32> %13, <i32 16, i32 16, i32 16, i32 16>
%15 = sitofp <4 x i32> %14 to <4 x float>
%16 = getelementptr inbounds float, float* %3, i64 4
%17 = bitcast float* %16 to <4 x float>*
store <4 x float> %15, <4 x float>* %17
%18 = mul <4 x i32> %8, <i32 16, i32 18, i32 20, i32 22>
%19 = sdiv <4 x i32> %18, <i32 16, i32 16, i32 16, i32 16>
%20 = sitofp <4 x i32> %19 to <4 x float>
%21 = getelementptr inbounds float, float* %3, i64 8
%22 = bitcast float* %21 to <4 x float>*
store <4 x float> %20, <4 x float>* %22
%23 = mul <4 x i32> %8, <i32 24, i32 26, i32 28, i32 30>
%24 = sdiv <4 x i32> %23, <i32 16, i32 16, i32 16, i32 16>
%25 = sitofp <4 x i32> %24 to <4 x float>
%26 = getelementptr inbounds float, float* %3, i64 12
%27 = bitcast float* %26 to <4 x float>*
store <4 x float> %25, <4 x float>* %27
%28 = shl i32 %6, 5
%29 = sdiv i32 %28, 16
%30 = sitofp i32 %29 to float
%31 = getelementptr inbounds float, float* %3, i64 16
store float %30, float* %31
%32 = load float, float* %3
%33 = tail call float @sin(float %32)
store float %33, float* %4
%34 = getelementptr inbounds float, float* %3, i64 1
%35 = load float, float* %34
%36 = tail call float @sin(float %35)
%37 = getelementptr inbounds float, float* %4, i64 1
store float %36, float* %37
%38 = getelementptr inbounds float, float* %3, i64 2
%39 = load float, float* %38
%40 = tail call float @sin(float %39)
%41 = getelementptr inbounds float, float* %4, i64 2
store float %40, float* %41
%42 = getelementptr inbounds float, float* %3, i64 3
%43 = load float, float* %42
%44 = tail call float @sin(float %43)
%45 = getelementptr inbounds float, float* %4, i64 3
store float %44, float* %45
%46 = getelementptr inbounds float, float* %3, i64 4
%47 = load float, float* %46
%48 = tail call float @sin(float %47)
%49 = getelementptr inbounds float, float* %4, i64 4
store float %48, float* %49
%50 = getelementptr inbounds float, float* %3, i64 5
%51 = load float, float* %50
%52 = tail call float @sin(float %51)
%53 = getelementptr inbounds float, float* %4, i64 5
store float %52, float* %53
%54 = getelementptr inbounds float, float* %3, i64 6
%55 = load float, float* %54
%56 = tail call float @sin(float %55)
%57 = getelementptr inbounds float, float* %4, i64 6
store float %56, float* %57
%58 = getelementptr inbounds float, float* %3, i64 7
%59 = load float, float* %58
%60 = tail call float @sin(float %59)
%61 = getelementptr inbounds float, float* %4, i64 7
store float %60, float* %61
%62 = getelementptr inbounds float, float* %3, i64 8
%63 = load float, float* %62
%64 = tail call float @sin(float %63)
%65 = getelementptr inbounds float, float* %4, i64 8
store float %64, float* %65
%66 = getelementptr inbounds float, float* %3, i64 9
%67 = load float, float* %66
%68 = tail call float @sin(float %67)
%69 = getelementptr inbounds float, float* %4, i64 9
store float %68, float* %69
%70 = getelementptr inbounds float, float* %3, i64 10
%71 = load float, float* %70
%72 = tail call float @sin(float %71)
%73 = getelementptr inbounds float, float* %4, i64 10
store float %72, float* %73
%74 = getelementptr inbounds float, float* %3, i64 11
%75 = load float, float* %74
%76 = tail call float @sin(float %75)
%77 = getelementptr inbounds float, float* %4, i64 11
store float %76, float* %77
%78 = getelementptr inbounds float, float* %3, i64 12
%79 = load float, float* %78
%80 = tail call float @sin(float %79)
%81 = getelementptr inbounds float, float* %4, i64 12
store float %80, float* %81
%82 = getelementptr inbounds float, float* %3, i64 13
%83 = load float, float* %82
%84 = tail call float @sin(float %83)
%85 = getelementptr inbounds float, float* %4, i64 13
store float %84, float* %85
%86 = getelementptr inbounds float, float* %3, i64 14
%87 = load float, float* %86
%88 = tail call float @sin(float %87)
%89 = getelementptr inbounds float, float* %4, i64 14
store float %88, float* %89
%90 = getelementptr inbounds float, float* %3, i64 15
%91 = load float, float* %90
%92 = tail call float @sin(float %91)
%93 = getelementptr inbounds float, float* %4, i64 15
store float %92, float* %93
%94 = getelementptr inbounds float, float* %3, i64 16
%95 = load float, float* %94
%96 = tail call float @sin(float %95)
%97 = getelementptr inbounds float, float* %4, i64 16
store float %96, float* %97
%98 = load float, float* %3
%99 = tail call float @cos(float %98)
store float %99, float* %5
%100 = load float, float* %34
%101 = tail call float @cos(float %100)
%102 = getelementptr inbounds float, float* %5, i64 1
store float %101, float* %102
%103 = load float, float* %38
%104 = tail call float @cos(float %103)
%105 = getelementptr inbounds float, float* %5, i64 2
store float %104, float* %105
%106 = load float, float* %42
%107 = tail call float @cos(float %106)
%108 = getelementptr inbounds float, float* %5, i64 3
store float %107, float* %108
%109 = load float, float* %46
%110 = tail call float @cos(float %109)
%111 = getelementptr inbounds float, float* %5, i64 4
store float %110, float* %111
%112 = load float, float* %50
%113 = tail call float @cos(float %112)
%114 = getelementptr inbounds float, float* %5, i64 5
store float %113, float* %114
%115 = load float, float* %54
%116 = tail call float @cos(float %115)
%117 = getelementptr inbounds float, float* %5, i64 6
store float %116, float* %117
%118 = load float, float* %58
%119 = tail call float @cos(float %118)
%120 = getelementptr inbounds float, float* %5, i64 7
store float %119, float* %120
%121 = load float, float* %62
%122 = tail call float @cos(float %121)
%123 = getelementptr inbounds float, float* %5, i64 8
store float %122, float* %123
%124 = load float, float* %66
%125 = tail call float @cos(float %124)
%126 = getelementptr inbounds float, float* %5, i64 9
store float %125, float* %126
%127 = load float, float* %70
%128 = tail call float @cos(float %127)
%129 = getelementptr inbounds float, float* %5, i64 10
store float %128, float* %129
%130 = load float, float* %74
%131 = tail call float @cos(float %130)
%132 = getelementptr inbounds float, float* %5, i64 11
store float %131, float* %132
%133 = load float, float* %78
%134 = tail call float @cos(float %133)
%135 = getelementptr inbounds float, float* %5, i64 12
store float %134, float* %135
%136 = load float, float* %82
%137 = tail call float @cos(float %136)
%138 = getelementptr inbounds float, float* %5, i64 13
store float %137, float* %138
%139 = load float, float* %86
%140 = tail call float @cos(float %139)
%141 = getelementptr inbounds float, float* %5, i64 14
store float %140, float* %141
%142 = load float, float* %90
%143 = tail call float @cos(float %142)
%144 = getelementptr inbounds float, float* %5, i64 15
store float %143, float* %144
%145 = load float, float* %94
%146 = tail call float @cos(float %145)
%147 = getelementptr inbounds float, float* %5, i64 16
store float %146, float* %147
%148 = load float, float* %3
%149 = fpext float %148 to double
%150 = load float, float* %4
%151 = fpext float %150 to double
%152 = load float, float* %5
%153 = fpext float %152 to double
%154 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %149, double %151, double %153)
%155 = load float, float* %34
%156 = fpext float %155 to double
%157 = load float, float* %37
%158 = fpext float %157 to double
%159 = load float, float* %102
%160 = fpext float %159 to double
%161 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %156, double %158, double %160)
%162 = load float, float* %38
%163 = fpext float %162 to double
%164 = load float, float* %41
%165 = fpext float %164 to double
%166 = load float, float* %105
%167 = fpext float %166 to double
%168 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %163, double %165, double %167)
%169 = load float, float* %42
%170 = fpext float %169 to double
%171 = load float, float* %45
%172 = fpext float %171 to double
%173 = load float, float* %108
%174 = fpext float %173 to double
%175 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %170, double %172, double %174)
%176 = load float, float* %46
%177 = fpext float %176 to double
%178 = load float, float* %49
%179 = fpext float %178 to double
%180 = load float, float* %111
%181 = fpext float %180 to double
%182 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %177, double %179, double %181)
%183 = load float, float* %50
%184 = fpext float %183 to double
%185 = load float, float* %53
%186 = fpext float %185 to double
%187 = load float, float* %114
%188 = fpext float %187 to double
%189 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %184, double %186, double %188)
%190 = load float, float* %54
%191 = fpext float %190 to double
%192 = load float, float* %57
%193 = fpext float %192 to double
%194 = load float, float* %117
%195 = fpext float %194 to double
%196 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %191, double %193, double %195)
%197 = load float, float* %58
%198 = fpext float %197 to double
%199 = load float, float* %61
%200 = fpext float %199 to double
%201 = load float, float* %120
%202 = fpext float %201 to double
%203 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %198, double %200, double %202)
%204 = load float, float* %62
%205 = fpext float %204 to double
%206 = load float, float* %65
%207 = fpext float %206 to double
%208 = load float, float* %123
%209 = fpext float %208 to double
%210 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %205, double %207, double %209)
%211 = load float, float* %66
%212 = fpext float %211 to double
%213 = load float, float* %69
%214 = fpext float %213 to double
%215 = load float, float* %126
%216 = fpext float %215 to double
%217 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %212, double %214, double %216)
%218 = load float, float* %70
%219 = fpext float %218 to double
%220 = load float, float* %73
%221 = fpext float %220 to double
%222 = load float, float* %129
%223 = fpext float %222 to double
%224 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %219, double %221, double %223)
%225 = load float, float* %74
%226 = fpext float %225 to double
%227 = load float, float* %77
%228 = fpext float %227 to double
%229 = load float, float* %132
%230 = fpext float %229 to double
%231 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %226, double %228, double %230)
%232 = load float, float* %78
%233 = fpext float %232 to double
%234 = load float, float* %81
%235 = fpext float %234 to double
%236 = load float, float* %135
%237 = fpext float %236 to double
%238 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %233, double %235, double %237)
%239 = load float, float* %82
%240 = fpext float %239 to double
%241 = load float, float* %85
%242 = fpext float %241 to double
%243 = load float, float* %138
%244 = fpext float %243 to double
%245 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %240, double %242, double %244)
%246 = load float, float* %86
%247 = fpext float %246 to double
%248 = load float, float* %89
%249 = fpext float %248 to double
%250 = load float, float* %141
%251 = fpext float %250 to double
%252 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %247, double %249, double %251)
%253 = load float, float* %90
%254 = fpext float %253 to double
%255 = load float, float* %93
%256 = fpext float %255 to double
%257 = load float, float* %144
%258 = fpext float %257 to double
%259 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), double %254, double %256, double %258)
%260 = tail call i32 @putchar(i32 10)
%261 = tail call i32 @free(float* %3)
%262 = tail call i32 @free(float* %4)
%263 = tail call i32 @free(float* %5)
ret i32 0
}