#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 DEDANS;
int DEHORS;
int /*<<< orphan*/ printf(char *, int);
void str_stats(char *arg) {
  const DEHORS = 0;
  const DEDANS = 1;
  enum voyellesMaj { A = 65, E = 69, I = 73, O = 79, U = 85, Y = 89 };
  enum chiffres { ZERO, UN, DEUX, TROIS, QUATRE, CINQ, SIX, SEPT, HUIT, NEUF };
  enum consonnes {
    B = 66,
    C = 67,
    D = 68,
    F = 70,
    G = 71,
    H = 72,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    V = 86,
    W = 87,
    X = 88,
    Z = 90
  };
  int i, j, g, taille, tailleV, tailleCo, tailleCh, etat, mots, voyelles,
      consonnes, chiffres;
  etat = mots = voyelles = consonnes = chiffres = 0;
  taille = tailleCo = tailleCh = 0;
  printf("taille : %d\n", taille);
  int tabv[12] = {A, E, I, O, U, Y};
  int tabco[21] = {B, C, D, F, G, H, J, K, L, M, N,
                   P, Q, R, S, T, V, W, X, Y, Z};
  int tabch[10] = {ZERO, UN, DEUX, TROIS, QUATRE, CINQ, SIX, SEPT, HUIT, NEUF};
  do {
    taille++;
  } while (arg[taille] != '\0');
  for (i = 0; i < taille; i++) {
    int c = arg[i];
    if ((c >= ' ' && c <= '/') ||
        (c >= '{' && c < 128 || c >= '[' && c <= 96)) {
      etat = DEHORS;
    } else if (c >= '0' && c <= 'Z' || c >= 'a' && c <= 'z') {
      if (etat == DEHORS)
        mots++;
      etat = DEDANS;
      for (j = 0; j < 12; j++) {
        (c == tabv[j]) ? voyelles++ : 0;
        (c == (tabv[j] + 32)) ? voyelles++ : 0;
      }
      for (j = 0; j < 21; j++) {
        (c == tabco[j]) ? consonnes++ : 0;
        (c == (tabco[j] + 32)) ? consonnes++ : 0;
      }
      for (j = 0; j < 10; j++) {
        (c == (tabch[j] + 48)) ? chiffres++ : 0;
      }
    }
  }
  printf("%d mot(s)\n", mots);
  printf("%d consonnes(s)\n", consonnes);
  printf("%d voyelle(s)\n", voyelles);
  printf("%d chiffre(s)", chiffres);
}


x86 assembly (clang, -O0):
<str_stats>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x1,-0x10(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%esi
lea    0xe71(%rip),%rdi
call   1030 <printf@plt>
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x30,%edx
call   1040 <memset@plt>
movl   $0x41,-0x70(%rbp)
movl   $0x45,-0x6c(%rbp)
movl   $0x49,-0x68(%rbp)
movl   $0x4f,-0x64(%rbp)
movl   $0x55,-0x60(%rbp)
movl   $0x59,-0x5c(%rbp)
lea    -0xd0(%rbp),%rdi
lea    0xe74(%rip),%rsi
mov    $0x54,%edx
call   1050 <memcpy@plt>
lea    -0x100(%rbp),%rdi
lea    0xebc(%rip),%rsi
mov    $0x28,%edx
call   1050 <memcpy@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    11fe <str_stats+0xce>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1441 <str_stats+0x311>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x104(%rbp)
cmpl   $0x20,-0x104(%rbp)
jl     125b <str_stats+0x12b>
cmpl   $0x2f,-0x104(%rbp)
jle    1292 <str_stats+0x162>
cmpl   $0x7b,-0x104(%rbp)
jl     1278 <str_stats+0x148>
cmpl   $0x80,-0x104(%rbp)
jl     1292 <str_stats+0x162>
cmpl   $0x5b,-0x104(%rbp)
jl     129e <str_stats+0x16e>
cmpl   $0x60,-0x104(%rbp)
jg     129e <str_stats+0x16e>
movl   $0x0,-0x30(%rbp)
jmp    142e <str_stats+0x2fe>
cmpl   $0x30,-0x104(%rbp)
jl     12b8 <str_stats+0x188>
cmpl   $0x5a,-0x104(%rbp)
jle    12d2 <str_stats+0x1a2>
cmpl   $0x61,-0x104(%rbp)
jl     1429 <str_stats+0x2f9>
cmpl   $0x7a,-0x104(%rbp)
jg     1429 <str_stats+0x2f9>
cmpl   $0x0,-0x30(%rbp)
jne    12e5 <str_stats+0x1b5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    135e <str_stats+0x22e>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
cmp    -0x70(%rbp,%rcx,4),%eax
jne    131f <str_stats+0x1ef>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1324 <str_stats+0x1f4>
jmp    1324 <str_stats+0x1f4>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0x70(%rbp,%rcx,4),%ecx
add    $0x20,%ecx
cmp    %ecx,%eax
jne    134b <str_stats+0x21b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1350 <str_stats+0x220>
jmp    1350 <str_stats+0x220>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12f3 <str_stats+0x1c3>
movl   $0x0,-0x18(%rbp)
cmpl   $0x15,-0x18(%rbp)
jge    13d6 <str_stats+0x2a6>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
cmp    -0xd0(%rbp,%rcx,4),%eax
jne    1394 <str_stats+0x264>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1399 <str_stats+0x269>
jmp    1399 <str_stats+0x269>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0xd0(%rbp,%rcx,4),%ecx
add    $0x20,%ecx
cmp    %ecx,%eax
jne    13c3 <str_stats+0x293>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13c8 <str_stats+0x298>
jmp    13c8 <str_stats+0x298>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1365 <str_stats+0x235>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    1424 <str_stats+0x2f4>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0x100(%rbp,%rcx,4),%ecx
add    $0x30,%ecx
cmp    %ecx,%eax
jne    1411 <str_stats+0x2e1>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1416 <str_stats+0x2e6>
jmp    1416 <str_stats+0x2e6>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13dd <str_stats+0x2ad>
jmp    1429 <str_stats+0x2f9>
jmp    142e <str_stats+0x2fe>
jmp    1433 <str_stats+0x303>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1223 <str_stats+0xf3>
mov    -0x34(%rbp),%esi
lea    0xbc2(%rip),%rdi
call   1030 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0xbbe(%rip),%rdi
call   1030 <printf@plt>
mov    -0x38(%rbp),%esi
lea    0xbc0(%rip),%rdi
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
lea    0xbc0(%rip),%rdi
call   1030 <printf@plt>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str_stats>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%rbx
lea    0xf8e(%rip),%rdi
xor    %ebp,%ebp
xor    %esi,%esi
call   1030 <printf@plt>
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%rbx,%rbp,1)
lea    0x1(%rbp),%rbp
jne    1130 <str_stats+0x20>
mov    %ebp,%r10d
xor    %ecx,%ecx
movdqa 0xeb7(%rip),%xmm8
movdqa 0xebe(%rip),%xmm9
movdqa 0xec5(%rip),%xmm10
movdqa 0xecc(%rip),%xmm11
movdqa 0xed3(%rip),%xmm12
movdqa 0xeda(%rip),%xmm13
movdqa 0xee2(%rip),%xmm6
movdqa 0xeea(%rip),%xmm7
movdqa 0xef2(%rip),%xmm0
movdqa 0xefa(%rip),%xmm1
movdqa 0xf02(%rip),%xmm2
movabs $0x1f0000003f,%r8
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
xor    %esi,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%rbx,%rcx,1),%edx
mov    %edx,%eax
and    $0xf0,%al
cmp    $0x20,%al
je     11df <str_stats+0xcf>
lea    -0x5b(%rdx),%ebp
cmp    $0x24,%bpl
ja     11ef <str_stats+0xdf>
movzbl %bpl,%eax
bt     %rax,%r8
jae    11ef <str_stats+0xdf>
xor    %edi,%edi
add    $0x1,%rcx
cmp    %rcx,%r10
jne    11c0 <str_stats+0xb0>
jmp    1398 <str_stats+0x288>
cmp    $0x60,%dl
jg     11fb <str_stats+0xeb>
lea    -0x30(%rdx),%eax
cmp    $0x2a,%al
ja     11e1 <str_stats+0xd1>
xor    %eax,%eax
cmp    $0x41,%dl
sete   %al
add    %eax,%r12d
xor    %eax,%eax
cmp    $0x61,%dl
sete   %al
add    %r12d,%eax
xor    %ebp,%ebp
cmp    $0x45,%dl
sete   %bpl
add    %eax,%ebp
xor    %eax,%eax
cmp    $0x65,%dl
sete   %al
add    %ebp,%eax
xor    %ebp,%ebp
cmp    $0x49,%dl
sete   %bpl
add    %eax,%ebp
xor    %eax,%eax
cmp    $0x69,%dl
sete   %al
add    %ebp,%eax
xor    %ebp,%ebp
cmp    $0x4f,%dl
sete   %bpl
add    %eax,%ebp
xor    %eax,%eax
cmp    $0x6f,%dl
sete   %al
add    %ebp,%eax
xor    %ebp,%ebp
cmp    $0x55,%dl
sete   %bpl
add    %eax,%ebp
xor    %eax,%eax
cmp    $0x75,%dl
sete   %al
add    %ebp,%eax
xor    %ebp,%ebp
cmp    $0x59,%dl
sete   %bpl
add    %eax,%ebp
xor    %r12d,%r12d
cmp    $0x79,%dl
sete   %r12b
add    %ebp,%r12d
movd   %edx,%xmm3
pshufd $0x0,%xmm3,%xmm5
movd   %r15d,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm8,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm9,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm10,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm11,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm12,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm13,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm6,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm7,%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm5,%xmm4
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm3
pcmpeqd %xmm1,%xmm5
psubd  %xmm5,%xmm3
pshufd $0xee,%xmm3,%xmm4
paddd  %xmm3,%xmm4
pshufd $0x55,%xmm4,%xmm3
paddd  %xmm4,%xmm3
movd   %xmm3,%eax
xor    %ebp,%ebp
cmp    $0x5a,%dl
sete   %bpl
add    %eax,%ebp
xor    %r15d,%r15d
cmp    $0x7a,%dl
sete   %r15b
add    %ebp,%r15d
movzbl %dl,%eax
movd   %eax,%xmm3
punpcklbw %xmm3,%xmm3
pshuflw $0x0,%xmm3,%xmm3
pcmpeqb %xmm2,%xmm3
xor    %r9d,%r9d
cmp    $0x38,%dl
sete   %r9b
xor    %ebp,%ebp
cmp    $0x39,%dl
sete   %bpl
pmovmskb %xmm3,%eax
mov    %eax,%edx
shr    %dl
and    $0x55,%dl
sub    %dl,%al
mov    %eax,%edx
and    $0x33,%dl
shr    $0x2,%al
and    $0x33,%al
add    %dl,%al
mov    %eax,%edx
shr    $0x4,%dl
add    %al,%dl
and    $0xf,%dl
movzbl %dl,%eax
add    %r9d,%eax
add    %ebp,%eax
add    %eax,%r14d
cmp    $0x1,%edi
adc    $0x0,%esi
mov    $0x1,%edi
jmp    11e1 <str_stats+0xd1>
lea    0xd1e(%rip),%rdi
call   1030 <printf@plt>
lea    0xd1d(%rip),%rdi
mov    %r15d,%esi
call   1030 <printf@plt>
lea    0xd1f(%rip),%rdi
mov    %r12d,%esi
call   1030 <printf@plt>
lea    0xd1f(%rip),%rdi
mov    %r14d,%esi
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [13 x i8] c"taille : %d\0A\00"
@__const.str_stats.tabco = [21 x i32] [i32 66, i32 67, i32 68, i32 70, i32 71, i32 72, i32 74, i32 75, i32 76, i32 77, i32 78, i32 80, i32 81, i32 82, i32 83, i32 84, i32 86, i32 87, i32 88, i32 89, i32 90]
@__const.str_stats.tabch = [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9]
@.str.1 = [11 x i8] c"%d mot(s)\0A\00"
@.str.2 = [17 x i8] c"%d consonnes(s)\0A\00"
@.str.3 = [15 x i8] c"%d voyelle(s)\0A\00"
@.str.4 = [14 x i8] c"%d chiffre(s)\00"
@DEDANS = global i32 0
@DEHORS = global i32 0
define void @str_stats(i8* %0) {
%2 = alloca i8*
%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 i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca [12 x i32]
%18 = alloca [21 x i32]
%19 = alloca [10 x i32]
%20 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
store i32 1, i32* %4
store i32 0, i32* %16
store i32 0, i32* %15
store i32 0, i32* %14
store i32 0, i32* %13
store i32 0, i32* %12
store i32 0, i32* %11
store i32 0, i32* %10
store i32 0, i32* %8
%21 = load i32, i32* %8
%22 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 %21)
%23 = bitcast [12 x i32]* %17 to i8*
%24 = bitcast i8* %23 to [12 x i32]*
%25 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 0
store i32 65, i32* %25
%26 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 1
store i32 69, i32* %26
%27 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 2
store i32 73, i32* %27
%28 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 3
store i32 79, i32* %28
%29 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 4
store i32 85, i32* %29
%30 = getelementptr inbounds [12 x i32], [12 x i32]* %24, i32 0, i32 5
store i32 89, i32* %30
%31 = bitcast [21 x i32]* %18 to i8*
%32 = bitcast [10 x i32]* %19 to i8*
br label %33
33: ; preds = %36, %1
%34 = load i32, i32* %8
%35 = add nsw i32 %34, 1
store i32 %35, i32* %8
br label %36
36: ; preds = %33
%37 = load i8*, i8** %2
%38 = load i32, i32* %8
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = icmp ne i32 %42, 0
br i1 %43, label %33, label %44
44: ; preds = %36
store i32 0, i32* %5
br label %45
45: ; preds = %182, %44
%46 = load i32, i32* %5
%47 = load i32, i32* %8
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %185
49: ; preds = %45
%50 = load i8*, i8** %2
%51 = load i32, i32* %5
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
store i32 %55, i32* %20
%56 = load i32, i32* %20
%57 = icmp sge i32 %56, 32
br i1 %57, label %58, label %61
58: ; preds = %49
%59 = load i32, i32* %20
%60 = icmp sle i32 %59, 47
br i1 %60, label %73, label %61
61: ; preds = %58, %49
%62 = load i32, i32* %20
%63 = icmp sge i32 %62, 123
br i1 %63, label %64, label %67
64: ; preds = %61
%65 = load i32, i32* %20
%66 = icmp slt i32 %65, 128
br i1 %66, label %73, label %67
67: ; preds = %64, %61
%68 = load i32, i32* %20
%69 = icmp sge i32 %68, 91
br i1 %69, label %70, label %74
70: ; preds = %67
%71 = load i32, i32* %20
%72 = icmp sle i32 %71, 96
br i1 %72, label %73, label %74
73: ; preds = %70, %64, %58
store i32 0, i32* %12
br label %181
74: ; preds = %70, %67
%75 = load i32, i32* %20
%76 = icmp sge i32 %75, 48
br i1 %76, label %77, label %80
77: ; preds = %74
%78 = load i32, i32* %20
%79 = icmp sle i32 %78, 90
br i1 %79, label %86, label %80
80: ; preds = %77, %74
%81 = load i32, i32* %20
%82 = icmp sge i32 %81, 97
br i1 %82, label %83, label %180
83: ; preds = %80
%84 = load i32, i32* %20
%85 = icmp sle i32 %84, 122
br i1 %85, label %86, label %180
86: ; preds = %83, %77
%87 = load i32, i32* %12
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %92
89: ; preds = %86
%90 = load i32, i32* %13
%91 = add nsw i32 %90, 1
store i32 %91, i32* %13
br label %92
92: ; preds = %89, %86
store i32 1, i32* %12
store i32 0, i32* %6
br label %93
93: ; preds = %122, %92
%94 = load i32, i32* %6
%95 = icmp slt i32 %94, 12
br i1 %95, label %96, label %125
96: ; preds = %93
%97 = load i32, i32* %20
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [12 x i32], [12 x i32]* %17, i64 0, i64 %99
%101 = load i32, i32* %100
%102 = icmp eq i32 %97, %101
br i1 %102, label %103, label %106
103: ; preds = %96
%104 = load i32, i32* %14
%105 = add nsw i32 %104, 1
store i32 %105, i32* %14
br label %107
106: ; preds = %96
br label %107
107: ; preds = %106, %103
%108 = phi i32 [ %104, %103 ], [ 0, %106 ]
%109 = load i32, i32* %20
%110 = load i32, i32* %6
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [12 x i32], [12 x i32]* %17, i64 0, i64 %111
%113 = load i32, i32* %112
%114 = add nsw i32 %113, 32
%115 = icmp eq i32 %109, %114
br i1 %115, label %116, label %119
116: ; preds = %107
%117 = load i32, i32* %14
%118 = add nsw i32 %117, 1
store i32 %118, i32* %14
br label %120
119: ; preds = %107
br label %120
120: ; preds = %119, %116
%121 = phi i32 [ %117, %116 ], [ 0, %119 ]
br label %122
122: ; preds = %120
%123 = load i32, i32* %6
%124 = add nsw i32 %123, 1
store i32 %124, i32* %6
br label %93
125: ; preds = %93
store i32 0, i32* %6
br label %126
126: ; preds = %155, %125
%127 = load i32, i32* %6
%128 = icmp slt i32 %127, 21
br i1 %128, label %129, label %158
129: ; preds = %126
%130 = load i32, i32* %20
%131 = load i32, i32* %6
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = icmp eq i32 %130, %134
br i1 %135, label %136, label %139
136: ; preds = %129
%137 = load i32, i32* %15
%138 = add nsw i32 %137, 1
store i32 %138, i32* %15
br label %140
139: ; preds = %129
br label %140
140: ; preds = %139, %136
%141 = phi i32 [ %137, %136 ], [ 0, %139 ]
%142 = load i32, i32* %20
%143 = load i32, i32* %6
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [21 x i32], [21 x i32]* %18, i64 0, i64 %144
%146 = load i32, i32* %145
%147 = add nsw i32 %146, 32
%148 = icmp eq i32 %142, %147
br i1 %148, label %149, label %152
149: ; preds = %140
%150 = load i32, i32* %15
%151 = add nsw i32 %150, 1
store i32 %151, i32* %15
br label %153
152: ; preds = %140
br label %153
153: ; preds = %152, %149
%154 = phi i32 [ %150, %149 ], [ 0, %152 ]
br label %155
155: ; preds = %153
%156 = load i32, i32* %6
%157 = add nsw i32 %156, 1
store i32 %157, i32* %6
br label %126
158: ; preds = %126
store i32 0, i32* %6
br label %159
159: ; preds = %176, %158
%160 = load i32, i32* %6
%161 = icmp slt i32 %160, 10
br i1 %161, label %162, label %179
162: ; preds = %159
%163 = load i32, i32* %20
%164 = load i32, i32* %6
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [10 x i32], [10 x i32]* %19, i64 0, i64 %165
%167 = load i32, i32* %166
%168 = add nsw i32 %167, 48
%169 = icmp eq i32 %163, %168
br i1 %169, label %170, label %173
170: ; preds = %162
%171 = load i32, i32* %16
%172 = add nsw i32 %171, 1
store i32 %172, i32* %16
br label %174
173: ; preds = %162
br label %174
174: ; preds = %173, %170
%175 = phi i32 [ %171, %170 ], [ 0, %173 ]
br label %176
176: ; preds = %174
%177 = load i32, i32* %6
%178 = add nsw i32 %177, 1
store i32 %178, i32* %6
br label %159
179: ; preds = %159
br label %180
180: ; preds = %179, %83, %80
br label %181
181: ; preds = %180, %73
br label %182
182: ; preds = %181
%183 = load i32, i32* %5
%184 = add nsw i32 %183, 1
store i32 %184, i32* %5
br label %45
185: ; preds = %45
%186 = load i32, i32* %13
%187 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i32 %186)
%188 = load i32, i32* %15
%189 = call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i32 %188)
%190 = load i32, i32* %14
%191 = call i32 @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 %190)
%192 = load i32, i32* %16
%193 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), i32 %192)
ret void
}

LLVM IR (-O2):
@.str = [13 x i8] c"taille : %d\0A\00"
@.str.1 = [11 x i8] c"%d mot(s)\0A\00"
@.str.2 = [17 x i8] c"%d consonnes(s)\0A\00"
@.str.3 = [15 x i8] c"%d voyelle(s)\0A\00"
@.str.4 = [14 x i8] c"%d chiffre(s)\00"
@DEDANS = global i32 0
@DEHORS = global i32 0
define void @str_stats(i8* nocapture %0) {
%2 = tail call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 0)
br label %3
3: ; preds = %3, %1
%4 = phi i64 [ %5, %3 ], [ 0, %1 ]
%5 = add nuw nsw i64 %4, 1
%6 = getelementptr inbounds i8, i8* %0, i64 %5
%7 = load i8, i8* %6
%8 = icmp eq i8 %7, 0
br i1 %8, label %9, label %3
9: ; preds = %3
%10 = add nuw i64 %4, 1
%11 = and i64 %10, 4294967295
br label %12
12: ; preds = %9, %124
%13 = phi i64 [ 0, %9 ], [ %130, %124 ]
%14 = phi i32 [ 0, %9 ], [ %129, %124 ]
%15 = phi i32 [ 0, %9 ], [ %128, %124 ]
%16 = phi i32 [ 0, %9 ], [ %127, %124 ]
%17 = phi i32 [ 0, %9 ], [ %126, %124 ]
%18 = phi i32 [ 0, %9 ], [ %125, %124 ]
%19 = getelementptr inbounds i8, i8* %0, i64 %13
%20 = load i8, i8* %19
%21 = sext i8 %20 to i32
%22 = freeze i8 %20
%23 = and i8 %22, -16
%24 = icmp eq i8 %23, 32
br i1 %24, label %124, label %25
25: ; preds = %12
switch i8 %22, label %26 [
i8 127, label %124
i8 126, label %124
i8 125, label %124
i8 124, label %124
i8 123, label %124
i8 96, label %124
i8 95, label %124
i8 94, label %124
i8 93, label %124
i8 92, label %124
i8 91, label %124
]
26: ; preds = %25
%27 = add i8 %22, -48
%28 = icmp ult i8 %27, 43
%29 = icmp sgt i8 %22, 96
%30 = or i1 %29, %28
br i1 %30, label %31, label %124
31: ; preds = %26
%32 = icmp eq i32 %18, 0
%33 = zext i1 %32 to i32
%34 = icmp eq i8 %22, 65
%35 = zext i1 %34 to i32
%36 = add nsw i32 %16, %35
%37 = icmp eq i8 %22, 97
%38 = zext i1 %37 to i32
%39 = add nsw i32 %36, %38
%40 = icmp eq i8 %22, 69
%41 = zext i1 %40 to i32
%42 = add nsw i32 %39, %41
%43 = icmp eq i8 %22, 101
%44 = zext i1 %43 to i32
%45 = add nsw i32 %42, %44
%46 = icmp eq i8 %22, 73
%47 = zext i1 %46 to i32
%48 = add nsw i32 %45, %47
%49 = icmp eq i8 %22, 105
%50 = zext i1 %49 to i32
%51 = add nsw i32 %48, %50
%52 = icmp eq i8 %22, 79
%53 = zext i1 %52 to i32
%54 = add nsw i32 %51, %53
%55 = icmp eq i8 %22, 111
%56 = zext i1 %55 to i32
%57 = add nsw i32 %54, %56
%58 = icmp eq i8 %22, 85
%59 = zext i1 %58 to i32
%60 = add nsw i32 %57, %59
%61 = icmp eq i8 %22, 117
%62 = zext i1 %61 to i32
%63 = add nsw i32 %60, %62
%64 = icmp eq i8 %22, 89
%65 = zext i1 %64 to i32
%66 = add nsw i32 %63, %65
%67 = icmp eq i8 %22, 121
%68 = zext i1 %67 to i32
%69 = add nsw i32 %66, %68
%70 = insertelement <4 x i32> poison, i32 %21, i64 0
%71 = shufflevector <4 x i32> %70, <4 x i32> poison, <4 x i32> zeroinitializer
%72 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %15, i64 0
%73 = icmp eq <4 x i32> %71, <i32 66, i32 67, i32 68, i32 70>
%74 = zext <4 x i1> %73 to <4 x i32>
%75 = add <4 x i32> %72, %74
%76 = icmp eq <4 x i32> %71, <i32 98, i32 99, i32 100, i32 102>
%77 = zext <4 x i1> %76 to <4 x i32>
%78 = add <4 x i32> %75, %77
%79 = icmp eq <4 x i32> %71, <i32 71, i32 72, i32 74, i32 75>
%80 = zext <4 x i1> %79 to <4 x i32>
%81 = add <4 x i32> %78, %80
%82 = icmp eq <4 x i32> %71, <i32 103, i32 104, i32 106, i32 107>
%83 = zext <4 x i1> %82 to <4 x i32>
%84 = add <4 x i32> %81, %83
%85 = icmp eq <4 x i32> %71, <i32 76, i32 77, i32 78, i32 80>
%86 = zext <4 x i1> %85 to <4 x i32>
%87 = add <4 x i32> %84, %86
%88 = icmp eq <4 x i32> %71, <i32 108, i32 109, i32 110, i32 112>
%89 = zext <4 x i1> %88 to <4 x i32>
%90 = add <4 x i32> %87, %89
%91 = icmp eq <4 x i32> %71, <i32 81, i32 82, i32 83, i32 84>
%92 = zext <4 x i1> %91 to <4 x i32>
%93 = add <4 x i32> %90, %92
%94 = icmp eq <4 x i32> %71, <i32 113, i32 114, i32 115, i32 116>
%95 = zext <4 x i1> %94 to <4 x i32>
%96 = add <4 x i32> %93, %95
%97 = icmp eq <4 x i32> %71, <i32 86, i32 87, i32 88, i32 89>
%98 = zext <4 x i1> %97 to <4 x i32>
%99 = add <4 x i32> %96, %98
%100 = icmp eq <4 x i32> %71, <i32 118, i32 119, i32 120, i32 121>
%101 = zext <4 x i1> %100 to <4 x i32>
%102 = add <4 x i32> %99, %101
%103 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %102)
%104 = icmp eq i8 %22, 90
%105 = zext i1 %104 to i32
%106 = add nsw i32 %103, %105
%107 = icmp eq i8 %22, 122
%108 = zext i1 %107 to i32
%109 = add nsw i32 %106, %108
%110 = insertelement <8 x i8> poison, i8 %22, i64 0
%111 = shufflevector <8 x i8> %110, <8 x i8> poison, <8 x i32> zeroinitializer
%112 = icmp eq <8 x i8> %111, <i8 48, i8 49, i8 50, i8 51, i8 52, i8 53, i8 54, i8 55>
%113 = icmp eq i8 %22, 56
%114 = zext i1 %113 to i32
%115 = icmp eq i8 %22, 57
%116 = zext i1 %115 to i32
%117 = bitcast <8 x i1> %112 to i8
%118 = call i8 @llvm.ctpop.i8(i8 %117)
%119 = zext i8 %118 to i32
%120 = add nuw nsw i32 %119, %114
%121 = add nuw nsw i32 %120, %116
%122 = add nsw i32 %121, %14
%123 = add nsw i32 %17, %33
br label %124
124: ; preds = %31, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %12, %26
%125 = phi i32 [ 0, %25 ], [ %18, %26 ], [ 0, %12 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 0, %25 ], [ 1, %31 ]
%126 = phi i32 [ %17, %25 ], [ %17, %26 ], [ %17, %12 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %17, %25 ], [ %123, %31 ]
%127 = phi i32 [ %16, %25 ], [ %16, %26 ], [ %16, %12 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %16, %25 ], [ %69, %31 ]
%128 = phi i32 [ %15, %25 ], [ %15, %26 ], [ %15, %12 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %15, %25 ], [ %109, %31 ]
%129 = phi i32 [ %14, %25 ], [ %14, %26 ], [ %14, %12 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %14, %25 ], [ %122, %31 ]
%130 = add nuw nsw i64 %13, 1
%131 = icmp eq i64 %130, %11
br i1 %131, label %132, label %12
132: ; preds = %124
%133 = tail call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i32 %126)
%134 = tail call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i32 %128)
%135 = tail call i32 @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 %127)
%136 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), i32 %129)
ret void
}