#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 */
size_t strlen(char const *);
char toupper(char const);
void encrypt(const char *p, const char *key, char *c) {
  size_t klen = strlen(key);
  size_t plen = strlen(p);
  size_t pplen = strlen(p) + (strlen(key) - strlen(p) % strlen(key));
  char pp[pplen];
  pplen = 0;
  for (size_t i = 0; i < plen; i++) {
    if (p[i] == ' ')
      continue;
    pp[pplen++] = toupper(p[i]);
  }
  if (pplen % klen != 0)
    for (size_t i = 0; i < klen - (pplen % klen); i++)
      pp[pplen++] = 'Q';
  pp[pplen] = '\0';
  for (size_t i = 0; i < pplen / klen; i++)
    for (size_t j = 0; j < klen; j++) {
      c[i * klen + j] = (pp[i * klen + j] - 'A' + (key[j] - 'A')) % 26 + 'A';
    }
}


x86 assembly (clang, -O0):
<encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x80(%rbp),%rcx
mov    %rax,%rsi
mov    -0x78(%rbp),%rax
xor    %edx,%edx
div    %rsi
mov    -0x70(%rbp),%rax
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1238 <encrypt+0x118>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    11fe <encrypt+0xde>
jmp    1227 <encrypt+0x107>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <toupper@plt>
mov    %al,%dl
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11d6 <encrypt+0xb6>
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x20(%rbp)
cmp    $0x0,%rdx
je     12af <encrypt+0x18f>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rax
xor    %edx,%edx
divq   -0x20(%rbp)
mov    -0x88(%rbp),%rax
sub    %rdx,%rcx
cmp    %rcx,%rax
jae    12aa <encrypt+0x18a>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movb   $0x51,(%rax,%rcx,1)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1256 <encrypt+0x136>
jmp    12af <encrypt+0x18f>
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x20(%rbp)
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
cmp    %rcx,%rax
jae    1372 <encrypt+0x252>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    135c <encrypt+0x23c>
mov    -0x68(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
mov    -0x10(%rbp),%rcx
mov    -0x60(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    $0x41,%ecx
add    %ecx,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x60(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    12f5 <encrypt+0x1d5>
jmp    1361 <encrypt+0x241>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    12c3 <encrypt+0x1a3>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encrypt>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r12
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsi,%rdi
call   1040 <strlen@plt>
mov    %rax,%r15
mov    %rbx,-0x40(%rbp)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rax,%rbx
or     %r15,%rax
shr    $0x20,%rax
je     1167 <encrypt+0x47>
mov    %rbx,%rax
xor    %edx,%edx
div    %r15
jmp    116e <encrypt+0x4e>
mov    %ebx,%eax
xor    %edx,%edx
div    %r15d
lea    (%rbx,%r15,1),%rax
sub    %rdx,%rax
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
test   %rbx,%rbx
mov    %r12,-0x38(%rbp)
je     11cc <encrypt+0xac>
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    11a9 <encrypt+0x89>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r13,%rbx
je     11cf <encrypt+0xaf>
mov    -0x40(%rbp),%rax
movzbl (%rax,%r13,1),%eax
cmp    $0x20,%al
je     11a0 <encrypt+0x80>
movsbl %al,%edi
call   1030 <toupper@plt>
mov    -0x30(%rbp),%rcx
mov    %al,(%rcx,%r12,1)
add    $0x1,%r12
jmp    11a0 <encrypt+0x80>
xor    %r12d,%r12d
mov    %r12,%rax
or     %r15,%rax
shr    $0x20,%rax
je     11ea <encrypt+0xca>
mov    %r12,%rax
xor    %edx,%edx
div    %r15
test   %rdx,%rdx
jne    11f7 <encrypt+0xd7>
jmp    1246 <encrypt+0x126>
mov    %r12d,%eax
xor    %edx,%edx
div    %r15d
test   %rdx,%rdx
je     1246 <encrypt+0x126>
mov    -0x30(%rbp),%rax
lea    (%rax,%r12,1),%rsi
xor    %ecx,%ecx
jmp    1220 <encrypt+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edx,%edx
div    %r15
mov    %r15,%rax
sub    %rdx,%rax
cmp    %rax,%rcx
jae    1243 <encrypt+0x123>
lea    (%r12,%rcx,1),%rax
add    $0x1,%rax
movb   $0x51,(%rsi,%rcx,1)
add    $0x1,%rcx
mov    %rax,%rdx
or     %r15,%rdx
shr    $0x20,%rdx
jne    1210 <encrypt+0xf0>
xor    %edx,%edx
div    %r15d
jmp    1215 <encrypt+0xf5>
add    %rcx,%r12
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax,%r12,1)
cmp    %r12,%r15
jbe    1263 <encrypt+0x143>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%rax
or     %r15,%rax
shr    $0x20,%rax
je     1279 <encrypt+0x159>
mov    %r12,%rax
xor    %edx,%edx
div    %r15
jmp    1281 <encrypt+0x161>
mov    %r12d,%eax
xor    %edx,%edx
div    %r15d
cmp    $0x2,%rax
mov    $0x1,%r9d
cmovae %rax,%r9
lea    (%r14,%r15,1),%rax
mov    %rax,-0x40(%rbp)
mov    %r15,%r10
and    $0xfffffffffffffff0,%r10
mov    %r15,%r11
and    $0xfffffffffffffff8,%r11
xor    %r13d,%r13d
movdqa 0xd50(%rip),%xmm0
movdqa 0xd58(%rip),%xmm1
movdqa 0xd60(%rip),%xmm2
movdqa 0xd68(%rip),%xmm3
movdqa 0xd7f(%rip),%xmm9
movdqa 0xd66(%rip),%xmm8
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
jmp    1303 <encrypt+0x1e3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
add    %r15,%rcx
add    %r15,%rax
cmp    %r9,%r13
je     1254 <encrypt+0x134>
test   %r15,%r15
je     12f0 <encrypt+0x1d0>
mov    %r15,%rbx
imul   %r13,%rbx
cmp    $0x8,%r15
jb     1337 <encrypt+0x217>
mov    -0x38(%rbp),%rsi
lea    (%rsi,%rbx,1),%rdx
cmp    -0x40(%rbp),%rdx
jae    1419 <encrypt+0x2f9>
lea    (%r15,%rbx,1),%rdx
add    %rsi,%rdx
cmp    %r14,%rdx
jbe    1419 <encrypt+0x2f9>
xor    %esi,%esi
mov    %rsi,%r8
or     $0x1,%r8
test   $0x1,%r15b
je     138f <encrypt+0x26f>
add    %rsi,%rbx
mov    -0x30(%rbp),%rdx
movsbl (%rdx,%rbx,1),%r12d
movsbl (%r14,%rsi,1),%esi
add    %r12d,%esi
add    $0xffffff7e,%esi
movswl %si,%edi
imul   $0x4ec5,%edi,%edi
mov    %edi,%r12d
shr    $0x1f,%r12d
shr    $0x13,%edi
add    %r12d,%edi
lea    (%rdi,%rdi,4),%edx
lea    (%rdx,%rdx,4),%edx
add    %edi,%edx
sub    %edx,%esi
add    $0x41,%sil
mov    -0x38(%rbp),%rdx
mov    %sil,(%rdx,%rbx,1)
mov    %r8,%rsi
cmp    %r8,%r15
je     12f0 <encrypt+0x1d0>
nopl   0x0(%rax,%rax,1)
movsbl (%rax,%rsi,1),%edx
movsbl (%r14,%rsi,1),%edi
add    %edi,%edx
add    $0xffffff7e,%edx
movswl %dx,%edi
imul   $0x4ec5,%edi,%edi
mov    %edi,%ebx
shr    $0x1f,%ebx
shr    $0x13,%edi
add    %ebx,%edi
lea    (%rdi,%rdi,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %edi,%ebx
sub    %ebx,%edx
add    $0x41,%dl
mov    %dl,(%rcx,%rsi,1)
movsbl 0x1(%rax,%rsi,1),%edx
movsbl 0x1(%r14,%rsi,1),%edi
add    %edi,%edx
add    $0xffffff7e,%edx
movswl %dx,%edi
imul   $0x4ec5,%edi,%edi
mov    %edi,%ebx
shr    $0x1f,%ebx
shr    $0x13,%edi
add    %ebx,%edi
lea    (%rdi,%rdi,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %edi,%ebx
sub    %ebx,%edx
add    $0x41,%dl
mov    %dl,0x1(%rcx,%rsi,1)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    13a0 <encrypt+0x280>
jmp    12f0 <encrypt+0x1d0>
cmp    $0x10,%r15
jae    1426 <encrypt+0x306>
xor    %edx,%edx
jmp    14f0 <encrypt+0x3d0>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu (%rax,%rsi,1),%xmm6
punpckhbw %xmm6,%xmm7
psraw  $0x8,%xmm7
punpcklbw %xmm6,%xmm5
psraw  $0x8,%xmm5
movdqu (%r14,%rsi,1),%xmm4
punpckhbw %xmm4,%xmm6
psraw  $0x8,%xmm6
paddw  %xmm7,%xmm6
punpcklbw %xmm4,%xmm7
psraw  $0x8,%xmm7
paddw  %xmm5,%xmm7
paddw  %xmm0,%xmm6
paddw  %xmm0,%xmm7
movdqa %xmm7,%xmm4
pmulhw %xmm1,%xmm4
movdqa %xmm4,%xmm5
psrlw  $0xf,%xmm5
psrlw  $0x3,%xmm4
paddw  %xmm5,%xmm4
pmullw %xmm2,%xmm4
psubw  %xmm4,%xmm7
movdqa %xmm6,%xmm4
pmulhw %xmm1,%xmm4
movdqa %xmm4,%xmm5
psrlw  $0xf,%xmm5
psrlw  $0x3,%xmm4
paddw  %xmm5,%xmm4
pmullw %xmm2,%xmm4
psubw  %xmm4,%xmm6
pand   %xmm3,%xmm6
pand   %xmm3,%xmm7
packuswb %xmm6,%xmm7
paddb  %xmm8,%xmm7
movdqu %xmm7,(%rcx,%rsi,1)
add    $0x10,%rsi
cmp    %rsi,%r10
jne    1430 <encrypt+0x310>
cmp    %r10,%r15
je     12f0 <encrypt+0x1d0>
mov    %r10,%rdx
mov    %r10,%rsi
test   $0x8,%r15b
je     1339 <encrypt+0x219>
nop
movq   (%rax,%rdx,1),%xmm4
punpcklbw %xmm4,%xmm4
psraw  $0x8,%xmm4
movq   (%r14,%rdx,1),%xmm5
punpcklbw %xmm5,%xmm5
psraw  $0x8,%xmm5
paddw  %xmm4,%xmm5
paddw  %xmm0,%xmm5
movdqa %xmm5,%xmm4
pmulhw %xmm1,%xmm4
movdqa %xmm4,%xmm6
psrlw  $0xf,%xmm6
psrlw  $0x3,%xmm4
paddw  %xmm6,%xmm4
pmullw %xmm2,%xmm4
psubw  %xmm4,%xmm5
pand   %xmm3,%xmm5
packuswb %xmm5,%xmm5
paddb  %xmm9,%xmm5
movq   %xmm5,(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r11
jne    14f0 <encrypt+0x3d0>
mov    %r11,%rsi
cmp    %r11,%r15
je     12f0 <encrypt+0x1d0>
jmp    1339 <encrypt+0x219>

LLVM IR (-O0):
define void @encrypt(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%16 = load i8*, i8** %5
%17 = call i64 @strlen(i8* %16)
store i64 %17, i64* %7
%18 = load i8*, i8** %4
%19 = call i64 @strlen(i8* %18)
store i64 %19, i64* %8
%20 = load i8*, i8** %4
%21 = call i64 @strlen(i8* %20)
%22 = load i8*, i8** %5
%23 = call i64 @strlen(i8* %22)
%24 = load i8*, i8** %4
%25 = call i64 @strlen(i8* %24)
%26 = load i8*, i8** %5
%27 = call i64 @strlen(i8* %26)
%28 = urem i64 %25, %27
%29 = sub i64 %23, %28
%30 = add i64 %21, %29
store i64 %30, i64* %9
%31 = load i64, i64* %9
%32 = call i8* @llvm.stacksave()
store i8* %32, i8** %10
%33 = alloca i8, i64 %31
store i64 %31, i64* %11
store i64 0, i64* %9
store i64 0, i64* %12
br label %34
34: ; preds = %55, %3
%35 = load i64, i64* %12
%36 = load i64, i64* %8
%37 = icmp ult i64 %35, %36
br i1 %37, label %38, label %58
38: ; preds = %34
%39 = load i8*, i8** %4
%40 = load i64, i64* %12
%41 = getelementptr inbounds i8, i8* %39, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = icmp eq i32 %43, 32
br i1 %44, label %45, label %46
45: ; preds = %38
br label %55
46: ; preds = %38
%47 = load i8*, i8** %4
%48 = load i64, i64* %12
%49 = getelementptr inbounds i8, i8* %47, i64 %48
%50 = load i8, i8* %49
%51 = call signext i8 @toupper(i8 signext %50)
%52 = load i64, i64* %9
%53 = add i64 %52, 1
store i64 %53, i64* %9
%54 = getelementptr inbounds i8, i8* %33, i64 %52
store i8 %51, i8* %54
br label %55
55: ; preds = %46, %45
%56 = load i64, i64* %12
%57 = add i64 %56, 1
store i64 %57, i64* %12
br label %34
58: ; preds = %34
%59 = load i64, i64* %9
%60 = load i64, i64* %7
%61 = urem i64 %59, %60
%62 = icmp ne i64 %61, 0
br i1 %62, label %63, label %80
63: ; preds = %58
store i64 0, i64* %13
br label %64
64: ; preds = %76, %63
%65 = load i64, i64* %13
%66 = load i64, i64* %7
%67 = load i64, i64* %9
%68 = load i64, i64* %7
%69 = urem i64 %67, %68
%70 = sub i64 %66, %69
%71 = icmp ult i64 %65, %70
br i1 %71, label %72, label %79
72: ; preds = %64
%73 = load i64, i64* %9
%74 = add i64 %73, 1
store i64 %74, i64* %9
%75 = getelementptr inbounds i8, i8* %33, i64 %73
store i8 81, i8* %75
br label %76
76: ; preds = %72
%77 = load i64, i64* %13
%78 = add i64 %77, 1
store i64 %78, i64* %13
br label %64
79: ; preds = %64
br label %80
80: ; preds = %79, %58
%81 = load i64, i64* %9
%82 = getelementptr inbounds i8, i8* %33, i64 %81
store i8 0, i8* %82
store i64 0, i64* %14
br label %83
83: ; preds = %125, %80
%84 = load i64, i64* %14
%85 = load i64, i64* %9
%86 = load i64, i64* %7
%87 = udiv i64 %85, %86
%88 = icmp ult i64 %84, %87
br i1 %88, label %89, label %128
89: ; preds = %83
store i64 0, i64* %15
br label %90
90: ; preds = %121, %89
%91 = load i64, i64* %15
%92 = load i64, i64* %7
%93 = icmp ult i64 %91, %92
br i1 %93, label %94, label %124
94: ; preds = %90
%95 = load i64, i64* %14
%96 = load i64, i64* %7
%97 = mul i64 %95, %96
%98 = load i64, i64* %15
%99 = add i64 %97, %98
%100 = getelementptr inbounds i8, i8* %33, i64 %99
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = sub nsw i32 %102, 65
%104 = load i8*, i8** %5
%105 = load i64, i64* %15
%106 = getelementptr inbounds i8, i8* %104, i64 %105
%107 = load i8, i8* %106
%108 = sext i8 %107 to i32
%109 = sub nsw i32 %108, 65
%110 = add nsw i32 %103, %109
%111 = srem i32 %110, 26
%112 = add nsw i32 %111, 65
%113 = trunc i32 %112 to i8
%114 = load i8*, i8** %6
%115 = load i64, i64* %14
%116 = load i64, i64* %7
%117 = mul i64 %115, %116
%118 = load i64, i64* %15
%119 = add i64 %117, %118
%120 = getelementptr inbounds i8, i8* %114, i64 %119
store i8 %113, i8* %120
br label %121
121: ; preds = %94
%122 = load i64, i64* %15
%123 = add i64 %122, 1
store i64 %123, i64* %15
br label %90
124: ; preds = %90
br label %125
125: ; preds = %124
%126 = load i64, i64* %14
%127 = add i64 %126, 1
store i64 %127, i64* %14
br label %83
128: ; preds = %83
%129 = load i8*, i8** %10
ret void
}

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