#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 */
scalar_t__ iscntrl(char);
scalar_t__ isdigit(char);
scalar_t__ islower(char);
int /*<<< orphan*/ isprint(char);
scalar_t__ ispunct(char);
scalar_t__ isspace(char);
scalar_t__ isupper(char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ puts(char *);
void analysis(char *string) {
  puts("**I was here**");
  float chars, ctrl, space, digits, lower, upper, punct, non;
  chars = ctrl = space = digits = lower = upper = punct = non = 0;
  char *pointer_to_first = string;
  while (*string) {
    chars++;
    string++;
  }
  string = pointer_to_first;
  while (*string) {
    if (iscntrl(*string))
      ctrl++;
    else if (isspace(*string))
      space++;
    else if (isdigit(*string))
      digits++;
    else if (islower(*string))
      lower++;
    else if (isupper(*string))
      upper++;
    else if (ispunct(*string))
      punct++;
    else if (!isprint(*string))
      non++;
    else
      printf("Mai era ceva bha!\n");
    string++;
  }
  ctrl = (ctrl * 100) / chars;
  space = (space * 100) / chars;
  digits = (digits * 100) / chars;
  lower = (lower * 100) / chars;
  upper = (upper * 100) / chars;
  punct = (punct * 100) / chars;
  non = (non * 100) / chars;
  printf("control chars: %.2f%%,\n", ctrl);
  printf("whitespace chars: %.2f%%,\n", space);
  printf("digits: %.2f%%,\n", digits);
  printf("lower case letters: %.2f%%,\n", lower);
  printf("upper case letters: %.2f%%,\n", upper);
  printf("punctuantion chars: %.2f%%,\n", punct);
  printf("non_printable chars: %.2f%%,\n", non);
}


x86 assembly (clang, -O0):
<analysis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xe65(%rip),%rdi
call   1050 <puts@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     1220 <analysis+0x90>
movss  0xdff(%rip),%xmm0
addss  -0xc(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    11f0 <analysis+0x60>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     13ac <analysis+0x21c>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1060 <iscntrl@plt>
cmp    $0x0,%rax
je     1262 <analysis+0xd2>
movss  0xdb1(%rip),%xmm0
addss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
jmp    139b <analysis+0x20b>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1090 <isspace@plt>
cmp    $0x0,%rax
je     128f <analysis+0xff>
movss  0xd84(%rip),%xmm0
addss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
jmp    1396 <analysis+0x206>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12bc <analysis+0x12c>
movss  0xd57(%rip),%xmm0
addss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
jmp    1391 <analysis+0x201>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%rax
je     12e9 <analysis+0x159>
movss  0xd2a(%rip),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    138c <analysis+0x1fc>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   10a0 <isupper@plt>
cmp    $0x0,%rax
je     1316 <analysis+0x186>
movss  0xcfd(%rip),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    1387 <analysis+0x1f7>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1080 <ispunct@plt>
cmp    $0x0,%rax
je     1343 <analysis+0x1b3>
movss  0xcd0(%rip),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
jmp    1382 <analysis+0x1f2>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   10b0 <isprint@plt>
cmp    $0x0,%eax
jne    136f <analysis+0x1df>
movss  0xca4(%rip),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    137d <analysis+0x1ed>
lea    0xca1(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1382 <analysis+0x1f2>
jmp    1387 <analysis+0x1f7>
jmp    138c <analysis+0x1fc>
jmp    1391 <analysis+0x201>
jmp    1396 <analysis+0x206>
jmp    139b <analysis+0x20b>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1228 <analysis+0x98>
movss  0xc4c(%rip),%xmm0
mulss  -0x10(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  0xc35(%rip),%xmm0
mulss  -0x14(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xc1e(%rip),%xmm0
mulss  -0x18(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xc07(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xbf0(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xbd9(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xbc2(%rip),%xmm0
mulss  -0x28(%rbp),%xmm0
divss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbcd(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbce(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbd2(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbcc(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbd2(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbd8(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbde(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<analysis>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%rbx
lea    0xe67(%rip),%rdi
call   1050 <puts@plt>
mov    (%rbx),%al
test   %al,%al
je     13e4 <analysis+0x254>
lea    0x1(%rbx),%rcx
xorps  %xmm3,%xmm3
movss  0xe41(%rip),%xmm0
nop
addss  %xmm0,%xmm3
cmpb   $0x0,(%rcx)
lea    0x1(%rcx),%rcx
jne    11c0 <analysis+0x30>
test   %al,%al
je     13e7 <analysis+0x257>
movss  %xmm3,0x24(%rsp)
xorps  %xmm1,%xmm1
lea    0xeeb(%rip),%r14
xorps  %xmm2,%xmm2
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
xorps  %xmm6,%xmm6
xorps  %xmm7,%xmm7
xorps  %xmm0,%xmm0
jmp    1246 <analysis+0xb6>
nopl   0x0(%rax)
movss  0x20(%rsp),%xmm0
movss  0xdf2(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x1c(%rsp),%xmm1
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movss  0xc(%rsp),%xmm6
movss  0x8(%rsp),%xmm7
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
je     13dc <analysis+0x24c>
movss  %xmm0,0x20(%rsp)
movss  %xmm7,0x8(%rsp)
movss  %xmm6,0xc(%rsp)
movss  %xmm5,0x10(%rsp)
movss  %xmm4,0x14(%rsp)
movss  %xmm2,0x18(%rsp)
movss  %xmm1,0x1c(%rsp)
movsbl %al,%edi
call   1060 <iscntrl@plt>
test   %rax,%rax
jne    1200 <analysis+0x70>
movsbl (%rbx),%edi
call   1090 <isspace@plt>
test   %rax,%rax
je     12bf <analysis+0x12f>
movss  0x8(%rsp),%xmm7
movss  0xd68(%rip),%xmm0
addss  %xmm0,%xmm7
movss  0x1c(%rsp),%xmm1
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movss  0xc(%rsp),%xmm6
jmp    13d1 <analysis+0x241>
movsbl (%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12fb <analysis+0x16b>
movss  0xc(%rsp),%xmm6
movss  0xd26(%rip),%xmm0
addss  %xmm0,%xmm6
movss  0x1c(%rsp),%xmm1
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
jmp    13cb <analysis+0x23b>
movsbl (%rbx),%edi
call   1040 <islower@plt>
test   %rax,%rax
je     1331 <analysis+0x1a1>
movss  0x10(%rsp),%xmm5
movss  0xcea(%rip),%xmm0
addss  %xmm0,%xmm5
movss  0x1c(%rsp),%xmm1
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm4
jmp    13c5 <analysis+0x235>
movsbl (%rbx),%edi
call   10a0 <isupper@plt>
test   %rax,%rax
je     135e <analysis+0x1ce>
movss  0x14(%rsp),%xmm4
movss  0xcb4(%rip),%xmm0
addss  %xmm0,%xmm4
movss  0x1c(%rsp),%xmm1
movss  0x18(%rsp),%xmm2
jmp    13bf <analysis+0x22f>
movsbl (%rbx),%edi
call   1080 <ispunct@plt>
test   %rax,%rax
je     1385 <analysis+0x1f5>
movss  0x18(%rsp),%xmm2
movss  0xc87(%rip),%xmm0
addss  %xmm0,%xmm2
movss  0x1c(%rsp),%xmm1
jmp    13b9 <analysis+0x229>
movsbl (%rbx),%edi
call   10b0 <isprint@plt>
test   %eax,%eax
je     13a1 <analysis+0x211>
mov    %r14,%rdi
call   1050 <puts@plt>
movss  0x1c(%rsp),%xmm1
jmp    13b3 <analysis+0x223>
movss  0x1c(%rsp),%xmm1
movss  0xc51(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm4
movss  0x10(%rsp),%xmm5
movss  0xc(%rsp),%xmm6
movss  0x8(%rsp),%xmm7
movss  0x20(%rsp),%xmm0
jmp    1236 <analysis+0xa6>
movss  0x24(%rsp),%xmm3
jmp    13fc <analysis+0x26c>
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
xorps  %xmm7,%xmm7
xorps  %xmm6,%xmm6
xorps  %xmm5,%xmm5
xorps  %xmm4,%xmm4
xorps  %xmm2,%xmm2
xorps  %xmm1,%xmm1
movss  0xbff(%rip),%xmm8
mulss  %xmm8,%xmm0
divss  %xmm3,%xmm0
mulss  %xmm8,%xmm7
divss  %xmm3,%xmm7
movss  %xmm7,0x8(%rsp)
mulss  %xmm8,%xmm6
divss  %xmm3,%xmm6
movss  %xmm6,0xc(%rsp)
mulss  %xmm8,%xmm5
divss  %xmm3,%xmm5
movss  %xmm5,0x10(%rsp)
mulss  %xmm8,%xmm4
divss  %xmm3,%xmm4
movss  %xmm4,0x14(%rsp)
mulss  %xmm8,%xmm2
divss  %xmm3,%xmm2
movss  %xmm2,0x18(%rsp)
mulss  %xmm8,%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x1c(%rsp)
cvtss2sd %xmm0,%xmm0
lea    0xba4(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xba4(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xba7(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xba0(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xba5(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbaa(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbaf(%rip),%rdi
mov    $0x1,%al
add    $0x28,%rsp
pop    %rbx
pop    %r14
jmp    1070 <printf@plt>

LLVM IR (-O0):
@.str = [15 x i8] c"**I was here**\00"
@.str.1 = [19 x i8] c"Mai era ceva bha!\0A\00"
@.str.2 = [24 x i8] c"control chars: %.2f%%,\0A\00"
@.str.3 = [27 x i8] c"whitespace chars: %.2f%%,\0A\00"
@.str.4 = [17 x i8] c"digits: %.2f%%,\0A\00"
@.str.5 = [29 x i8] c"lower case letters: %.2f%%,\0A\00"
@.str.6 = [29 x i8] c"upper case letters: %.2f%%,\0A\00"
@.str.7 = [29 x i8] c"punctuantion chars: %.2f%%,\0A\00"
@.str.8 = [30 x i8] c"non_printable chars: %.2f%%,\0A\00"
define void @analysis(i8* %0) {
%2 = alloca i8*
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca i8*
store i8* %0, i8** %2
%12 = call i32 @puts(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %8
store float 0.000000e+00, float* %7
store float 0.000000e+00, float* %6
store float 0.000000e+00, float* %5
store float 0.000000e+00, float* %4
store float 0.000000e+00, float* %3
%13 = load i8*, i8** %2
store i8* %13, i8** %11
br label %14
14: ; preds = %18, %1
%15 = load i8*, i8** %2
%16 = load i8, i8* %15
%17 = icmp ne i8 %16, 0
br i1 %17, label %18, label %23
18: ; preds = %14
%19 = load float, float* %3
%20 = fadd float %19, 1.000000e+00
store float %20, float* %3
%21 = load i8*, i8** %2
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %2
br label %14
23: ; preds = %14
%24 = load i8*, i8** %11
store i8* %24, i8** %2
br label %25
25: ; preds = %93, %23
%26 = load i8*, i8** %2
%27 = load i8, i8* %26
%28 = icmp ne i8 %27, 0
br i1 %28, label %29, label %96
29: ; preds = %25
%30 = load i8*, i8** %2
%31 = load i8, i8* %30
%32 = call i64 @iscntrl(i8 signext %31)
%33 = icmp ne i64 %32, 0
br i1 %33, label %34, label %37
34: ; preds = %29
%35 = load float, float* %4
%36 = fadd float %35, 1.000000e+00
store float %36, float* %4
br label %93
37: ; preds = %29
%38 = load i8*, i8** %2
%39 = load i8, i8* %38
%40 = call i64 @isspace(i8 signext %39)
%41 = icmp ne i64 %40, 0
br i1 %41, label %42, label %45
42: ; preds = %37
%43 = load float, float* %5
%44 = fadd float %43, 1.000000e+00
store float %44, float* %5
br label %92
45: ; preds = %37
%46 = load i8*, i8** %2
%47 = load i8, i8* %46
%48 = call i64 @isdigit(i8 signext %47)
%49 = icmp ne i64 %48, 0
br i1 %49, label %50, label %53
50: ; preds = %45
%51 = load float, float* %6
%52 = fadd float %51, 1.000000e+00
store float %52, float* %6
br label %91
53: ; preds = %45
%54 = load i8*, i8** %2
%55 = load i8, i8* %54
%56 = call i64 @islower(i8 signext %55)
%57 = icmp ne i64 %56, 0
br i1 %57, label %58, label %61
58: ; preds = %53
%59 = load float, float* %7
%60 = fadd float %59, 1.000000e+00
store float %60, float* %7
br label %90
61: ; preds = %53
%62 = load i8*, i8** %2
%63 = load i8, i8* %62
%64 = call i64 @isupper(i8 signext %63)
%65 = icmp ne i64 %64, 0
br i1 %65, label %66, label %69
66: ; preds = %61
%67 = load float, float* %8
%68 = fadd float %67, 1.000000e+00
store float %68, float* %8
br label %89
69: ; preds = %61
%70 = load i8*, i8** %2
%71 = load i8, i8* %70
%72 = call i64 @ispunct(i8 signext %71)
%73 = icmp ne i64 %72, 0
br i1 %73, label %74, label %77
74: ; preds = %69
%75 = load float, float* %9
%76 = fadd float %75, 1.000000e+00
store float %76, float* %9
br label %88
77: ; preds = %69
%78 = load i8*, i8** %2
%79 = load i8, i8* %78
%80 = call i32 @isprint(i8 signext %79)
%81 = icmp ne i32 %80, 0
br i1 %81, label %85, label %82
82: ; preds = %77
%83 = load float, float* %10
%84 = fadd float %83, 1.000000e+00
store float %84, float* %10
br label %87
85: ; preds = %77
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0))
br label %87
87: ; preds = %85, %82
br label %88
88: ; preds = %87, %74
br label %89
89: ; preds = %88, %66
br label %90
90: ; preds = %89, %58
br label %91
91: ; preds = %90, %50
br label %92
92: ; preds = %91, %42
br label %93
93: ; preds = %92, %34
%94 = load i8*, i8** %2
%95 = getelementptr inbounds i8, i8* %94, i32 1
store i8* %95, i8** %2
br label %25
96: ; preds = %25
%97 = load float, float* %4
%98 = fmul float %97, 1.000000e+02
%99 = load float, float* %3
%100 = fdiv float %98, %99
store float %100, float* %4
%101 = load float, float* %5
%102 = fmul float %101, 1.000000e+02
%103 = load float, float* %3
%104 = fdiv float %102, %103
store float %104, float* %5
%105 = load float, float* %6
%106 = fmul float %105, 1.000000e+02
%107 = load float, float* %3
%108 = fdiv float %106, %107
store float %108, float* %6
%109 = load float, float* %7
%110 = fmul float %109, 1.000000e+02
%111 = load float, float* %3
%112 = fdiv float %110, %111
store float %112, float* %7
%113 = load float, float* %8
%114 = fmul float %113, 1.000000e+02
%115 = load float, float* %3
%116 = fdiv float %114, %115
store float %116, float* %8
%117 = load float, float* %9
%118 = fmul float %117, 1.000000e+02
%119 = load float, float* %3
%120 = fdiv float %118, %119
store float %120, float* %9
%121 = load float, float* %10
%122 = fmul float %121, 1.000000e+02
%123 = load float, float* %3
%124 = fdiv float %122, %123
store float %124, float* %10
%125 = load float, float* %4
%126 = fpext float %125 to double
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0), double %126)
%128 = load float, float* %5
%129 = fpext float %128 to double
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), double %129)
%131 = load float, float* %6
%132 = fpext float %131 to double
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), double %132)
%134 = load float, float* %7
%135 = fpext float %134 to double
%136 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), double %135)
%137 = load float, float* %8
%138 = fpext float %137 to double
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), double %138)
%140 = load float, float* %9
%141 = fpext float %140 to double
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), double %141)
%143 = load float, float* %10
%144 = fpext float %143 to double
%145 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), double %144)
ret void
}

LLVM IR (-O2):
@.str = [15 x i8] c"**I was here**\00"
@.str.2 = [24 x i8] c"control chars: %.2f%%,\0A\00"
@.str.3 = [27 x i8] c"whitespace chars: %.2f%%,\0A\00"
@.str.4 = [17 x i8] c"digits: %.2f%%,\0A\00"
@.str.5 = [29 x i8] c"lower case letters: %.2f%%,\0A\00"
@.str.6 = [29 x i8] c"upper case letters: %.2f%%,\0A\00"
@.str.7 = [29 x i8] c"punctuantion chars: %.2f%%,\0A\00"
@.str.8 = [30 x i8] c"non_printable chars: %.2f%%,\0A\00"
@str = [18 x i8] c"Mai era ceva bha!\00"
define void @analysis(i8* nocapture %0) {
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %76, label %6
5: ; preds = %6
br i1 %4, label %76, label %13
6: ; preds = %1, %6
%7 = phi i8* [ %10, %6 ], [ %0, %1 ]
%8 = phi float [ %9, %6 ], [ 0.000000e+00, %1 ]
%9 = fadd float %8, 1.000000e+00
%10 = getelementptr inbounds i8, i8* %7, i64 1
%11 = load i8, i8* %10
%12 = icmp eq i8 %11, 0
br i1 %12, label %5, label %6
13: ; preds = %5, %65
%14 = phi i8 [ %74, %65 ], [ %3, %5 ]
%15 = phi i8* [ %73, %65 ], [ %0, %5 ]
%16 = phi float [ %72, %65 ], [ 0.000000e+00, %5 ]
%17 = phi float [ %71, %65 ], [ 0.000000e+00, %5 ]
%18 = phi float [ %70, %65 ], [ 0.000000e+00, %5 ]
%19 = phi float [ %69, %65 ], [ 0.000000e+00, %5 ]
%20 = phi float [ %68, %65 ], [ 0.000000e+00, %5 ]
%21 = phi float [ %67, %65 ], [ 0.000000e+00, %5 ]
%22 = phi float [ %66, %65 ], [ 0.000000e+00, %5 ]
%23 = tail call i64 @iscntrl(i8 signext %14)
%24 = icmp eq i64 %23, 0
br i1 %24, label %27, label %25
25: ; preds = %13
%26 = fadd float %22, 1.000000e+00
br label %65
27: ; preds = %13
%28 = load i8, i8* %15
%29 = tail call i64 @isspace(i8 signext %28)
%30 = icmp eq i64 %29, 0
br i1 %30, label %33, label %31
31: ; preds = %27
%32 = fadd float %21, 1.000000e+00
br label %65
33: ; preds = %27
%34 = load i8, i8* %15
%35 = tail call i64 @isdigit(i8 signext %34)
%36 = icmp eq i64 %35, 0
br i1 %36, label %39, label %37
37: ; preds = %33
%38 = fadd float %20, 1.000000e+00
br label %65
39: ; preds = %33
%40 = load i8, i8* %15
%41 = tail call i64 @islower(i8 signext %40)
%42 = icmp eq i64 %41, 0
br i1 %42, label %45, label %43
43: ; preds = %39
%44 = fadd float %19, 1.000000e+00
br label %65
45: ; preds = %39
%46 = load i8, i8* %15
%47 = tail call i64 @isupper(i8 signext %46)
%48 = icmp eq i64 %47, 0
br i1 %48, label %51, label %49
49: ; preds = %45
%50 = fadd float %18, 1.000000e+00
br label %65
51: ; preds = %45
%52 = load i8, i8* %15
%53 = tail call i64 @ispunct(i8 signext %52)
%54 = icmp eq i64 %53, 0
br i1 %54, label %57, label %55
55: ; preds = %51
%56 = fadd float %17, 1.000000e+00
br label %65
57: ; preds = %51
%58 = load i8, i8* %15
%59 = tail call i32 @isprint(i8 signext %58)
%60 = icmp eq i32 %59, 0
br i1 %60, label %61, label %63
61: ; preds = %57
%62 = fadd float %16, 1.000000e+00
br label %65
63: ; preds = %57
%64 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
br label %65
65: ; preds = %31, %43, %55, %63, %61, %49, %37, %25
%66 = phi float [ %26, %25 ], [ %22, %31 ], [ %22, %37 ], [ %22, %43 ], [ %22, %49 ], [ %22, %55 ], [ %22, %63 ], [ %22, %61 ]
%67 = phi float [ %21, %25 ], [ %32, %31 ], [ %21, %37 ], [ %21, %43 ], [ %21, %49 ], [ %21, %55 ], [ %21, %63 ], [ %21, %61 ]
%68 = phi float [ %20, %25 ], [ %20, %31 ], [ %38, %37 ], [ %20, %43 ], [ %20, %49 ], [ %20, %55 ], [ %20, %63 ], [ %20, %61 ]
%69 = phi float [ %19, %25 ], [ %19, %31 ], [ %19, %37 ], [ %44, %43 ], [ %19, %49 ], [ %19, %55 ], [ %19, %63 ], [ %19, %61 ]
%70 = phi float [ %18, %25 ], [ %18, %31 ], [ %18, %37 ], [ %18, %43 ], [ %50, %49 ], [ %18, %55 ], [ %18, %63 ], [ %18, %61 ]
%71 = phi float [ %17, %25 ], [ %17, %31 ], [ %17, %37 ], [ %17, %43 ], [ %17, %49 ], [ %56, %55 ], [ %17, %63 ], [ %17, %61 ]
%72 = phi float [ %16, %25 ], [ %16, %31 ], [ %16, %37 ], [ %16, %43 ], [ %16, %49 ], [ %16, %55 ], [ %16, %63 ], [ %62, %61 ]
%73 = getelementptr inbounds i8, i8* %15, i64 1
%74 = load i8, i8* %73
%75 = icmp eq i8 %74, 0
br i1 %75, label %76, label %13
76: ; preds = %65, %1, %5
%77 = phi float [ %9, %5 ], [ 0.000000e+00, %1 ], [ %9, %65 ]
%78 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %66, %65 ]
%79 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %67, %65 ]
%80 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %68, %65 ]
%81 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %69, %65 ]
%82 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %70, %65 ]
%83 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %71, %65 ]
%84 = phi float [ 0.000000e+00, %5 ], [ 0.000000e+00, %1 ], [ %72, %65 ]
%85 = fmul float %78, 1.000000e+02
%86 = fdiv float %85, %77
%87 = fmul float %79, 1.000000e+02
%88 = fdiv float %87, %77
%89 = fmul float %80, 1.000000e+02
%90 = fdiv float %89, %77
%91 = fmul float %81, 1.000000e+02
%92 = fdiv float %91, %77
%93 = fmul float %82, 1.000000e+02
%94 = fdiv float %93, %77
%95 = fmul float %83, 1.000000e+02
%96 = fdiv float %95, %77
%97 = fmul float %84, 1.000000e+02
%98 = fdiv float %97, %77
%99 = fpext float %86 to double
%100 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0), double %99)
%101 = fpext float %88 to double
%102 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), double %101)
%103 = fpext float %90 to double
%104 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), double %103)
%105 = fpext float %92 to double
%106 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), double %105)
%107 = fpext float %94 to double
%108 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), double %107)
%109 = fpext float %96 to double
%110 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.7, i64 0, i64 0), double %109)
%111 = fpext float %98 to double
%112 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), double %111)
ret void
}