#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 */
float RAND_MAX;
int /*<<< orphan*/ free(float *);
float *malloc(int);
int /*<<< orphan*/ printf(char *, float, ...);
scalar_t__ rand();
void probme(int *a, int asz) {
  int i;
  int tsum = 1;
  float *af = malloc((asz - 1) * sizeof(float));
  for (i = 1; i < asz; ++i)
    tsum += a[i];
  af[0] = 1.0 / tsum;
  for (i = 1; i < asz; ++i)
    af[i] = af[i - 1] + (float)a[i] / tsum;
  float pn = (float)rand() / RAND_MAX;
  int choseni;
  for (i = 0; i < asz; ++i)
    if (pn < af[i]) {
      choseni = i;
      break;
    }
  if (choseni != 0)
    a[choseni]++;
  for (i = 0; i < asz; ++i)
    printf("%4.4f ", af[i]);
  printf("pn=%4.4f choseni=%i\n", pn, choseni);
  free(af);
  return;
}


x86 assembly (clang, -O0):
<probme>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119f <probme+0x5f>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1174 <probme+0x34>
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  0xe54(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1216 <probme+0xd6>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x14(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c3 <probme+0x83>
mov    $0x0,%al
call   1060 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2dbf(%rip),%rax
divss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    127e <probme+0x13e>
movss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    126b <probme+0x12b>
mov    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    127e <probme+0x13e>
jmp    1270 <probme+0x130>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1239 <probme+0xf9>
cmpl   $0x0,-0x28(%rbp)
je     1299 <probme+0x159>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d5 <probme+0x195>
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
lea    0xd48(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12a0 <probme+0x160>
movss  -0x24(%rbp),%xmm0
mov    -0x28(%rbp),%esi
lea    0xd2b(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<probme>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r14d
mov    %rdi,%rbx
lea    -0x4(,%r14,4),%edi
ff
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%r13d
cmp    $0x1,%r14d
jle    1183 <probme+0x43>
lea    -0x1(%r13),%rax
cmp    $0x8,%rax
jae    119d <probme+0x5d>
mov    $0x1,%edx
mov    $0x1,%ecx
jmp    1290 <probme+0x150>
movl   $0x3f800000,(%r15)
movss  0xe6e(%rip),%xmm0
movss  %xmm0,0x4(%rsp)
jmp    134a <probme+0x20a>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    11ce <probme+0x8e>
pxor   %xmm1,%xmm1
movdqa 0xe46(%rip),%xmm0
xor    %esi,%esi
jmp    123a <probme+0xfa>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm1,%xmm1
movdqa 0xe32(%rip),%xmm0
xor    %esi,%esi
movdqu 0x4(%rbx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x14(%rbx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x24(%rbx,%rsi,4),%xmm1
movdqu 0x34(%rbx,%rsi,4),%xmm3
movdqu 0x44(%rbx,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x54(%rbx,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x64(%rbx,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x74(%rbx,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    11e0 <probme+0xa0>
test   %rdx,%rdx
je     1269 <probme+0x129>
nop
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movdqu (%rbx,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rbx,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
jne    1240 <probme+0x100>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rcx,%rax
je     129c <probme+0x15c>
or     $0x1,%rcx
nopl   0x0(%rax)
add    (%rbx,%rcx,4),%edx
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1290 <probme+0x150>
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  0xd75(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm3,%xmm3
cvtsd2ss %xmm1,%xmm3
movss  %xmm3,(%r15)
cmp    $0x2,%r14d
movss  %xmm3,0x4(%rsp)
jl     134a <probme+0x20a>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mov    $0x1,%ecx
movaps %xmm3,%xmm1
je     1330 <probme+0x1f0>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
movaps %xmm3,%xmm1
xchg   %ax,%ax
xorps  %xmm2,%xmm2
cvtsi2ssl (%rbx,%rcx,4),%xmm2
divss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%r15,%rcx,4)
xorps  %xmm1,%xmm1
cvtsi2ssl 0x4(%rbx,%rcx,4),%xmm1
divss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%r15,%rcx,4)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    12f0 <probme+0x1b0>
test   $0x1,%al
je     134a <probme+0x20a>
xorps  %xmm2,%xmm2
cvtsi2ssl (%rbx,%rcx,4),%xmm2
divss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  %xmm1,(%r15,%rcx,4)
xor    %r12d,%r12d
xor    %eax,%eax
call   1060 <rand@plt>
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
mov    0x2c85(%rip),%rax
divss  (%rax),%xmm2
test   %r14d,%r14d
jle    13fe <probme+0x2be>
xor    %r12d,%r12d
movss  0x4(%rsp),%xmm0
ucomiss %xmm2,%xmm0
mov    $0x0,%eax
ja     13a9 <probme+0x269>
lea    -0x1(%r13),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
cmp    %rax,%rcx
je     1428 <probme+0x2e8>
movss  0x4(%r15,%rax,4),%xmm1
add    $0x1,%rax
ucomiss %xmm2,%xmm1
jbe    1390 <probme+0x250>
test   %eax,%eax
je     13b6 <probme+0x276>
mov    %eax,%ecx
addl   $0x1,(%rbx,%rcx,4)
mov    %eax,%r12d
test   %r14d,%r14d
jle    13fe <probme+0x2be>
movss  %xmm2,(%rsp)
lea    0xc61(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
cmp    $0x1,%r14d
je     13f9 <probme+0x2b9>
mov    $0x1,%ebp
lea    0xc48(%rip),%rbx
movss  (%r15,%rbp,4),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    13e0 <probme+0x2a0>
movss  (%rsp),%xmm2
lea    0xc2a(%rip),%rdi
movaps %xmm2,%xmm0
mov    %r12d,%esi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r15,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    %r13d,%eax
test   %eax,%eax
jne    13ad <probme+0x26d>
jmp    13b6 <probme+0x276>

LLVM IR (-O0):
@RAND_MAX = global float 0.000000e+00
@.str = [7 x i8] c"%4.4f \00"
@.str.1 = [21 x i8] c"pn=%4.4f choseni=%i\0A\00"
define void @probme(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca float*
%8 = alloca float
%9 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
store i32 1, i32* %6
%10 = load i32, i32* %4
%11 = sub nsw i32 %10, 1
%12 = sext i32 %11 to i64
%13 = mul i64 %12, 4
%14 = trunc i64 %13 to i32
%15 = call float* @malloc(i32 %14)
store float* %15, float** %7
store i32 1, i32* %5
br label %16
16: ; preds = %28, %2
%17 = load i32, i32* %5
%18 = load i32, i32* %4
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %31
20: ; preds = %16
%21 = load i32*, i32** %3
%22 = load i32, i32* %5
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
%25 = load i32, i32* %24
%26 = load i32, i32* %6
%27 = add nsw i32 %26, %25
store i32 %27, i32* %6
br label %28
28: ; preds = %20
%29 = load i32, i32* %5
%30 = add nsw i32 %29, 1
store i32 %30, i32* %5
br label %16
31: ; preds = %16
%32 = load i32, i32* %6
%33 = sitofp i32 %32 to double
%34 = fdiv double 1.000000e+00, %33
%35 = fptrunc double %34 to float
%36 = load float*, float** %7
%37 = getelementptr inbounds float, float* %36, i64 0
store float %35, float* %37
store i32 1, i32* %5
br label %38
38: ; preds = %63, %31
%39 = load i32, i32* %5
%40 = load i32, i32* %4
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %66
42: ; preds = %38
%43 = load float*, float** %7
%44 = load i32, i32* %5
%45 = sub nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %43, i64 %46
%48 = load float, float* %47
%49 = load i32*, i32** %3
%50 = load i32, i32* %5
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
%53 = load i32, i32* %52
%54 = sitofp i32 %53 to float
%55 = load i32, i32* %6
%56 = sitofp i32 %55 to float
%57 = fdiv float %54, %56
%58 = fadd float %48, %57
%59 = load float*, float** %7
%60 = load i32, i32* %5
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float %58, float* %62
br label %63
63: ; preds = %42
%64 = load i32, i32* %5
%65 = add nsw i32 %64, 1
store i32 %65, i32* %5
br label %38
66: ; preds = %38
%67 = call i64 (...) @rand()
%68 = sitofp i64 %67 to float
%69 = load float, float* @RAND_MAX
%70 = fdiv float %68, %69
store float %70, float* %8
store i32 0, i32* %5
br label %71
71: ; preds = %86, %66
%72 = load i32, i32* %5
%73 = load i32, i32* %4
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %89
75: ; preds = %71
%76 = load float, float* %8
%77 = load float*, float** %7
%78 = load i32, i32* %5
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %77, i64 %79
%81 = load float, float* %80
%82 = fcmp olt float %76, %81
br i1 %82, label %83, label %85
83: ; preds = %75
%84 = load i32, i32* %5
store i32 %84, i32* %9
br label %89
85: ; preds = %75
br label %86
86: ; preds = %85
%87 = load i32, i32* %5
%88 = add nsw i32 %87, 1
store i32 %88, i32* %5
br label %71
89: ; preds = %83, %71
%90 = load i32, i32* %9
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %99
92: ; preds = %89
%93 = load i32*, i32** %3
%94 = load i32, i32* %9
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = add nsw i32 %97, 1
store i32 %98, i32* %96
br label %99
99: ; preds = %92, %89
store i32 0, i32* %5
br label %100
100: ; preds = %111, %99
%101 = load i32, i32* %5
%102 = load i32, i32* %4
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %114
104: ; preds = %100
%105 = load float*, float** %7
%106 = load i32, i32* %5
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %105, i64 %107
%109 = load float, float* %108
%110 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), float %109)
br label %111
111: ; preds = %104
%112 = load i32, i32* %5
%113 = add nsw i32 %112, 1
store i32 %113, i32* %5
br label %100
114: ; preds = %100
%115 = load float, float* %8
%116 = load i32, i32* %9
%117 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), float %115, i32 %116)
%118 = load float*, float** %7
%119 = call i32 @free(float* %118)
ret void
}

LLVM IR (-O2):
@RAND_MAX = global float 0.000000e+00
@.str = [7 x i8] c"%4.4f \00"
@.str.1 = [21 x i8] c"pn=%4.4f choseni=%i\0A\00"
define void @probme(i32* nocapture %0, i32 %1) {
%3 = shl i32 %1, 2
%4 = add i32 %3, -4
%5 = tail call float* @malloc(i32 %4)
%6 = icmp sgt i32 %1, 1
br i1 %6, label %8, label %7
7: ; preds = %2
store float 1.000000e+00, float* %5
br label %149
8: ; preds = %2
%9 = zext i32 %1 to i64
%10 = add nsw i64 %9, -1
%11 = icmp ult i64 %10, 8
br i1 %11, label %96, label %12
12: ; preds = %8
%13 = and i64 %10, -8
%14 = or i64 %13, 1
%15 = add nsw i64 %13, -8
%16 = lshr exact i64 %15, 3
%17 = add nuw nsw i64 %16, 1
%18 = and i64 %17, 3
%19 = icmp ult i64 %15, 24
br i1 %19, label %66, label %20
20: ; preds = %12
%21 = and i64 %17, 4611686018427387900
br label %22
22: ; preds = %22, %20
%23 = phi i64 [ 0, %20 ], [ %63, %22 ]
%24 = phi <4 x i32> [ <i32 1, i32 0, i32 0, i32 0>, %20 ], [ %61, %22 ]
%25 = phi <4 x i32> [ zeroinitializer, %20 ], [ %62, %22 ]
%26 = phi i64 [ 0, %20 ], [ %64, %22 ]
%27 = or i64 %23, 1
%28 = getelementptr inbounds i32, i32* %0, i64 %27
%29 = bitcast i32* %28 to <4 x i32>*
%30 = load <4 x i32>, <4 x i32>* %29
%31 = getelementptr inbounds i32, i32* %28, i64 4
%32 = bitcast i32* %31 to <4 x i32>*
%33 = load <4 x i32>, <4 x i32>* %32
%34 = add <4 x i32> %30, %24
%35 = add <4 x i32> %33, %25
%36 = or i64 %23, 9
%37 = getelementptr inbounds i32, i32* %0, i64 %36
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = getelementptr inbounds i32, i32* %37, i64 4
%41 = bitcast i32* %40 to <4 x i32>*
%42 = load <4 x i32>, <4 x i32>* %41
%43 = add <4 x i32> %39, %34
%44 = add <4 x i32> %42, %35
%45 = or i64 %23, 17
%46 = getelementptr inbounds i32, i32* %0, i64 %45
%47 = bitcast i32* %46 to <4 x i32>*
%48 = load <4 x i32>, <4 x i32>* %47
%49 = getelementptr inbounds i32, i32* %46, i64 4
%50 = bitcast i32* %49 to <4 x i32>*
%51 = load <4 x i32>, <4 x i32>* %50
%52 = add <4 x i32> %48, %43
%53 = add <4 x i32> %51, %44
%54 = or i64 %23, 25
%55 = getelementptr inbounds i32, i32* %0, i64 %54
%56 = bitcast i32* %55 to <4 x i32>*
%57 = load <4 x i32>, <4 x i32>* %56
%58 = getelementptr inbounds i32, i32* %55, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = add <4 x i32> %57, %52
%62 = add <4 x i32> %60, %53
%63 = add nuw i64 %23, 32
%64 = add i64 %26, 4
%65 = icmp eq i64 %64, %21
br i1 %65, label %66, label %22
66: ; preds = %22, %12
%67 = phi <4 x i32> [ undef, %12 ], [ %61, %22 ]
%68 = phi <4 x i32> [ undef, %12 ], [ %62, %22 ]
%69 = phi i64 [ 0, %12 ], [ %63, %22 ]
%70 = phi <4 x i32> [ <i32 1, i32 0, i32 0, i32 0>, %12 ], [ %61, %22 ]
%71 = phi <4 x i32> [ zeroinitializer, %12 ], [ %62, %22 ]
%72 = icmp eq i64 %18, 0
br i1 %72, label %90, label %73
73: ; preds = %66, %73
%74 = phi i64 [ %87, %73 ], [ %69, %66 ]
%75 = phi <4 x i32> [ %85, %73 ], [ %70, %66 ]
%76 = phi <4 x i32> [ %86, %73 ], [ %71, %66 ]
%77 = phi i64 [ %88, %73 ], [ 0, %66 ]
%78 = or i64 %74, 1
%79 = getelementptr inbounds i32, i32* %0, i64 %78
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = getelementptr inbounds i32, i32* %79, i64 4
%83 = bitcast i32* %82 to <4 x i32>*
%84 = load <4 x i32>, <4 x i32>* %83
%85 = add <4 x i32> %81, %75
%86 = add <4 x i32> %84, %76
%87 = add nuw i64 %74, 8
%88 = add i64 %77, 1
%89 = icmp eq i64 %88, %18
br i1 %89, label %90, label %73
90: ; preds = %73, %66
%91 = phi <4 x i32> [ %67, %66 ], [ %85, %73 ]
%92 = phi <4 x i32> [ %68, %66 ], [ %86, %73 ]
%93 = add <4 x i32> %92, %91
%94 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %93)
%95 = icmp eq i64 %10, %13
br i1 %95, label %107, label %96
96: ; preds = %8, %90
%97 = phi i64 [ 1, %8 ], [ %14, %90 ]
%98 = phi i32 [ 1, %8 ], [ %94, %90 ]
br label %99
99: ; preds = %96, %99
%100 = phi i64 [ %105, %99 ], [ %97, %96 ]
%101 = phi i32 [ %104, %99 ], [ %98, %96 ]
%102 = getelementptr inbounds i32, i32* %0, i64 %100
%103 = load i32, i32* %102
%104 = add nsw i32 %103, %101
%105 = add nuw nsw i64 %100, 1
%106 = icmp eq i64 %105, %9
br i1 %106, label %107, label %99
107: ; preds = %99, %90
%108 = phi i32 [ %94, %90 ], [ %104, %99 ]
%109 = sitofp i32 %108 to double
%110 = fdiv double 1.000000e+00, %109
%111 = fptrunc double %110 to float
store float %111, float* %5
br i1 %6, label %112, label %149
112: ; preds = %107
%113 = sitofp i32 %108 to float
%114 = and i64 %10, 1
%115 = icmp eq i32 %1, 2
br i1 %115, label %138, label %116
116: ; preds = %112
%117 = and i64 %10, -2
br label %118
118: ; preds = %118, %116
%119 = phi float [ %111, %116 ], [ %133, %118 ]
%120 = phi i64 [ 1, %116 ], [ %135, %118 ]
%121 = phi i64 [ 0, %116 ], [ %136, %118 ]
%122 = getelementptr inbounds i32, i32* %0, i64 %120
%123 = load i32, i32* %122
%124 = sitofp i32 %123 to float
%125 = fdiv float %124, %113
%126 = fadd float %119, %125
%127 = getelementptr inbounds float, float* %5, i64 %120
store float %126, float* %127
%128 = add nuw nsw i64 %120, 1
%129 = getelementptr inbounds i32, i32* %0, i64 %128
%130 = load i32, i32* %129
%131 = sitofp i32 %130 to float
%132 = fdiv float %131, %113
%133 = fadd float %126, %132
%134 = getelementptr inbounds float, float* %5, i64 %128
store float %133, float* %134
%135 = add nuw nsw i64 %120, 2
%136 = add i64 %121, 2
%137 = icmp eq i64 %136, %117
br i1 %137, label %138, label %118
138: ; preds = %118, %112
%139 = phi float [ %111, %112 ], [ %133, %118 ]
%140 = phi i64 [ 1, %112 ], [ %135, %118 ]
%141 = icmp eq i64 %114, 0
br i1 %141, label %149, label %142
142: ; preds = %138
%143 = getelementptr inbounds i32, i32* %0, i64 %140
%144 = load i32, i32* %143
%145 = sitofp i32 %144 to float
%146 = fdiv float %145, %113
%147 = fadd float %139, %146
%148 = getelementptr inbounds float, float* %5, i64 %140
store float %147, float* %148
br label %149
149: ; preds = %142, %138, %7, %107
%150 = phi float [ 1.000000e+00, %7 ], [ %111, %107 ], [ %111, %138 ], [ %111, %142 ]
%151 = tail call i64 (...) @rand()
%152 = sitofp i64 %151 to float
%153 = load float, float* @RAND_MAX
%154 = fdiv float %152, %153
%155 = icmp sgt i32 %1, 0
br i1 %155, label %156, label %190
156: ; preds = %149
%157 = zext i32 %1 to i64
%158 = fcmp olt float %154, %150
br i1 %158, label %169, label %159
159: ; preds = %156, %163
%160 = phi i64 [ %161, %163 ], [ 0, %156 ]
%161 = add nuw nsw i64 %160, 1
%162 = icmp eq i64 %161, %157
br i1 %162, label %169, label %163
163: ; preds = %159
%164 = getelementptr inbounds float, float* %5, i64 %161
%165 = load float, float* %164
%166 = fcmp olt float %154, %165
br i1 %166, label %167, label %159
167: ; preds = %163
%168 = trunc i64 %161 to i32
br label %169
169: ; preds = %159, %156, %167
%170 = phi i32 [ %168, %167 ], [ 0, %156 ], [ %1, %159 ]
%171 = icmp eq i32 %170, 0
br i1 %171, label %177, label %172
172: ; preds = %169
%173 = zext i32 %170 to i64
%174 = getelementptr inbounds i32, i32* %0, i64 %173
%175 = load i32, i32* %174
%176 = add nsw i32 %175, 1
store i32 %176, i32* %174
br label %177
177: ; preds = %172, %169
%178 = phi i32 [ %170, %172 ], [ 0, %169 ]
br i1 %155, label %179, label %190
179: ; preds = %177
%180 = zext i32 %1 to i64
%181 = tail call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), float %150)
%182 = icmp eq i32 %1, 1
br i1 %182, label %190, label %183
183: ; preds = %179, %183
%184 = phi i64 [ %188, %183 ], [ 1, %179 ]
%185 = getelementptr inbounds float, float* %5, i64 %184
%186 = load float, float* %185
%187 = tail call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), float %186)
%188 = add nuw nsw i64 %184, 1
%189 = icmp eq i64 %188, %180
br i1 %189, label %190, label %183
190: ; preds = %183, %179, %149, %177
%191 = phi i32 [ %178, %177 ], [ 0, %149 ], [ %178, %179 ], [ %178, %183 ]
%192 = tail call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), float %154, i32 %191)
%193 = tail call i32 @free(float* %5)
ret void
}