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


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    0xeba(%rip),%rax
mov    %rax,-0x14(%rbp)
mov    0xeb7(%rip),%ax
mov    %ax,-0xc(%rbp)
mov    0xeaf(%rip),%al
mov    %al,-0xa(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jae    118d <main+0x5d>
mov    $0x0,%al
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x9(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1165 <main+0x35>
movsbl -0x5(%rbp),%eax
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <__VERIFIER_assume@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
movsbl -0x9(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     11c7 <main+0x97>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a8 <main+0x78>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1239 <main+0x109>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jae    1226 <main+0xf6>
mov    -0x18(%rbp),%eax
movsbl -0x9(%rbp,%rax,1),%eax
mov    -0x1c(%rbp),%ecx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    1213 <main+0xe3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1218 <main+0xe8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e8 <main+0xb8>
jmp    122b <main+0xfb>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d5 <main+0xa5>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
movsbl -0x9(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     12ab <main+0x17b>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jae    129d <main+0x16d>
mov    -0x18(%rbp),%eax
movsbl -0x9(%rbp,%rax,1),%eax
mov    -0x1c(%rbp),%ecx
movsbl -0x14(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    128a <main+0x15a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128f <main+0x15f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    125f <main+0x12f>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1247 <main+0x117>
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <__VERIFIER_assert@plt>
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
push   %rax
xor    %ebp,%ebp
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %eax,%ebx
mov    %al,0x3(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x4(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x5(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x6(%rsp)
xor    %eax,%eax
call   1030 <__VERIFIER_nondet_char@plt>
mov    %al,0x7(%rsp)
xor    %edi,%edi
test   %al,%al
sete   %dil
call   1050 <__VERIFIER_assume@plt>
mov    $0x0,%eax
test   %bl,%bl
je     119a <main+0x6a>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%eax
cmpb   $0x0,0x3(%rsp,%rax,1)
jne    1190 <main+0x60>
test   %eax,%eax
je     12d4 <main+0x1a4>
mov    %eax,%eax
xor    %ecx,%ecx
cmp    $0x61,%bl
sete   %cl
xor    %ebp,%ebp
cmp    $0x41,%bl
sete   %bpl
add    %ecx,%ebp
cmp    $0x1,%eax
je     12d4 <main+0x1a4>
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     12b0 <main+0x180>
mov    %rdx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
movd   %ebp,%xmm4
pxor   %xmm0,%xmm0
xor    %edi,%edi
movdqa 0xe0f(%rip),%xmm8
movdqa 0xe17(%rip),%xmm1
movdqa 0xe1f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   0x4(%rsp,%rdi,1),%xmm6
movd   0x8(%rsp,%rdi,1),%xmm3
movdqa %xmm6,%xmm7
pcmpeqb %xmm8,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm1,%xmm7
paddd  %xmm4,%xmm7
movdqa %xmm3,%xmm5
pcmpeqb %xmm8,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm1,%xmm5
paddd  %xmm0,%xmm5
pcmpeqb %xmm2,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
pand   %xmm1,%xmm6
movdqa %xmm6,%xmm4
paddd  %xmm7,%xmm4
pcmpeqb %xmm2,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm1,%xmm3
movdqa %xmm3,%xmm0
paddd  %xmm5,%xmm0
add    $0x8,%rdi
cmp    %rdi,%rsi
jne    1210 <main+0xe0>
paddd  %xmm4,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %rsi,%rdx
je     12d4 <main+0x1a4>
cs nopw 0x0(%rax,%rax,1)
movzbl 0x3(%rsp,%rcx,1),%edx
xor    %esi,%esi
cmp    $0x61,%dl
sete   %sil
add    %ebp,%esi
xor    %ebp,%ebp
cmp    $0x41,%dl
sete   %bpl
add    %esi,%ebp
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12b0 <main+0x180>
xor    %eax,%eax
test   %bl,%bl
je     1302 <main+0x1d2>
mov    $0x1,%ecx
nop
xor    %edx,%edx
cmp    $0x61,%bl
sete   %dl
add    %eax,%edx
xor    %eax,%eax
cmp    $0x41,%bl
sete   %al
add    %edx,%eax
mov    %ecx,%edx
movzbl 0x3(%rsp,%rdx,1),%ebx
add    $0x1,%ecx
test   %bl,%bl
jne    12e0 <main+0x1b0>
xor    %edi,%edi
cmp    %ebp,%eax
sete   %dil
call   1040 <__VERIFIER_assert@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

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

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