#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*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ strcat(char *, char *);
int strlen(char *);
char toupper(char);
void main(int argc, char *argv[]) {
  int i, j;
  int iLen;
  char szName[100];
  char c;
  if (argc != 2) {
    printf("Need to supply a name in quotes to encode\n");
    exit(0);
  }
  for (i = 0, j = 0; i < strlen(argv[1]); i += 2) {
    if (argv[1][i] != '\"' && argv[1][i] != ' ' && argv[1][i] != '\t') {
      szName[j++] = toupper(argv[1][i]);
    }
  }
  szName[j] = '\0';
  strcat(szName, "AQUA");
  iLen = strlen(szName);
  for (i = 0; i < iLen - 1; i += 2) {
    c = szName[i];
    szName[i] = (((szName[i + 1] - 'A' + 13) % 26) + 'A');
    szName[i + 1] = (((c - 'A' + 13) % 26) + 'A');
  }
  if (iLen & 1) {
    szName[iLen - 1] = (((szName[iLen - 1] - 'A' + 13) % 26) + 'A');
  }
  printf("ID=%s\n", szName);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x4(%rbp)
je     1181 <main+0x31>
lea    0xe8d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
xor    %edi,%edi
call   1070 <exit@plt>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x88(%rbp),%eax
cmp    %ecx,%eax
jge    123b <main+0xeb>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
je     1228 <main+0xd8>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1228 <main+0xd8>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
je     1228 <main+0xd8>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <toupper@plt>
mov    %al,%cl
mov    -0x18(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
cltq
mov    %cl,-0x80(%rbp,%rax,1)
jmp    122d <main+0xdd>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    118f <main+0x3f>
movslq -0x18(%rbp),%rax
movb   $0x0,-0x80(%rbp,%rax,1)
lea    -0x80(%rbp),%rdi
lea    0xddc(%rip),%rsi
call   1060 <strcat@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12e2 <main+0x192>
movslq -0x14(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%al
mov    %al,-0x81(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x80(%rbp,%rax,1),%eax
sub    $0x41,%eax
add    $0xd,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    %dl,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
movsbl -0x81(%rbp),%eax
sub    $0x41,%eax
add    $0xd,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    %dl,%cl
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1267 <main+0x117>
mov    -0x1c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     131d <main+0x1cd>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x80(%rbp,%rax,1),%eax
sub    $0x41,%eax
add    $0xd,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    %dl,%cl
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0x80(%rbp,%rax,1)
lea    -0x80(%rbp),%rsi
lea    0xd08(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x68,%rsp
cmp    $0x2,%edi
jne    1494 <main+0x334>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    11d9 <main+0x79>
xor    %ebp,%ebp
movabs $0x500000200,%r15
xor    %r14d,%r14d
jmp    11c3 <main+0x63>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl %al,%edi
call   1030 <toupper@plt>
movslq %r14d,%rcx
add    $0x1,%r14d
mov    %al,(%rsp,%rcx,1)
mov    0x8(%rbx),%rdi
add    $0x2,%rbp
call   1050 <strlen@plt>
cmp    %ebp,%eax
jle    11dc <main+0x7c>
mov    0x8(%rbx),%rdi
movzbl (%rdi,%rbp,1),%eax
cmp    $0x22,%rax
ja     11a0 <main+0x40>
bt     %rax,%r15
jb     11b6 <main+0x56>
jmp    11a0 <main+0x40>
xor    %r14d,%r14d
movslq %r14d,%rax
movb   $0x0,(%rsp,%rax,1)
lea    0xe66(%rip),%rsi
mov    %rsp,%rbx
mov    %rbx,%rdi
call   1070 <strcat@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
movslq %eax,%rcx
lea    -0x1(%rcx),%r8
cmp    $0x2,%ecx
jl     1447 <main+0x2e7>
mov    %r8d,%edx
cmp    $0x3,%rdx
mov    $0x2,%r9d
cmovae %rdx,%r9
add    $0xffffffffffffffff,%r9
cmp    $0xe,%r9
jae    122f <main+0xcf>
xor    %esi,%esi
jmp    13e0 <main+0x280>
shr    %r9
add    $0x1,%r9
movabs $0x7ffffffffffffff8,%rbx
ff ff 7f
and    %r9,%rbx
lea    (%rbx,%rbx,1),%rsi
xor    %ecx,%ecx
movdqa 0xdae(%rip),%xmm8
movdqa 0xdb6(%rip),%xmm1
movdqa 0xdbe(%rip),%xmm2
movdqa 0xdc6(%rip),%xmm3
movdqa 0xdce(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x3(%rsp,%rcx,2),%ebp
shl    $0x8,%ebp
movzbl 0x1(%rsp,%rcx,2),%edi
shl    $0x8,%edi
movd   %edi,%xmm5
pinsrw $0x1,%ebp,%xmm5
movzbl 0x5(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x2,%edi,%xmm5
movzbl 0x7(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x3,%edi,%xmm5
movzbl 0x9(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x4,%edi,%xmm5
movzbl 0xb(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x5,%edi,%xmm5
movzbl 0xd(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x6,%edi,%xmm5
movzbl 0xf(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x7,%edi,%xmm5
psraw  $0x8,%xmm5
paddw  %xmm8,%xmm5
movdqa %xmm5,%xmm6
pmulhw %xmm1,%xmm6
movdqa %xmm6,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x3,%xmm6
paddw  %xmm7,%xmm6
pmullw %xmm2,%xmm6
psubw  %xmm6,%xmm5
pand   %xmm3,%xmm5
packuswb %xmm5,%xmm5
movzbl 0x2(%rsp,%rcx,2),%edi
shl    $0x8,%edi
mov    (%rsp,%rcx,2),%ebp
shl    $0x8,%ebp
movd   %ebp,%xmm6
pinsrw $0x1,%edi,%xmm6
mov    0x4(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x2,%edi,%xmm6
movzbl 0x6(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x3,%edi,%xmm6
mov    0x8(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x4,%edi,%xmm6
movzbl 0xa(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x5,%edi,%xmm6
mov    0xc(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x6,%edi,%xmm6
movzbl 0xe(%rsp,%rcx,2),%edi
shl    $0x8,%edi
pinsrw $0x7,%edi,%xmm6
paddb  %xmm4,%xmm5
psraw  $0x8,%xmm6
paddw  %xmm8,%xmm6
movdqa %xmm6,%xmm7
pmulhw %xmm1,%xmm7
movdqa %xmm7,%xmm0
psrlw  $0xf,%xmm0
psrlw  $0x3,%xmm7
paddw  %xmm0,%xmm7
pmullw %xmm2,%xmm7
psubw  %xmm7,%xmm6
pand   %xmm3,%xmm6
packuswb %xmm6,%xmm6
paddb  %xmm4,%xmm6
punpcklbw %xmm6,%xmm5
movdqa %xmm5,(%rsp,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%rbx
jne    1280 <main+0x120>
cmp    %rbx,%r9
je     1447 <main+0x2e7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl (%rsp,%rsi,1),%ecx
movsbl 0x1(%rsp,%rsi,1),%edi
lea    -0x34(%rdi),%ebp
imul   $0x4ec5,%ebp,%ebp
mov    %ebp,%ebx
shr    $0x1f,%ebx
shr    $0x13,%ebp
add    %ebx,%ebp
lea    0x0(%rbp,%rbp,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %ebp,%ebx
neg    %ebx
add    %ebx,%edi
add    $0xffffffcc,%edi
add    $0x41,%dil
mov    %dil,(%rsp,%rsi,1)
lea    -0x34(%rcx),%edi
imul   $0x4ec5,%edi,%edi
mov    %edi,%ebp
shr    $0x1f,%ebp
shr    $0x13,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
neg    %ebp
add    %ebp,%ecx
add    $0xffffffcc,%ecx
add    $0x41,%cl
mov    %cl,0x1(%rsp,%rsi,1)
add    $0x2,%rsi
cmp    %rdx,%rsi
jb     13e0 <main+0x280>
test   $0x1,%al
je     1478 <main+0x318>
movsbl (%rsp,%r8,1),%eax
lea    -0x34(%rax),%ecx
imul   $0x4ec5,%ecx,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
shr    $0x13,%ecx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rdx,%rdx,4),%edx
add    %ecx,%edx
neg    %edx
add    %edx,%eax
add    $0xffffffcc,%eax
add    $0x41,%al
mov    %al,(%rsp,%r8,1)
lea    0xbd6(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xbc1(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@.str = [43 x i8] c"Need to supply a name in quotes to encode\0A\00"
@.str.1 = [5 x i8] c"AQUA\00"
@.str.2 = [7 x i8] c"ID=%s\0A\00"
define void @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca [100 x i8]
%9 = alloca i8
store i32 %0, i32* %3
store i8** %1, i8*** %4
%10 = load i32, i32* %3
%11 = icmp ne i32 %10, 2
br i1 %11, label %12, label %15
12: ; preds = %2
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str, i64 0, i64 0))
%14 = call i32 @exit(i32 0)
unreachable
15: ; preds = %2
store i32 0, i32* %5
store i32 0, i32* %6
br label %16
16: ; preds = %67, %15
%17 = load i32, i32* %5
%18 = load i8**, i8*** %4
%19 = getelementptr inbounds i8*, i8** %18, i64 1
%20 = load i8*, i8** %19
%21 = call i32 @strlen(i8* %20)
%22 = icmp slt i32 %17, %21
br i1 %22, label %23, label %70
23: ; preds = %16
%24 = load i8**, i8*** %4
%25 = getelementptr inbounds i8*, i8** %24, i64 1
%26 = load i8*, i8** %25
%27 = load i32, i32* %5
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
%32 = icmp ne i32 %31, 34
br i1 %32, label %33, label %66
33: ; preds = %23
%34 = load i8**, i8*** %4
%35 = getelementptr inbounds i8*, i8** %34, i64 1
%36 = load i8*, i8** %35
%37 = load i32, i32* %5
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp ne i32 %41, 32
br i1 %42, label %43, label %66
43: ; preds = %33
%44 = load i8**, i8*** %4
%45 = getelementptr inbounds i8*, i8** %44, i64 1
%46 = load i8*, i8** %45
%47 = load i32, i32* %5
%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 ne i32 %51, 9
br i1 %52, label %53, label %66
53: ; preds = %43
%54 = load i8**, i8*** %4
%55 = getelementptr inbounds i8*, i8** %54, i64 1
%56 = load i8*, i8** %55
%57 = load i32, i32* %5
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %56, i64 %58
%60 = load i8, i8* %59
%61 = call signext i8 @toupper(i8 signext %60)
%62 = load i32, i32* %6
%63 = add nsw i32 %62, 1
store i32 %63, i32* %6
%64 = sext i32 %62 to i64
%65 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %64
store i8 %61, i8* %65
br label %66
66: ; preds = %53, %43, %33, %23
br label %67
67: ; preds = %66
%68 = load i32, i32* %5
%69 = add nsw i32 %68, 2
store i32 %69, i32* %5
br label %16
70: ; preds = %16
%71 = load i32, i32* %6
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %72
store i8 0, i8* %73
%74 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 0
%75 = call i32 @strcat(i8* %74, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%76 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 0
%77 = call i32 @strlen(i8* %76)
store i32 %77, i32* %7
store i32 0, i32* %5
br label %78
78: ; preds = %113, %70
%79 = load i32, i32* %5
%80 = load i32, i32* %7
%81 = sub nsw i32 %80, 1
%82 = icmp slt i32 %79, %81
br i1 %82, label %83, label %116
83: ; preds = %78
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %85
%87 = load i8, i8* %86
store i8 %87, i8* %9
%88 = load i32, i32* %5
%89 = add nsw i32 %88, 1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = sub nsw i32 %93, 65
%95 = add nsw i32 %94, 13
%96 = srem i32 %95, 26
%97 = add nsw i32 %96, 65
%98 = trunc i32 %97 to i8
%99 = load i32, i32* %5
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %100
store i8 %98, i8* %101
%102 = load i8, i8* %9
%103 = sext i8 %102 to i32
%104 = sub nsw i32 %103, 65
%105 = add nsw i32 %104, 13
%106 = srem i32 %105, 26
%107 = add nsw i32 %106, 65
%108 = trunc i32 %107 to i8
%109 = load i32, i32* %5
%110 = add nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %111
store i8 %108, i8* %112
br label %113
113: ; preds = %83
%114 = load i32, i32* %5
%115 = add nsw i32 %114, 2
store i32 %115, i32* %5
br label %78
116: ; preds = %78
%117 = load i32, i32* %7
%118 = and i32 %117, 1
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %136
120: ; preds = %116
%121 = load i32, i32* %7
%122 = sub nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %123
%125 = load i8, i8* %124
%126 = sext i8 %125 to i32
%127 = sub nsw i32 %126, 65
%128 = add nsw i32 %127, 13
%129 = srem i32 %128, 26
%130 = add nsw i32 %129, 65
%131 = trunc i32 %130 to i8
%132 = load i32, i32* %7
%133 = sub nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 %134
store i8 %131, i8* %135
br label %136
136: ; preds = %120, %116
%137 = getelementptr inbounds [100 x i8], [100 x i8]* %8, i64 0, i64 0
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), i8* %137)
ret void
}

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