#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 */
char getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ putchar(char);
int /*<<< orphan*/ puts(char *);
int main() {
  int y, x = 0;
  char c;
  char prop[1000], invers[1000];
  do {
    for (;;) {
      c = getchar();
      if (c == '~') {
        printf("\nSo... Do you wanna stop?\n\t Okey..\n");
        printf("But first let me dazzle you a bit :-)\n");
        y = 0;
        x--;
        do {
          invers[y] = prop[x];
          y++;
          x--;
        } while (x >= 0);
        invers[y] = '\0';
        putchar('\t');
        puts(invers);
        puts("\n\tMuahahaha!!! :-)");
        break;
      } else if (c != '\n') {
        prop[x++] = c;
      } else {
        y = 0;
        x--;
        do {
          invers[y] = prop[x];
          y++;
          x++;
        } while (x >= 0);
        printf("X este %d", x);
        invers[y] = '\0';
        putchar('\t');
        puts(invers);
      }
    }
  } while (c != '~');
  while (getchar() != '\n')
    continue;
  getchar();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7f0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xc(%rbp)
jmp    115e <main+0x1e>
mov    $0x0,%al
call   1060 <getchar@plt>
mov    %al,-0xd(%rbp)
movsbl -0xd(%rbp),%eax
cmp    $0x7e,%eax
jne    1206 <main+0xc6>
lea    0xe84(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movslq -0xc(%rbp),%rax
mov    -0x400(%rbp,%rax,1),%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x7f0(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jge    11a1 <main+0x61>
movslq -0x8(%rbp),%rax
movb   $0x0,-0x7f0(%rbp,%rax,1)
mov    $0x9,%edi
call   1030 <putchar@plt>
lea    -0x7f0(%rbp),%rdi
call   1040 <puts@plt>
lea    0xe4f(%rip),%rdi
call   1040 <puts@plt>
jmp    12ae <main+0x16e>
movsbl -0xd(%rbp),%eax
cmp    $0xa,%eax
je     122f <main+0xef>
mov    -0xd(%rbp),%cl
mov    -0xc(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc(%rbp)
cltq
mov    %cl,-0x400(%rbp,%rax,1)
jmp    12a4 <main+0x164>
movl   $0x0,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movslq -0xc(%rbp),%rax
mov    -0x400(%rbp,%rax,1),%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x7f0(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jge    123f <main+0xff>
mov    -0xc(%rbp),%esi
lea    0xde3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x8(%rbp),%rax
movb   $0x0,-0x7f0(%rbp,%rax,1)
mov    $0x9,%edi
call   1030 <putchar@plt>
lea    -0x7f0(%rbp),%rdi
call   1040 <puts@plt>
jmp    12a9 <main+0x169>
jmp    115e <main+0x1e>
jmp    12b3 <main+0x173>
movsbl -0xd(%rbp),%eax
cmp    $0x7e,%eax
jne    1159 <main+0x19>
jmp    12c5 <main+0x185>
mov    $0x0,%al
call   1060 <getchar@plt>
movsbl %al,%eax
cmp    $0xa,%eax
je     12dd <main+0x19d>
jmp    12c5 <main+0x185>
mov    $0x0,%al
call   1060 <getchar@plt>
xor    %eax,%eax
add    $0x7f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x7e0,%rsp
lea    0xebd(%rip),%r14
mov    %rsp,%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1060 <getchar@plt>
cmp    $0xa,%al
je     1180 <main+0x40>
movslq %ebx,%rbp
cmp    $0x7e,%al
je     11e0 <main+0xa0>
add    $0x1,%ebx
mov    %al,0x3f0(%rsp,%rbp,1)
jmp    1160 <main+0x20>
xchg   %ax,%ax
lea    -0x1(%rbx),%r12d
movslq %r12d,%rax
add    %rsp,%rax
add    $0x3f0,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rax,%rbp,1),%ecx
mov    %cl,(%rsp,%rbp,1)
add    $0x1,%rbp
cmp    $0x80000001,%ebx
jb     11a0 <main+0x60>
add    %ebp,%r12d
mov    %r14,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %ebp,%eax
movb   $0x0,(%rsp,%rax,1)
mov    $0x9,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
call   1040 <puts@plt>
mov    %r12d,%ebx
jmp    1160 <main+0x20>
lea    0xe36(%rip),%rdi
call   1040 <puts@plt>
lea    0xe4d(%rip),%rdi
call   1040 <puts@plt>
test   %ebx,%ebx
mov    $0x1,%eax
cmovle %ebx,%eax
neg    %eax
add    %ebx,%eax
add    $0x1,%eax
cmp    $0x8,%eax
jae    1215 <main+0xd5>
xor    %ecx,%ecx
jmp    1327 <main+0x1e7>
cmp    $0x20,%eax
jae    1221 <main+0xe1>
xor    %ecx,%ecx
jmp    12ca <main+0x18a>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    (%rsp,%rbp,1),%rdx
add    $0x3e0,%rdx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,(%rsp,%rsi,1)
movdqa %xmm1,0x10(%rsp,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdx
cmp    %rsi,%rcx
jne    1240 <main+0x100>
cmp    %rax,%rcx
je     1353 <main+0x213>
test   $0x18,%al
je     1324 <main+0x1e4>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rdx,%rsi
neg    %rsi
add    %rsp,%rsi
add    $0x3f0,%rsi
add    %rbp,%rsi
add    $0xfffffffffffffff8,%rsi
sub    %rcx,%rbp
pxor   %xmm0,%xmm0
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsp,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    12f0 <main+0x1b0>
cmp    %rax,%rcx
jne    1327 <main+0x1e7>
jmp    1353 <main+0x213>
sub    %rcx,%rbp
lea    0x3f0(%rsp),%rdx
add    %rbp,%rdx
add    $0xffffffffffffffff,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
mov    %bl,(%rsp,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rcx,%rax
jne    1340 <main+0x200>
movb   $0x0,(%rsp,%rax,1)
mov    $0x9,%edi
call   1030 <putchar@plt>
mov    %rsp,%rdi
call   1040 <puts@plt>
lea    0xc90(%rip),%rdi
call   1040 <puts@plt>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   1060 <getchar@plt>
cmp    $0xa,%al
jne    1380 <main+0x240>
xor    %eax,%eax
call   1060 <getchar@plt>
xor    %eax,%eax
add    $0x7e0,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [36 x i8] c"\0ASo... Do you wanna stop?\0A\09 Okey..\0A\00"
@.str.1 = [39 x i8] c"But first let me dazzle you a bit :-)\0A\00"
@.str.2 = [19 x i8] c"\0A\09Muahahaha!!! :-)\00"
@.str.3 = [10 x i8] c"X este %d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i8
%5 = alloca [1000 x i8]
%6 = alloca [1000 x i8]
store i32 0, i32* %1
store i32 0, i32* %3
br label %7
7: ; preds = %81, %0
br label %8
8: ; preds = %79, %7
%9 = call signext i8 (...) @getchar()
store i8 %9, i8* %4
%10 = load i8, i8* %4
%11 = sext i8 %10 to i32
%12 = icmp eq i32 %11, 126
br i1 %12, label %13, label %41
13: ; preds = %8
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %2
%16 = load i32, i32* %3
%17 = add nsw i32 %16, -1
store i32 %17, i32* %3
br label %18
18: ; preds = %30, %13
%19 = load i32, i32* %3
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %20
%22 = load i8, i8* %21
%23 = load i32, i32* %2
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %24
store i8 %22, i8* %25
%26 = load i32, i32* %2
%27 = add nsw i32 %26, 1
store i32 %27, i32* %2
%28 = load i32, i32* %3
%29 = add nsw i32 %28, -1
store i32 %29, i32* %3
br label %30
30: ; preds = %18
%31 = load i32, i32* %3
%32 = icmp sge i32 %31, 0
br i1 %32, label %18, label %33
33: ; preds = %30
%34 = load i32, i32* %2
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %35
store i8 0, i8* %36
%37 = call i32 @putchar(i8 signext 9)
%38 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 0
%39 = call i32 @puts(i8* %38)
%40 = call i32 @puts(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
br label %80
41: ; preds = %8
%42 = load i8, i8* %4
%43 = sext i8 %42 to i32
%44 = icmp ne i32 %43, 10
br i1 %44, label %45, label %51
45: ; preds = %41
%46 = load i8, i8* %4
%47 = load i32, i32* %3
%48 = add nsw i32 %47, 1
store i32 %48, i32* %3
%49 = sext i32 %47 to i64
%50 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %49
store i8 %46, i8* %50
br label %78
51: ; preds = %41
store i32 0, i32* %2
%52 = load i32, i32* %3
%53 = add nsw i32 %52, -1
store i32 %53, i32* %3
br label %54
54: ; preds = %66, %51
%55 = load i32, i32* %3
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %56
%58 = load i8, i8* %57
%59 = load i32, i32* %2
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %60
store i8 %58, i8* %61
%62 = load i32, i32* %2
%63 = add nsw i32 %62, 1
store i32 %63, i32* %2
%64 = load i32, i32* %3
%65 = add nsw i32 %64, 1
store i32 %65, i32* %3
br label %66
66: ; preds = %54
%67 = load i32, i32* %3
%68 = icmp sge i32 %67, 0
br i1 %68, label %54, label %69
69: ; preds = %66
%70 = load i32, i32* %3
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i32 %70)
%72 = load i32, i32* %2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %73
store i8 0, i8* %74
%75 = call i32 @putchar(i8 signext 9)
%76 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 0
%77 = call i32 @puts(i8* %76)
br label %78
78: ; preds = %69, %45
br label %79
79: ; preds = %78
br label %8
80: ; preds = %33
br label %81
81: ; preds = %80
%82 = load i8, i8* %4
%83 = sext i8 %82 to i32
%84 = icmp ne i32 %83, 126
br i1 %84, label %7, label %85
85: ; preds = %81
br label %86
86: ; preds = %90, %85
%87 = call signext i8 (...) @getchar()
%88 = sext i8 %87 to i32
%89 = icmp ne i32 %88, 10
br i1 %89, label %90, label %91
90: ; preds = %86
br label %86
91: ; preds = %86
%92 = call signext i8 (...) @getchar()
ret i32 0
}

LLVM IR (-O2):
@.str.2 = [19 x i8] c"\0A\09Muahahaha!!! :-)\00"
@.str.3 = [10 x i8] c"X este %d\00"
@str = [35 x i8] c"\0ASo... Do you wanna stop?\0A\09 Okey..\00"
@str.4 = [38 x i8] c"But first let me dazzle you a bit :-)\00"
define i32 @main() {
%1 = alloca [1000 x i8]
%2 = alloca [1000 x i8]
%3 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 0
%4 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 0
br label %5
5: ; preds = %86, %0
%6 = phi i32 [ 0, %0 ], [ %87, %86 ]
%7 = tail call signext i8 (...) @getchar()
switch i8 %7, label %82 [
i8 126, label %8
i8 10, label %88
]
8: ; preds = %5
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.4, i64 0, i64 0))
%11 = sext i32 %6 to i64
%12 = add i32 %6, 1
%13 = call i32 @llvm.smin.i32(i32 %6, i32 1)
%14 = sub i32 %12, %13
%15 = zext i32 %14 to i64
%16 = icmp ult i32 %14, 8
br i1 %16, label %65, label %17
17: ; preds = %8
%18 = icmp ult i32 %14, 32
br i1 %18, label %46, label %19
19: ; preds = %17
%20 = and i64 %15, 4294967264
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %38, %21 ]
%23 = xor i64 %22, -1
%24 = add i64 %23, %11
%25 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %24
%26 = getelementptr inbounds i8, i8* %25, i64 -15
%27 = bitcast i8* %26 to <16 x i8>*
%28 = load <16 x i8>, <16 x i8>* %27
%29 = shufflevector <16 x i8> %28, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%30 = getelementptr inbounds i8, i8* %25, i64 -31
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = shufflevector <16 x i8> %32, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%34 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %22
%35 = bitcast i8* %34 to <16 x i8>*
store <16 x i8> %29, <16 x i8>* %35
%36 = getelementptr inbounds i8, i8* %34, i64 16
%37 = bitcast i8* %36 to <16 x i8>*
store <16 x i8> %33, <16 x i8>* %37
%38 = add nuw i64 %22, 32
%39 = icmp eq i64 %38, %20
br i1 %39, label %40, label %21
40: ; preds = %21
%41 = icmp eq i64 %20, %15
br i1 %41, label %77, label %42
42: ; preds = %40
%43 = sub nsw i64 %11, %20
%44 = and i64 %15, 24
%45 = icmp eq i64 %44, 0
br i1 %45, label %65, label %46
46: ; preds = %17, %42
%47 = phi i64 [ %20, %42 ], [ 0, %17 ]
%48 = and i64 %15, 4294967288
%49 = sub nsw i64 %11, %48
br label %50
50: ; preds = %50, %46
%51 = phi i64 [ %47, %46 ], [ %61, %50 ]
%52 = xor i64 %51, -1
%53 = add i64 %52, %11
%54 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %53
%55 = getelementptr inbounds i8, i8* %54, i64 -7
%56 = bitcast i8* %55 to <8 x i8>*
%57 = load <8 x i8>, <8 x i8>* %56
%58 = shufflevector <8 x i8> %57, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%59 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %51
%60 = bitcast i8* %59 to <8 x i8>*
store <8 x i8> %58, <8 x i8>* %60
%61 = add nuw i64 %51, 8
%62 = icmp eq i64 %61, %48
br i1 %62, label %63, label %50
63: ; preds = %50
%64 = icmp eq i64 %48, %15
br i1 %64, label %77, label %65
65: ; preds = %8, %42, %63
%66 = phi i64 [ %11, %8 ], [ %43, %42 ], [ %49, %63 ]
%67 = phi i64 [ 0, %8 ], [ %20, %42 ], [ %48, %63 ]
br label %68
68: ; preds = %65, %68
%69 = phi i64 [ %71, %68 ], [ %66, %65 ]
%70 = phi i64 [ %75, %68 ], [ %67, %65 ]
%71 = add nsw i64 %69, -1
%72 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %70
store i8 %73, i8* %74
%75 = add nuw nsw i64 %70, 1
%76 = icmp eq i64 %75, %15
br i1 %76, label %77, label %68
77: ; preds = %68, %63, %40
%78 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %15
store i8 0, i8* %78
%79 = tail call i32 @putchar(i8 signext 9)
%80 = call i32 @puts(i8* %4)
%81 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
br label %107
82: ; preds = %5
%83 = add nsw i32 %6, 1
%84 = sext i32 %6 to i64
%85 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %84
store i8 %7, i8* %85
br label %86
86: ; preds = %82, %100
%87 = phi i32 [ %83, %82 ], [ %101, %100 ]
br label %5
88: ; preds = %5
%89 = add i32 %6, -1
%90 = sext i32 %89 to i64
%91 = icmp ult i32 %6, -2147483647
br label %92
92: ; preds = %92, %88
%93 = phi i64 [ %99, %92 ], [ %90, %88 ]
%94 = phi i64 [ %98, %92 ], [ 0, %88 ]
%95 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %93
%96 = load i8, i8* %95
%97 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %94
store i8 %96, i8* %97
%98 = add nuw i64 %94, 1
%99 = add i64 %93, 1
br i1 %91, label %92, label %100
100: ; preds = %92
%101 = trunc i64 %99 to i32
%102 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i32 %101)
%103 = and i64 %98, 4294967295
%104 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %103
store i8 0, i8* %104
%105 = tail call i32 @putchar(i8 signext 9)
%106 = call i32 @puts(i8* %4)
br label %86
107: ; preds = %77, %107
%108 = tail call signext i8 (...) @getchar()
%109 = icmp eq i8 %108, 10
br i1 %109, label %110, label %107
110: ; preds = %107
%111 = tail call signext i8 (...) @getchar()
ret i32 0
}