#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*/ __VERIFIER_assert(int);
char __VERIFIER_nondet_char();
main(void) {
  char string_entrada[10],
      vetor_vogais[] = {'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U', '\0'};
  ;
  unsigned int i, j, cont, tam_string, n_caracter;
  for (i = 0; i < 10; i++)
    string_entrada[i] = __VERIFIER_nondet_char();
  string_entrada[10 - 1] = '\0';
  n_caracter = 0;
  while (string_entrada[n_caracter] != '\0')
    n_caracter++;
  cont = 0;
  for (i = 0; i < n_caracter; i++)
    for (j = 0; j < 8; j++)
      if (string_entrada[i] == vetor_vogais[j])
        cont++;
  i = 0;
  int cont_aux = 0;
  while (string_entrada[i] != '\0') {
    for (j = 0; j < 10; j++) {
      if (string_entrada[i] == vetor_vogais[j])
        cont_aux++;
    }
    i++;
  }
  __VERIFIER_assert(cont_aux == cont);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    0xeca(%rip),%rax
mov    %rax,-0x19(%rbp)
mov    0xec7(%rip),%ax
mov    %ax,-0x11(%rbp)
mov    0xebf(%rip),%al
mov    %al,-0xf(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jae    117d <main+0x5d>
mov    $0x0,%al
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,%cl
mov    -0x20(%rbp),%eax
mov    %cl,-0xe(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1155 <main+0x35>
movb   $0x0,-0x5(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
movsbl -0xe(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     11a7 <main+0x87>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1188 <main+0x68>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
jae    1219 <main+0xf9>
movl   $0x0,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jae    1206 <main+0xe6>
mov    -0x20(%rbp),%eax
movsbl -0xe(%rbp,%rax,1),%eax
mov    -0x24(%rbp),%ecx
movsbl -0x19(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    11f3 <main+0xd3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11f8 <main+0xd8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c8 <main+0xa8>
jmp    120b <main+0xeb>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b5 <main+0x95>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%eax
movsbl -0xe(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     128b <main+0x16b>
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jae    127d <main+0x15d>
mov    -0x20(%rbp),%eax
movsbl -0xe(%rbp,%rax,1),%eax
mov    -0x24(%rbp),%ecx
movsbl -0x19(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    126a <main+0x14a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126f <main+0x14f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    123f <main+0x11f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1227 <main+0x107>
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <__VERIFIER_assert@plt>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
xor    %ebp,%ebp
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %eax,%r14d
mov    %al,0x6(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x7(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x8(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x9(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0xa(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0xb(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0xc(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0xd(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0xe(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
movb   $0x0,0xf(%rsp)
mov    $0x0,%eax
test   %r14b,%r14b
je     11ba <main+0x9a>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmpb   $0x0,0x6(%rsp,%rax,1)
jne    11b0 <main+0x90>
test   %eax,%eax
je     1234 <main+0x114>
mov    %eax,%eax
xor    %ebp,%ebp
mov    $0x1,%ecx
movdqa 0xe31(%rip),%xmm0
mov    %r14d,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,%edx
movzbl %bl,%esi
movd   %esi,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%esi
mov    %esi,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%sil
mov    %esi,%ebx
and    $0x33,%bl
shr    $0x2,%sil
and    $0x33,%sil
add    %bl,%sil
mov    %esi,%ebx
shr    $0x4,%bl
add    %sil,%bl
and    $0xf,%bl
movzbl %bl,%ebp
add    %edx,%ebp
cmp    %rcx,%rax
je     1234 <main+0x114>
movzbl 0x6(%rsp,%rcx,1),%ebx
add    $0x1,%rcx
jmp    11e0 <main+0xc0>
xor    %eax,%eax
test   %r14b,%r14b
je     12ba <main+0x19a>
mov    $0x1,%ecx
movdqa 0xdb8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movzbl %r14b,%edi
movd   %edi,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pcmpeqb %xmm0,%xmm1
xor    %edx,%edx
cmp    $0x75,%dil
sete   %dl
xor    %esi,%esi
cmp    $0x55,%dil
sete   %sil
pmovmskb %xmm1,%edi
mov    %edi,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%dil
mov    %edi,%ebx
and    $0x33,%bl
shr    $0x2,%dil
and    $0x33,%dil
add    %bl,%dil
mov    %edi,%ebx
shr    $0x4,%bl
add    %dil,%bl
and    $0xf,%bl
movzbl %bl,%edi
add    %edx,%edi
add    %esi,%edi
add    %edi,%eax
mov    %ecx,%edx
movzbl 0x6(%rsp,%rdx,1),%r14d
add    $0x1,%ecx
test   %r14b,%r14b
jne    1250 <main+0x130>
xor    %edi,%edi
cmp    %ebp,%eax
sete   %dil
call   1040 <__VERIFIER_assert@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@__const.main.vetor_vogais = [11 x i8] c"aAeEiIoOuU\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10 x i8]
%3 = alloca [11 x i8]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 0, i32* %1
%10 = bitcast [11 x i8]* %3 to i8*
store i32 0, i32* %4
br label %11
11: ; preds = %19, %0
%12 = load i32, i32* %4
%13 = icmp ult i32 %12, 10
br i1 %13, label %14, label %22
14: ; preds = %11
%15 = call signext i8 (...) @__VERIFIER_nondet_char()
%16 = load i32, i32* %4
%17 = zext i32 %16 to i64
%18 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 %17
store i8 %15, i8* %18
br label %19
19: ; preds = %14
%20 = load i32, i32* %4
%21 = add i32 %20, 1
store i32 %21, i32* %4
br label %11
22: ; preds = %11
%23 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 9
store i8 0, i8* %23
store i32 0, i32* %8
br label %24
24: ; preds = %31, %22
%25 = load i32, i32* %8
%26 = zext i32 %25 to i64
%27 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 %26
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %34
31: ; preds = %24
%32 = load i32, i32* %8
%33 = add i32 %32, 1
store i32 %33, i32* %8
br label %24
34: ; preds = %24
store i32 0, i32* %6
store i32 0, i32* %4
br label %35
35: ; preds = %63, %34
%36 = load i32, i32* %4
%37 = load i32, i32* %8
%38 = icmp ult i32 %36, %37
br i1 %38, label %39, label %66
39: ; preds = %35
store i32 0, i32* %5
br label %40
40: ; preds = %59, %39
%41 = load i32, i32* %5
%42 = icmp ult i32 %41, 8
br i1 %42, label %43, label %62
43: ; preds = %40
%44 = load i32, i32* %4
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = load i32, i32* %5
%50 = zext i32 %49 to i64
%51 = getelementptr inbounds [11 x i8], [11 x i8]* %3, i64 0, i64 %50
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = icmp eq i32 %48, %53
br i1 %54, label %55, label %58
55: ; preds = %43
%56 = load i32, i32* %6
%57 = add i32 %56, 1
store i32 %57, i32* %6
br label %58
58: ; preds = %55, %43
br label %59
59: ; preds = %58
%60 = load i32, i32* %5
%61 = add i32 %60, 1
store i32 %61, i32* %5
br label %40
62: ; preds = %40
br label %63
63: ; preds = %62
%64 = load i32, i32* %4
%65 = add i32 %64, 1
store i32 %65, i32* %4
br label %35
66: ; preds = %35
store i32 0, i32* %4
store i32 0, i32* %9
br label %67
67: ; preds = %97, %66
%68 = load i32, i32* %4
%69 = zext i32 %68 to i64
%70 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = icmp ne i32 %72, 0
br i1 %73, label %74, label %100
74: ; preds = %67
store i32 0, i32* %5
br label %75
75: ; preds = %94, %74
%76 = load i32, i32* %5
%77 = icmp ult i32 %76, 10
br i1 %77, label %78, label %97
78: ; preds = %75
%79 = load i32, i32* %4
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds [10 x i8], [10 x i8]* %2, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = load i32, i32* %5
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds [11 x i8], [11 x i8]* %3, i64 0, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp eq i32 %83, %88
br i1 %89, label %90, label %93
90: ; preds = %78
%91 = load i32, i32* %9
%92 = add nsw i32 %91, 1
store i32 %92, i32* %9
br label %93
93: ; preds = %90, %78
br label %94
94: ; preds = %93
%95 = load i32, i32* %5
%96 = add i32 %95, 1
store i32 %96, i32* %5
br label %75
97: ; preds = %75
%98 = load i32, i32* %4
%99 = add i32 %98, 1
store i32 %99, i32* %4
br label %67
100: ; preds = %67
%101 = load i32, i32* %9
%102 = load i32, i32* %6
%103 = icmp eq i32 %101, %102
%104 = zext i1 %103 to i32
%105 = call i32 @__VERIFIER_assert(i32 %104)
%106 = load i32, i32* %1
ret i32 %106
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca [10 x i8]
%2 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 0
%3 = tail call signext i8 (...) @__VERIFIER_nondet_char()
store i8 %3, i8* %2
%4 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%5 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 1
store i8 %4, i8* %5
%6 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%7 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 2
store i8 %6, i8* %7
%8 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%9 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 3
store i8 %8, i8* %9
%10 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%11 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 4
store i8 %10, i8* %11
%12 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%13 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 5
store i8 %12, i8* %13
%14 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%15 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 6
store i8 %14, i8* %15
%16 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%17 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 7
store i8 %16, i8* %17
%18 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%19 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 8
store i8 %18, i8* %19
%20 = tail call signext i8 (...) @__VERIFIER_nondet_char()
%21 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 9
store i8 0, i8* %21
%22 = icmp eq i8 %3, 0
br i1 %22, label %30, label %23
23: ; preds = %0, %23
%24 = phi i32 [ %29, %23 ], [ 1, %0 ]
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 %25
%27 = load i8, i8* %26
%28 = icmp eq i8 %27, 0
%29 = add i32 %24, 1
br i1 %28, label %30, label %23
30: ; preds = %23, %0
%31 = phi i32 [ 0, %0 ], [ %24, %23 ]
%32 = zext i32 %31 to i64
%33 = icmp eq i32 %31, 0
br i1 %33, label %50, label %34
34: ; preds = %30, %47
%35 = phi i8 [ %49, %47 ], [ %3, %30 ]
%36 = phi i64 [ %45, %47 ], [ 0, %30 ]
%37 = phi i32 [ %44, %47 ], [ 0, %30 ]
%38 = insertelement <8 x i8> poison, i8 %35, i64 0
%39 = shufflevector <8 x i8> %38, <8 x i8> poison, <8 x i32> zeroinitializer
%40 = icmp eq <8 x i8> %39, <i8 97, i8 65, i8 101, i8 69, i8 105, i8 73, i8 111, i8 79>
%41 = bitcast <8 x i1> %40 to i8
%42 = call i8 @llvm.ctpop.i8(i8 %41)
%43 = zext i8 %42 to i32
%44 = add i32 %37, %43
%45 = add nuw nsw i64 %36, 1
%46 = icmp eq i64 %45, %32
br i1 %46, label %50, label %47
47: ; preds = %34
%48 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 %45
%49 = load i8, i8* %48
br label %34
50: ; preds = %34, %30
%51 = phi i32 [ 0, %30 ], [ %44, %34 ]
%52 = icmp eq i8 %3, 0
br i1 %52, label %75, label %53
53: ; preds = %50, %53
%54 = phi i8 [ %73, %53 ], [ %3, %50 ]
%55 = phi i32 [ %69, %53 ], [ 0, %50 ]
%56 = phi i32 [ %70, %53 ], [ 0, %50 ]
%57 = insertelement <8 x i8> poison, i8 %54, i64 0
%58 = shufflevector <8 x i8> %57, <8 x i8> poison, <8 x i32> zeroinitializer
%59 = icmp eq <8 x i8> %58, <i8 97, i8 65, i8 101, i8 69, i8 105, i8 73, i8 111, i8 79>
%60 = icmp eq i8 %54, 117
%61 = zext i1 %60 to i32
%62 = icmp eq i8 %54, 85
%63 = zext i1 %62 to i32
%64 = bitcast <8 x i1> %59 to i8
%65 = call i8 @llvm.ctpop.i8(i8 %64)
%66 = zext i8 %65 to i32
%67 = add nuw nsw i32 %66, %61
%68 = add nuw nsw i32 %67, %63
%69 = add nuw nsw i32 %68, %55
%70 = add i32 %56, 1
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds [10 x i8], [10 x i8]* %1, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = icmp eq i8 %73, 0
br i1 %74, label %75, label %53
75: ; preds = %53, %50
%76 = phi i32 [ 0, %50 ], [ %69, %53 ]
%77 = icmp eq i32 %76, %51
%78 = zext i1 %77 to i32
%79 = tail call i32 @__VERIFIER_assert(i32 %78)
ret i32 0
}