#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 strlen(char *);
void decrypt_caesar_cipher(char *string) {
  int i, size_str;
  size_str = strlen(string);
  for (i = 0; i < size_str; i++) {
    if (string[i] >= 97 && string[i] <= 122)
      string[i] = 97 + ((string[i] - 97 - 3) % 26 + 26) % 26;
    else if (string[i] >= 65 && string[i] <= 90)
      string[i] = 65 + ((string[i] - 65 - 3) % 26 + 26) % 26;
  }
}


x86 assembly (clang, -O0):
<decrypt_caesar_cipher>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1216 <decrypt_caesar_cipher+0x106>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     119f <decrypt_caesar_cipher+0x8f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     119f <decrypt_caesar_cipher+0x8f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
sub    $0x3,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x1a,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x61,%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1203 <decrypt_caesar_cipher+0xf3>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     11fe <decrypt_caesar_cipher+0xee>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     11fe <decrypt_caesar_cipher+0xee>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
sub    $0x3,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x1a,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1203 <decrypt_caesar_cipher+0xf3>
jmp    1208 <decrypt_caesar_cipher+0xf8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    112f <decrypt_caesar_cipher+0x1f>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decrypt_caesar_cipher>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
call   1030 <strlen@plt>
test   %eax,%eax
jle    1504 <decrypt_caesar_cipher+0x3f4>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    1133 <decrypt_caesar_cipher+0x23>
xor    %eax,%eax
jmp    155e <decrypt_caesar_cipher+0x44e>
mov    %r8d,%eax
and    $0xfffffff8,%eax
xor    %edx,%edx
movdqa 0xebc(%rip),%xmm8
movdqa 0xec4(%rip),%xmm1
pcmpeqd %xmm2,%xmm2
movdqa 0xec7(%rip),%xmm9
movdqa 0xece(%rip),%xmm10
movdqa 0xed5(%rip),%xmm11
movdqa 0xedc(%rip),%xmm12
movdqa 0xee4(%rip),%xmm7
jmp    118d <decrypt_caesar_cipher+0x7d>
xchg   %ax,%ax
add    $0x8,%rdx
cmp    %rdx,%rax
je     14ff <decrypt_caesar_cipher+0x3ef>
movq   (%r14,%rdx,1),%xmm3
movdqa %xmm3,%xmm0
paddb  %xmm8,%xmm0
movdqa %xmm0,%xmm4
pmaxub %xmm1,%xmm4
pcmpeqb %xmm0,%xmm4
movdqa %xmm3,%xmm5
paddb  %xmm9,%xmm5
movdqa %xmm5,%xmm6
pmaxub %xmm1,%xmm6
pcmpeqb %xmm5,%xmm6
movdqa %xmm6,%xmm5
pandn  %xmm4,%xmm6
pxor   %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
pxor   %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
por    %xmm4,%xmm5
movdqa %xmm6,%xmm0
pandn  %xmm10,%xmm0
movdqa %xmm6,%xmm4
pand   %xmm11,%xmm4
por    %xmm0,%xmm4
movdqa %xmm6,%xmm0
pandn  %xmm12,%xmm0
pand   %xmm7,%xmm6
por    %xmm0,%xmm6
psraw  $0x8,%xmm5
movd   %xmm5,%esi
test   $0x1,%sil
je     125b <decrypt_caesar_cipher+0x14b>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
movd   %xmm0,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%edi
movzwl %di,%ebx
shr    $0xb,%edi
shr    $0xf,%ebx
add    %dil,%bl
movzbl %bl,%edi
lea    (%rdi,%rdi,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %edi,%ebx
sub    %bl,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%edi
shr    $0xb,%edi
lea    (%rdi,%rdi,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %edi,%ebx
sub    %bl,%cl
movd   %xmm6,%edi
add    %cl,%dil
mov    %dil,(%r14,%rdx,1)
shr    $0x10,%esi
test   $0x1,%sil
je     12ba <decrypt_caesar_cipher+0x1aa>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
movd   %xmm0,%ecx
shr    $0x8,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
movd   %xmm6,%esi
shr    $0x8,%esi
add    %cl,%sil
mov    %sil,0x1(%r14,%rdx,1)
pextrw $0x2,%xmm5,%ecx
test   $0x1,%cl
je     131a <decrypt_caesar_cipher+0x20a>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
movd   %xmm0,%ecx
shr    $0x10,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
movd   %xmm6,%esi
shr    $0x10,%esi
add    %cl,%sil
mov    %sil,0x2(%r14,%rdx,1)
pextrw $0x3,%xmm5,%ecx
test   $0x1,%cl
je     137e <decrypt_caesar_cipher+0x26e>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
movd   %xmm0,%ecx
mov    %ecx,%esi
shr    $0x18,%esi
sar    $0x18,%ecx
imul   $0x4f,%ecx,%ecx
movzwl %cx,%edi
shr    $0xb,%ecx
shr    $0xf,%edi
add    %cl,%dil
movzbl %dil,%ecx
lea    (%rcx,%rcx,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %ecx,%edi
sub    %dil,%sil
add    $0x1a,%sil
movzbl %sil,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
movd   %xmm6,%esi
shr    $0x18,%esi
add    %cl,%sil
mov    %sil,0x3(%r14,%rdx,1)
pextrw $0x4,%xmm5,%ecx
test   $0x1,%cl
je     13da <decrypt_caesar_cipher+0x2ca>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
pextrw $0x2,%xmm0,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
pextrw $0x2,%xmm6,%esi
add    %cl,%sil
mov    %sil,0x4(%r14,%rdx,1)
pextrw $0x5,%xmm5,%ecx
test   $0x1,%cl
je     143c <decrypt_caesar_cipher+0x32c>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
pextrw $0x2,%xmm0,%ecx
shr    $0x8,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
pextrw $0x2,%xmm6,%esi
sub    %dil,%cl
shr    $0x8,%esi
add    %cl,%sil
mov    %sil,0x5(%r14,%rdx,1)
pextrw $0x6,%xmm5,%ecx
test   $0x1,%cl
je     1498 <decrypt_caesar_cipher+0x388>
movdqa %xmm4,%xmm0
paddb  %xmm3,%xmm0
pextrw $0x3,%xmm0,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
pextrw $0x3,%xmm6,%esi
add    %cl,%sil
mov    %sil,0x6(%r14,%rdx,1)
pextrw $0x7,%xmm5,%ecx
test   $0x1,%cl
je     1180 <decrypt_caesar_cipher+0x70>
paddb  %xmm3,%xmm4
pextrw $0x3,%xmm4,%ecx
shr    $0x8,%ecx
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
pextrw $0x3,%xmm6,%esi
sub    %dil,%cl
shr    $0x8,%esi
add    %cl,%sil
mov    %sil,0x7(%r14,%rdx,1)
jmp    1180 <decrypt_caesar_cipher+0x70>
cmp    %r8,%rax
jne    155e <decrypt_caesar_cipher+0x44e>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
nopl   0x0(%rax)
mov    $0x61,%dl
mov    $0x9c,%cl
add    %sil,%cl
movsbl %cl,%ecx
imul   $0x4f,%ecx,%esi
movzwl %si,%edi
shr    $0xb,%esi
shr    $0xf,%edi
add    %sil,%dil
movzbl %dil,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    $0x1a,%cl
movzbl %cl,%ecx
imul   $0x4f,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %esi,%edi
sub    %dil,%cl
add    %dl,%cl
mov    %cl,(%r14,%rax,1)
add    $0x1,%rax
cmp    %rax,%r8
je     1504 <decrypt_caesar_cipher+0x3f4>
movzbl (%r14,%rax,1),%esi
lea    -0x61(%rsi),%ecx
cmp    $0x1a,%cl
jb     1510 <decrypt_caesar_cipher+0x400>
lea    -0x41(%rsi),%ecx
cmp    $0x19,%cl
ja     1555 <decrypt_caesar_cipher+0x445>
mov    $0x41,%dl
mov    $0xbc,%cl
jmp    1514 <decrypt_caesar_cipher+0x404>

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

LLVM IR (-O2):
define void @decrypt_caesar_cipher(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = icmp sgt i32 %2, 0
br i1 %3, label %4, label %144
4: ; preds = %1
%5 = zext i32 %2 to i64
%6 = icmp ult i32 %2, 8
br i1 %6, label %122, label %7
7: ; preds = %4
%8 = and i64 %5, 4294967288
br label %9
9: ; preds = %117, %7
%10 = phi i64 [ 0, %7 ], [ %118, %117 ]
%11 = getelementptr inbounds i8, i8* %0, i64 %10
%12 = bitcast i8* %11 to <8 x i8>*
%13 = load <8 x i8>, <8 x i8>* %12
%14 = add <8 x i8> %13, <i8 -97, i8 -97, i8 -97, i8 -97, i8 -97, i8 -97, i8 -97, i8 -97>
%15 = icmp ult <8 x i8> %14, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%16 = add <8 x i8> %13, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%17 = icmp ult <8 x i8> %16, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%18 = xor <8 x i1> %15, <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
%19 = select <8 x i1> %18, <8 x i1> %17, <8 x i1> zeroinitializer
%20 = select <8 x i1> %19, <8 x i8> <i8 -68, i8 -68, i8 -68, i8 -68, i8 -68, i8 -68, i8 -68, i8 -68>, <8 x i8> <i8 -100, i8 -100, i8 -100, i8 -100, i8 -100, i8 -100, i8 -100, i8 -100>
%21 = select <8 x i1> %19, <8 x i8> <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>, <8 x i8> <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%22 = or <8 x i1> %19, %15
%23 = extractelement <8 x i1> %22, i64 0
br i1 %23, label %24, label %33
24: ; preds = %9
%25 = add <8 x i8> %20, %13
%26 = extractelement <8 x i8> %25, i64 0
%27 = srem i8 %26, 26
%28 = add nsw i8 %27, 26
%29 = urem i8 %28, 26
%30 = extractelement <8 x i8> %21, i64 0
%31 = add nuw nsw i8 %29, %30
%32 = getelementptr inbounds i8, i8* %0, i64 %10
store i8 %31, i8* %32
br label %33
33: ; preds = %24, %9
%34 = extractelement <8 x i1> %22, i64 1
br i1 %34, label %35, label %45
35: ; preds = %33
%36 = or i64 %10, 1
%37 = add <8 x i8> %20, %13
%38 = extractelement <8 x i8> %37, i64 1
%39 = srem i8 %38, 26
%40 = add nsw i8 %39, 26
%41 = urem i8 %40, 26
%42 = extractelement <8 x i8> %21, i64 1
%43 = add nuw nsw i8 %41, %42
%44 = getelementptr inbounds i8, i8* %0, i64 %36
store i8 %43, i8* %44
br label %45
45: ; preds = %35, %33
%46 = extractelement <8 x i1> %22, i64 2
br i1 %46, label %47, label %57
47: ; preds = %45
%48 = or i64 %10, 2
%49 = add <8 x i8> %20, %13
%50 = extractelement <8 x i8> %49, i64 2
%51 = srem i8 %50, 26
%52 = add nsw i8 %51, 26
%53 = urem i8 %52, 26
%54 = extractelement <8 x i8> %21, i64 2
%55 = add nuw nsw i8 %53, %54
%56 = getelementptr inbounds i8, i8* %0, i64 %48
store i8 %55, i8* %56
br label %57
57: ; preds = %47, %45
%58 = extractelement <8 x i1> %22, i64 3
br i1 %58, label %59, label %69
59: ; preds = %57
%60 = or i64 %10, 3
%61 = add <8 x i8> %20, %13
%62 = extractelement <8 x i8> %61, i64 3
%63 = srem i8 %62, 26
%64 = add nsw i8 %63, 26
%65 = urem i8 %64, 26
%66 = extractelement <8 x i8> %21, i64 3
%67 = add nuw nsw i8 %65, %66
%68 = getelementptr inbounds i8, i8* %0, i64 %60
store i8 %67, i8* %68
br label %69
69: ; preds = %59, %57
%70 = extractelement <8 x i1> %22, i64 4
br i1 %70, label %71, label %81
71: ; preds = %69
%72 = or i64 %10, 4
%73 = add <8 x i8> %20, %13
%74 = extractelement <8 x i8> %73, i64 4
%75 = srem i8 %74, 26
%76 = add nsw i8 %75, 26
%77 = urem i8 %76, 26
%78 = extractelement <8 x i8> %21, i64 4
%79 = add nuw nsw i8 %77, %78
%80 = getelementptr inbounds i8, i8* %0, i64 %72
store i8 %79, i8* %80
br label %81
81: ; preds = %71, %69
%82 = extractelement <8 x i1> %22, i64 5
br i1 %82, label %83, label %93
83: ; preds = %81
%84 = or i64 %10, 5
%85 = add <8 x i8> %20, %13
%86 = extractelement <8 x i8> %85, i64 5
%87 = srem i8 %86, 26
%88 = add nsw i8 %87, 26
%89 = urem i8 %88, 26
%90 = extractelement <8 x i8> %21, i64 5
%91 = add nuw nsw i8 %89, %90
%92 = getelementptr inbounds i8, i8* %0, i64 %84
store i8 %91, i8* %92
br label %93
93: ; preds = %83, %81
%94 = extractelement <8 x i1> %22, i64 6
br i1 %94, label %95, label %105
95: ; preds = %93
%96 = or i64 %10, 6
%97 = add <8 x i8> %20, %13
%98 = extractelement <8 x i8> %97, i64 6
%99 = srem i8 %98, 26
%100 = add nsw i8 %99, 26
%101 = urem i8 %100, 26
%102 = extractelement <8 x i8> %21, i64 6
%103 = add nuw nsw i8 %101, %102
%104 = getelementptr inbounds i8, i8* %0, i64 %96
store i8 %103, i8* %104
br label %105
105: ; preds = %95, %93
%106 = extractelement <8 x i1> %22, i64 7
br i1 %106, label %107, label %117
107: ; preds = %105
%108 = or i64 %10, 7
%109 = add <8 x i8> %20, %13
%110 = extractelement <8 x i8> %109, i64 7
%111 = srem i8 %110, 26
%112 = add nsw i8 %111, 26
%113 = urem i8 %112, 26
%114 = extractelement <8 x i8> %21, i64 7
%115 = add nuw nsw i8 %113, %114
%116 = getelementptr inbounds i8, i8* %0, i64 %108
store i8 %115, i8* %116
br label %117
117: ; preds = %107, %105
%118 = add nuw i64 %10, 8
%119 = icmp eq i64 %118, %8
br i1 %119, label %120, label %9
120: ; preds = %117
%121 = icmp eq i64 %8, %5
br i1 %121, label %144, label %122
122: ; preds = %4, %120
%123 = phi i64 [ 0, %4 ], [ %8, %120 ]
br label %124
124: ; preds = %122, %141
%125 = phi i64 [ %142, %141 ], [ %123, %122 ]
%126 = getelementptr inbounds i8, i8* %0, i64 %125
%127 = load i8, i8* %126
%128 = add i8 %127, -97
%129 = icmp ult i8 %128, 26
br i1 %129, label %133, label %130
130: ; preds = %124
%131 = add i8 %127, -65
%132 = icmp ult i8 %131, 26
br i1 %132, label %133, label %141
133: ; preds = %130, %124
%134 = phi i8 [ -100, %124 ], [ -68, %130 ]
%135 = phi i8 [ 97, %124 ], [ 65, %130 ]
%136 = add i8 %134, %127
%137 = srem i8 %136, 26
%138 = add nsw i8 %137, 26
%139 = urem i8 %138, 26
%140 = add nuw nsw i8 %139, %135
store i8 %140, i8* %126
br label %141
141: ; preds = %133, %130
%142 = add nuw nsw i64 %125, 1
%143 = icmp eq i64 %142, %5
br i1 %143, label %144, label %124
144: ; preds = %141, %120, %1
ret void
}