#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 *);
void trans(char arr[34]) {
  int i;
  char ch;
  for (i = 0; i < 34 / 2; i++) {
    ch = arr[i];
    arr[i] = arr[33 - i];
    arr[33 - i] = ch;
  }
  for (i = 0; arr[i] != '\0'; i++) {
    ch = arr[i];
    int number, n = 13;
    if ((arr[i] >= 'A') && (arr[i] <= 'Z')) {
      arr[i] = 'A';
      number = ch - 'A';
    } else {
      number = ch - 'a';
      arr[i] = 'a';
    }
    number = (number + n) % 26;
    arr[i] = arr[i] + number;
  }
  printf("%s\n", arr);
}


x86 assembly (clang, -O0):
<trans>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x11,-0xc(%rbp)
jge    117b <trans+0x6b>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xd(%rbp)
mov    -0x8(%rbp),%rax
mov    $0x21,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xd(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    $0x21,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1123 <trans+0x13>
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1242 <trans+0x132>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xd(%rbp)
movl   $0xd,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     11f1 <trans+0xe1>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     11f1 <trans+0xe1>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x41,(%rax,%rcx,1)
movsbl -0xd(%rbp),%eax
sub    $0x41,%eax
mov    %eax,-0x14(%rbp)
jmp    1207 <trans+0xf7>
movsbl -0xd(%rbp),%eax
sub    $0x61,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    -0x14(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1182 <trans+0x72>
mov    -0x8(%rbp),%rsi
lea    0xdb3(%rip),%rdi
call   1030 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trans>:
mov    %rdi,%r8
movzwl (%rdi),%eax
rol    $0x8,%ax
movdqu 0x12(%rdi),%xmm0
mov    %ax,0x20(%rdi)
movq   0x2(%rdi),%xmm1
movd   0xa(%rdi),%xmm3
movzwl 0xe(%rdi),%eax
movd   %eax,%xmm4
pxor   %xmm2,%xmm2
movdqa %xmm0,%xmm5
punpcklbw %xmm2,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
movdqa %xmm0,%xmm6
punpckhbw %xmm2,%xmm6
pshufd $0x4e,%xmm6,%xmm6
pshuflw $0x1b,%xmm6,%xmm6
pshufhw $0x1b,%xmm6,%xmm6
packuswb %xmm5,%xmm6
movdqu %xmm6,(%rdi)
movzwl 0x10(%rdi),%eax
movd   %eax,%xmm5
movdqa %xmm5,%xmm6
psrlw  $0x8,%xmm6
psllw  $0x8,%xmm5
por    %xmm6,%xmm5
movdqa 0xe6f(%rip),%xmm6
pand   %xmm6,%xmm5
punpcklbw %xmm2,%xmm4
pshuflw $0x14,%xmm4,%xmm4
packuswb %xmm4,%xmm4
pandn  %xmm4,%xmm6
por    %xmm5,%xmm6
punpcklbw %xmm2,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
packuswb %xmm3,%xmm3
punpckldq %xmm3,%xmm6
punpcklbw %xmm2,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movsd  %xmm6,%xmm1
movupd %xmm1,0x10(%rdi)
movdqa %xmm0,-0x18(%rsp)
mov    -0x9(%rsp),%cl
test   %cl,%cl
je     123d <trans+0x12d>
lea    0x1(%r8),%rax
nopl   (%rax)
movsbl %cl,%ecx
lea    -0x41(%rcx),%edx
xor    %edi,%edi
cmp    $0x1a,%dl
setae  %dl
setb   %dil
shl    $0x5,%edi
shl    $0x5,%dl
add    %edi,%ecx
add    $0xffffffac,%ecx
movswl %cx,%edi
imul   $0x4ec5,%edi,%edi
mov    %edi,%esi
shr    $0x1f,%esi
shr    $0x13,%edi
add    %esi,%edi
lea    (%rdi,%rdi,4),%esi
lea    (%rsi,%rsi,4),%esi
add    %edi,%esi
sub    %esi,%ecx
add    %dl,%cl
add    $0x41,%cl
mov    %cl,-0x1(%rax)
movzbl (%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    11f0 <trans+0xe0>
lea    0xdcc(%rip),%rdi
mov    %r8,%rsi
jmp    1030 <printf@plt>

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

LLVM IR (-O2):
@.str = [4 x i8] c"%s\0A\00"
define void @trans(i8* %0) {
%2 = load i8, i8* %0
%3 = getelementptr inbounds i8, i8* %0, i64 33
%4 = getelementptr inbounds i8, i8* %0, i64 32
%5 = getelementptr inbounds i8, i8* %0, i64 18
%6 = bitcast i8* %5 to <16 x i8>*
%7 = load <16 x i8>, <16 x i8>* %6
store i8 %2, i8* %3
%8 = getelementptr inbounds i8, i8* %0, i64 1
%9 = load i8, i8* %8
store i8 %9, i8* %4
%10 = getelementptr inbounds i8, i8* %0, i64 2
%11 = bitcast i8* %10 to <8 x i8>*
%12 = load <8 x i8>, <8 x i8>* %11
%13 = getelementptr inbounds i8, i8* %0, i64 10
%14 = bitcast i8* %13 to <4 x i8>*
%15 = load <4 x i8>, <4 x i8>* %14
%16 = getelementptr inbounds i8, i8* %0, i64 14
%17 = bitcast i8* %16 to <2 x i8>*
%18 = load <2 x i8>, <2 x i8>* %17
%19 = shufflevector <16 x i8> %7, <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>
%20 = bitcast i8* %0 to <16 x i8>*
store <16 x i8> %19, <16 x i8>* %20
%21 = getelementptr inbounds i8, i8* %0, i64 16
%22 = bitcast i8* %21 to <2 x i8>*
%23 = load <2 x i8>, <2 x i8>* %22
%24 = shufflevector <2 x i8> %23, <2 x i8> poison, <16 x i32> <i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%25 = shufflevector <2 x i8> %18, <2 x i8> poison, <16 x i32> <i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%26 = shufflevector <16 x i8> %24, <16 x i8> %25, <16 x i32> <i32 0, i32 1, i32 16, i32 17, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%27 = shufflevector <4 x i8> %15, <4 x i8> poison, <16 x i32> <i32 3, i32 2, i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%28 = shufflevector <16 x i8> %26, <16 x i8> %27, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%29 = shufflevector <8 x i8> %12, <8 x i8> poison, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%30 = shufflevector <16 x i8> %28, <16 x i8> %29, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%31 = bitcast i8* %21 to <16 x i8>*
store <16 x i8> %30, <16 x i8>* %31
%32 = extractelement <16 x i8> %7, i64 15
%33 = icmp eq i8 %32, 0
br i1 %33, label %52, label %34
34: ; preds = %1, %34
%35 = phi i64 [ %48, %34 ], [ 0, %1 ]
%36 = phi i8 [ %50, %34 ], [ %32, %1 ]
%37 = phi i8* [ %49, %34 ], [ %0, %1 ]
%38 = sext i8 %36 to i16
%39 = add i8 %36, -65
%40 = icmp ult i8 %39, 26
%41 = select i1 %40, i16 -65, i16 -97
%42 = select i1 %40, i8 65, i8 97
%43 = add nsw i16 %41, %38
%44 = add nsw i16 %43, 13
%45 = srem i16 %44, 26
%46 = trunc i16 %45 to i8
%47 = add nsw i8 %42, %46
store i8 %47, i8* %37
%48 = add nuw i64 %35, 1
%49 = getelementptr inbounds i8, i8* %0, i64 %48
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 0
br i1 %51, label %52, label %34
52: ; preds = %34, %1
%53 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %0)
ret void
}