#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 /*<<< orphan*/ printf(char *, int, ...);
int rand();
int main() {
  int c0 = 0, c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0, c7 = 0, c8 = 0,
      c9 = 0;
  int azar;
  printf("Voy a buscar %d numeros aleatorios entre 0 y 9, y contar su "
         "ocurrencia\n\n",
         100000000);
  unsigned int vuelta;
  for (vuelta = 0; vuelta < 100000000; vuelta++) {
    azar = rand() % 10;
    switch (azar) {
    case 0:
      c0++;
      break;
    case 1:
      c1++;
      break;
    case 2:
      c2++;
      break;
    case 3:
      c3++;
      break;
    case 4:
      c4++;
      break;
    case 5:
      c5++;
      break;
    case 6:
      c6++;
      break;
    case 7:
      c7++;
      break;
    case 8:
      c8++;
      break;
    case 9:
      c9++;
      break;
    }
  }
  float p0, p1, p2, p3, p4, p5, p6, p7, p8, p9;
  p0 = (float)c0 * 100 / vuelta;
  p1 = (float)c1 * 100 / vuelta;
  p2 = (float)c2 * 100 / vuelta;
  p3 = (float)c3 * 100 / vuelta;
  p4 = (float)c4 * 100 / vuelta;
  p5 = (float)c5 * 100 / vuelta;
  p6 = (float)c6 * 100 / vuelta;
  p7 = (float)c7 * 100 / vuelta;
  p8 = (float)c8 * 100 / vuelta;
  p9 = (float)c9 * 100 / vuelta;
  printf("El 0 ocurrio %d veces, representando %f %% del total\n", c0, p0);
  printf("El 1 ocurrio %d veces, representando %f %% del total\n", c1, p1);
  printf("El 2 ocurrio %d veces, representando %f %% del total\n", c2, p2);
  printf("El 3 ocurrio %d veces, representando %f %% del total\n", c3, p3);
  printf("El 4 ocurrio %d veces, representando %f %% del total\n", c4, p4);
  printf("El 5 ocurrio %d veces, representando %f %% del total\n", c5, p5);
  printf("El 6 ocurrio %d veces, representando %f %% del total\n", c6, p6);
  printf("El 7 ocurrio %d veces, representando %f %% del total\n", c7, p7);
  printf("El 8 ocurrio %d veces, representando %f %% del total\n", c8, p8);
  printf("El 9 ocurrio %d veces, representando %f %% del total\n", c9, p9);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    0xeb0(%rip),%rdi
mov    $0x5f5e100,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5f5e100,-0x34(%rbp)
jae    1285 <main+0x165>
xor    %eax,%eax
call   1040 <rand@plt>
movslq %eax,%rcx
imul   $0x66666667,%rcx,%rdx
mov    %rdx,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rdx
add    %ecx,%edx
add    %edx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %rax,-0x68(%rbp)
sub    $0x9,%rax
ja     1272 <main+0x152>
mov    -0x68(%rbp),%rax
lea    0xe22(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1272 <main+0x152>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1272 <main+0x152>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1272 <main+0x152>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1272 <main+0x152>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1272 <main+0x152>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1272 <main+0x152>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1272 <main+0x152>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1272 <main+0x152>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1272 <main+0x152>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1277 <main+0x157>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118f <main+0x6f>
cvtsi2ssl -0x8(%rbp),%xmm0
movss  0xd6e(%rip),%xmm1
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl -0xc(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x3c(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x40(%rbp)
cvtsi2ssl -0x14(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x44(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x4c(%rbp)
cvtsi2ssl -0x20(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x50(%rbp)
cvtsi2ssl -0x24(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x54(%rbp)
cvtsi2ssl -0x28(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,-0x58(%rbp)
cvtsi2ssl -0x2c(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x34(%rbp),%eax
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%esi
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcd1(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xced(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%esi
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd09(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%esi
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd25(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%esi
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd41(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%esi
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd5d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x20(%rbp),%esi
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd79(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x24(%rbp),%esi
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd95(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%esi
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdb1(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x2c(%rbp),%esi
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdcd(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
lea    0xefb(%rip),%rdi
mov    $0x5f5e100,%ebx
mov    $0x5f5e100,%esi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xebb(%rip),%rbp
xor    %r15d,%r15d
xor    %r13d,%r13d
xor    %r12d,%r12d
xor    %r14d,%r14d
movl   $0x0,0x18(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x20(%rsp)
movl   $0x0,0xc(%rsp)
movl   $0x0,0x10(%rsp)
movl   $0x0,0x14(%rsp)
jmp    1195 <main+0x75>
addl   $0x1,0x14(%rsp)
add    $0xffffffff,%ebx
je     1203 <main+0xe3>
xor    %eax,%eax
call   1040 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
cmp    $0x9,%eax
ja     1190 <main+0x70>
movslq 0x0(%rbp,%rax,4),%rax
add    %rbp,%rax
jmp    *%rax
add    $0x1,%r15d
jmp    1190 <main+0x70>
add    $0x1,%r13d
jmp    1190 <main+0x70>
add    $0x1,%r12d
jmp    1190 <main+0x70>
add    $0x1,%r14d
jmp    1190 <main+0x70>
addl   $0x1,0x18(%rsp)
jmp    1190 <main+0x70>
addl   $0x1,0x1c(%rsp)
jmp    1190 <main+0x70>
addl   $0x1,0x20(%rsp)
jmp    1190 <main+0x70>
addl   $0x1,0xc(%rsp)
jmp    1190 <main+0x70>
addl   $0x1,0x10(%rsp)
jmp    1190 <main+0x70>
mov    %r15d,%esi
cvtsi2ss %r15d,%xmm0
movss  0xded(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0xde5(%rip),%xmm2
mov    %r13d,%ebp
cvtsi2ss %r13d,%xmm4
divss  %xmm2,%xmm0
mov    %r12d,%ebx
cvtsi2ss %r12d,%xmm3
mulss  %xmm1,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,0x24(%rsp)
mulss  %xmm1,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x28(%rsp)
xorps  %xmm3,%xmm3
cvtsi2ss %r14d,%xmm3
mulss  %xmm1,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x2c(%rsp)
mov    0x18(%rsp),%r12d
xorps  %xmm3,%xmm3
cvtsi2ss %r12d,%xmm3
mulss  %xmm1,%xmm3
mov    0x1c(%rsp),%r15d
xorps  %xmm4,%xmm4
cvtsi2ss %r15d,%xmm4
divss  %xmm2,%xmm3
movss  %xmm3,0x30(%rsp)
mov    0x20(%rsp),%r13d
xorps  %xmm3,%xmm3
cvtsi2ss %r13d,%xmm3
mulss  %xmm1,%xmm4
divss  %xmm2,%xmm4
movss  %xmm4,0x34(%rsp)
mulss  %xmm1,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x38(%rsp)
xorps  %xmm3,%xmm3
cvtsi2ssl 0xc(%rsp),%xmm3
mulss  %xmm1,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x3c(%rsp)
xorps  %xmm4,%xmm4
cvtsi2ssl 0x10(%rsp),%xmm4
mulss  %xmm1,%xmm4
xorps  %xmm3,%xmm3
cvtsi2ssl 0x14(%rsp),%xmm3
divss  %xmm2,%xmm4
movss  %xmm4,0x40(%rsp)
mulss  %xmm1,%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x44(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xd73(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd91(%rip),%rdi
mov    %ebp,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdad(%rip),%rdi
mov    %ebx,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x2c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdc9(%rip),%rdi
mov    %r14d,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xde4(%rip),%rdi
mov    %r12d,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdff(%rip),%rdi
mov    %r15d,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x38(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe1a(%rip),%rdi
mov    %r13d,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe35(%rip),%rdi
mov    0xc(%rsp),%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe4f(%rip),%rdi
mov    0x10(%rsp),%esi
mov    $0x1,%al
call   1030 <printf@plt>
movss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe69(%rip),%rdi
mov    0x14(%rsp),%esi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [73 x i8] c"Voy a buscar %d numeros aleatorios entre 0 y 9, y contar su ocurrencia\0A\0A\00"
@.str.1 = [54 x i8] c"El 0 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.2 = [54 x i8] c"El 1 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.3 = [54 x i8] c"El 2 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.4 = [54 x i8] c"El 3 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.5 = [54 x i8] c"El 4 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.6 = [54 x i8] c"El 5 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.7 = [54 x i8] c"El 6 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.8 = [54 x i8] c"El 7 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.9 = [54 x i8] c"El 8 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.10 = [54 x i8] c"El 9 ocurrio %d veces, representando %f %% del total\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca 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 i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store i32 0, i32* %1
store i32 0, i32* %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
%24 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i32 100000000)
store i32 0, i32* %13
br label %25
25: ; preds = %63, %0
%26 = load i32, i32* %13
%27 = icmp ult i32 %26, 100000000
br i1 %27, label %28, label %66
28: ; preds = %25
%29 = call i32 (...) @rand()
%30 = srem i32 %29, 10
store i32 %30, i32* %12
%31 = load i32, i32* %12
switch i32 %31, label %62 [
i32 0, label %32
i32 1, label %35
i32 2, label %38
i32 3, label %41
i32 4, label %44
i32 5, label %47
i32 6, label %50
i32 7, label %53
i32 8, label %56
i32 9, label %59
]
32: ; preds = %28
%33 = load i32, i32* %2
%34 = add nsw i32 %33, 1
store i32 %34, i32* %2
br label %62
35: ; preds = %28
%36 = load i32, i32* %3
%37 = add nsw i32 %36, 1
store i32 %37, i32* %3
br label %62
38: ; preds = %28
%39 = load i32, i32* %4
%40 = add nsw i32 %39, 1
store i32 %40, i32* %4
br label %62
41: ; preds = %28
%42 = load i32, i32* %5
%43 = add nsw i32 %42, 1
store i32 %43, i32* %5
br label %62
44: ; preds = %28
%45 = load i32, i32* %6
%46 = add nsw i32 %45, 1
store i32 %46, i32* %6
br label %62
47: ; preds = %28
%48 = load i32, i32* %7
%49 = add nsw i32 %48, 1
store i32 %49, i32* %7
br label %62
50: ; preds = %28
%51 = load i32, i32* %8
%52 = add nsw i32 %51, 1
store i32 %52, i32* %8
br label %62
53: ; preds = %28
%54 = load i32, i32* %9
%55 = add nsw i32 %54, 1
store i32 %55, i32* %9
br label %62
56: ; preds = %28
%57 = load i32, i32* %10
%58 = add nsw i32 %57, 1
store i32 %58, i32* %10
br label %62
59: ; preds = %28
%60 = load i32, i32* %11
%61 = add nsw i32 %60, 1
store i32 %61, i32* %11
br label %62
62: ; preds = %28, %59, %56, %53, %50, %47, %44, %41, %38, %35, %32
br label %63
63: ; preds = %62
%64 = load i32, i32* %13
%65 = add i32 %64, 1
store i32 %65, i32* %13
br label %25
66: ; preds = %25
%67 = load i32, i32* %2
%68 = sitofp i32 %67 to float
%69 = fmul float %68, 1.000000e+02
%70 = load i32, i32* %13
%71 = uitofp i32 %70 to float
%72 = fdiv float %69, %71
store float %72, float* %14
%73 = load i32, i32* %3
%74 = sitofp i32 %73 to float
%75 = fmul float %74, 1.000000e+02
%76 = load i32, i32* %13
%77 = uitofp i32 %76 to float
%78 = fdiv float %75, %77
store float %78, float* %15
%79 = load i32, i32* %4
%80 = sitofp i32 %79 to float
%81 = fmul float %80, 1.000000e+02
%82 = load i32, i32* %13
%83 = uitofp i32 %82 to float
%84 = fdiv float %81, %83
store float %84, float* %16
%85 = load i32, i32* %5
%86 = sitofp i32 %85 to float
%87 = fmul float %86, 1.000000e+02
%88 = load i32, i32* %13
%89 = uitofp i32 %88 to float
%90 = fdiv float %87, %89
store float %90, float* %17
%91 = load i32, i32* %6
%92 = sitofp i32 %91 to float
%93 = fmul float %92, 1.000000e+02
%94 = load i32, i32* %13
%95 = uitofp i32 %94 to float
%96 = fdiv float %93, %95
store float %96, float* %18
%97 = load i32, i32* %7
%98 = sitofp i32 %97 to float
%99 = fmul float %98, 1.000000e+02
%100 = load i32, i32* %13
%101 = uitofp i32 %100 to float
%102 = fdiv float %99, %101
store float %102, float* %19
%103 = load i32, i32* %8
%104 = sitofp i32 %103 to float
%105 = fmul float %104, 1.000000e+02
%106 = load i32, i32* %13
%107 = uitofp i32 %106 to float
%108 = fdiv float %105, %107
store float %108, float* %20
%109 = load i32, i32* %9
%110 = sitofp i32 %109 to float
%111 = fmul float %110, 1.000000e+02
%112 = load i32, i32* %13
%113 = uitofp i32 %112 to float
%114 = fdiv float %111, %113
store float %114, float* %21
%115 = load i32, i32* %10
%116 = sitofp i32 %115 to float
%117 = fmul float %116, 1.000000e+02
%118 = load i32, i32* %13
%119 = uitofp i32 %118 to float
%120 = fdiv float %117, %119
store float %120, float* %22
%121 = load i32, i32* %11
%122 = sitofp i32 %121 to float
%123 = fmul float %122, 1.000000e+02
%124 = load i32, i32* %13
%125 = uitofp i32 %124 to float
%126 = fdiv float %123, %125
store float %126, float* %23
%127 = load i32, i32* %2
%128 = load float, float* %14
%129 = fpext float %128 to double
%130 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.1, i64 0, i64 0), i32 %127, double %129)
%131 = load i32, i32* %3
%132 = load float, float* %15
%133 = fpext float %132 to double
%134 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %131, double %133)
%135 = load i32, i32* %4
%136 = load float, float* %16
%137 = fpext float %136 to double
%138 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.3, i64 0, i64 0), i32 %135, double %137)
%139 = load i32, i32* %5
%140 = load float, float* %17
%141 = fpext float %140 to double
%142 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.4, i64 0, i64 0), i32 %139, double %141)
%143 = load i32, i32* %6
%144 = load float, float* %18
%145 = fpext float %144 to double
%146 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.5, i64 0, i64 0), i32 %143, double %145)
%147 = load i32, i32* %7
%148 = load float, float* %19
%149 = fpext float %148 to double
%150 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i64 0, i64 0), i32 %147, double %149)
%151 = load i32, i32* %8
%152 = load float, float* %20
%153 = fpext float %152 to double
%154 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.7, i64 0, i64 0), i32 %151, double %153)
%155 = load i32, i32* %9
%156 = load float, float* %21
%157 = fpext float %156 to double
%158 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.8, i64 0, i64 0), i32 %155, double %157)
%159 = load i32, i32* %10
%160 = load float, float* %22
%161 = fpext float %160 to double
%162 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.9, i64 0, i64 0), i32 %159, double %161)
%163 = load i32, i32* %11
%164 = load float, float* %23
%165 = fpext float %164 to double
%166 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.10, i64 0, i64 0), i32 %163, double %165)
ret i32 0
}

LLVM IR (-O2):
@.str = [73 x i8] c"Voy a buscar %d numeros aleatorios entre 0 y 9, y contar su ocurrencia\0A\0A\00"
@.str.1 = [54 x i8] c"El 0 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.2 = [54 x i8] c"El 1 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.3 = [54 x i8] c"El 2 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.4 = [54 x i8] c"El 3 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.5 = [54 x i8] c"El 4 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.6 = [54 x i8] c"El 5 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.7 = [54 x i8] c"El 6 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.8 = [54 x i8] c"El 7 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.9 = [54 x i8] c"El 8 ocurrio %d veces, representando %f %% del total\0A\00"
@.str.10 = [54 x i8] c"El 9 ocurrio %d veces, representando %f %% del total\0A\00"
define i32 @main() {
%1 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i32 100000000)
br label %2
2: ; preds = %0, %36
%3 = phi i32 [ 0, %0 ], [ %46, %36 ]
%4 = phi i32 [ 0, %0 ], [ %45, %36 ]
%5 = phi i32 [ 0, %0 ], [ %44, %36 ]
%6 = phi i32 [ 0, %0 ], [ %43, %36 ]
%7 = phi i32 [ 0, %0 ], [ %42, %36 ]
%8 = phi i32 [ 0, %0 ], [ %41, %36 ]
%9 = phi i32 [ 0, %0 ], [ %40, %36 ]
%10 = phi i32 [ 0, %0 ], [ %39, %36 ]
%11 = phi i32 [ 0, %0 ], [ %38, %36 ]
%12 = phi i32 [ 0, %0 ], [ %37, %36 ]
%13 = phi i32 [ 0, %0 ], [ %47, %36 ]
%14 = tail call i32 (...) @rand()
%15 = srem i32 %14, 10
switch i32 %15, label %36 [
i32 0, label %16
i32 1, label %18
i32 2, label %20
i32 3, label %22
i32 4, label %24
i32 5, label %26
i32 6, label %28
i32 7, label %30
i32 8, label %32
i32 9, label %34
]
16: ; preds = %2
%17 = add nsw i32 %3, 1
br label %36
18: ; preds = %2
%19 = add nsw i32 %4, 1
br label %36
20: ; preds = %2
%21 = add nsw i32 %5, 1
br label %36
22: ; preds = %2
%23 = add nsw i32 %6, 1
br label %36
24: ; preds = %2
%25 = add nsw i32 %7, 1
br label %36
26: ; preds = %2
%27 = add nsw i32 %8, 1
br label %36
28: ; preds = %2
%29 = add nsw i32 %9, 1
br label %36
30: ; preds = %2
%31 = add nsw i32 %10, 1
br label %36
32: ; preds = %2
%33 = add nsw i32 %11, 1
br label %36
34: ; preds = %2
%35 = add nsw i32 %12, 1
br label %36
36: ; preds = %16, %18, %20, %22, %24, %26, %28, %30, %32, %34, %2
%37 = phi i32 [ %12, %2 ], [ %35, %34 ], [ %12, %32 ], [ %12, %30 ], [ %12, %28 ], [ %12, %26 ], [ %12, %24 ], [ %12, %22 ], [ %12, %20 ], [ %12, %18 ], [ %12, %16 ]
%38 = phi i32 [ %11, %2 ], [ %11, %34 ], [ %33, %32 ], [ %11, %30 ], [ %11, %28 ], [ %11, %26 ], [ %11, %24 ], [ %11, %22 ], [ %11, %20 ], [ %11, %18 ], [ %11, %16 ]
%39 = phi i32 [ %10, %2 ], [ %10, %34 ], [ %10, %32 ], [ %31, %30 ], [ %10, %28 ], [ %10, %26 ], [ %10, %24 ], [ %10, %22 ], [ %10, %20 ], [ %10, %18 ], [ %10, %16 ]
%40 = phi i32 [ %9, %2 ], [ %9, %34 ], [ %9, %32 ], [ %9, %30 ], [ %29, %28 ], [ %9, %26 ], [ %9, %24 ], [ %9, %22 ], [ %9, %20 ], [ %9, %18 ], [ %9, %16 ]
%41 = phi i32 [ %8, %2 ], [ %8, %34 ], [ %8, %32 ], [ %8, %30 ], [ %8, %28 ], [ %27, %26 ], [ %8, %24 ], [ %8, %22 ], [ %8, %20 ], [ %8, %18 ], [ %8, %16 ]
%42 = phi i32 [ %7, %2 ], [ %7, %34 ], [ %7, %32 ], [ %7, %30 ], [ %7, %28 ], [ %7, %26 ], [ %25, %24 ], [ %7, %22 ], [ %7, %20 ], [ %7, %18 ], [ %7, %16 ]
%43 = phi i32 [ %6, %2 ], [ %6, %34 ], [ %6, %32 ], [ %6, %30 ], [ %6, %28 ], [ %6, %26 ], [ %6, %24 ], [ %23, %22 ], [ %6, %20 ], [ %6, %18 ], [ %6, %16 ]
%44 = phi i32 [ %5, %2 ], [ %5, %34 ], [ %5, %32 ], [ %5, %30 ], [ %5, %28 ], [ %5, %26 ], [ %5, %24 ], [ %5, %22 ], [ %21, %20 ], [ %5, %18 ], [ %5, %16 ]
%45 = phi i32 [ %4, %2 ], [ %4, %34 ], [ %4, %32 ], [ %4, %30 ], [ %4, %28 ], [ %4, %26 ], [ %4, %24 ], [ %4, %22 ], [ %4, %20 ], [ %19, %18 ], [ %4, %16 ]
%46 = phi i32 [ %3, %2 ], [ %3, %34 ], [ %3, %32 ], [ %3, %30 ], [ %3, %28 ], [ %3, %26 ], [ %3, %24 ], [ %3, %22 ], [ %3, %20 ], [ %3, %18 ], [ %17, %16 ]
%47 = add nuw nsw i32 %13, 1
%48 = icmp eq i32 %47, 100000000
br i1 %48, label %49, label %2
49: ; preds = %36
%50 = sitofp i32 %46 to float
%51 = fmul float %50, 1.000000e+02
%52 = fdiv float %51, 1.000000e+08
%53 = sitofp i32 %45 to float
%54 = fmul float %53, 1.000000e+02
%55 = fdiv float %54, 1.000000e+08
%56 = sitofp i32 %44 to float
%57 = fmul float %56, 1.000000e+02
%58 = fdiv float %57, 1.000000e+08
%59 = sitofp i32 %43 to float
%60 = fmul float %59, 1.000000e+02
%61 = fdiv float %60, 1.000000e+08
%62 = sitofp i32 %42 to float
%63 = fmul float %62, 1.000000e+02
%64 = fdiv float %63, 1.000000e+08
%65 = sitofp i32 %41 to float
%66 = fmul float %65, 1.000000e+02
%67 = fdiv float %66, 1.000000e+08
%68 = sitofp i32 %40 to float
%69 = fmul float %68, 1.000000e+02
%70 = fdiv float %69, 1.000000e+08
%71 = sitofp i32 %39 to float
%72 = fmul float %71, 1.000000e+02
%73 = fdiv float %72, 1.000000e+08
%74 = sitofp i32 %38 to float
%75 = fmul float %74, 1.000000e+02
%76 = fdiv float %75, 1.000000e+08
%77 = sitofp i32 %37 to float
%78 = fmul float %77, 1.000000e+02
%79 = fdiv float %78, 1.000000e+08
%80 = fpext float %52 to double
%81 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.1, i64 0, i64 0), i32 %46, double %80)
%82 = fpext float %55 to double
%83 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.2, i64 0, i64 0), i32 %45, double %82)
%84 = fpext float %58 to double
%85 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.3, i64 0, i64 0), i32 %44, double %84)
%86 = fpext float %61 to double
%87 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.4, i64 0, i64 0), i32 %43, double %86)
%88 = fpext float %64 to double
%89 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.5, i64 0, i64 0), i32 %42, double %88)
%90 = fpext float %67 to double
%91 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i64 0, i64 0), i32 %41, double %90)
%92 = fpext float %70 to double
%93 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.7, i64 0, i64 0), i32 %40, double %92)
%94 = fpext float %73 to double
%95 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.8, i64 0, i64 0), i32 %39, double %94)
%96 = fpext float %76 to double
%97 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.9, i64 0, i64 0), i32 %38, double %96)
%98 = fpext float %79 to double
%99 = tail call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.10, i64 0, i64 0), i32 %37, double %98)
ret i32 0
}