#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*/ printf(char *, char *);
int /*<<< orphan*/ scanf(char *, char *);
int main() {
  char A[100];
  int i, j;
  int count = 0;
  scanf("%s", A);
  for (i = 0; A[i] != '\0'; i++) {
    count++;
  }
  for (j = 0; j < count; j++) {
    if ((A[j] - 'a' + 1) <= 'z' - A[j])
      A[j] = A[j] + A[j] - 'a' + 1;
    else
      A[j] = (A[j] - 'a' + 1) - ('z' - A[j]) + 'a' - 1;
  }
  printf("%s", A);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x7c(%rbp)
lea    -0x70(%rbp),%rsi
lea    0xebc(%rip),%rdi
call   1040 <scanf@plt>
movl   $0x0,-0x74(%rbp)
movslq -0x74(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     1179 <main+0x59>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1150 <main+0x30>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1220 <main+0x100>
movslq -0x78(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
sub    $0x61,%eax
add    $0x1,%eax
movslq -0x78(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%edx
mov    $0x7a,%ecx
sub    %edx,%ecx
cmp    %ecx,%eax
jg     11dc <main+0xbc>
movslq -0x78(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
movslq -0x78(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%ecx
add    %ecx,%eax
sub    $0x61,%eax
add    $0x1,%eax
mov    %al,%cl
movslq -0x78(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
jmp    120d <main+0xed>
movslq -0x78(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
sub    $0x61,%eax
add    $0x1,%eax
movslq -0x78(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%edx
mov    $0x7a,%ecx
sub    %edx,%ecx
sub    %ecx,%eax
add    $0x61,%eax
sub    $0x1,%eax
mov    %al,%cl
movslq -0x78(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
jmp    1212 <main+0xf2>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1180 <main+0x60>
lea    -0x70(%rbp),%rsi
lea    0xdd5(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x68,%rsp
lea    0xf45(%rip),%rdi
mov    %rsp,%rsi
call   1040 <scanf@plt>
movsbl (%rsp),%ecx
test   %ecx,%ecx
je     1426 <main+0x306>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%rsp,%rax,1)
lea    0x1(%rax),%rax
jne    1150 <main+0x30>
test   %eax,%eax
je     1426 <main+0x306>
mov    $0x7a,%edx
sub    %ecx,%edx
mov    %ecx,%esi
add    $0xffffffa0,%esi
mov    %esi,%edi
sub    %edx,%edi
add    $0x60,%dil
add    %ecx,%ecx
add    $0xa0,%cl
cmp    %edx,%esi
mov    %eax,%r9d
movzbl %dil,%edx
movzbl %cl,%ecx
cmovg  %edx,%ecx
mov    %cl,(%rsp)
cmp    $0x1,%r9
je     1426 <main+0x306>
add    $0xffffffffffffffff,%r9
mov    $0x1,%esi
cmp    $0x8,%r9
jb     13ea <main+0x2ca>
cmp    $0x10,%r9
jae    11b8 <main+0x98>
xor    %edx,%edx
jmp    130e <main+0x1ee>
mov    %r9,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %eax,%esi
add    $0xffffffffffffffff,%rsi
and    $0xfffffffffffffff0,%rsi
xor    %edi,%edi
movdqa 0xe2c(%rip),%xmm10
movdqa 0xe33(%rip),%xmm12
movdqa 0xe3a(%rip),%xmm11
movdqa 0xe51(%rip),%xmm9
nop
movdqu 0x1(%rsp,%rdi,1),%xmm13
punpckhbw %xmm13,%xmm0
punpckhwd %xmm0,%xmm3
psrad  $0x18,%xmm3
punpcklwd %xmm0,%xmm2
psrad  $0x18,%xmm2
punpcklbw %xmm13,%xmm0
punpckhwd %xmm0,%xmm4
psrad  $0x18,%xmm4
punpcklwd %xmm0,%xmm6
psrad  $0x18,%xmm6
movdqa %xmm12,%xmm14
psubd  %xmm6,%xmm14
paddd  %xmm10,%xmm6
movdqa %xmm12,%xmm15
psubd  %xmm4,%xmm15
paddd  %xmm10,%xmm4
movdqa %xmm12,%xmm5
psubd  %xmm2,%xmm5
paddd  %xmm10,%xmm2
movdqa %xmm12,%xmm1
psubd  %xmm3,%xmm1
paddd  %xmm10,%xmm3
movdqa %xmm3,%xmm0
pcmpgtd %xmm1,%xmm0
movdqa %xmm2,%xmm7
pcmpgtd %xmm5,%xmm7
packssdw %xmm0,%xmm7
movdqa %xmm4,%xmm8
pcmpgtd %xmm15,%xmm8
movdqa %xmm6,%xmm0
pcmpgtd %xmm14,%xmm0
packssdw %xmm8,%xmm0
packsswb %xmm7,%xmm0
psubd  %xmm14,%xmm6
psubd  %xmm15,%xmm4
psubd  %xmm5,%xmm2
psubd  %xmm1,%xmm3
pand   %xmm11,%xmm3
pand   %xmm11,%xmm2
packuswb %xmm3,%xmm2
pand   %xmm11,%xmm4
pand   %xmm11,%xmm6
packuswb %xmm4,%xmm6
packuswb %xmm2,%xmm6
paddb  0xd67(%rip),%xmm6
paddb  %xmm13,%xmm13
paddb  %xmm9,%xmm13
pand   %xmm0,%xmm6
pandn  %xmm13,%xmm0
por    %xmm6,%xmm0
movdqu %xmm0,0x1(%rsp,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rsi
jne    11f0 <main+0xd0>
cmp    %rdx,%r9
je     1426 <main+0x306>
test   $0x8,%r9b
jne    130e <main+0x1ee>
or     $0x1,%rdx
mov    %rdx,%rsi
jmp    13ea <main+0x2ca>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    0x1(%r8),%rsi
mov    %eax,%edi
add    $0xffffffffffffffff,%rdi
and    $0xfffffffffffffff8,%rdi
movdqa 0xcd4(%rip),%xmm10
movdqa 0xcdb(%rip),%xmm11
movdqa 0xce3(%rip),%xmm2
movdqa 0xd0a(%rip),%xmm8
movdqa 0xd11(%rip),%xmm9
nop
movq   0x1(%rsp,%rdx,1),%xmm5
punpcklbw %xmm5,%xmm6
punpckhwd %xmm6,%xmm7
psrad  $0x18,%xmm7
punpcklwd %xmm6,%xmm6
psrad  $0x18,%xmm6
movdqa %xmm11,%xmm1
psubd  %xmm6,%xmm1
paddd  %xmm10,%xmm6
movdqa %xmm11,%xmm3
psubd  %xmm7,%xmm3
paddd  %xmm10,%xmm7
movdqa %xmm7,%xmm0
pcmpgtd %xmm3,%xmm0
movdqa %xmm6,%xmm4
pcmpgtd %xmm1,%xmm4
packssdw %xmm0,%xmm4
packsswb %xmm4,%xmm4
psubd  %xmm1,%xmm6
psubd  %xmm3,%xmm7
pand   %xmm2,%xmm7
pand   %xmm2,%xmm6
packuswb %xmm7,%xmm6
packuswb %xmm6,%xmm6
paddb  %xmm8,%xmm6
paddb  %xmm5,%xmm5
paddb  %xmm9,%xmm5
pand   %xmm4,%xmm6
pandn  %xmm5,%xmm4
por    %xmm6,%xmm4
movq   %xmm4,0x1(%rsp,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1350 <main+0x230>
cmp    %r8,%r9
je     1426 <main+0x306>
mov    %eax,%r8d
nopl   (%rax)
movsbl (%rsp,%rsi,1),%ecx
mov    $0x7a,%edx
sub    %ecx,%edx
lea    (%rcx,%rcx,1),%edi
mov    %ecx,%eax
add    $0xffffffa0,%eax
mov    %eax,%ecx
sub    %edx,%ecx
add    $0x60,%cl
add    $0xa0,%dil
cmp    %edx,%eax
movzbl %cl,%eax
movzbl %dil,%ecx
cmovg  %eax,%ecx
mov    %cl,(%rsp,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    13f0 <main+0x2d0>
lea    0xc43(%rip),%rdi
mov    %rsp,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x68,%rsp
ret

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

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