float bootstrap_stats(float *bootstrap, int n, float actual_value) {
  int n_larger = 0;
  float p_larger;
  int i;
  for (i = 1; i <= n; i++) {
    if (bootstrap[i] > actual_value)
      n_larger++;
  }
  p_larger = (float)n_larger / (float)n;
  return p_larger;
}


x86 assembly (clang, -O0):
<bootstrap_stats>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     115d <bootstrap_stats+0x5d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x10(%rbp),%xmm0
jbe    114a <bootstrap_stats+0x4a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114f <bootstrap_stats+0x4f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111e <bootstrap_stats+0x1e>
cvtsi2ssl -0x14(%rbp),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<bootstrap_stats>:
test   %esi,%esi
jle    1118 <bootstrap_stats+0x18>
mov    %esi,%r9d
cmp    $0x8,%esi
jae    1120 <bootstrap_stats+0x20>
xor    %eax,%eax
mov    $0x1,%ecx
jmp    11f5 <bootstrap_stats+0xf5>
xorps  %xmm0,%xmm0
jmp    121f <bootstrap_stats+0x11f>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     122b <bootstrap_stats+0x12b>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm2,%xmm2
mov    $0x1,%edx
pxor   %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rdx,4),%xmm4
movups 0x10(%rdi,%rdx,4),%xmm5
movups 0x20(%rdi,%rdx,4),%xmm6
movups 0x30(%rdi,%rdx,4),%xmm7
movaps %xmm8,%xmm1
cmpltps %xmm4,%xmm1
psubd  %xmm1,%xmm2
movaps %xmm8,%xmm1
cmpltps %xmm5,%xmm1
psubd  %xmm1,%xmm3
movaps %xmm8,%xmm1
cmpltps %xmm6,%xmm1
psubd  %xmm1,%xmm2
movaps %xmm8,%xmm1
cmpltps %xmm7,%xmm1
psubd  %xmm1,%xmm3
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1160 <bootstrap_stats+0x60>
test   $0x1,%r8b
je     11d2 <bootstrap_stats+0xd2>
movups (%rdi,%rdx,4),%xmm1
movups 0x10(%rdi,%rdx,4),%xmm4
movaps %xmm8,%xmm5
cmpltps %xmm1,%xmm5
psubd  %xmm5,%xmm2
cmpltps %xmm4,%xmm8
psubd  %xmm8,%xmm3
paddd  %xmm3,%xmm2
pshufd $0xee,%xmm2,%xmm1
paddd  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm2
paddd  %xmm1,%xmm2
movd   %xmm2,%eax
cmp    %rcx,%r9
je     1218 <bootstrap_stats+0x118>
or     $0x1,%rcx
add    $0x1,%r9
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm1
xor    %edx,%edx
ucomiss %xmm0,%xmm1
seta   %dl
add    %edx,%eax
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1200 <bootstrap_stats+0x100>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
divss  %xmm1,%xmm0
ret
pxor   %xmm2,%xmm2
mov    $0x1,%edx
pxor   %xmm3,%xmm3
test   $0x1,%r8b
jne    11b3 <bootstrap_stats+0xb3>
jmp    11d2 <bootstrap_stats+0xd2>

LLVM IR (-O0):
define float @bootstrap_stats(float* %0, i32 %1, float %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca float
%7 = alloca i32
%8 = alloca float
%9 = alloca i32
store float* %0, float** %4
store i32 %1, i32* %5
store float %2, float* %6
store i32 0, i32* %7
store i32 1, i32* %9
br label %10
10: ; preds = %26, %3
%11 = load i32, i32* %9
%12 = load i32, i32* %5
%13 = icmp sle i32 %11, %12
br i1 %13, label %14, label %29
14: ; preds = %10
%15 = load float*, float** %4
%16 = load i32, i32* %9
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds float, float* %15, i64 %17
%19 = load float, float* %18
%20 = load float, float* %6
%21 = fcmp ogt float %19, %20
br i1 %21, label %22, label %25
22: ; preds = %14
%23 = load i32, i32* %7
%24 = add nsw i32 %23, 1
store i32 %24, i32* %7
br label %25
25: ; preds = %22, %14
br label %26
26: ; preds = %25
%27 = load i32, i32* %9
%28 = add nsw i32 %27, 1
store i32 %28, i32* %9
br label %10
29: ; preds = %10
%30 = load i32, i32* %7
%31 = sitofp i32 %30 to float
%32 = load i32, i32* %5
%33 = sitofp i32 %32 to float
%34 = fdiv float %31, %33
store float %34, float* %8
%35 = load float, float* %8
ret float %35
}

LLVM IR (-O2):
define float @bootstrap_stats(float* nocapture %0, i32 %1, float %2) {
%4 = icmp slt i32 %1, 1
br i1 %4, label %102, label %5
5: ; preds = %3
%6 = add nuw i32 %1, 1
%7 = zext i32 %6 to i64
%8 = add nsw i64 %7, -1
%9 = icmp ult i64 %8, 8
br i1 %9, label %86, label %10
10: ; preds = %5
%11 = and i64 %8, -8
%12 = or i64 %11, 1
%13 = insertelement <4 x float> poison, float %2, i64 0
%14 = shufflevector <4 x float> %13, <4 x float> poison, <4 x i32> zeroinitializer
%15 = insertelement <4 x float> poison, float %2, i64 0
%16 = shufflevector <4 x float> %15, <4 x float> poison, <4 x i32> zeroinitializer
%17 = add nsw i64 %11, -8
%18 = lshr exact i64 %17, 3
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 1
%21 = icmp eq i64 %17, 0
br i1 %21, label %60, label %22
22: ; preds = %10
%23 = and i64 %19, 4611686018427387902
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %55, %24 ]
%26 = phi <4 x i32> [ zeroinitializer, %22 ], [ %53, %24 ]
%27 = phi <4 x i32> [ zeroinitializer, %22 ], [ %54, %24 ]
%28 = phi i64 [ 0, %22 ], [ %56, %24 ]
%29 = or i64 %25, 1
%30 = getelementptr inbounds float, float* %0, i64 %29
%31 = bitcast float* %30 to <4 x float>*
%32 = load <4 x float>, <4 x float>* %31
%33 = getelementptr inbounds float, float* %30, i64 4
%34 = bitcast float* %33 to <4 x float>*
%35 = load <4 x float>, <4 x float>* %34
%36 = fcmp ogt <4 x float> %32, %14
%37 = fcmp ogt <4 x float> %35, %16
%38 = zext <4 x i1> %36 to <4 x i32>
%39 = zext <4 x i1> %37 to <4 x i32>
%40 = add <4 x i32> %26, %38
%41 = add <4 x i32> %27, %39
%42 = or i64 %25, 9
%43 = getelementptr inbounds float, float* %0, i64 %42
%44 = bitcast float* %43 to <4 x float>*
%45 = load <4 x float>, <4 x float>* %44
%46 = getelementptr inbounds float, float* %43, i64 4
%47 = bitcast float* %46 to <4 x float>*
%48 = load <4 x float>, <4 x float>* %47
%49 = fcmp ogt <4 x float> %45, %14
%50 = fcmp ogt <4 x float> %48, %16
%51 = zext <4 x i1> %49 to <4 x i32>
%52 = zext <4 x i1> %50 to <4 x i32>
%53 = add <4 x i32> %40, %51
%54 = add <4 x i32> %41, %52
%55 = add nuw i64 %25, 16
%56 = add i64 %28, 2
%57 = icmp eq i64 %56, %23
br i1 %57, label %58, label %24
58: ; preds = %24
%59 = or i64 %55, 1
br label %60
60: ; preds = %58, %10
%61 = phi <4 x i32> [ undef, %10 ], [ %53, %58 ]
%62 = phi <4 x i32> [ undef, %10 ], [ %54, %58 ]
%63 = phi i64 [ 1, %10 ], [ %59, %58 ]
%64 = phi <4 x i32> [ zeroinitializer, %10 ], [ %53, %58 ]
%65 = phi <4 x i32> [ zeroinitializer, %10 ], [ %54, %58 ]
%66 = icmp eq i64 %20, 0
br i1 %66, label %80, label %67
67: ; preds = %60
%68 = getelementptr inbounds float, float* %0, i64 %63
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %68, i64 4
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = fcmp ogt <4 x float> %70, %14
%75 = fcmp ogt <4 x float> %73, %16
%76 = zext <4 x i1> %74 to <4 x i32>
%77 = zext <4 x i1> %75 to <4 x i32>
%78 = add <4 x i32> %64, %76
%79 = add <4 x i32> %65, %77
br label %80
80: ; preds = %60, %67
%81 = phi <4 x i32> [ %61, %60 ], [ %78, %67 ]
%82 = phi <4 x i32> [ %62, %60 ], [ %79, %67 ]
%83 = add <4 x i32> %82, %81
%84 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %83)
%85 = icmp eq i64 %8, %11
br i1 %85, label %99, label %86
86: ; preds = %5, %80
%87 = phi i64 [ 1, %5 ], [ %12, %80 ]
%88 = phi i32 [ 0, %5 ], [ %84, %80 ]
br label %89
89: ; preds = %86, %89
%90 = phi i64 [ %97, %89 ], [ %87, %86 ]
%91 = phi i32 [ %96, %89 ], [ %88, %86 ]
%92 = getelementptr inbounds float, float* %0, i64 %90
%93 = load float, float* %92
%94 = fcmp ogt float %93, %2
%95 = zext i1 %94 to i32
%96 = add nuw nsw i32 %91, %95
%97 = add nuw nsw i64 %90, 1
%98 = icmp eq i64 %97, %7
br i1 %98, label %99, label %89
99: ; preds = %89, %80
%100 = phi i32 [ %84, %80 ], [ %96, %89 ]
%101 = sitofp i32 %100 to float
br label %102
102: ; preds = %99, %3
%103 = phi float [ 0.000000e+00, %3 ], [ %101, %99 ]
%104 = sitofp i32 %1 to float
%105 = fdiv float %103, %104
ret float %105
}