#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*/ gets(char *);
int /*<<< orphan*/ printf(char *, ...);
int strlen(char *);
int main() {
  int i, k, len;
  char str[256];
  do {
    printf("Inserire una frase da tradurre: ");
    gets(str);
    len = strlen(str);
  } while (len > 256);
  for (i = 0; i <= len; i++) {
    if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' ||
        str[i] == 'u') {
      for (k = len; k > i; k--)
        str[k + 2] = str[k];
      str[i + 1] = 'f';
      str[i + 2] = str[i];
      i = i + 2;
      len = len + 2;
    }
  }
  printf("%s\n", str);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x110(%rbp),%rdi
call   1050 <gets@plt>
lea    -0x110(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x10(%rbp)
cmpl   $0x100,-0x10(%rbp)
jg     1142 <main+0x12>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     127d <main+0x14d>
movslq -0x8(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x61,%eax
je     11f4 <main+0xc4>
movslq -0x8(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x65,%eax
je     11f4 <main+0xc4>
movslq -0x8(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x69,%eax
je     11f4 <main+0xc4>
movslq -0x8(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x6f,%eax
je     11f4 <main+0xc4>
movslq -0x8(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x75,%eax
jne    126a <main+0x13a>
mov    -0x10(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    122e <main+0xfe>
movslq -0xc(%rbp),%rax
mov    -0x110(%rbp,%rax,1),%cl
mov    -0xc(%rbp),%eax
add    $0x2,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    11fa <main+0xca>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
movb   $0x66,-0x110(%rbp,%rax,1)
66
movslq -0x8(%rbp),%rax
mov    -0x110(%rbp,%rax,1),%cl
mov    -0x8(%rbp),%eax
add    $0x2,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    126f <main+0x13f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    117f <main+0x4f>
lea    -0x110(%rbp),%rsi
lea    0xd96(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x100,%rsp
lea    0xeaa(%rip),%rbx
mov    %rsp,%r14
nopl   0x0(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,%rdi
call   1060 <gets@plt>
mov    %r14,%rdi
call   1040 <strlen@plt>
cmp    $0x100,%eax
jg     1160 <main+0x20>
test   %eax,%eax
js     1306 <main+0x1c6>
lea    -0xd(%rsp),%r8
xor    %ecx,%ecx
lea    -0x1(%rsp),%r9
mov    $0x495,%r10d
jmp    11c6 <main+0x86>
nopl   (%rax)
mov    (%rsp,%r12,1),%dl
movb   $0x66,0x1(%r12,%r14,1)
mov    %dl,0x2(%rsp,%r12,1)
add    $0x2,%r12
add    $0x2,%eax
mov    %r12d,%ecx
lea    0x1(%rcx),%edx
cmp    %eax,%ecx
mov    %edx,%ecx
jge    1306 <main+0x1c6>
movslq %ecx,%r12
mov    (%rsp,%r12,1),%dl
lea    -0x61(%rdx),%esi
ror    %sil
cmp    $0xa,%sil
ja     11b9 <main+0x79>
movzbl %sil,%esi
bt     %rsi,%r10
jae    11b9 <main+0x79>
cmp    %ecx,%eax
jle    11a4 <main+0x64>
movslq %eax,%rbx
mov    %rbx,%r11
sub    %r12,%r11
cmp    $0x4,%r11
jb     12f0 <main+0x1b0>
cmp    $0x10,%r11
jae    1207 <main+0xc7>
xor    %ecx,%ecx
jmp    12b4 <main+0x174>
mov    %r11,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r15d
and    $0x3,%r15d
cmp    $0x30,%rdx
jae    1233 <main+0xf3>
xor    %edx,%edx
test   %r15,%r15
jne    1279 <main+0x139>
jmp    12a5 <main+0x165>
and    $0xfffffffffffffffc,%rsi
lea    (%r8,%rbx,1),%rdi
xor    %edx,%edx
nopl   (%rax)
movups -0x32(%rdi,%rdx,1),%xmm0
movups -0x22(%rdi,%rdx,1),%xmm1
movups -0x12(%rdi,%rdx,1),%xmm2
movups -0x2(%rdi,%rdx,1),%xmm3
movups %xmm3,(%rdi,%rdx,1)
movups %xmm2,-0x10(%rdi,%rdx,1)
movups %xmm1,-0x20(%rdi,%rdx,1)
movups %xmm0,-0x30(%rdi,%rdx,1)
add    $0xffffffffffffffc0,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1240 <main+0x100>
neg    %rdx
test   %r15,%r15
je     12a5 <main+0x165>
mov    %rbx,%rsi
sub    %rdx,%rsi
add    %r8,%rsi
shl    $0x4,%r15
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x2(%rsi,%rdx,1),%xmm0
movups %xmm0,(%rsi,%rdx,1)
add    $0xfffffffffffffff0,%rdx
mov    %r15,%rdi
add    %rdx,%rdi
jne    1290 <main+0x150>
cmp    %rcx,%r11
je     11a0 <main+0x60>
test   $0xc,%r11b
je     12ea <main+0x1aa>
mov    %r11,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,%rsi
neg    %rsi
neg    %rcx
lea    (%r9,%rbx,1),%rdi
sub    %rdx,%rbx
nopl   0x0(%rax,%rax,1)
mov    -0x2(%rdi,%rcx,1),%ebp
mov    %ebp,(%rdi,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%rsi
jne    12d0 <main+0x190>
cmp    %rdx,%r11
jne    12f0 <main+0x1b0>
jmp    11a0 <main+0x60>
sub    %rcx,%rbx
nopl   (%rax)
movzbl (%rsp,%rbx,1),%ecx
mov    %cl,0x2(%rsp,%rbx,1)
add    $0xffffffffffffffff,%rbx
cmp    %r12,%rbx
jg     12f0 <main+0x1b0>
jmp    11a0 <main+0x60>
mov    %rsp,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x100,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [33 x i8] c"Inserire una frase da tradurre: \00"
define i32 @main() {
%1 = alloca [256 x i8]
%2 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 0
br label %3
3: ; preds = %3, %0
%4 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%5 = call i32 @gets(i8* %2)
%6 = call i32 @strlen(i8* %2)
%7 = icmp sgt i32 %6, 256
br i1 %7, label %3, label %8
8: ; preds = %3
%9 = icmp slt i32 %6, 0
br i1 %9, label %152, label %10
10: ; preds = %8, %147
%11 = phi i32 [ %149, %147 ], [ %6, %8 ]
%12 = phi i32 [ %150, %147 ], [ 0, %8 ]
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %13
%15 = load i8, i8* %14
%16 = add i8 %15, -97
%17 = call i8 @llvm.fshl.i8(i8 %16, i8 %16, i8 7)
switch i8 %17, label %147 [
i8 0, label %18
i8 2, label %18
i8 4, label %18
i8 7, label %18
i8 10, label %18
]
18: ; preds = %10, %10, %10, %10, %10
%19 = icmp sgt i32 %11, %12
br i1 %19, label %20, label %138
20: ; preds = %18
%21 = sext i32 %11 to i64
%22 = sub nsw i64 %21, %13
%23 = icmp ult i64 %22, 4
br i1 %23, label %126, label %24
24: ; preds = %20
%25 = icmp ult i64 %22, 16
br i1 %25, label %104, label %26
26: ; preds = %24
%27 = and i64 %22, -16
%28 = add nsw i64 %27, -16
%29 = lshr exact i64 %28, 4
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %30, 3
%32 = icmp ult i64 %28, 48
br i1 %32, label %80, label %33
33: ; preds = %26
%34 = and i64 %30, 2305843009213693948
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %77, %35 ]
%37 = phi i64 [ 0, %33 ], [ %78, %35 ]
%38 = sub i64 %21, %36
%39 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %38
%40 = getelementptr inbounds i8, i8* %39, i64 -15
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = add nsw i64 %38, 2
%44 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %43
%45 = getelementptr inbounds i8, i8* %44, i64 -15
%46 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %46
%47 = or i64 %36, 16
%48 = sub i64 %21, %47
%49 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %48
%50 = getelementptr inbounds i8, i8* %49, i64 -15
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = add nsw i64 %48, 2
%54 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %53
%55 = getelementptr inbounds i8, i8* %54, i64 -15
%56 = bitcast i8* %55 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %56
%57 = or i64 %36, 32
%58 = sub i64 %21, %57
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %58
%60 = getelementptr inbounds i8, i8* %59, i64 -15
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = add nsw i64 %58, 2
%64 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %63
%65 = getelementptr inbounds i8, i8* %64, i64 -15
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %66
%67 = or i64 %36, 48
%68 = sub i64 %21, %67
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %68
%70 = getelementptr inbounds i8, i8* %69, i64 -15
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = add nsw i64 %68, 2
%74 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %73
%75 = getelementptr inbounds i8, i8* %74, i64 -15
%76 = bitcast i8* %75 to <16 x i8>*
store <16 x i8> %72, <16 x i8>* %76
%77 = add nuw i64 %36, 64
%78 = add i64 %37, 4
%79 = icmp eq i64 %78, %34
br i1 %79, label %80, label %35
80: ; preds = %35, %26
%81 = phi i64 [ 0, %26 ], [ %77, %35 ]
%82 = icmp eq i64 %31, 0
br i1 %82, label %98, label %83
83: ; preds = %80, %83
%84 = phi i64 [ %95, %83 ], [ %81, %80 ]
%85 = phi i64 [ %96, %83 ], [ 0, %80 ]
%86 = sub i64 %21, %84
%87 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %86
%88 = getelementptr inbounds i8, i8* %87, i64 -15
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = add nsw i64 %86, 2
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %91
%93 = getelementptr inbounds i8, i8* %92, i64 -15
%94 = bitcast i8* %93 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %94
%95 = add nuw i64 %84, 16
%96 = add i64 %85, 1
%97 = icmp eq i64 %96, %31
br i1 %97, label %98, label %83
98: ; preds = %83, %80
%99 = icmp eq i64 %22, %27
br i1 %99, label %136, label %100
100: ; preds = %98
%101 = sub nsw i64 %21, %27
%102 = and i64 %22, 12
%103 = icmp eq i64 %102, 0
br i1 %103, label %126, label %104
104: ; preds = %24, %100
%105 = phi i64 [ %27, %100 ], [ 0, %24 ]
%106 = sext i32 %11 to i64
%107 = sext i32 %12 to i64
%108 = sub nsw i64 %106, %107
%109 = and i64 %108, -4
%110 = sub nsw i64 %21, %109
br label %111
111: ; preds = %111, %104
%112 = phi i64 [ %105, %104 ], [ %122, %111 ]
%113 = sub i64 %21, %112
%114 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %113
%115 = getelementptr inbounds i8, i8* %114, i64 -3
%116 = bitcast i8* %115 to <4 x i8>*
%117 = load <4 x i8>, <4 x i8>* %116
%118 = add nsw i64 %113, 2
%119 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %118
%120 = getelementptr inbounds i8, i8* %119, i64 -3
%121 = bitcast i8* %120 to <4 x i8>*
store <4 x i8> %117, <4 x i8>* %121
%122 = add nuw i64 %112, 4
%123 = icmp eq i64 %122, %109
br i1 %123, label %124, label %111
124: ; preds = %111
%125 = icmp eq i64 %108, %109
br i1 %125, label %136, label %126
126: ; preds = %20, %100, %124
%127 = phi i64 [ %21, %20 ], [ %101, %100 ], [ %110, %124 ]
br label %128
128: ; preds = %126, %128
%129 = phi i64 [ %134, %128 ], [ %127, %126 ]
%130 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %129
%131 = load i8, i8* %130
%132 = add nsw i64 %129, 2
%133 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %132
store i8 %131, i8* %133
%134 = add nsw i64 %129, -1
%135 = icmp sgt i64 %134, %13
br i1 %135, label %128, label %136
136: ; preds = %128, %124, %98
%137 = load i8, i8* %14
br label %138
138: ; preds = %136, %18
%139 = phi i8 [ %137, %136 ], [ %15, %18 ]
%140 = add nsw i32 %12, 1
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %141
store i8 102, i8* %142
%143 = add nsw i32 %12, 2
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %144
store i8 %139, i8* %145
%146 = add nsw i32 %11, 2
br label %147
147: ; preds = %10, %138
%148 = phi i32 [ %143, %138 ], [ %12, %10 ]
%149 = phi i32 [ %146, %138 ], [ %11, %10 ]
%150 = add nsw i32 %148, 1
%151 = icmp slt i32 %148, %149
br i1 %151, label %10, label %152
152: ; preds = %147, %8
%153 = call i32 @puts(i8* %2)
ret i32 0
}