#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 RAND_MAX;
double compute_expected_fraction_heads_min();
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, int, int, int, double, double, double, double,
                          double);
int rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main() {
  int head_count_array[1000];
  unsigned int experiment_index;
  unsigned int coin_index;
  unsigned int toss_index;
  int bitshift = 0;
  int bitmask = 1;
  int current_coins;
  int coin_index_first;
  int coin_index_random;
  int coin_index_min;
  long total_head_count_first;
  long total_head_count_random;
  long total_head_count_min;
  long total_random_index;
  long num_toss_experiments;
  double fraction_heads_first;
  double fraction_heads_random;
  double fraction_heads_min;
  double average_random_index;
  srand(time(NULL));
  coin_index_first = 0;
  total_head_count_first = 0;
  total_head_count_random = 0;
  total_head_count_min = 0;
  total_random_index = 0;
  experiment_index = 0;
  while (experiment_index < 100000) {
    memset(head_count_array, 0, sizeof head_count_array);
    coin_index_random = rand() % 1000;
    coin_index_min = 0;
    coin_index = 0;
    while (coin_index < 1000) {
      toss_index = 0;
      while (toss_index < 10) {
        if (!(RAND_MAX >> bitshift)) {
          current_coins = rand();
          bitshift = 0;
        }
        head_count_array[coin_index] += (current_coins >> bitshift) & bitmask;
        bitshift++;
        toss_index++;
      }
      if (head_count_array[coin_index] < head_count_array[coin_index_min]) {
        coin_index_min = coin_index;
      }
      coin_index++;
    }
    total_head_count_first += (long)head_count_array[coin_index_first];
    total_head_count_random += (long)head_count_array[coin_index_random];
    total_head_count_min += (long)head_count_array[coin_index_min];
    total_random_index += (long)coin_index_random;
    experiment_index++;
  }
  num_toss_experiments = 100000 * 10;
  fraction_heads_first = (double)total_head_count_first / num_toss_experiments;
  fraction_heads_random =
      (double)total_head_count_random / num_toss_experiments;
  fraction_heads_min = (double)total_head_count_min / num_toss_experiments;
  average_random_index = (double)total_random_index / 100000;
  printf("%d experiments complete, %d coins tossed per experiment, each coin "
         "tossed %d times, average fraction heads of first coin = %f, of "
         "randomly selected coin (average index %f) = %f, and of min coin with "
         "fewest head in current experiment = %f (expected value = %f)\n",
         100000, 1000, 10, fraction_heads_first, average_random_index,
         fraction_heads_random, fraction_heads_min,
         compute_expected_fraction_heads_min());
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1040,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xfc0(%rbp)
movl   $0x1,-0xfc4(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1060 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
movl   $0x0,-0xfcc(%rbp)
movq   $0x0,-0xfe0(%rbp)
movq   $0x0,-0xfe8(%rbp)
movq   $0x0,-0xff0(%rbp)
movq   $0x0,-0xff8(%rbp)
movl   $0x0,-0xfb4(%rbp)
cmpl   $0x186a0,-0xfb4(%rbp)
jae    1388 <main+0x228>
lea    -0xfb0(%rbp),%rdi
xor    %esi,%esi
mov    $0xfa0,%edx
call   1040 <memset@plt>
mov    $0x0,%al
call   1080 <rand@plt>
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %edx,-0xfd0(%rbp)
movl   $0x0,-0xfd4(%rbp)
movl   $0x0,-0xfb8(%rbp)
cmpl   $0x3e8,-0xfb8(%rbp)
jae    1308 <main+0x1a8>
movl   $0x0,-0xfbc(%rbp)
cmpl   $0xa,-0xfbc(%rbp)
jae    12c7 <main+0x167>
mov    0x2d98(%rip),%rax
mov    (%rax),%eax
mov    -0xfc0(%rbp),%ecx
sar    %cl,%eax
cmp    $0x0,%eax
jne    127a <main+0x11a>
mov    $0x0,%al
call   1080 <rand@plt>
mov    %eax,-0xfc8(%rbp)
movl   $0x0,-0xfc0(%rbp)
mov    -0xfc8(%rbp),%eax
mov    -0xfc0(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
and    -0xfc4(%rbp),%ecx
mov    -0xfb8(%rbp),%eax
add    -0xfb0(%rbp,%rax,4),%ecx
mov    %ecx,-0xfb0(%rbp,%rax,4)
mov    -0xfc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc0(%rbp)
mov    -0xfbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfbc(%rbp)
jmp    123c <main+0xdc>
mov    -0xfb8(%rbp),%eax
mov    -0xfb0(%rbp,%rax,4),%eax
movslq -0xfd4(%rbp),%rcx
cmp    -0xfb0(%rbp,%rcx,4),%eax
jge    12f4 <main+0x194>
mov    -0xfb8(%rbp),%eax
mov    %eax,-0xfd4(%rbp)
mov    -0xfb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfb8(%rbp)
jmp    1222 <main+0xc2>
movslq -0xfcc(%rbp),%rax
movslq -0xfb0(%rbp,%rax,4),%rax
ff
add    -0xfe0(%rbp),%rax
mov    %rax,-0xfe0(%rbp)
movslq -0xfd0(%rbp),%rax
movslq -0xfb0(%rbp,%rax,4),%rax
ff
add    -0xfe8(%rbp),%rax
mov    %rax,-0xfe8(%rbp)
movslq -0xfd4(%rbp),%rax
movslq -0xfb0(%rbp,%rax,4),%rax
ff
add    -0xff0(%rbp),%rax
mov    %rax,-0xff0(%rbp)
movslq -0xfd0(%rbp),%rax
add    -0xff8(%rbp),%rax
mov    %rax,-0xff8(%rbp)
mov    -0xfb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfb4(%rbp)
jmp    11d6 <main+0x76>
movq   $0xf4240,-0x1000(%rbp)
cvtsi2sdq -0xfe0(%rbp),%xmm0
ff ff
cvtsi2sdq -0x1000(%rbp),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1008(%rbp)
ff
cvtsi2sdq -0xfe8(%rbp),%xmm0
ff ff
cvtsi2sdq -0x1000(%rbp),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1010(%rbp)
ff
cvtsi2sdq -0xff0(%rbp),%xmm0
ff ff
cvtsi2sdq -0x1000(%rbp),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1018(%rbp)
ff
cvtsi2sdq -0xff8(%rbp),%xmm0
ff ff
movsd  0xc02(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1020(%rbp)
ff
movsd  -0x1008(%rbp),%xmm0
ff
movsd  %xmm0,-0x1028(%rbp)
ff
movsd  -0x1020(%rbp),%xmm0
ff
movsd  %xmm0,-0x1040(%rbp)
ff
movsd  -0x1010(%rbp),%xmm0
ff
movsd  %xmm0,-0x1038(%rbp)
ff
movsd  -0x1018(%rbp),%xmm0
ff
movsd  %xmm0,-0x1030(%rbp)
ff
mov    $0x0,%al
call   1070 <compute_expected_fraction_heads_min@plt>
movsd  -0x1040(%rbp),%xmm1
ff
movsd  -0x1038(%rbp),%xmm2
ff
movsd  -0x1030(%rbp),%xmm3
ff
movaps %xmm0,%xmm4
movsd  -0x1028(%rbp),%xmm0
ff
lea    0xb8d(%rip),%rdi
mov    $0x186a0,%esi
mov    $0x3e8,%edx
mov    $0xa,%ecx
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1040,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xfd8,%rsp
xor    %edi,%edi
call   1060 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
mov    0x2e62(%rip),%r14
xor    %r12d,%r12d
xor    %ebp,%ebp
xor    %eax,%eax
xor    %edx,%edx
xor    %esi,%esi
xor    %edi,%edi
jmp    1209 <main+0xa9>
cs nopw 0x0(%rax,%rax,1)
nop
movslq 0x2c(%rsp),%rax
imul   $0x10624dd3,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x26,%rcx
add    %edx,%ecx
imul   $0x3e8,%ecx,%ecx
sub    %ecx,%eax
movslq 0x30(%rsp),%rcx
mov    0x8(%rsp),%rdi
add    %rcx,%rdi
cltq
movslq 0x30(%rsp,%rax,4),%rcx
mov    0x10(%rsp),%rsi
add    %rcx,%rsi
movslq %r15d,%rcx
movslq 0x30(%rsp,%rcx,4),%rcx
mov    0x18(%rsp),%rdx
add    %rcx,%rdx
mov    0x20(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,%rax
add    $0x1,%r12d
cmp    $0x186a0,%r12d
je     1454 <main+0x2f4>
mov    %rdi,0x8(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rax,0x20(%rsp)
lea    0x30(%rsp),%rdi
xor    %esi,%esi
mov    $0xfa0,%edx
call   1040 <memset@plt>
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,0x2c(%rsp)
mov    (%r14),%eax
xor    %r13d,%r13d
xor    %r15d,%r15d
jmp    1280 <main+0x120>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%esi
mov    %ebp,%ecx
shr    %cl,%esi
and    $0x1,%esi
add    %edx,%esi
mov    %esi,0x30(%rsp,%r13,4)
add    $0x1,%ebp
movslq %r15d,%r15
cmp    0x30(%rsp,%r15,4),%esi
cmovl  %r13d,%r15d
add    $0x1,%r13
cmp    $0x3e8,%r13
je     11a0 <main+0x40>
mov    %eax,%edx
mov    %ebp,%ecx
sar    %cl,%edx
test   %edx,%edx
jne    1298 <main+0x138>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    (%r14),%eax
mov    %ebx,%edx
mov    %ebp,%ecx
shr    %cl,%edx
and    $0x1,%edx
add    0x30(%rsp,%r13,4),%edx
mov    %edx,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%esi
mov    %ebp,%ecx
sar    %cl,%esi
test   %esi,%esi
jne    12cb <main+0x16b>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%edx
mov    (%r14),%eax
mov    %ebx,%esi
mov    %ebp,%ecx
shr    %cl,%esi
and    $0x1,%esi
add    %edx,%esi
mov    %esi,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%edx
mov    %ebp,%ecx
sar    %cl,%edx
test   %edx,%edx
jne    12fb <main+0x19b>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%esi
mov    (%r14),%eax
mov    %ebx,%edx
mov    %ebp,%ecx
shr    %cl,%edx
and    $0x1,%edx
add    %esi,%edx
mov    %edx,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%esi
mov    %ebp,%ecx
sar    %cl,%esi
test   %esi,%esi
jne    132b <main+0x1cb>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%edx
mov    (%r14),%eax
mov    %ebx,%esi
mov    %ebp,%ecx
shr    %cl,%esi
and    $0x1,%esi
add    %edx,%esi
mov    %esi,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%edx
mov    %ebp,%ecx
sar    %cl,%edx
test   %edx,%edx
jne    135b <main+0x1fb>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%esi
mov    (%r14),%eax
mov    %ebx,%edx
mov    %ebp,%ecx
shr    %cl,%edx
and    $0x1,%edx
add    %esi,%edx
mov    %edx,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%esi
mov    %ebp,%ecx
sar    %cl,%esi
test   %esi,%esi
jne    138b <main+0x22b>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%edx
mov    (%r14),%eax
mov    %ebx,%esi
mov    %ebp,%ecx
shr    %cl,%esi
and    $0x1,%esi
add    %edx,%esi
mov    %esi,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%edx
mov    %ebp,%ecx
sar    %cl,%edx
test   %edx,%edx
jne    13bb <main+0x25b>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%esi
mov    (%r14),%eax
mov    %ebx,%edx
mov    %ebp,%ecx
shr    %cl,%edx
and    $0x1,%edx
add    %esi,%edx
mov    %edx,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%esi
mov    %ebp,%ecx
sar    %cl,%esi
test   %esi,%esi
jne    13eb <main+0x28b>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%edx
mov    (%r14),%eax
mov    %ebx,%esi
mov    %ebp,%ecx
shr    %cl,%esi
and    $0x1,%esi
add    %edx,%esi
mov    %esi,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%edx
mov    %ebp,%ecx
sar    %cl,%edx
test   %edx,%edx
jne    141b <main+0x2bb>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    0x30(%rsp,%r13,4),%esi
mov    (%r14),%eax
mov    %ebx,%edx
mov    %ebp,%ecx
shr    %cl,%edx
and    $0x1,%edx
add    %esi,%edx
mov    %edx,0x30(%rsp,%r13,4)
add    $0x1,%ebp
mov    %eax,%esi
mov    %ebp,%ecx
sar    %cl,%esi
test   %esi,%esi
jne    1250 <main+0xf0>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <rand@plt>
mov    %eax,%ebx
mov    (%r14),%eax
mov    0x30(%rsp,%r13,4),%edx
jmp    1250 <main+0xf0>
cvtsi2sd %rdi,%xmm1
movsd  0xb9f(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %rsi,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %rdx,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
divsd  0xb69(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <compute_expected_fraction_heads_min@plt>
movapd %xmm0,%xmm4
lea    0xb59(%rip),%rdi
mov    $0x186a0,%esi
mov    $0x3e8,%edx
mov    $0xa,%ecx
movsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
movsd  0x18(%rsp),%xmm2
movsd  0x10(%rsp),%xmm3
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xfd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@RAND_MAX = global i32 0
@.str = [261 x i8] c"%d experiments complete, %d coins tossed per experiment, each coin tossed %d times, average fraction heads of first coin = %f, of randomly selected coin (average index %f) = %f, and of min coin with fewest head in current experiment = %f (expected value = %f)\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1000 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
store i32 0, i32* %1
store i32 0, i32* %6
store i32 1, i32* %7
%21 = call i32 @time(i32* null)
%22 = call i32 @srand(i32 %21)
store i32 0, i32* %9
store i64 0, i64* %12
store i64 0, i64* %13
store i64 0, i64* %14
store i64 0, i64* %15
store i32 0, i32* %3
br label %23
23: ; preds = %75, %0
%24 = load i32, i32* %3
%25 = icmp ult i32 %24, 100000
br i1 %25, label %26, label %103
26: ; preds = %23
%27 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 0
%28 = call i32 @memset(i32* %27, i32 0, i32 4000)
%29 = call i32 (...) @rand()
%30 = srem i32 %29, 1000
store i32 %30, i32* %10
store i32 0, i32* %11
store i32 0, i32* %4
br label %31
31: ; preds = %72, %26
%32 = load i32, i32* %4
%33 = icmp ult i32 %32, 1000
br i1 %33, label %34, label %75
34: ; preds = %31
store i32 0, i32* %5
br label %35
35: ; preds = %45, %34
%36 = load i32, i32* %5
%37 = icmp ult i32 %36, 10
br i1 %37, label %38, label %60
38: ; preds = %35
%39 = load i32, i32* @RAND_MAX
%40 = load i32, i32* %6
%41 = ashr i32 %39, %40
%42 = icmp ne i32 %41, 0
br i1 %42, label %45, label %43
43: ; preds = %38
%44 = call i32 (...) @rand()
store i32 %44, i32* %8
store i32 0, i32* %6
br label %45
45: ; preds = %43, %38
%46 = load i32, i32* %8
%47 = load i32, i32* %6
%48 = ashr i32 %46, %47
%49 = load i32, i32* %7
%50 = and i32 %48, %49
%51 = load i32, i32* %4
%52 = zext i32 %51 to i64
%53 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %52
%54 = load i32, i32* %53
%55 = add nsw i32 %54, %50
store i32 %55, i32* %53
%56 = load i32, i32* %6
%57 = add nsw i32 %56, 1
store i32 %57, i32* %6
%58 = load i32, i32* %5
%59 = add i32 %58, 1
store i32 %59, i32* %5
br label %35
60: ; preds = %35
%61 = load i32, i32* %4
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %62
%64 = load i32, i32* %63
%65 = load i32, i32* %11
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %66
%68 = load i32, i32* %67
%69 = icmp slt i32 %64, %68
br i1 %69, label %70, label %72
70: ; preds = %60
%71 = load i32, i32* %4
store i32 %71, i32* %11
br label %72
72: ; preds = %70, %60
%73 = load i32, i32* %4
%74 = add i32 %73, 1
store i32 %74, i32* %4
br label %31
75: ; preds = %31
%76 = load i32, i32* %9
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %77
%79 = load i32, i32* %78
%80 = sext i32 %79 to i64
%81 = load i64, i64* %12
%82 = add nsw i64 %81, %80
store i64 %82, i64* %12
%83 = load i32, i32* %10
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = sext i32 %86 to i64
%88 = load i64, i64* %13
%89 = add nsw i64 %88, %87
store i64 %89, i64* %13
%90 = load i32, i32* %11
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %91
%93 = load i32, i32* %92
%94 = sext i32 %93 to i64
%95 = load i64, i64* %14
%96 = add nsw i64 %95, %94
store i64 %96, i64* %14
%97 = load i32, i32* %10
%98 = sext i32 %97 to i64
%99 = load i64, i64* %15
%100 = add nsw i64 %99, %98
store i64 %100, i64* %15
%101 = load i32, i32* %3
%102 = add i32 %101, 1
store i32 %102, i32* %3
br label %23
103: ; preds = %23
store i64 1000000, i64* %16
%104 = load i64, i64* %12
%105 = sitofp i64 %104 to double
%106 = load i64, i64* %16
%107 = sitofp i64 %106 to double
%108 = fdiv double %105, %107
store double %108, double* %17
%109 = load i64, i64* %13
%110 = sitofp i64 %109 to double
%111 = load i64, i64* %16
%112 = sitofp i64 %111 to double
%113 = fdiv double %110, %112
store double %113, double* %18
%114 = load i64, i64* %14
%115 = sitofp i64 %114 to double
%116 = load i64, i64* %16
%117 = sitofp i64 %116 to double
%118 = fdiv double %115, %117
store double %118, double* %19
%119 = load i64, i64* %15
%120 = sitofp i64 %119 to double
%121 = fdiv double %120, 1.000000e+05
store double %121, double* %20
%122 = load double, double* %17
%123 = load double, double* %20
%124 = load double, double* %18
%125 = load double, double* %19
%126 = call double (...) @compute_expected_fraction_heads_min()
%127 = call i32 @printf(i8* getelementptr inbounds ([261 x i8], [261 x i8]* @.str, i64 0, i64 0), i32 100000, i32 1000, i32 10, double %122, double %123, double %124, double %125, double %126)
ret i32 0
}

LLVM IR (-O2):
@RAND_MAX = global i32 0
@.str = [261 x i8] c"%d experiments complete, %d coins tossed per experiment, each coin tossed %d times, average fraction heads of first coin = %f, of randomly selected coin (average index %f) = %f, and of min coin with fewest head in current experiment = %f (expected value = %f)\0A\00"
define i32 @main() {
%1 = alloca [1000 x i32]
%2 = bitcast [1000 x i32]* %1 to i8*
%3 = tail call i32 @time(i32* null)
%4 = tail call i32 @srand(i32 %3)
%5 = getelementptr inbounds [1000 x i32], [1000 x i32]* %1, i64 0, i64 0
br label %6
6: ; preds = %0, %181
%7 = phi i32 [ 0, %0 ], [ %197, %181 ]
%8 = phi i32 [ 0, %0 ], [ %172, %181 ]
%9 = phi i32 [ undef, %0 ], [ %167, %181 ]
%10 = phi i64 [ 0, %0 ], [ %196, %181 ]
%11 = phi i64 [ 0, %0 ], [ %195, %181 ]
%12 = phi i64 [ 0, %0 ], [ %190, %181 ]
%13 = phi i64 [ 0, %0 ], [ %185, %181 ]
%14 = call i32 @memset(i32* %5, i32 0, i32 4000)
%15 = call i32 (...) @rand()
%16 = load i32, i32* @RAND_MAX
br label %17
17: ; preds = %6, %164
%18 = phi i32 [ %16, %6 ], [ %166, %164 ]
%19 = phi i64 [ 0, %6 ], [ %179, %164 ]
%20 = phi i32 [ %8, %6 ], [ %172, %164 ]
%21 = phi i32 [ %9, %6 ], [ %167, %164 ]
%22 = phi i32 [ 0, %6 ], [ %178, %164 ]
%23 = getelementptr inbounds [1000 x i32], [1000 x i32]* %1, i64 0, i64 %19
%24 = ashr i32 %18, %20
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %29
26: ; preds = %17
%27 = call i32 (...) @rand()
%28 = load i32, i32* @RAND_MAX
br label %29
29: ; preds = %26, %17
%30 = phi i32 [ %18, %17 ], [ %28, %26 ]
%31 = phi i32 [ %21, %17 ], [ %27, %26 ]
%32 = phi i32 [ %20, %17 ], [ 0, %26 ]
%33 = lshr i32 %31, %32
%34 = and i32 %33, 1
%35 = load i32, i32* %23
%36 = add nsw i32 %34, %35
store i32 %36, i32* %23
%37 = add nsw i32 %32, 1
%38 = ashr i32 %30, %37
%39 = icmp eq i32 %38, 0
br i1 %39, label %40, label %44
40: ; preds = %29
%41 = call i32 (...) @rand()
%42 = load i32, i32* %23
%43 = load i32, i32* @RAND_MAX
br label %44
44: ; preds = %40, %29
%45 = phi i32 [ %30, %29 ], [ %43, %40 ]
%46 = phi i32 [ %36, %29 ], [ %42, %40 ]
%47 = phi i32 [ %31, %29 ], [ %41, %40 ]
%48 = phi i32 [ %37, %29 ], [ 0, %40 ]
%49 = lshr i32 %47, %48
%50 = and i32 %49, 1
%51 = add nsw i32 %50, %46
store i32 %51, i32* %23
%52 = add nsw i32 %48, 1
%53 = ashr i32 %45, %52
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %59
55: ; preds = %44
%56 = call i32 (...) @rand()
%57 = load i32, i32* %23
%58 = load i32, i32* @RAND_MAX
br label %59
59: ; preds = %55, %44
%60 = phi i32 [ %45, %44 ], [ %58, %55 ]
%61 = phi i32 [ %51, %44 ], [ %57, %55 ]
%62 = phi i32 [ %47, %44 ], [ %56, %55 ]
%63 = phi i32 [ %52, %44 ], [ 0, %55 ]
%64 = lshr i32 %62, %63
%65 = and i32 %64, 1
%66 = add nsw i32 %65, %61
store i32 %66, i32* %23
%67 = add nsw i32 %63, 1
%68 = ashr i32 %60, %67
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %74
70: ; preds = %59
%71 = call i32 (...) @rand()
%72 = load i32, i32* %23
%73 = load i32, i32* @RAND_MAX
br label %74
74: ; preds = %70, %59
%75 = phi i32 [ %60, %59 ], [ %73, %70 ]
%76 = phi i32 [ %66, %59 ], [ %72, %70 ]
%77 = phi i32 [ %62, %59 ], [ %71, %70 ]
%78 = phi i32 [ %67, %59 ], [ 0, %70 ]
%79 = lshr i32 %77, %78
%80 = and i32 %79, 1
%81 = add nsw i32 %80, %76
store i32 %81, i32* %23
%82 = add nsw i32 %78, 1
%83 = ashr i32 %75, %82
%84 = icmp eq i32 %83, 0
br i1 %84, label %85, label %89
85: ; preds = %74
%86 = call i32 (...) @rand()
%87 = load i32, i32* %23
%88 = load i32, i32* @RAND_MAX
br label %89
89: ; preds = %85, %74
%90 = phi i32 [ %75, %74 ], [ %88, %85 ]
%91 = phi i32 [ %81, %74 ], [ %87, %85 ]
%92 = phi i32 [ %77, %74 ], [ %86, %85 ]
%93 = phi i32 [ %82, %74 ], [ 0, %85 ]
%94 = lshr i32 %92, %93
%95 = and i32 %94, 1
%96 = add nsw i32 %95, %91
store i32 %96, i32* %23
%97 = add nsw i32 %93, 1
%98 = ashr i32 %90, %97
%99 = icmp eq i32 %98, 0
br i1 %99, label %100, label %104
100: ; preds = %89
%101 = call i32 (...) @rand()
%102 = load i32, i32* %23
%103 = load i32, i32* @RAND_MAX
br label %104
104: ; preds = %100, %89
%105 = phi i32 [ %90, %89 ], [ %103, %100 ]
%106 = phi i32 [ %96, %89 ], [ %102, %100 ]
%107 = phi i32 [ %92, %89 ], [ %101, %100 ]
%108 = phi i32 [ %97, %89 ], [ 0, %100 ]
%109 = lshr i32 %107, %108
%110 = and i32 %109, 1
%111 = add nsw i32 %110, %106
store i32 %111, i32* %23
%112 = add nsw i32 %108, 1
%113 = ashr i32 %105, %112
%114 = icmp eq i32 %113, 0
br i1 %114, label %115, label %119
115: ; preds = %104
%116 = call i32 (...) @rand()
%117 = load i32, i32* %23
%118 = load i32, i32* @RAND_MAX
br label %119
119: ; preds = %115, %104
%120 = phi i32 [ %105, %104 ], [ %118, %115 ]
%121 = phi i32 [ %111, %104 ], [ %117, %115 ]
%122 = phi i32 [ %107, %104 ], [ %116, %115 ]
%123 = phi i32 [ %112, %104 ], [ 0, %115 ]
%124 = lshr i32 %122, %123
%125 = and i32 %124, 1
%126 = add nsw i32 %125, %121
store i32 %126, i32* %23
%127 = add nsw i32 %123, 1
%128 = ashr i32 %120, %127
%129 = icmp eq i32 %128, 0
br i1 %129, label %130, label %134
130: ; preds = %119
%131 = call i32 (...) @rand()
%132 = load i32, i32* %23
%133 = load i32, i32* @RAND_MAX
br label %134
134: ; preds = %130, %119
%135 = phi i32 [ %120, %119 ], [ %133, %130 ]
%136 = phi i32 [ %126, %119 ], [ %132, %130 ]
%137 = phi i32 [ %122, %119 ], [ %131, %130 ]
%138 = phi i32 [ %127, %119 ], [ 0, %130 ]
%139 = lshr i32 %137, %138
%140 = and i32 %139, 1
%141 = add nsw i32 %140, %136
store i32 %141, i32* %23
%142 = add nsw i32 %138, 1
%143 = ashr i32 %135, %142
%144 = icmp eq i32 %143, 0
br i1 %144, label %145, label %149
145: ; preds = %134
%146 = call i32 (...) @rand()
%147 = load i32, i32* %23
%148 = load i32, i32* @RAND_MAX
br label %149
149: ; preds = %145, %134
%150 = phi i32 [ %135, %134 ], [ %148, %145 ]
%151 = phi i32 [ %141, %134 ], [ %147, %145 ]
%152 = phi i32 [ %137, %134 ], [ %146, %145 ]
%153 = phi i32 [ %142, %134 ], [ 0, %145 ]
%154 = lshr i32 %152, %153
%155 = and i32 %154, 1
%156 = add nsw i32 %155, %151
store i32 %156, i32* %23
%157 = add nsw i32 %153, 1
%158 = ashr i32 %150, %157
%159 = icmp eq i32 %158, 0
br i1 %159, label %160, label %164
160: ; preds = %149
%161 = call i32 (...) @rand()
%162 = load i32, i32* @RAND_MAX
%163 = load i32, i32* %23
br label %164
164: ; preds = %160, %149
%165 = phi i32 [ %156, %149 ], [ %163, %160 ]
%166 = phi i32 [ %150, %149 ], [ %162, %160 ]
%167 = phi i32 [ %152, %149 ], [ %161, %160 ]
%168 = phi i32 [ %157, %149 ], [ 0, %160 ]
%169 = lshr i32 %167, %168
%170 = and i32 %169, 1
%171 = add nsw i32 %170, %165
store i32 %171, i32* %23
%172 = add nsw i32 %168, 1
%173 = sext i32 %22 to i64
%174 = getelementptr inbounds [1000 x i32], [1000 x i32]* %1, i64 0, i64 %173
%175 = load i32, i32* %174
%176 = icmp slt i32 %171, %175
%177 = trunc i64 %19 to i32
%178 = select i1 %176, i32 %177, i32 %22
%179 = add nuw nsw i64 %19, 1
%180 = icmp eq i64 %179, 1000
br i1 %180, label %181, label %17
181: ; preds = %164
%182 = srem i32 %15, 1000
%183 = load i32, i32* %5
%184 = sext i32 %183 to i64
%185 = add nsw i64 %13, %184
%186 = sext i32 %182 to i64
%187 = getelementptr inbounds [1000 x i32], [1000 x i32]* %1, i64 0, i64 %186
%188 = load i32, i32* %187
%189 = sext i32 %188 to i64
%190 = add nsw i64 %12, %189
%191 = sext i32 %178 to i64
%192 = getelementptr inbounds [1000 x i32], [1000 x i32]* %1, i64 0, i64 %191
%193 = load i32, i32* %192
%194 = sext i32 %193 to i64
%195 = add nsw i64 %11, %194
%196 = add nsw i64 %10, %186
%197 = add nuw nsw i32 %7, 1
%198 = icmp eq i32 %197, 100000
br i1 %198, label %199, label %6
199: ; preds = %181
%200 = sitofp i64 %185 to double
%201 = fdiv double %200, 1.000000e+06
%202 = sitofp i64 %190 to double
%203 = fdiv double %202, 1.000000e+06
%204 = sitofp i64 %195 to double
%205 = fdiv double %204, 1.000000e+06
%206 = sitofp i64 %196 to double
%207 = fdiv double %206, 1.000000e+05
%208 = call double (...) @compute_expected_fraction_heads_min()
%209 = call i32 @printf(i8* getelementptr inbounds ([261 x i8], [261 x i8]* @.str, i64 0, i64 0), i32 100000, i32 1000, i32 10, double %201, double %207, double %203, double %205, double %208)
ret i32 0
}