#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 *);
size_t strlen(char *);
int main() {
  char buffer1[1503];
  char *buffer2 = buffer1 + 501;
  char *buffer3 = buffer1 + 1002;
  scanf("%s", buffer1);
  scanf("%s", buffer2);
  size_t len1 = strlen(buffer1);
  size_t len2 = strlen(buffer2);
  size_t min_len = len1 < len2 ? len1 : len2;
  int index_in = 0, index_out = 0;
  for (size_t i = 0; i < min_len; i++) {
    buffer3[index_in++] = (char)(((buffer1[i] - buffer2[i] + 26) % 26) + 65);
  }
  for (size_t i = len2; i < len1; i++) {
    buffer3[index_in++] =
        (char)(((buffer1[i] - buffer3[index_out++] + 26) % 26) + 65);
  }
  buffer3[index_in] = '\0';
  printf("%s\n", buffer3);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x640,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x5f0(%rbp),%rax
add    $0x1f5,%rax
mov    %rax,-0x5f8(%rbp)
lea    -0x5f0(%rbp),%rax
add    $0x3ea,%rax
mov    %rax,-0x600(%rbp)
lea    -0x5f0(%rbp),%rsi
lea    0xe88(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x5f8(%rbp),%rsi
lea    0xe75(%rip),%rdi
call   1050 <scanf@plt>
lea    -0x5f0(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x608(%rbp)
mov    -0x5f8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x610(%rbp)
mov    -0x608(%rbp),%rax
cmp    -0x610(%rbp),%rax
jae    11dd <main+0xad>
mov    -0x608(%rbp),%rax
mov    %rax,-0x638(%rbp)
jmp    11eb <main+0xbb>
mov    -0x610(%rbp),%rax
mov    %rax,-0x638(%rbp)
mov    -0x638(%rbp),%rax
mov    %rax,-0x618(%rbp)
movl   $0x0,-0x61c(%rbp)
movl   $0x0,-0x620(%rbp)
movq   $0x0,-0x628(%rbp)
mov    -0x628(%rbp),%rax
cmp    -0x618(%rbp),%rax
jae    1292 <main+0x162>
mov    -0x628(%rbp),%rax
movsbl -0x5f0(%rbp,%rax,1),%eax
ff
mov    -0x5f8(%rbp),%rcx
mov    -0x628(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
add    $0x1a,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    -0x600(%rbp),%rax
mov    -0x61c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x61c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x628(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x628(%rbp)
jmp    1218 <main+0xe8>
mov    -0x610(%rbp),%rax
mov    %rax,-0x630(%rbp)
mov    -0x630(%rbp),%rax
cmp    -0x608(%rbp),%rax
jae    1327 <main+0x1f7>
mov    -0x630(%rbp),%rax
movsbl -0x5f0(%rbp,%rax,1),%eax
ff
mov    -0x600(%rbp),%rcx
mov    -0x620(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x620(%rbp)
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
add    $0x1a,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    -0x600(%rbp),%rax
mov    -0x61c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x61c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x630(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x630(%rbp)
jmp    12a0 <main+0x170>
mov    -0x600(%rbp),%rax
movslq -0x61c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x600(%rbp),%rsi
lea    0xcbc(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x640,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x5e8,%rsp
lea    0x1f5(%rsp),%r15
lea    0xf04(%rip),%r14
mov    %rsp,%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
call   1050 <scanf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    %rbx,%rdi
call   1030 <strlen@plt>
mov    %rax,%r14
mov    %r15,%rdi
call   1030 <strlen@plt>
cmp    %rax,%r14
mov    %rax,%r11
cmovb  %r14,%r11
test   %r11,%r11
je     1194 <main+0x64>
cmp    $0x8,%r11
jae    119c <main+0x6c>
xor    %edx,%edx
jmp    133a <main+0x20a>
xor    %r11d,%r11d
jmp    137b <main+0x24b>
cmp    $0x10,%r11
jae    11a9 <main+0x79>
xor    %edx,%edx
jmp    129f <main+0x16f>
mov    %r11,%rdx
and    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
movdqa 0xe46(%rip),%xmm0
movdqa 0xe4e(%rip),%xmm1
movdqa 0xe56(%rip),%xmm2
movdqa 0xe5e(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa (%rsp,%rsi,1),%xmm5
punpcklbw %xmm5,%xmm4
psraw  $0x8,%xmm4
punpckhbw %xmm5,%xmm5
psraw  $0x8,%xmm5
movdqu 0x1f5(%rsp,%rsi,1),%xmm6
punpcklbw %xmm6,%xmm7
psraw  $0x8,%xmm7
psubw  %xmm7,%xmm4
punpckhbw %xmm6,%xmm6
psraw  $0x8,%xmm6
psubw  %xmm6,%xmm5
paddw  %xmm0,%xmm5
paddw  %xmm0,%xmm4
movdqa %xmm4,%xmm6
pmulhw %xmm1,%xmm6
movdqa %xmm6,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x3,%xmm6
paddw  %xmm7,%xmm6
pmullw %xmm0,%xmm6
psubw  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pmulhw %xmm1,%xmm6
movdqa %xmm6,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x3,%xmm6
paddw  %xmm7,%xmm6
pmullw %xmm0,%xmm6
psubw  %xmm6,%xmm5
pand   %xmm2,%xmm5
pand   %xmm2,%xmm4
packuswb %xmm5,%xmm4
paddb  %xmm3,%xmm4
movdqu %xmm4,0x3ea(%rsp,%rsi,1)
add    $0x10,%rsi
cmp    %rsi,%rdx
jne    11e0 <main+0xb0>
cmp    %rdx,%r11
je     137b <main+0x24b>
test   $0x8,%r11b
je     133a <main+0x20a>
mov    %rdx,%rsi
mov    %r11,%rdx
and    $0xfffffffffffffff8,%rdx
movdqa 0xd4f(%rip),%xmm0
movdqa 0xd57(%rip),%xmm1
movdqa 0xd5f(%rip),%xmm2
movdqa 0xd77(%rip),%xmm3
nopl   0x0(%rax)
movq   (%rsp,%rsi,1),%xmm4
punpcklbw %xmm4,%xmm4
psraw  $0x8,%xmm4
movq   0x1f5(%rsp,%rsi,1),%xmm5
punpcklbw %xmm5,%xmm5
psraw  $0x8,%xmm5
psubw  %xmm5,%xmm4
paddw  %xmm0,%xmm4
movdqa %xmm4,%xmm5
pmulhw %xmm1,%xmm5
movdqa %xmm5,%xmm6
psrlw  $0xf,%xmm6
psrlw  $0x3,%xmm5
paddw  %xmm6,%xmm5
pmullw %xmm0,%xmm5
psubw  %xmm5,%xmm4
pand   %xmm2,%xmm4
packuswb %xmm4,%xmm4
paddb  %xmm3,%xmm4
movq   %xmm4,0x3ea(%rsp,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    12d0 <main+0x1a0>
jmp    1376 <main+0x246>
movsbl (%rsp,%rdx,1),%ecx
movsbl 0x1f5(%rsp,%rdx,1),%esi
sub    %esi,%ecx
add    $0x1a,%ecx
movswl %cx,%esi
imul   $0x4ec5,%esi,%esi
mov    %esi,%edi
shr    $0x1f,%edi
shr    $0x13,%esi
add    %edi,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %edi,%ecx
add    $0x41,%cl
mov    %cl,0x3ea(%rsp,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%r11
jne    133a <main+0x20a>
lea    0x3ea(%rsp),%rsi
mov    %r14,%r15
sub    %rax,%r15
jbe    140e <main+0x2de>
mov    %r11d,%r10d
cmp    $0x10,%r15
jae    1435 <main+0x305>
xor    %r8d,%r8d
mov    %r10,%r11
mov    %rax,%r9
mov    %rsp,%rcx
lea    (%r11,%rcx,1),%r10
add    $0x3ea,%r10
lea    (%r8,%rcx,1),%rdi
add    $0x3ea,%rdi
sub    %r8,%r15
lea    (%rsp,%r9,1),%rcx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsbl (%rcx,%rbx,1),%ebp
movsbl (%rdi,%rbx,1),%edx
sub    %edx,%ebp
add    $0x1a,%ebp
movswl %bp,%edx
imul   $0x4ec5,%edx,%edx
mov    %edx,%eax
shr    $0x1f,%eax
shr    $0x13,%edx
add    %eax,%edx
lea    (%rdx,%rdx,4),%eax
lea    (%rax,%rax,4),%eax
add    %edx,%eax
sub    %eax,%ebp
add    $0x41,%bpl
mov    %bpl,(%r10,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    13d0 <main+0x2a0>
add    %rbx,%r11
mov    %r11d,%eax
movb   $0x0,0x3ea(%rsp,%rax,1)
lea    0xc33(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x5e8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r10,%rbx,1),%rcx
add    $0x3ea,%rcx
lea    (%r14,%r10,1),%rdi
sub    %rax,%rdi
add    %rbx,%rdi
add    $0x3ea,%rdi
lea    (%rsp,%rax,1),%r8
lea    (%rsp,%r14,1),%r9
lea    (%r15,%rbx,1),%r11
add    $0x3ea,%r11
cmp    %r9,%rcx
setb   %r9b
cmp    %rdi,%r8
setb   %bpl
cmp    %r11,%rcx
setb   %cl
cmp    %rdi,%rsi
setb   %dil
xor    %r8d,%r8d
test   %bpl,%r9b
jne    139f <main+0x26f>
and    %dil,%cl
jne    139f <main+0x26f>
mov    %r15,%r8
and    $0xfffffffffffffff0,%r8
lea    (%r8,%r10,1),%r11
mov    %rax,%r9
add    %r8,%r9
movdqa 0xb53(%rip),%xmm0
movdqa 0xb5b(%rip),%xmm1
movdqa 0xb63(%rip),%xmm2
movdqa 0xb6b(%rip),%xmm3
mov    %r8,%rdi
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rax,1),%xmm5
punpcklbw %xmm5,%xmm4
psraw  $0x8,%xmm4
punpckhbw %xmm5,%xmm5
psraw  $0x8,%xmm5
movdqu 0x3ea(%rbx),%xmm6
punpcklbw %xmm6,%xmm7
psraw  $0x8,%xmm7
psubw  %xmm7,%xmm4
punpckhbw %xmm6,%xmm6
psraw  $0x8,%xmm6
psubw  %xmm6,%xmm5
paddw  %xmm0,%xmm5
paddw  %xmm0,%xmm4
movdqa %xmm4,%xmm6
pmulhw %xmm1,%xmm6
movdqa %xmm6,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x3,%xmm6
paddw  %xmm7,%xmm6
pmullw %xmm0,%xmm6
psubw  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pmulhw %xmm1,%xmm6
movdqa %xmm6,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x3,%xmm6
paddw  %xmm7,%xmm6
pmullw %xmm0,%xmm6
psubw  %xmm6,%xmm5
pand   %xmm2,%xmm5
pand   %xmm2,%xmm4
packuswb %xmm5,%xmm4
paddb  %xmm3,%xmm4
movdqu %xmm4,0x3ea(%rbx,%r10,1)
add    $0x10,%rbx
add    $0xfffffffffffffff0,%rdi
jne    14d0 <main+0x3a0>
cmp    %r8,%r15
jne    13a5 <main+0x275>
jmp    140e <main+0x2de>

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

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