#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 main(int argc, char **argv) {
  *(long *)&*argv = 0;
  while (*(*(argv + 1) + (*((char *)&*argv + 3))++))
    ;
  (*((char *)&*argv + 3))--;
  while (*(*(argv + 2) + (*((char *)&*argv + 4))++))
    ;
  (*((char *)&*argv + 4))--;
s:
  ((*(*(argv + 2) + (*((char *)&*argv))) > 64 &
    *(*(argv + 2) + (*((char *)&*argv))) < 91) |
   (*(*(argv + 2) + (*((char *)&*argv))) > 96 &
    *(*(argv + 2) + (*((char *)&*argv))) < 123))
      ? *(*(argv + 2) + (*((char *)&*argv))) =
            (((((*(*(argv + 2) + (*((char *)&*argv)))) -=
                (*(*(argv + 2) + (*((char *)&*argv))) > 96) ? 32 : 0) -
               65 +
               ((*(*(argv + 1) +
                   ((*((char *)&*argv + 1)) % *((char *)&*argv + 3)))) -=
                ((*(*(argv + 1) + ((*((char *)&*argv + 1)) %
                                   (unsigned)*((char *)&*argv + 3)))) > 96)
                    ? 32
                    : 0) -
               65) %
              26) +
             65)
      : (*((char *)&*argv + 1))--;
  (*((char *)&*argv))++;
  (*((char *)&*argv + 1))++;
  if ((*((char *)&*argv)) < (unsigned)*((char *)&*argv + 4))
    goto s;
  printf("%s\n", *(argv + 2));
}


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),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rdx
mov    0x3(%rdx),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,0x3(%rdx)
movsbl %cl,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1160 <main+0x50>
jmp    1131 <main+0x21>
mov    -0x10(%rbp),%rax
mov    0x3(%rax),%cl
add    $0xff,%cl
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rdx
mov    0x4(%rdx),%cl
mov    %cl,%sil
add    $0x1,%sil
mov    %sil,0x4(%rdx)
movsbl %cl,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     119c <main+0x8c>
jmp    116d <main+0x5d>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%cl
add    $0xff,%cl
mov    %cl,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x40,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x10(%rbp),%rdx
movsbl (%rdx),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    $0x5b,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x10(%rbp),%rdx
movsbl (%rdx),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    $0x60,%ecx
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
mov    -0x10(%rbp),%rsi
movsbl (%rsi),%esi
movslq %esi,%rsi
movsbl (%rdx,%rsi,1),%edx
cmp    $0x7b,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%edx
and    %edx,%ecx
or     %ecx,%eax
cmp    $0x0,%eax
je     1323 <main+0x213>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %esi,%esi
mov    $0x20,%eax
cmp    $0x60,%ecx
cmovg  %eax,%esi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movslq %eax,%rdx
movsbl (%rcx,%rdx,1),%eax
sub    %esi,%eax
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
sub    $0x41,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x3(%rcx),%ecx
xor    %edx,%edx
div    %ecx
mov    -0x28(%rbp),%rax
mov    %edx,%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %edi,%edi
mov    $0x20,%eax
cmp    $0x60,%ecx
cmovg  %eax,%edi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x3(%rcx),%ecx
cltd
idiv   %ecx
mov    -0x1c(%rbp),%eax
mov    %edx,%ecx
mov    -0x18(%rbp),%rdx
movslq %ecx,%rsi
movsbl (%rdx,%rsi,1),%ecx
sub    %edi,%ecx
mov    %cl,(%rdx,%rsi,1)
movsbl %cl,%ecx
add    %ecx,%eax
sub    $0x41,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x41,%edx
mov    %dl,%al
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
mov    -0x10(%rbp),%rdx
movsbl (%rdx),%edx
movslq %edx,%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
jmp    1335 <main+0x225>
mov    -0x10(%rbp),%rcx
mov    0x1(%rcx),%al
mov    %al,%dl
add    $0xff,%dl
mov    %dl,0x1(%rcx)
movsbl %al,%eax
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%cl
add    $0x1,%cl
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x4(%rcx),%ecx
cmp    %ecx,%eax
jae    1369 <main+0x259>
jmp    11a9 <main+0x99>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rsi
lea    0xc88(%rip),%rdi
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
movq   $0x0,(%rsi)
mov    0x8(%rsi),%rax
mov    $0xff,%cl
xchg   %ax,%ax
mov    %ecx,%edx
lea    0x1(%rdx),%ecx
add    $0x2,%dl
mov    %dl,0x3(%rsi)
movsbq %cl,%rdx
cmpb   $0x0,(%rax,%rdx,1)
jne    1120 <main+0x10>
mov    %cl,0x3(%rsi)
mov    0x10(%rsi),%r9
mov    $0xff,%r10b
nop
mov    %r10d,%eax
lea    0x1(%rax),%r10d
add    $0x2,%al
mov    %al,0x4(%rsi)
movsbq %r10b,%rax
cmpb   $0x0,(%r9,%rax,1)
jne    1140 <main+0x30>
mov    %r10b,0x4(%rsi)
xor    %edx,%edx
xor    %edi,%edi
jmp    118d <main+0x7d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xff,%dl
add    $0x1,%dil
mov    %dil,(%rsi)
add    $0x1,%dl
mov    %dl,0x1(%rsi)
mov    0x10(%rsi),%r9
cmp    %r10b,%dil
jae    1237 <main+0x127>
movsbq %dil,%r8
movzbl (%r9,%r8,1),%ecx
mov    %ecx,%eax
and    $0xdf,%al
add    $0xbf,%al
cmp    $0x19,%al
ja     1170 <main+0x60>
cmp    $0x61,%cl
setl   %al
shl    $0x5,%al
add    %cl,%al
add    $0xe0,%al
mov    %al,(%r9,%r8,1)
movsbl %al,%r8d
mov    0x8(%rsi),%r10
movsbl 0x1(%rsi),%eax
movswl %ax,%edi
movsbl 0x3(%rsi),%eax
movswl %ax,%r9d
mov    %edi,%eax
xor    %edx,%edx
div    %r9d
cmpb   $0x61,(%r10,%rdx,1)
setl   %cl
shl    $0x5,%cl
mov    %edi,%eax
cwtd
idiv   %r9w
movswq %dx,%rax
add    (%r10,%rax,1),%cl
add    $0xe0,%cl
mov    %cl,(%r10,%rax,1)
movsbl %cl,%eax
add    %r8d,%eax
add    $0xffffff7e,%eax
movswl %ax,%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
sub    %edx,%eax
add    $0x41,%al
mov    0x10(%rsi),%rcx
movsbq (%rsi),%rdx
mov    %al,(%rcx,%rdx,1)
movzbl (%rsi),%edi
movzbl 0x1(%rsi),%edx
movzbl 0x4(%rsi),%r10d
jmp    1173 <main+0x63>
lea    0xdc2(%rip),%rdi
mov    %r9,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
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 = %22, %2
%9 = load i8**, i8*** %5
%10 = getelementptr inbounds i8*, i8** %9, i64 1
%11 = load i8*, i8** %10
%12 = load i8**, i8*** %5
%13 = bitcast i8** %12 to i8*
%14 = getelementptr inbounds i8, i8* %13, i64 3
%15 = load i8, i8* %14
%16 = add i8 %15, 1
store i8 %16, i8* %14
%17 = sext i8 %15 to i32
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i8, i8* %11, i64 %18
%20 = load i8, i8* %19
%21 = icmp ne i8 %20, 0
br i1 %21, label %22, label %23
22: ; preds = %8
br label %8
23: ; preds = %8
%24 = load i8**, i8*** %5
%25 = bitcast i8** %24 to i8*
%26 = getelementptr inbounds i8, i8* %25, i64 3
%27 = load i8, i8* %26
%28 = add i8 %27, -1
store i8 %28, i8* %26
br label %29
29: ; preds = %43, %23
%30 = load i8**, i8*** %5
%31 = getelementptr inbounds i8*, i8** %30, i64 2
%32 = load i8*, i8** %31
%33 = load i8**, i8*** %5
%34 = bitcast i8** %33 to i8*
%35 = getelementptr inbounds i8, i8* %34, i64 4
%36 = load i8, i8* %35
%37 = add i8 %36, 1
store i8 %37, i8* %35
%38 = sext i8 %36 to i32
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %32, i64 %39
%41 = load i8, i8* %40
%42 = icmp ne i8 %41, 0
br i1 %42, label %43, label %44
43: ; preds = %29
br label %29
44: ; preds = %29
%45 = load i8**, i8*** %5
%46 = bitcast i8** %45 to i8*
%47 = getelementptr inbounds i8, i8* %46, i64 4
%48 = load i8, i8* %47
%49 = add i8 %48, -1
store i8 %49, i8* %47
br label %50
50: ; preds = %222, %44
%51 = load i8**, i8*** %5
%52 = getelementptr inbounds i8*, i8** %51, i64 2
%53 = load i8*, i8** %52
%54 = load i8**, i8*** %5
%55 = bitcast i8** %54 to i8*
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %53, i64 %58
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp sgt i32 %61, 64
%63 = zext i1 %62 to i32
%64 = load i8**, i8*** %5
%65 = getelementptr inbounds i8*, i8** %64, i64 2
%66 = load i8*, i8** %65
%67 = load i8**, i8*** %5
%68 = bitcast i8** %67 to i8*
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %66, i64 %71
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp slt i32 %74, 91
%76 = zext i1 %75 to i32
%77 = and i32 %63, %76
%78 = load i8**, i8*** %5
%79 = getelementptr inbounds i8*, i8** %78, i64 2
%80 = load i8*, i8** %79
%81 = load i8**, i8*** %5
%82 = bitcast i8** %81 to i8*
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %80, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp sgt i32 %88, 96
%90 = zext i1 %89 to i32
%91 = load i8**, i8*** %5
%92 = getelementptr inbounds i8*, i8** %91, i64 2
%93 = load i8*, i8** %92
%94 = load i8**, i8*** %5
%95 = bitcast i8** %94 to i8*
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %93, i64 %98
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = icmp slt i32 %101, 123
%103 = zext i1 %102 to i32
%104 = and i32 %90, %103
%105 = or i32 %77, %104
%106 = icmp ne i32 %105, 0
br i1 %106, label %107, label %194
107: ; preds = %50
%108 = load i8**, i8*** %5
%109 = getelementptr inbounds i8*, i8** %108, i64 2
%110 = load i8*, i8** %109
%111 = load i8**, i8*** %5
%112 = bitcast i8** %111 to i8*
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %110, i64 %115
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = icmp sgt i32 %118, 96
%120 = zext i1 %119 to i64
%121 = select i1 %119, i32 32, i32 0
%122 = load i8**, i8*** %5
%123 = getelementptr inbounds i8*, i8** %122, i64 2
%124 = load i8*, i8** %123
%125 = load i8**, i8*** %5
%126 = bitcast i8** %125 to i8*
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %124, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = sub nsw i32 %132, %121
%134 = trunc i32 %133 to i8
store i8 %134, i8* %130
%135 = sext i8 %134 to i32
%136 = sub nsw i32 %135, 65
%137 = load i8**, i8*** %5
%138 = getelementptr inbounds i8*, i8** %137, i64 1
%139 = load i8*, i8** %138
%140 = load i8**, i8*** %5
%141 = bitcast i8** %140 to i8*
%142 = getelementptr inbounds i8, i8* %141, i64 1
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = load i8**, i8*** %5
%146 = bitcast i8** %145 to i8*
%147 = getelementptr inbounds i8, i8* %146, i64 3
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = urem i32 %144, %149
%151 = zext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %139, i64 %151
%153 = load i8, i8* %152
%154 = sext i8 %153 to i32
%155 = icmp sgt i32 %154, 96
%156 = zext i1 %155 to i64
%157 = select i1 %155, i32 32, i32 0
%158 = load i8**, i8*** %5
%159 = getelementptr inbounds i8*, i8** %158, i64 1
%160 = load i8*, i8** %159
%161 = load i8**, i8*** %5
%162 = bitcast i8** %161 to i8*
%163 = getelementptr inbounds i8, i8* %162, i64 1
%164 = load i8, i8* %163
%165 = sext i8 %164 to i32
%166 = load i8**, i8*** %5
%167 = bitcast i8** %166 to i8*
%168 = getelementptr inbounds i8, i8* %167, i64 3
%169 = load i8, i8* %168
%170 = sext i8 %169 to i32
%171 = srem i32 %165, %170
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i8, i8* %160, i64 %172
%174 = load i8, i8* %173
%175 = sext i8 %174 to i32
%176 = sub nsw i32 %175, %157
%177 = trunc i32 %176 to i8
store i8 %177, i8* %173
%178 = sext i8 %177 to i32
%179 = add nsw i32 %136, %178
%180 = sub nsw i32 %179, 65
%181 = srem i32 %180, 26
%182 = add nsw i32 %181, 65
%183 = trunc i32 %182 to i8
%184 = load i8**, i8*** %5
%185 = getelementptr inbounds i8*, i8** %184, i64 2
%186 = load i8*, i8** %185
%187 = load i8**, i8*** %5
%188 = bitcast i8** %187 to i8*
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %186, i64 %191
store i8 %183, i8* %192
%193 = sext i8 %183 to i32
br label %201
194: ; preds = %50
%195 = load i8**, i8*** %5
%196 = bitcast i8** %195 to i8*
%197 = getelementptr inbounds i8, i8* %196, i64 1
%198 = load i8, i8* %197
%199 = add i8 %198, -1
store i8 %199, i8* %197
%200 = sext i8 %198 to i32
br label %201
201: ; preds = %194, %107
%202 = phi i32 [ %193, %107 ], [ %200, %194 ]
%203 = load i8**, i8*** %5
%204 = bitcast i8** %203 to i8*
%205 = load i8, i8* %204
%206 = add i8 %205, 1
store i8 %206, i8* %204
%207 = load i8**, i8*** %5
%208 = bitcast i8** %207 to i8*
%209 = getelementptr inbounds i8, i8* %208, i64 1
%210 = load i8, i8* %209
%211 = add i8 %210, 1
store i8 %211, i8* %209
%212 = load i8**, i8*** %5
%213 = bitcast i8** %212 to i8*
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = load i8**, i8*** %5
%217 = bitcast i8** %216 to i8*
%218 = getelementptr inbounds i8, i8* %217, i64 4
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = icmp ult i32 %215, %220
br i1 %221, label %222, label %223
222: ; preds = %201
br label %50
223: ; preds = %201
%224 = load i8**, i8*** %5
%225 = getelementptr inbounds i8*, i8** %224, i64 2
%226 = load i8*, i8** %225
%227 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %226)
%228 = load i32, i32* %3
ret i32 %228
}

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