#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 /*<<< orphan*/ system(char *);
int main() {
  char frase[81], aux[81];
  int i, j = 0, k = 0, tam, cont = 0;
  printf("entre com uma frase: ");
  gets(frase);
  tam = strlen(frase);
  i = 0;
  while (frase[0] == ' ') {
    for (i = 0; i < tam; i++)
      frase[j++] = frase[i + 1];
    j = 0;
  }
  tam = strlen(frase);
  i = 1;
  while (frase[tam - i] == ' ') {
    frase[tam - i] = '\0';
    i++;
  }
  tam = strlen(frase);
  i = j = 0;
  for (; i < tam; i++) {
    while (frase[i] == ' ' && frase[i + 1] == ' ') {
      for (j = i; j < tam; j++)
        frase[j] = frase[j + 1];
    }
  }
  tam = strlen(frase);
  i = 0;
  for (; i <= tam; i++) {
    if (frase[i] == ' ' || frase[i] == '\0') {
      j = i - 1;
      while (j >= 0) {
        aux[k++] = frase[j];
        j--;
        if (frase[j] == ' ')
          break;
      }
      aux[k++] = ' ';
    }
  }
  printf("%s\n", aux);
  system("pause");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xc8(%rbp)
movl   $0x0,-0xcc(%rbp)
movl   $0x0,-0xd4(%rbp)
lea    0xe89(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x60(%rbp),%rdi
call   1060 <gets@plt>
lea    -0x60(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xd0(%rbp)
movl   $0x0,-0xc4(%rbp)
movsbl -0x60(%rbp),%eax
cmp    $0x20,%eax
jne    1212 <main+0xd2>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jge    1203 <main+0xc3>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x60(%rbp,%rax,1),%cl
mov    -0xc8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc8(%rbp)
cltq
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    11b7 <main+0x77>
movl   $0x0,-0xc8(%rbp)
jmp    11a0 <main+0x60>
lea    -0x60(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xd0(%rbp)
movl   $0x1,-0xc4(%rbp)
mov    -0xd0(%rbp),%eax
sub    -0xc4(%rbp),%eax
cltq
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x20,%eax
jne    126e <main+0x12e>
mov    -0xd0(%rbp),%eax
sub    -0xc4(%rbp),%eax
cltq
movb   $0x0,-0x60(%rbp,%rax,1)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    122b <main+0xeb>
lea    -0x60(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xd0(%rbp)
movl   $0x0,-0xc8(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jge    135e <main+0x21e>
jmp    12a8 <main+0x168>
movslq -0xc4(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0xd5(%rbp)
jne    12e1 <main+0x1a1>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x20,%eax
sete   %al
mov    %al,-0xd5(%rbp)
mov    -0xd5(%rbp),%al
test   $0x1,%al
jne    12f4 <main+0x1b4>
jmp    1345 <main+0x205>
mov    -0xc4(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jge    1340 <main+0x200>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x60(%rbp,%rax,1),%cl
movslq -0xc8(%rbp),%rax
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1300 <main+0x1c0>
jmp    12a8 <main+0x168>
jmp    134a <main+0x20a>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1291 <main+0x151>
lea    -0x60(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xd0(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xd0(%rbp),%eax
jg     1456 <main+0x316>
movslq -0xc4(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x20,%eax
je     13b3 <main+0x273>
movslq -0xc4(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x0,%eax
jne    143d <main+0x2fd>
mov    -0xc4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x0,-0xc8(%rbp)
jl     1422 <main+0x2e2>
movslq -0xc8(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%cl
mov    -0xcc(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xcc(%rbp)
cltq
mov    %cl,-0xc0(%rbp,%rax,1)
mov    -0xc8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc8(%rbp)
movslq -0xc8(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x20,%eax
jne    141d <main+0x2dd>
jmp    1422 <main+0x2e2>
jmp    13c2 <main+0x282>
mov    -0xcc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xcc(%rbp)
cltq
movb   $0x20,-0xc0(%rbp,%rax,1)
20
jmp    1442 <main+0x302>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1377 <main+0x237>
lea    -0xc0(%rbp),%rsi
lea    0xbb2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xba8(%rip),%rdi
call   1040 <system@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
lea    0xe88(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rsp,%r14
mov    %r14,%rdi
call   1070 <gets@plt>
mov    %r14,%rdi
call   1040 <strlen@plt>
cmpb   $0x20,(%rsp)
jne    11d0 <main+0x70>
mov    %eax,%ebp
lea    0x1(%rsp),%r15
mov    %eax,%ebx
mov    %rsp,%r12
jmp    11c6 <main+0x66>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
call   1080 <memmove@plt>
movzbl (%rsp),%eax
cmp    $0x20,%al
jne    11d0 <main+0x70>
test   %ebp,%ebp
jg     11b0 <main+0x50>
mov    $0x20,%al
cmp    $0x20,%al
je     11c6 <main+0x66>
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
cmpb   $0x20,-0x1(%rax,%r14,1)
jne    1212 <main+0xb2>
lea    (%rax,%r14,1),%rcx
add    $0xffffffffffffffff,%rcx
add    %r14,%rax
add    $0xfffffffffffffffe,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%rcx)
lea    -0x1(%rax),%rdx
cmpb   $0x20,(%rax)
mov    %rax,%rcx
mov    %rdx,%rax
je     1200 <main+0xa0>
mov    %rsp,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    13b9 <main+0x259>
mov    %eax,%eax
lea    0x31(%rsp),%rcx
lea    -0x20(%rax),%r8
lea    0x1(%rsp),%rsi
xor    %r14d,%r14d
mov    %rax,%r10
jmp    1259 <main+0xf9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r8
add    $0xffffffffffffffff,%r10
add    $0x1,%rsi
cmp    %rax,%r14
je     13b9 <main+0x259>
mov    %r14,%r12
add    $0x1,%r14
cmpb   $0x20,(%rsp,%r12,1)
jne    1240 <main+0xe0>
mov    %r10,%rdi
and    $0xfffffffffffffff8,%rdi
mov    %r8,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x60(%rsp)
mov    %rax,%rdx
sub    %r12,%rdx
lea    -0x20(%rdx),%rbp
mov    %rbp,0x70(%rsp)
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %rbp,0x68(%rsp)
mov    %rdx,%r15
and    $0xffffffffffffffe0,%r15
lea    (%r12,%r15,1),%rbp
mov    %rbp,0x58(%rsp)
mov    %rdx,%r13
and    $0xfffffffffffffff8,%r13
lea    (%r12,%r13,1),%rbp
mov    %rbp,0x78(%rsp)
jmp    12cb <main+0x16b>
cmpb   $0x20,(%rsp,%r12,1)
jne    1240 <main+0xe0>
cmpb   $0x20,(%rsp,%r14,1)
jne    1240 <main+0xe0>
mov    %r12,%rbp
cmp    $0x8,%rdx
jb     13a0 <main+0x240>
cmp    $0x20,%rdx
jae    12f0 <main+0x190>
xor    %ebx,%ebx
jmp    1380 <main+0x220>
cmpq   $0x20,0x70(%rsp)
jae    12fd <main+0x19d>
xor    %r11d,%r11d
jmp    1349 <main+0x1e9>
mov    0x60(%rsp),%r9
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rcx,%r11,1),%xmm0
movups -0x20(%rcx,%r11,1),%xmm1
movups -0x10(%rcx,%r11,1),%xmm2
movups (%rcx,%r11,1),%xmm3
movups %xmm0,-0x31(%rcx,%r11,1)
movups %xmm1,-0x21(%rcx,%r11,1)
movups %xmm2,-0x11(%rcx,%r11,1)
movups %xmm3,-0x1(%rcx,%r11,1)
add    $0x40,%r11
add    $0xfffffffffffffffe,%r9
jne    1310 <main+0x1b0>
testb  $0x1,0x68(%rsp)
je     136a <main+0x20a>
add    %r12,%r11
movups 0x1(%rsp,%r11,1),%xmm0
movups 0x11(%rsp,%r11,1),%xmm1
movups %xmm0,(%rsp,%r11,1)
movups %xmm1,0x10(%rsp,%r11,1)
cmp    %r15,%rdx
je     12c0 <main+0x160>
mov    %r15,%rbx
mov    0x58(%rsp),%rbp
test   $0x18,%dl
je     13a0 <main+0x240>
mov    (%rsi,%rbx,1),%rbp
mov    %rbp,-0x1(%rsi,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%rdi
jne    1380 <main+0x220>
mov    0x78(%rsp),%rbp
cmp    %r13,%rdx
je     12c0 <main+0x160>
movzbl 0x1(%rsp,%rbp,1),%ebx
mov    %bl,(%rsp,%rbp,1)
lea    0x1(%rbp),%rbx
mov    %rbx,%rbp
cmp    %rbx,%rax
jne    13a0 <main+0x240>
jmp    12c0 <main+0x160>
mov    %rsp,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
js     1451 <main+0x2f1>
add    $0x1,%eax
lea    -0x2(%rsp),%rcx
xor    %r9d,%r9d
mov    $0xffffffffffffffff,%rsi
xor    %r8d,%r8d
jmp    1403 <main+0x2a3>
sub    %edx,%r8d
movslq %r8d,%rdx
add    $0x1,%r8d
movb   $0x20,0x80(%rsp,%rdx,1)
20
add    $0x1,%r9
add    $0x1,%rsi
add    $0x1,%rcx
cmp    %rax,%r9
je     1451 <main+0x2f1>
testb  $0xdf,(%rsp,%r9,1)
jne    13f2 <main+0x292>
test   %r9,%r9
je     13e3 <main+0x283>
movslq %r8d,%rdx
mov    (%rsp,%rsi,1),%bl
lea    (%rsp,%rdx,1),%rbp
add    $0x80,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %bl,0x0(%rbp)
movzbl (%rcx,%rdi,1),%ebx
lea    -0x1(%rdi),%rdx
cmp    $0x20,%bl
je     13e0 <main+0x280>
add    %rsi,%rdi
add    $0x1,%rbp
test   %rdi,%rdi
mov    %rdx,%rdi
jg     1430 <main+0x2d0>
jmp    13e0 <main+0x280>
lea    0x80(%rsp),%rdi
call   1030 <puts@plt>
lea    0xbb1(%rip),%rdi
call   1050 <system@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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