#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 *, char *);
int /*<<< orphan*/ scanf(char *, int *);
int strlen(char *);
int main(int argc, char const *argv[]) {
  int i = 0, v = 0, i2 = 0, j = 0, op = 0, tam = 0;
  char c[1000] = {'0'};
  char d[1000] = {'0'};
  scanf("%d\n", &op);
  for (j = 0; j < op; ++j) {
    gets(c);
    tam = strlen(c);
    for (i = tam; i >= 0; i--) {
      v = c[i - 1];
      if ((v >= 65 && v <= 90) || (v >= 97 && v <= 122)) {
        v = v + 3;
        d[i2] = v;
        i2++;
      } else {
        d[i2] = v;
        i2++;
      }
    }
    tam = strlen(d);
    for (i = (tam / 2); i < tam; i++) {
      v = d[i];
      v = v - 1;
      d[i] = v;
    }
    printf("%s\n", d);
    i = 0;
    i2 = 0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x800,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
lea    -0x410(%rbp),%rdi
xor    %esi,%esi
mov    $0x3e8,%edx
call   1050 <memset@plt>
movb   $0x30,-0x410(%rbp)
lea    -0x800(%rbp),%rdi
xor    %esi,%esi
mov    $0x3e8,%edx
call   1050 <memset@plt>
movb   $0x30,-0x800(%rbp)
lea    0xe32(%rip),%rdi
lea    -0x24(%rbp),%rsi
call   1070 <scanf@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1331 <main+0x1e1>
lea    -0x410(%rbp),%rdi
call   1060 <gets@plt>
lea    -0x410(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     12a3 <main+0x153>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x410(%rbp,%rax,1),%eax
ff
mov    %eax,-0x18(%rbp)
cmpl   $0x41,-0x18(%rbp)
jl     123c <main+0xec>
cmpl   $0x5a,-0x18(%rbp)
jle    1250 <main+0x100>
cmpl   $0x61,-0x18(%rbp)
jl     1277 <main+0x127>
cmpl   $0x7a,-0x18(%rbp)
jg     1277 <main+0x127>
mov    -0x18(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x800(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1290 <main+0x140>
mov    -0x18(%rbp),%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x800(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1295 <main+0x145>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    120b <main+0xbb>
lea    -0x800(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1302 <main+0x1b2>
movslq -0x14(%rbp),%rax
movsbl -0x800(%rbp,%rax,1),%eax
ff
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x800(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12c0 <main+0x170>
lea    -0x800(%rbp),%rsi
lea    0xcf4(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11de <main+0x8e>
xor    %eax,%eax
add    $0x800,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7e8,%rsp
movl   $0x0,0xc(%rsp)
lea    0x400(%rsp),%rdi
xor    %r13d,%r13d
mov    $0x3e8,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movb   $0x30,0x400(%rsp)
30
lea    0x10(%rsp),%rdi
mov    $0x3e8,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movb   $0x30,0x10(%rsp)
lea    0xedb(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1070 <scanf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1553 <main+0x403>
lea    0x400(%rsp),%r14
lea    0x10(%rsp),%r12
lea    0xeb6(%rip),%r15
jmp    11ea <main+0x9a>
mov    %r15,%rdi
mov    %r12,%rsi
call   1040 <printf@plt>
add    $0x1,%r13d
cmp    0xc(%rsp),%r13d
jge    1553 <main+0x403>
mov    %r14,%rdi
call   1060 <gets@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
js     13da <main+0x28a>
mov    %eax,%edx
lea    0x1(%rax),%ecx
cmp    $0x7,%eax
jae    1220 <main+0xd0>
mov    %rdx,%rsi
xor    %eax,%eax
jmp    139f <main+0x24f>
cs nopw 0x0(%rax,%rax,1)
cmp    $0xf,%eax
jae    122c <main+0xdc>
xor    %eax,%eax
jmp    12fa <main+0x1aa>
mov    %ecx,%eax
and    $0xfffffff0,%eax
lea    0x3f0(%rsp),%rsi
add    %rdx,%rsi
xor    %edi,%edi
pxor   %xmm3,%xmm3
movdqa 0xdb6(%rip),%xmm4
movdqa 0xdbe(%rip),%xmm5
movdqa 0xdc6(%rip),%xmm6
movdqa 0xdce(%rip),%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rsi),%xmm0
movdqa %xmm0,%xmm1
punpcklbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm1,%xmm0
movdqa %xmm0,%xmm1
pand   %xmm4,%xmm1
paddb  %xmm5,%xmm1
movdqa %xmm1,%xmm2
pminub %xmm6,%xmm2
pcmpeqb %xmm1,%xmm2
movdqa %xmm2,%xmm1
pandn  %xmm0,%xmm1
paddb  %xmm7,%xmm0
pand   %xmm2,%xmm0
por    %xmm1,%xmm0
movdqa %xmm0,0x10(%rsp,%rdi,1)
add    $0x10,%rdi
add    $0xfffffffffffffff0,%rsi
cmp    %rdi,%rax
jne    1270 <main+0x120>
cmp    %rcx,%rax
je     13da <main+0x28a>
test   $0x8,%cl
jne    12fa <main+0x1aa>
sub    %rax,%rdx
mov    %rdx,%rsi
jmp    139f <main+0x24f>
pxor   %xmm3,%xmm3
movdqa 0xd3a(%rip),%xmm4
movdqa 0xd42(%rip),%xmm5
movdqa 0xd4a(%rip),%xmm6
movdqa 0xd52(%rip),%xmm7
mov    %rax,%rdi
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rdx,%rsi
sub    %rax,%rsi
sub    %rdi,%rdx
lea    0x3f8(%rsp),%rbp
add    %rbp,%rdx
nopw   0x0(%rax,%rax,1)
movq   (%rdx),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa %xmm0,%xmm1
pand   %xmm4,%xmm1
paddb  %xmm5,%xmm1
movdqa %xmm1,%xmm2
pmaxub %xmm6,%xmm2
pcmpeqb %xmm1,%xmm2
movdqa %xmm2,%xmm1
pand   %xmm0,%xmm1
paddb  %xmm7,%xmm0
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movq   %xmm2,0x10(%rsp,%rdi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rdx
cmp    %rdi,%rax
jne    1340 <main+0x1f0>
cmp    %rcx,%rax
je     13da <main+0x28a>
lea    0x3ff(%rsp),%rdx
add    %rdx,%rsi
nopw   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
mov    %edx,%ebx
and    $0xdf,%bl
add    $0xbf,%bl
lea    0x3(%rdx),%edi
cmp    $0x1a,%bl
movzbl %dil,%edi
cmovae %edx,%edi
mov    %dil,0x10(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
cmp    %rax,%rcx
jne    13b0 <main+0x260>
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
cmp    %eax,%ecx
jge    11d0 <main+0x80>
movslq %ecx,%r9
cltq
mov    %rax,%rcx
sub    %r9,%rcx
cmp    $0x8,%rcx
jae    1410 <main+0x2c0>
mov    %r9,%rdi
jmp    1540 <main+0x3f0>
nopl   0x0(%rax)
cmp    $0x20,%rcx
jae    141d <main+0x2cd>
xor    %edx,%edx
jmp    14df <main+0x38f>
mov    %rcx,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1523 <main+0x3d3>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x40(%rsp),%rsi
add    %r9,%rsi
xor    %ebp,%ebp
pcmpeqd %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rbp,1),%xmm0
movdqu -0x20(%rsi,%rbp,1),%xmm1
movdqu -0x10(%rsi,%rbp,1),%xmm2
movdqu (%rsi,%rbp,1),%xmm3
paddb  %xmm4,%xmm0
paddb  %xmm4,%xmm1
movdqu %xmm0,-0x30(%rsi,%rbp,1)
movdqu %xmm1,-0x20(%rsi,%rbp,1)
paddb  %xmm4,%xmm2
paddb  %xmm4,%xmm3
movdqu %xmm2,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1460 <main+0x310>
test   $0x1,%r8b
je     14d1 <main+0x381>
add    %r9,%rbp
movdqu 0x10(%rsp,%rbp,1),%xmm0
movdqu 0x20(%rsp,%rbp,1),%xmm1
paddb  %xmm4,%xmm0
paddb  %xmm4,%xmm1
movdqu %xmm0,0x10(%rsp,%rbp,1)
movdqu %xmm1,0x20(%rsp,%rbp,1)
cmp    %rdx,%rcx
je     11d0 <main+0x80>
test   $0x18,%cl
je     1535 <main+0x3e5>
mov    %rcx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rsi,%r9,1),%rdi
lea    (%rsp,%r9,1),%rbp
add    $0x10,%rbp
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movq   0x0(%rbp,%rdx,1),%xmm0
paddb  %xmm1,%xmm0
movq   %xmm0,0x0(%rbp,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1500 <main+0x3b0>
cmp    %rsi,%rcx
jne    1540 <main+0x3f0>
jmp    11d0 <main+0x80>
xor    %ebp,%ebp
pcmpeqd %xmm4,%xmm4
test   $0x1,%r8b
jne    14ae <main+0x35e>
jmp    14d1 <main+0x381>
add    %r9,%rdx
mov    %rdx,%rdi
nopl   0x0(%rax,%rax,1)
addb   $0xff,0x10(%rsp,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1540 <main+0x3f0>
jmp    11d0 <main+0x80>
xor    %eax,%eax
add    $0x7e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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