#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;
  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)
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    0xe33(%rip),%rsi
mov    $0x54,%edx
call   1050 <memcpy@plt>
lea    -0x100(%rbp),%rdi
lea    0xe7b(%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    11ef <str_stats+0xbf>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1432 <str_stats+0x302>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x104(%rbp)
cmpl   $0x20,-0x104(%rbp)
jl     124c <str_stats+0x11c>
cmpl   $0x2f,-0x104(%rbp)
jle    1283 <str_stats+0x153>
cmpl   $0x7b,-0x104(%rbp)
jl     1269 <str_stats+0x139>
cmpl   $0x80,-0x104(%rbp)
jl     1283 <str_stats+0x153>
cmpl   $0x5b,-0x104(%rbp)
jl     128f <str_stats+0x15f>
cmpl   $0x60,-0x104(%rbp)
jg     128f <str_stats+0x15f>
movl   $0x0,-0x30(%rbp)
jmp    141f <str_stats+0x2ef>
cmpl   $0x30,-0x104(%rbp)
jl     12a9 <str_stats+0x179>
cmpl   $0x5a,-0x104(%rbp)
jle    12c3 <str_stats+0x193>
cmpl   $0x61,-0x104(%rbp)
jl     141a <str_stats+0x2ea>
cmpl   $0x7a,-0x104(%rbp)
jg     141a <str_stats+0x2ea>
cmpl   $0x0,-0x30(%rbp)
jne    12d6 <str_stats+0x1a6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    134f <str_stats+0x21f>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
cmp    -0x70(%rbp,%rcx,4),%eax
jne    1310 <str_stats+0x1e0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1315 <str_stats+0x1e5>
jmp    1315 <str_stats+0x1e5>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0x70(%rbp,%rcx,4),%ecx
add    $0x20,%ecx
cmp    %ecx,%eax
jne    133c <str_stats+0x20c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1341 <str_stats+0x211>
jmp    1341 <str_stats+0x211>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12e4 <str_stats+0x1b4>
movl   $0x0,-0x18(%rbp)
cmpl   $0x15,-0x18(%rbp)
jge    13c7 <str_stats+0x297>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
cmp    -0xd0(%rbp,%rcx,4),%eax
jne    1385 <str_stats+0x255>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    138a <str_stats+0x25a>
jmp    138a <str_stats+0x25a>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0xd0(%rbp,%rcx,4),%ecx
add    $0x20,%ecx
cmp    %ecx,%eax
jne    13b4 <str_stats+0x284>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b9 <str_stats+0x289>
jmp    13b9 <str_stats+0x289>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1356 <str_stats+0x226>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    1415 <str_stats+0x2e5>
mov    -0x104(%rbp),%eax
movslq -0x18(%rbp),%rcx
mov    -0x100(%rbp,%rcx,4),%ecx
add    $0x30,%ecx
cmp    %ecx,%eax
jne    1402 <str_stats+0x2d2>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1407 <str_stats+0x2d7>
jmp    1407 <str_stats+0x2d7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13ce <str_stats+0x29e>
jmp    141a <str_stats+0x2ea>
jmp    141f <str_stats+0x2ef>
jmp    1424 <str_stats+0x2f4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1214 <str_stats+0xe4>
mov    -0x34(%rbp),%esi
lea    0xc4c(%rip),%rdi
call   1030 <printf@plt>
mov    -0x3c(%rbp),%esi
lea    0xc48(%rip),%rdi
call   1030 <printf@plt>
mov    -0x38(%rbp),%esi
lea    0xc4a(%rip),%rdi
call   1030 <printf@plt>
mov    -0x40(%rbp),%esi
lea    0xc4a(%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
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%rdi,%rax,1)
lea    0x1(%rax),%rax
jne    1120 <str_stats+0x10>
mov    %eax,%r10d
xor    %ecx,%ecx
movdqa 0xec7(%rip),%xmm8
movdqa 0xece(%rip),%xmm9
movdqa 0xed5(%rip),%xmm10
movdqa 0xedc(%rip),%xmm11
movdqa 0xee3(%rip),%xmm12
movdqa 0xeea(%rip),%xmm13
movdqa 0xef2(%rip),%xmm6
movdqa 0xefa(%rip),%xmm7
movdqa 0xf02(%rip),%xmm0
movdqa 0xf0a(%rip),%xmm1
movdqa 0xf12(%rip),%xmm2
movabs $0x1f0000003f,%r8
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
xor    %esi,%esi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%rdi,%rcx,1),%edx
mov    %edx,%ebx
and    $0xf0,%bl
cmp    $0x20,%bl
je     11cf <str_stats+0xbf>
lea    -0x5b(%rdx),%ebx
cmp    $0x24,%bl
ja     11df <str_stats+0xcf>
movzbl %bl,%ebx
bt     %rbx,%r8
jae    11df <str_stats+0xcf>
xor    %ebp,%ebp
add    $0x1,%rcx
cmp    %rcx,%r10
jne    11b0 <str_stats+0xa0>
jmp    1382 <str_stats+0x272>
cmp    $0x60,%dl
jg     11ec <str_stats+0xdc>
lea    -0x30(%rdx),%ebx
cmp    $0x2a,%bl
ja     11d1 <str_stats+0xc1>
xor    %ebx,%ebx
cmp    $0x41,%dl
sete   %bl
add    %ebx,%r12d
xor    %ebx,%ebx
cmp    $0x61,%dl
sete   %bl
add    %r12d,%ebx
xor    %eax,%eax
cmp    $0x45,%dl
sete   %al
add    %ebx,%eax
xor    %ebx,%ebx
cmp    $0x65,%dl
sete   %bl
add    %eax,%ebx
xor    %eax,%eax
cmp    $0x49,%dl
sete   %al
add    %ebx,%eax
xor    %ebx,%ebx
cmp    $0x69,%dl
sete   %bl
add    %eax,%ebx
xor    %eax,%eax
cmp    $0x4f,%dl
sete   %al
add    %ebx,%eax
xor    %ebx,%ebx
cmp    $0x6f,%dl
sete   %bl
add    %eax,%ebx
xor    %eax,%eax
cmp    $0x55,%dl
sete   %al
add    %ebx,%eax
xor    %ebx,%ebx
cmp    $0x75,%dl
sete   %bl
add    %eax,%ebx
xor    %eax,%eax
cmp    $0x59,%dl
sete   %al
add    %ebx,%eax
xor    %r12d,%r12d
cmp    $0x79,%dl
sete   %r12b
add    %eax,%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    %ebx,%ebx
cmp    $0x5a,%dl
sete   %bl
add    %eax,%ebx
xor    %r15d,%r15d
cmp    $0x7a,%dl
sete   %r15b
add    %ebx,%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    %ebx,%ebx
cmp    $0x39,%dl
sete   %bl
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    %ebx,%eax
add    %eax,%r14d
cmp    $0x1,%ebp
adc    $0x0,%esi
mov    $0x1,%ebp
jmp    11d1 <str_stats+0xc1>
lea    0xd27(%rip),%rdi
call   1030 <printf@plt>
lea    0xd26(%rip),%rdi
mov    %r15d,%esi
call   1030 <printf@plt>
lea    0xd28(%rip),%rdi
mov    %r12d,%esi
call   1030 <printf@plt>
lea    0xd28(%rip),%rdi
mov    %r14d,%esi
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

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

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