#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 atoi(char const *);
double fabsf(float);
int pow(float, int);
int /*<<< orphan*/ printf(char *, char *, float);
int /*<<< orphan*/ putchar(char);
int sqrt(float);
int main(int argc, const char *argv[]) {
  int sample_size = atoi(argv[1]);
  float pi_value_array[sample_size];
  for (int i = 0; i < sample_size; i++) {
    float a = 1;
    float b = 1 / sqrt(2);
    float t = 0.25;
    float p = 1;
    float temp_a = 0;
    float temp_b = 0;
    float temp_t = 0;
    float temp_p = 0;
    int count = 0;
    while (fabsf(a - b) > 0.00001) {
      temp_a = a;
      temp_b = b;
      temp_t = t;
      temp_p = p;
      a = (temp_a + temp_b) / 2;
      b = sqrt(temp_a * temp_b);
      t = temp_t - temp_p * pow(temp_a - a, 2);
      p = 2 * temp_p;
      count++;
    }
    float PI = pow(a + b, 2) / (4 * t);
    pi_value_array[i] = PI;
  }
  float final_pi_value = 0;
  for (int k = 0; k < sample_size; k++) {
    final_pi_value = final_pi_value + pi_value_array[k];
  }
  printf("%s%.16f", "Value of Pi : ", final_pi_value / sample_size);
  putchar('\n');
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    136a <main+0x20a>
movss  0xe38(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0xe33(%rip),%xmm0
call   1080 <sqrt@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xe0f(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xdfe(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
call   1040 <fabsf@plt>
movsd  0xdcb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    131a <main+0x1ba>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  0xd7f(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
call   1080 <sqrt@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
mov    $0x2,%edi
call   1060 <pow@plt>
movss  -0x70(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm1
cvtsi2ss %eax,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xd06(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    122e <main+0xce>
movss  -0x30(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
mov    $0x2,%edi
call   1060 <pow@plt>
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
cvtsi2ss %ecx,%xmm0
movss  0xccc(%rip),%xmm1
mulss  -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b4 <main+0x54>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13aa <main+0x24a>
mov    -0x68(%rbp),%rax
movss  -0x58(%rbp),%xmm0
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1379 <main+0x219>
movss  -0x58(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
lea    0xc59(%rip),%rdi
lea    0xc5a(%rip),%rsi
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    0x8(%rsi),%rdi
call   1070 <atoi@plt>
mov    %eax,%r14d
mov    %rsp,%r15
lea    0xf(,%r14,4),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%r15
mov    %r15,%rsp
xorps  %xmm0,%xmm0
test   %eax,%eax
jle    139e <main+0x23e>
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    1206 <main+0xa6>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xe4c(%rip),%xmm1
movss  0xe48(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
mov    $0x2,%edi
call   1060 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  -0x30(%rbp),%xmm1
mulss  0xe21(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%r15,%r13,4)
add    $0x1,%r13
cmp    %r14,%r13
je     1306 <main+0x1a6>
movss  0xdf2(%rip),%xmm0
call   1080 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0xdd8(%rip),%xmm0
movss  %xmm1,-0x2c(%rbp)
subss  %xmm1,%xmm0
call   1040 <fabsf@plt>
movsd  0xdd6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    11b0 <main+0x50>
movss  0xdb0(%rip),%xmm2
movss  %xmm2,-0x38(%rbp)
movss  0xda7(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movaps %xmm2,%xmm1
movss  -0x2c(%rbp),%xmm0
xchg   %ax,%ax
movss  %xmm2,-0x2c(%rbp)
addss  %xmm0,%xmm1
mulss  0xd8b(%rip),%xmm1
movss  %xmm1,-0x34(%rbp)
mulss  %xmm2,%xmm0
call   1080 <sqrt@plt>
mov    %eax,%ebx
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
mov    $0x2,%edi
call   1060 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
movss  -0x30(%rbp),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x30(%rbp)
addss  %xmm2,%xmm2
movss  %xmm2,-0x38(%rbp)
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
movss  %xmm1,-0x2c(%rbp)
movss  -0x34(%rbp),%xmm0
subss  %xmm1,%xmm0
call   1040 <fabsf@plt>
movss  -0x34(%rbp),%xmm1
ucomisd 0xd25(%rip),%xmm0
movss  -0x2c(%rbp),%xmm0
movaps %xmm1,%xmm2
ja     1270 <main+0x110>
jmp    11ca <main+0x6a>
test   %r14d,%r14d
xorps  %xmm0,%xmm0
jle    139e <main+0x23e>
lea    -0x1(%r14),%rcx
mov    %r14d,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
jae    1329 <main+0x1c9>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1380 <main+0x220>
mov    %r14d,%edx
and    $0xfffffff8,%edx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  (%r15,%rcx,4),%xmm0
addss  0x4(%r15,%rcx,4),%xmm0
addss  0x8(%r15,%rcx,4),%xmm0
addss  0xc(%r15,%rcx,4),%xmm0
addss  0x10(%r15,%rcx,4),%xmm0
addss  0x14(%r15,%rcx,4),%xmm0
addss  0x18(%r15,%rcx,4),%xmm0
addss  0x1c(%r15,%rcx,4),%xmm0
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1340 <main+0x1e0>
test   %rax,%rax
je     139e <main+0x23e>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addss  (%rcx,%rdx,4),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1390 <main+0x230>
xorps  %xmm1,%xmm1
cvtsi2ss %r14d,%xmm1
divss  %xmm1,%xmm0
lea    0xc6f(%rip),%rdi
lea    0xc70(%rip),%rsi
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [8 x i8] c"%s%.16f\00"
@.str.1 = [15 x i8] c"Value of Pi : \00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%22 = load i8**, i8*** %5
%23 = getelementptr inbounds i8*, i8** %22, i64 1
%24 = load i8*, i8** %23
%25 = call i32 @atoi(i8* %24)
store i32 %25, i32* %6
%26 = load i32, i32* %6
%27 = zext i32 %26 to i64
%28 = call i8* @llvm.stacksave()
store i8* %28, i8** %7
%29 = alloca float, i64 %27
store i64 %27, i64* %8
store i32 0, i32* %9
br label %30
30: ; preds = %84, %2
%31 = load i32, i32* %9
%32 = load i32, i32* %6
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %87
34: ; preds = %30
store float 1.000000e+00, float* %10
%35 = call i32 @sqrt(float 2.000000e+00)
%36 = sdiv i32 1, %35
%37 = sitofp i32 %36 to float
store float %37, float* %11
store float 2.500000e-01, float* %12
store float 1.000000e+00, float* %13
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %17
store i32 0, i32* %18
br label %38
38: ; preds = %44, %34
%39 = load float, float* %10
%40 = load float, float* %11
%41 = fsub float %39, %40
%42 = call double @fabsf(float %41)
%43 = fcmp ogt double %42, 1.000000e-05
br i1 %43, label %44, label %71
44: ; preds = %38
%45 = load float, float* %10
store float %45, float* %14
%46 = load float, float* %11
store float %46, float* %15
%47 = load float, float* %12
store float %47, float* %16
%48 = load float, float* %13
store float %48, float* %17
%49 = load float, float* %14
%50 = load float, float* %15
%51 = fadd float %49, %50
%52 = fdiv float %51, 2.000000e+00
store float %52, float* %10
%53 = load float, float* %14
%54 = load float, float* %15
%55 = fmul float %53, %54
%56 = call i32 @sqrt(float %55)
%57 = sitofp i32 %56 to float
store float %57, float* %11
%58 = load float, float* %16
%59 = load float, float* %17
%60 = load float, float* %14
%61 = load float, float* %10
%62 = fsub float %60, %61
%63 = call i32 @pow(float %62, i32 2)
%64 = sitofp i32 %63 to float
%65 = fneg float %59
%66 = call float @llvm.fmuladd.f32(float %65, float %64, float %58)
store float %66, float* %12
%67 = load float, float* %17
%68 = fmul float 2.000000e+00, %67
store float %68, float* %13
%69 = load i32, i32* %18
%70 = add nsw i32 %69, 1
store i32 %70, i32* %18
br label %38
71: ; preds = %38
%72 = load float, float* %10
%73 = load float, float* %11
%74 = fadd float %72, %73
%75 = call i32 @pow(float %74, i32 2)
%76 = sitofp i32 %75 to float
%77 = load float, float* %12
%78 = fmul float 4.000000e+00, %77
%79 = fdiv float %76, %78
store float %79, float* %19
%80 = load float, float* %19
%81 = load i32, i32* %9
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %29, i64 %82
store float %80, float* %83
br label %84
84: ; preds = %71
%85 = load i32, i32* %9
%86 = add nsw i32 %85, 1
store i32 %86, i32* %9
br label %30
87: ; preds = %30
store float 0.000000e+00, float* %20
store i32 0, i32* %21
br label %88
88: ; preds = %99, %87
%89 = load i32, i32* %21
%90 = load i32, i32* %6
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %102
92: ; preds = %88
%93 = load float, float* %20
%94 = load i32, i32* %21
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %29, i64 %95
%97 = load float, float* %96
%98 = fadd float %93, %97
store float %98, float* %20
br label %99
99: ; preds = %92
%100 = load i32, i32* %21
%101 = add nsw i32 %100, 1
store i32 %101, i32* %21
br label %88
102: ; preds = %88
%103 = load float, float* %20
%104 = load i32, i32* %6
%105 = sitofp i32 %104 to float
%106 = fdiv float %103, %105
%107 = call i32 @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), float %106)
%108 = call i32 @putchar(i8 signext 10)
store i32 0, i32* %3
%109 = load i8*, i8** %7
%110 = load i32, i32* %3
ret i32 %110
}

LLVM IR (-O2):
@.str = [8 x i8] c"%s%.16f\00"
@.str.1 = [15 x i8] c"Value of Pi : \00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = getelementptr inbounds i8*, i8** %1, i64 1
%4 = load i8*, i8** %3
%5 = tail call i32 @atoi(i8* %4)
%6 = zext i32 %5 to i64
%7 = alloca float, i64 %6
%8 = icmp sgt i32 %5, 0
br i1 %8, label %16, label %72
9: ; preds = %45
br i1 %8, label %10, label %72
10: ; preds = %9
%11 = add nsw i64 %6, -1
%12 = and i64 %6, 7
%13 = icmp ult i64 %11, 7
br i1 %13, label %57, label %14
14: ; preds = %10
%15 = and i64 %6, 4294967288
br label %78
16: ; preds = %2, %45
%17 = phi i64 [ %55, %45 ], [ 0, %2 ]
%18 = tail call i32 @sqrt(float 2.000000e+00)
%19 = add i32 %18, 1
%20 = icmp ult i32 %19, 3
%21 = select i1 %20, i32 %18, i32 0
%22 = sitofp i32 %21 to float
%23 = fsub float 1.000000e+00, %22
%24 = tail call double @fabsf(float %23)
%25 = fcmp ogt double %24, 1.000000e-05
br i1 %25, label %26, label %45
26: ; preds = %16, %26
%27 = phi float [ %41, %26 ], [ %22, %16 ]
%28 = phi float [ %40, %26 ], [ 1.000000e+00, %16 ]
%29 = phi float [ %39, %26 ], [ 2.500000e-01, %16 ]
%30 = phi float [ %32, %26 ], [ 1.000000e+00, %16 ]
%31 = fadd float %30, %27
%32 = fmul float %31, 5.000000e-01
%33 = fmul float %30, %27
%34 = tail call i32 @sqrt(float %33)
%35 = fsub float %30, %32
%36 = tail call i32 @pow(float %35, i32 2)
%37 = sitofp i32 %36 to float
%38 = fneg float %28
%39 = tail call float @llvm.fmuladd.f32(float %38, float %37, float %29)
%40 = fmul float %28, 2.000000e+00
%41 = sitofp i32 %34 to float
%42 = fsub float %32, %41
%43 = tail call double @fabsf(float %42)
%44 = fcmp ogt double %43, 1.000000e-05
br i1 %44, label %26, label %45
45: ; preds = %26, %16
%46 = phi float [ 1.000000e+00, %16 ], [ %32, %26 ]
%47 = phi float [ 2.500000e-01, %16 ], [ %39, %26 ]
%48 = phi float [ %22, %16 ], [ %41, %26 ]
%49 = fadd float %46, %48
%50 = tail call i32 @pow(float %49, i32 2)
%51 = sitofp i32 %50 to float
%52 = fmul float %47, 4.000000e+00
%53 = fdiv float %51, %52
%54 = getelementptr inbounds float, float* %7, i64 %17
store float %53, float* %54
%55 = add nuw nsw i64 %17, 1
%56 = icmp eq i64 %55, %6
br i1 %56, label %9, label %16
57: ; preds = %78, %10
%58 = phi float [ undef, %10 ], [ %112, %78 ]
%59 = phi i64 [ 0, %10 ], [ %113, %78 ]
%60 = phi float [ 0.000000e+00, %10 ], [ %112, %78 ]
%61 = icmp eq i64 %12, 0
br i1 %61, label %72, label %62
62: ; preds = %57, %62
%63 = phi i64 [ %69, %62 ], [ %59, %57 ]
%64 = phi float [ %68, %62 ], [ %60, %57 ]
%65 = phi i64 [ %70, %62 ], [ 0, %57 ]
%66 = getelementptr inbounds float, float* %7, i64 %63
%67 = load float, float* %66
%68 = fadd float %64, %67
%69 = add nuw nsw i64 %63, 1
%70 = add i64 %65, 1
%71 = icmp eq i64 %70, %12
br i1 %71, label %72, label %62
72: ; preds = %57, %62, %2, %9
%73 = phi float [ 0.000000e+00, %9 ], [ 0.000000e+00, %2 ], [ %58, %57 ], [ %68, %62 ]
%74 = sitofp i32 %5 to float
%75 = fdiv float %73, %74
%76 = tail call i32 @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), float %75)
%77 = tail call i32 @putchar(i8 signext 10)
ret i32 0
78: ; preds = %78, %14
%79 = phi i64 [ 0, %14 ], [ %113, %78 ]
%80 = phi float [ 0.000000e+00, %14 ], [ %112, %78 ]
%81 = phi i64 [ 0, %14 ], [ %114, %78 ]
%82 = getelementptr inbounds float, float* %7, i64 %79
%83 = load float, float* %82
%84 = fadd float %80, %83
%85 = or i64 %79, 1
%86 = getelementptr inbounds float, float* %7, i64 %85
%87 = load float, float* %86
%88 = fadd float %84, %87
%89 = or i64 %79, 2
%90 = getelementptr inbounds float, float* %7, i64 %89
%91 = load float, float* %90
%92 = fadd float %88, %91
%93 = or i64 %79, 3
%94 = getelementptr inbounds float, float* %7, i64 %93
%95 = load float, float* %94
%96 = fadd float %92, %95
%97 = or i64 %79, 4
%98 = getelementptr inbounds float, float* %7, i64 %97
%99 = load float, float* %98
%100 = fadd float %96, %99
%101 = or i64 %79, 5
%102 = getelementptr inbounds float, float* %7, i64 %101
%103 = load float, float* %102
%104 = fadd float %100, %103
%105 = or i64 %79, 6
%106 = getelementptr inbounds float, float* %7, i64 %105
%107 = load float, float* %106
%108 = fadd float %104, %107
%109 = or i64 %79, 7
%110 = getelementptr inbounds float, float* %7, i64 %109
%111 = load float, float* %110
%112 = fadd float %108, %111
%113 = add nuw nsw i64 %79, 8
%114 = add i64 %81, 8
%115 = icmp eq i64 %114, %15
br i1 %115, label %57, label %78
}