#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 atoi(char *);
int /*<<< orphan*/ puts(char *);
int main(int argc, char **argv) {
  *(long *)&*argv = 0;
s:
  switch (*(*(argv + 2) + (*((short *)&*argv + 2))++)) {
  case 0:
    puts(*(argv + 2));
    break;
  default:
    *((short *)&*argv + 1) = *((short *)&*argv + 2) - 1;
    ((*(*(argv + 2) + (*((short *)&*argv + 1))) > 64 &&
      *(*(argv + 2) + (*((short *)&*argv + 1))) < 91) ||
     (*(*(argv + 2) + (*((short *)&*argv + 1))) > 96 &&
      *(*(argv + 2) + (*((short *)&*argv + 1))) < 123))
        ? ((((*((short *)&*argv)) =
                 *(*(argv + 2) + (*((short *)&*argv + 1))) > 96)
                ? *(*(argv + 2) + (*((short *)&*argv + 1))) -= 32
                : 0) |
           ((*(*(argv + 2) + (*((short *)&*argv + 1))) +=
             (atoi(argv[1]) % 26) - 65) > 25
                ? *(*(argv + 2) + (*((short *)&*argv + 1))) += 6
                : 0) |
           (*(*(argv + 2) + (*((short *)&*argv + 1))) += 65) |
           ((*((short *)&*argv))
                ? (*(*(argv + 2) + (*((short *)&*argv + 1))) < 91)
                      ? *(*(argv + 2) + (*((short *)&*argv + 1))) += 32
                      : ((*(*(argv + 2) + (*((short *)&*argv + 1))) > 96)
                             ? *(*(argv + 2) + (*((short *)&*argv + 1))) -= 32
                             : 0)
                : 0))
        : 0;
    goto s;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rax
movswq 0x4(%rdx),%rcx
mov    %ecx,%esi
add    $0x1,%esi
mov    %si,0x4(%rdx)
mov    (%rax,%rcx,1),%al
test   %al,%al
jne    1179 <main+0x59>
jmp    1167 <main+0x47>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1030 <puts@plt>
jmp    13f7 <main+0x2d7>
mov    -0x10(%rbp),%rax
movswl 0x4(%rax),%eax
sub    $0x1,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %cx,0x2(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x40,%eax
jle    11cf <main+0xaf>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5b,%eax
jl     120f <main+0xef>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x60,%eax
jle    13ed <main+0x2cd>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7b,%eax
jge    13ed <main+0x2cd>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x60,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    -0x10(%rbp),%rcx
mov    %ax,(%rcx)
cwtl
cmp    $0x0,%eax
je     126a <main+0x14a>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movswl 0x2(%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
sub    $0x20,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
mov    %eax,-0x14(%rbp)
jmp    1274 <main+0x154>
xor    %eax,%eax
mov    %eax,-0x14(%rbp)
jmp    1274 <main+0x154>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atoi@plt>
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
sub    $0x41,%esi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movswl 0x2(%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
add    %esi,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
cmp    $0x19,%eax
jle    12e4 <main+0x1c4>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movswl 0x2(%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
add    $0x6,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ee <main+0x1ce>
xor    %eax,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ee <main+0x1ce>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rdx
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rsi
movsbl (%rdx,%rsi,1),%ecx
add    $0x41,%ecx
mov    %cl,(%rdx,%rsi,1)
movsbl %cl,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movswl (%rax),%eax
cmp    $0x0,%eax
je     13d6 <main+0x2b6>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5b,%eax
jge    1373 <main+0x253>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movswl 0x2(%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
add    $0x20,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
mov    %eax,-0x24(%rbp)
jmp    13cb <main+0x2ab>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movswl 0x2(%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x60,%eax
jle    13bb <main+0x29b>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movswl 0x2(%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
sub    $0x20,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
mov    %eax,-0x28(%rbp)
jmp    13c5 <main+0x2a5>
xor    %eax,%eax
mov    %eax,-0x28(%rbp)
jmp    13c5 <main+0x2a5>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    13e0 <main+0x2c0>
xor    %eax,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e0 <main+0x2c0>
mov    -0x20(%rbp),%eax
mov    -0x2c(%rbp),%ecx
or     %ecx,%eax
jmp    13f2 <main+0x2d2>
jmp    13f2 <main+0x2d2>
jmp    1141 <main+0x21>
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
movabs $0x100000000,%rax
mov    %rax,(%rsi)
mov    0x10(%rsi),%r14
cmpb   $0x0,(%r14)
je     1232 <main+0x112>
mov    %rsi,%r15
xor    %ebx,%ebx
mov    %r14,%rax
jmp    1175 <main+0x55>
nopw   0x0(%rax,%rax,1)
add    %bl,%dl
mov    %dl,(%rax,%rcx,1)
mov    0x10(%r15),%r14
movswq 0x4(%r15),%rbx
lea    0x1(%rbx),%eax
mov    %ax,0x4(%r15)
lea    (%r14,%rbx,1),%rax
cmpb   $0x0,(%r14,%rbx,1)
je     1232 <main+0x112>
mov    %bx,0x2(%r15)
movzbl (%rax),%ecx
lea    -0x41(%rcx),%edx
cmp    $0x1a,%dl
jae    1190 <main+0x70>
movw   $0x0,(%r15)
jmp    11aa <main+0x8a>
nopl   (%rax)
add    $0x9f,%cl
cmp    $0x1a,%cl
jae    1155 <main+0x35>
movw   $0x1,(%r15)
addb   $0xe0,(%rax)
mov    0x10(%r15),%r14
movzwl 0x2(%r15),%ebx
mov    0x8(%r15),%rdi
call   1040 <atoi@plt>
cltq
imul   $0x4ec4ec4f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x23,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rdx,%rdx,4),%edx
add    %ecx,%edx
sub    %edx,%eax
movswq %bx,%rcx
add    (%r14,%rcx,1),%al
add    $0xbf,%al
mov    %al,(%r14,%rcx,1)
cmp    $0x1a,%al
jl     11f2 <main+0xd2>
mov    0x10(%r15),%rax
movswq 0x2(%r15),%rcx
addb   $0x6,(%rax,%rcx,1)
mov    0x10(%r15),%rax
movswq 0x2(%r15),%rcx
addb   $0x41,(%rax,%rcx,1)
cmpw   $0x0,(%r15)
je     1155 <main+0x35>
mov    0x10(%r15),%rax
movswq 0x2(%r15),%rcx
movzbl (%rax,%rcx,1),%edx
mov    $0x20,%bl
cmp    $0x5b,%dl
jl     1150 <main+0x30>
mov    $0xe0,%bl
cmp    $0x61,%dl
jae    1150 <main+0x30>
jmp    1155 <main+0x35>
mov    %r14,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%6 = load i8**, i8*** %5
%7 = bitcast i8** %6 to i64*
store i64 0, i64* %7
br label %8
8: ; preds = %265, %2
%9 = load i8**, i8*** %5
%10 = getelementptr inbounds i8*, i8** %9, i64 2
%11 = load i8*, i8** %10
%12 = load i8**, i8*** %5
%13 = bitcast i8** %12 to i16*
%14 = getelementptr inbounds i16, i16* %13, i64 2
%15 = load i16, i16* %14
%16 = add i16 %15, 1
store i16 %16, i16* %14
%17 = sext i16 %15 to i32
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i8, i8* %11, i64 %18
%20 = load i8, i8* %19
%21 = sext i8 %20 to i32
switch i32 %21, label %27 [
i32 0, label %22
]
22: ; preds = %8
%23 = load i8**, i8*** %5
%24 = getelementptr inbounds i8*, i8** %23, i64 2
%25 = load i8*, i8** %24
%26 = call i32 @puts(i8* %25)
br label %267
27: ; preds = %8
%28 = load i8**, i8*** %5
%29 = bitcast i8** %28 to i16*
%30 = getelementptr inbounds i16, i16* %29, i64 2
%31 = load i16, i16* %30
%32 = sext i16 %31 to i32
%33 = sub nsw i32 %32, 1
%34 = trunc i32 %33 to i16
%35 = load i8**, i8*** %5
%36 = bitcast i8** %35 to i16*
%37 = getelementptr inbounds i16, i16* %36, i64 1
store i16 %34, i16* %37
%38 = load i8**, i8*** %5
%39 = getelementptr inbounds i8*, i8** %38, i64 2
%40 = load i8*, i8** %39
%41 = load i8**, i8*** %5
%42 = bitcast i8** %41 to i16*
%43 = getelementptr inbounds i16, i16* %42, i64 1
%44 = load i16, i16* %43
%45 = sext i16 %44 to i32
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %40, i64 %46
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp sgt i32 %49, 64
br i1 %50, label %51, label %65
51: ; preds = %27
%52 = load i8**, i8*** %5
%53 = getelementptr inbounds i8*, i8** %52, i64 2
%54 = load i8*, i8** %53
%55 = load i8**, i8*** %5
%56 = bitcast i8** %55 to i16*
%57 = getelementptr inbounds i16, i16* %56, i64 1
%58 = load i16, i16* %57
%59 = sext i16 %58 to i32
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %54, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = icmp slt i32 %63, 91
br i1 %64, label %93, label %65
65: ; preds = %51, %27
%66 = load i8**, i8*** %5
%67 = getelementptr inbounds i8*, i8** %66, i64 2
%68 = load i8*, i8** %67
%69 = load i8**, i8*** %5
%70 = bitcast i8** %69 to i16*
%71 = getelementptr inbounds i16, i16* %70, i64 1
%72 = load i16, i16* %71
%73 = sext i16 %72 to i32
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %68, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = icmp sgt i32 %77, 96
br i1 %78, label %79, label %264
79: ; preds = %65
%80 = load i8**, i8*** %5
%81 = getelementptr inbounds i8*, i8** %80, i64 2
%82 = load i8*, i8** %81
%83 = load i8**, i8*** %5
%84 = bitcast i8** %83 to i16*
%85 = getelementptr inbounds i16, i16* %84, i64 1
%86 = load i16, i16* %85
%87 = sext i16 %86 to i32
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %82, i64 %88
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
%92 = icmp slt i32 %91, 123
br i1 %92, label %93, label %264
93: ; preds = %79, %51
%94 = load i8**, i8*** %5
%95 = getelementptr inbounds i8*, i8** %94, i64 2
%96 = load i8*, i8** %95
%97 = load i8**, i8*** %5
%98 = bitcast i8** %97 to i16*
%99 = getelementptr inbounds i16, i16* %98, i64 1
%100 = load i16, i16* %99
%101 = sext i16 %100 to i32
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %96, i64 %102
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = icmp sgt i32 %105, 96
%107 = zext i1 %106 to i32
%108 = trunc i32 %107 to i16
%109 = load i8**, i8*** %5
%110 = bitcast i8** %109 to i16*
store i16 %108, i16* %110
%111 = sext i16 %108 to i32
%112 = icmp ne i32 %111, 0
br i1 %112, label %113, label %129
113: ; preds = %93
%114 = load i8**, i8*** %5
%115 = getelementptr inbounds i8*, i8** %114, i64 2
%116 = load i8*, i8** %115
%117 = load i8**, i8*** %5
%118 = bitcast i8** %117 to i16*
%119 = getelementptr inbounds i16, i16* %118, i64 1
%120 = load i16, i16* %119
%121 = sext i16 %120 to i32
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %116, i64 %122
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = sub nsw i32 %125, 32
%127 = trunc i32 %126 to i8
store i8 %127, i8* %123
%128 = sext i8 %127 to i32
br label %130
129: ; preds = %93
br label %130
130: ; preds = %129, %113
%131 = phi i32 [ %128, %113 ], [ 0, %129 ]
%132 = load i8**, i8*** %5
%133 = getelementptr inbounds i8*, i8** %132, i64 1
%134 = load i8*, i8** %133
%135 = call i32 @atoi(i8* %134)
%136 = srem i32 %135, 26
%137 = sub nsw i32 %136, 65
%138 = load i8**, i8*** %5
%139 = getelementptr inbounds i8*, i8** %138, i64 2
%140 = load i8*, i8** %139
%141 = load i8**, i8*** %5
%142 = bitcast i8** %141 to i16*
%143 = getelementptr inbounds i16, i16* %142, i64 1
%144 = load i16, i16* %143
%145 = sext i16 %144 to i32
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %140, i64 %146
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = add nsw i32 %149, %137
%151 = trunc i32 %150 to i8
store i8 %151, i8* %147
%152 = sext i8 %151 to i32
%153 = icmp sgt i32 %152, 25
br i1 %153, label %154, label %170
154: ; preds = %130
%155 = load i8**, i8*** %5
%156 = getelementptr inbounds i8*, i8** %155, i64 2
%157 = load i8*, i8** %156
%158 = load i8**, i8*** %5
%159 = bitcast i8** %158 to i16*
%160 = getelementptr inbounds i16, i16* %159, i64 1
%161 = load i16, i16* %160
%162 = sext i16 %161 to i32
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %157, i64 %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = add nsw i32 %166, 6
%168 = trunc i32 %167 to i8
store i8 %168, i8* %164
%169 = sext i8 %168 to i32
br label %171
170: ; preds = %130
br label %171
171: ; preds = %170, %154
%172 = phi i32 [ %169, %154 ], [ 0, %170 ]
%173 = or i32 %131, %172
%174 = load i8**, i8*** %5
%175 = getelementptr inbounds i8*, i8** %174, i64 2
%176 = load i8*, i8** %175
%177 = load i8**, i8*** %5
%178 = bitcast i8** %177 to i16*
%179 = getelementptr inbounds i16, i16* %178, i64 1
%180 = load i16, i16* %179
%181 = sext i16 %180 to i32
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %176, i64 %182
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = add nsw i32 %185, 65
%187 = trunc i32 %186 to i8
store i8 %187, i8* %183
%188 = sext i8 %187 to i32
%189 = or i32 %173, %188
%190 = load i8**, i8*** %5
%191 = bitcast i8** %190 to i16*
%192 = load i16, i16* %191
%193 = sext i16 %192 to i32
%194 = icmp ne i32 %193, 0
br i1 %194, label %195, label %260
195: ; preds = %171
%196 = load i8**, i8*** %5
%197 = getelementptr inbounds i8*, i8** %196, i64 2
%198 = load i8*, i8** %197
%199 = load i8**, i8*** %5
%200 = bitcast i8** %199 to i16*
%201 = getelementptr inbounds i16, i16* %200, i64 1
%202 = load i16, i16* %201
%203 = sext i16 %202 to i32
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %198, i64 %204
%206 = load i8, i8* %205
%207 = sext i8 %206 to i32
%208 = icmp slt i32 %207, 91
br i1 %208, label %209, label %225
209: ; preds = %195
%210 = load i8**, i8*** %5
%211 = getelementptr inbounds i8*, i8** %210, i64 2
%212 = load i8*, i8** %211
%213 = load i8**, i8*** %5
%214 = bitcast i8** %213 to i16*
%215 = getelementptr inbounds i16, i16* %214, i64 1
%216 = load i16, i16* %215
%217 = sext i16 %216 to i32
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i8, i8* %212, i64 %218
%220 = load i8, i8* %219
%221 = sext i8 %220 to i32
%222 = add nsw i32 %221, 32
%223 = trunc i32 %222 to i8
store i8 %223, i8* %219
%224 = sext i8 %223 to i32
br label %258
225: ; preds = %195
%226 = load i8**, i8*** %5
%227 = getelementptr inbounds i8*, i8** %226, i64 2
%228 = load i8*, i8** %227
%229 = load i8**, i8*** %5
%230 = bitcast i8** %229 to i16*
%231 = getelementptr inbounds i16, i16* %230, i64 1
%232 = load i16, i16* %231
%233 = sext i16 %232 to i32
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i8, i8* %228, i64 %234
%236 = load i8, i8* %235
%237 = sext i8 %236 to i32
%238 = icmp sgt i32 %237, 96
br i1 %238, label %239, label %255
239: ; preds = %225
%240 = load i8**, i8*** %5
%241 = getelementptr inbounds i8*, i8** %240, i64 2
%242 = load i8*, i8** %241
%243 = load i8**, i8*** %5
%244 = bitcast i8** %243 to i16*
%245 = getelementptr inbounds i16, i16* %244, i64 1
%246 = load i16, i16* %245
%247 = sext i16 %246 to i32
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %242, i64 %248
%250 = load i8, i8* %249
%251 = sext i8 %250 to i32
%252 = sub nsw i32 %251, 32
%253 = trunc i32 %252 to i8
store i8 %253, i8* %249
%254 = sext i8 %253 to i32
br label %256
255: ; preds = %225
br label %256
256: ; preds = %255, %239
%257 = phi i32 [ %254, %239 ], [ 0, %255 ]
br label %258
258: ; preds = %256, %209
%259 = phi i32 [ %224, %209 ], [ %257, %256 ]
br label %261
260: ; preds = %171
br label %261
261: ; preds = %260, %258
%262 = phi i32 [ %259, %258 ], [ 0, %260 ]
%263 = or i32 %189, %262
br label %265
264: ; preds = %79, %65
br label %265
265: ; preds = %264, %261
%266 = phi i32 [ %263, %261 ], [ 0, %264 ]
br label %8
267: ; preds = %22
%268 = load i32, i32* %3
ret i32 %268
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = bitcast i8** %1 to i64*
store i64 4294967296, i64* %3
%4 = getelementptr inbounds i8*, i8** %1, i64 2
%5 = bitcast i8** %1 to i16*
%6 = getelementptr inbounds i16, i16* %5, i64 2
%7 = load i8*, i8** %4
%8 = load i8, i8* %7
%9 = icmp eq i8 %8, 0
br i1 %9, label %13, label %10
10: ; preds = %2
%11 = getelementptr inbounds i16, i16* %5, i64 1
%12 = getelementptr inbounds i8*, i8** %1, i64 1
br label %16
13: ; preds = %73, %2
%14 = phi i8* [ %7, %2 ], [ %74, %73 ]
%15 = tail call i32 @puts(i8* dereferenceable(1) %14)
ret i32 0
16: ; preds = %10, %73
%17 = phi i8* [ %7, %10 ], [ %74, %73 ]
%18 = phi i8* [ %7, %10 ], [ %78, %73 ]
%19 = phi i16 [ 0, %10 ], [ %75, %73 ]
store i16 %19, i16* %11
%20 = load i8, i8* %18
%21 = add i8 %20, -65
%22 = icmp ult i8 %21, 26
br i1 %22, label %26, label %23
23: ; preds = %16
%24 = add i8 %20, -97
%25 = icmp ult i8 %24, 26
br i1 %25, label %27, label %73
26: ; preds = %16
store i16 0, i16* %5
br label %32
27: ; preds = %23
store i16 1, i16* %5
%28 = load i8, i8* %18
%29 = add i8 %28, -32
store i8 %29, i8* %18
%30 = load i8*, i8** %4
%31 = load i16, i16* %11
br label %32
32: ; preds = %26, %27
%33 = phi i16 [ %19, %26 ], [ %31, %27 ]
%34 = phi i8* [ %17, %26 ], [ %30, %27 ]
%35 = load i8*, i8** %12
%36 = tail call i32 @atoi(i8* %35)
%37 = srem i32 %36, 26
%38 = sext i16 %33 to i64
%39 = getelementptr inbounds i8, i8* %34, i64 %38
%40 = load i8, i8* %39
%41 = trunc i32 %37 to i8
%42 = add nsw i8 %41, -65
%43 = add i8 %42, %40
store i8 %43, i8* %39
%44 = icmp sgt i8 %43, 25
br i1 %44, label %45, label %52
45: ; preds = %32
%46 = load i8*, i8** %4
%47 = load i16, i16* %11
%48 = sext i16 %47 to i64
%49 = getelementptr inbounds i8, i8* %46, i64 %48
%50 = load i8, i8* %49
%51 = add i8 %50, 6
store i8 %51, i8* %49
br label %52
52: ; preds = %32, %45
%53 = load i8*, i8** %4
%54 = load i16, i16* %11
%55 = sext i16 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
%57 = load i8, i8* %56
%58 = add i8 %57, 65
store i8 %58, i8* %56
%59 = load i16, i16* %5
%60 = icmp eq i16 %59, 0
br i1 %60, label %73, label %61
61: ; preds = %52
%62 = load i8*, i8** %4
%63 = load i16, i16* %11
%64 = sext i16 %63 to i64
%65 = getelementptr inbounds i8, i8* %62, i64 %64
%66 = load i8, i8* %65
%67 = icmp slt i8 %66, 91
br i1 %67, label %70, label %68
68: ; preds = %61
%69 = icmp ugt i8 %66, 96
br i1 %69, label %70, label %73
70: ; preds = %68, %61
%71 = phi i8 [ 32, %61 ], [ -32, %68 ]
%72 = add nsw i8 %66, %71
store i8 %72, i8* %65
br label %73
73: ; preds = %70, %68, %52, %23
%74 = load i8*, i8** %4
%75 = load i16, i16* %6
%76 = add i16 %75, 1
store i16 %76, i16* %6
%77 = sext i16 %75 to i64
%78 = getelementptr inbounds i8, i8* %74, i64 %77
%79 = load i8, i8* %78
%80 = icmp eq i8 %79, 0
br i1 %80, label %13, label %16
}