#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 *, char *);
int main() {
  char c[500];
  int i;
  for (i = 0; c[i] < 499; i++) {
    c[i] = getchar();
    if (c[i] == 'P') {
      if (c[i - 1] == 'O') {
        if (c[i - 2] == 'T') {
          if (c[i - 3] == 'S') {
            c[i] = ' ';
            c[i - 1] = ' ';
            c[i - 2] = ' ';
            c[i - 3] = ' ';
            break;
          }
        }
      }
    }
  }
  for (i = 0; i < 499; i++) {
    if (c[i] <= 'z') {
      if (c[i] >= 'a')
        c[i] = c[i] - 32;
    }
  }
  printf("\n%s\n", c);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x204(%rbp)
movslq -0x204(%rbp),%rax
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x1f3,%eax
jge    124e <main+0x12e>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    %al,%cl
movslq -0x204(%rbp),%rax
mov    %cl,-0x200(%rbp,%rax,1)
movslq -0x204(%rbp),%rax
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x50,%eax
jne    1235 <main+0x115>
mov    -0x204(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x4f,%eax
jne    1230 <main+0x110>
mov    -0x204(%rbp),%eax
sub    $0x2,%eax
cltq
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x54,%eax
jne    122b <main+0x10b>
mov    -0x204(%rbp),%eax
sub    $0x3,%eax
cltq
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x53,%eax
jne    1226 <main+0x106>
movslq -0x204(%rbp),%rax
movb   $0x20,-0x200(%rbp,%rax,1)
20
mov    -0x204(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x20,-0x200(%rbp,%rax,1)
20
mov    -0x204(%rbp),%eax
sub    $0x2,%eax
cltq
movb   $0x20,-0x200(%rbp,%rax,1)
20
mov    -0x204(%rbp),%eax
sub    $0x3,%eax
cltq
movb   $0x20,-0x200(%rbp,%rax,1)
20
jmp    124e <main+0x12e>
jmp    122b <main+0x10b>
jmp    1230 <main+0x110>
jmp    1235 <main+0x115>
jmp    123a <main+0x11a>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    113c <main+0x1c>
movl   $0x0,-0x204(%rbp)
cmpl   $0x1f3,-0x204(%rbp)
jge    12d8 <main+0x1b8>
movslq -0x204(%rbp),%rax
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x7a,%eax
jg     12bf <main+0x19f>
movslq -0x204(%rbp),%rax
movsbl -0x200(%rbp,%rax,1),%eax
ff
cmp    $0x61,%eax
jl     12ba <main+0x19a>
movslq -0x204(%rbp),%rax
movsbl -0x200(%rbp,%rax,1),%eax
ff
sub    $0x20,%eax
mov    %al,%cl
movslq -0x204(%rbp),%rax
mov    %cl,-0x200(%rbp,%rax,1)
jmp    12bf <main+0x19f>
jmp    12c4 <main+0x1a4>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1258 <main+0x138>
lea    -0x200(%rbp),%rsi
lea    0xd1a(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x200,%rsp
xor    %ebx,%ebx
jmp    1134 <main+0x14>
nopl   0x0(%rax)
add    $0x1,%rbx
xor    %eax,%eax
call   1040 <getchar@plt>
mov    %al,(%rsp,%rbx,1)
cmp    $0x50,%al
jne    1130 <main+0x10>
cmpb   $0x4f,-0x1(%rsp,%rbx,1)
jne    1130 <main+0x10>
cmpb   $0x54,-0x2(%rsp,%rbx,1)
jne    1130 <main+0x10>
cmpb   $0x53,-0x3(%rsp,%rbx,1)
jne    1130 <main+0x10>
mov    %ebx,%eax
movb   $0x20,(%rsp,%rax,1)
movb   $0x20,-0x1(%rsp,%rbx,1)
movw   $0x2020,-0x3(%rsp,%rbx,1)
xor    %eax,%eax
movdqa 0xe8d(%rip),%xmm0
movdqa 0xe95(%rip),%xmm1
pcmpeqd %xmm2,%xmm2
jmp    11a0 <main+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x8,%rax
cmp    $0x1f0,%rax
je     12b9 <main+0x199>
movq   (%rsp,%rax,1),%xmm3
movdqa %xmm3,%xmm4
paddb  %xmm0,%xmm4
movdqa %xmm4,%xmm5
pmaxub %xmm1,%xmm5
pcmpeqb %xmm4,%xmm5
movd   %xmm5,%ecx
not    %cl
test   $0x1,%cl
je     11ce <main+0xae>
movd   %xmm3,%ecx
add    $0xe0,%cl
mov    %cl,(%rsp,%rax,1)
movdqa %xmm5,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,%xmm6
pslld  $0x8,%xmm6
movd   %xmm6,%ecx
shr    $0x10,%ecx
test   $0x1,%cl
je     11f9 <main+0xd9>
movd   %xmm3,%ecx
shr    $0x8,%ecx
add    $0xe0,%cl
mov    %cl,0x1(%rsp,%rax,1)
pshuflw $0x55,%xmm5,%xmm6
pxor   %xmm2,%xmm6
pextrw $0x2,%xmm6,%ecx
test   $0x1,%cl
je     121a <main+0xfa>
movd   %xmm3,%ecx
shr    $0x10,%ecx
add    $0xe0,%cl
mov    %cl,0x2(%rsp,%rax,1)
movdqa %xmm4,%xmm6
psllq  $0x18,%xmm6
pextrw $0x3,%xmm6,%ecx
test   $0x1,%cl
je     123b <main+0x11b>
movd   %xmm3,%ecx
shr    $0x18,%ecx
add    $0xe0,%cl
mov    %cl,0x3(%rsp,%rax,1)
pshufd $0x55,%xmm5,%xmm5
pxor   %xmm2,%xmm5
pextrw $0x4,%xmm5,%ecx
test   $0x1,%cl
je     125a <main+0x13a>
pextrw $0x2,%xmm3,%ecx
add    $0xe0,%cl
mov    %cl,0x4(%rsp,%rax,1)
movdqa %xmm4,%xmm5
pslldq $0x5,%xmm5
pextrw $0x5,%xmm5,%ecx
test   $0x1,%cl
je     127c <main+0x15c>
pextrw $0x2,%xmm3,%ecx
shr    $0x8,%ecx
add    $0xe0,%cl
mov    %cl,0x5(%rsp,%rax,1)
pextrw $0x3,%xmm4,%ecx
test   $0x1,%cl
je     1292 <main+0x172>
pextrw $0x3,%xmm3,%ecx
add    $0xe0,%cl
mov    %cl,0x6(%rsp,%rax,1)
pslldq $0x7,%xmm4
pextrw $0x7,%xmm4,%ecx
test   $0x1,%cl
je     1190 <main+0x70>
pextrw $0x3,%xmm3,%ecx
shr    $0x8,%ecx
add    $0xe0,%cl
mov    %cl,0x7(%rsp,%rax,1)
jmp    1190 <main+0x70>
mov    0x1f0(%rsp),%al
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     12d1 <main+0x1b1>
add    $0xe0,%al
mov    %al,0x1f0(%rsp)
mov    0x1f1(%rsp),%al
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     12e9 <main+0x1c9>
add    $0xe0,%al
mov    %al,0x1f1(%rsp)
mov    0x1f2(%rsp),%al
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     1301 <main+0x1e1>
add    $0xe0,%al
mov    %al,0x1f2(%rsp)
lea    0xd18(%rip),%rdi
mov    %rsp,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x200,%rsp
pop    %rbx
ret

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

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