#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*/ assert(int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
char *decode_base64(char *dest, char *src, size_t *size) {
  int cc = 0;
  char buf[4] = {0, 0, 0, 0};
  int p = 0;
  int valid_data = 0;
  size_t size_out = 0;
  while (*src && p < (int)*size && (cc != -1)) {
    cc = *src++;
    if ((cc >= 'A') && (cc <= 'Z'))
      cc = cc - 'A';
    else if ((cc >= 'a') && (cc <= 'z'))
      cc = cc - 'a' + 26;
    else if ((cc >= '0') && (cc <= '9'))
      cc = cc - '0' + 52;
    else if (cc == '/')
      cc = 63;
    else if (cc == '+')
      cc = 62;
    else
      cc = -1;
    assert(cc < 64);
    if (cc == -1) {
      if (valid_data == 0) {
        return 0;
      }
      while (p % 4 != 3) {
        p++;
        buf[p % 4] = 0;
      }
    } else {
      buf[p % 4] = cc;
      size_out++;
      valid_data = 1;
    }
    if (p % 4 == 3) {
      *dest++ = (buf[0] << 2) | ((buf[1] & 0x30) >> 4);
      *dest++ = ((buf[1] & 0x0F) << 4) | ((buf[2] & 0x3C) >> 2);
      *dest++ = ((buf[2] & 0x03) << 6) | (buf[3] & 0x3F);
      memset(buf, 0, 4);
    }
    p++;
  }
  *size = ((int)(size_out / 4)) * 3;
  if (size_out % 4 == 2)
    *size += 1;
  if (size_out % 4 == 3)
    *size += 2;
  return (dest);
}


x86 assembly (clang, -O0):
<decode_base64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
lea    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x39(%rbp)
je     1199 <decode_base64+0x79>
mov    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x39(%rbp)
jge    1199 <decode_base64+0x79>
cmpl   $0xffffffff,-0x24(%rbp)
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    11a9 <decode_base64+0x89>
jmp    13b3 <decode_base64+0x293>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x41,-0x24(%rbp)
jl     11e0 <decode_base64+0xc0>
cmpl   $0x5a,-0x24(%rbp)
jg     11e0 <decode_base64+0xc0>
mov    -0x24(%rbp),%eax
sub    $0x41,%eax
mov    %eax,-0x24(%rbp)
jmp    1271 <decode_base64+0x151>
cmpl   $0x61,-0x24(%rbp)
jl     1205 <decode_base64+0xe5>
cmpl   $0x7a,-0x24(%rbp)
jg     1205 <decode_base64+0xe5>
mov    -0x24(%rbp),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0x24(%rbp)
jmp    126c <decode_base64+0x14c>
cmpl   $0x30,-0x24(%rbp)
jl     122a <decode_base64+0x10a>
cmpl   $0x39,-0x24(%rbp)
jg     122a <decode_base64+0x10a>
mov    -0x24(%rbp),%eax
sub    $0x30,%eax
add    $0x34,%eax
mov    %eax,-0x24(%rbp)
jmp    1267 <decode_base64+0x147>
cmpl   $0x2f,-0x24(%rbp)
jne    1240 <decode_base64+0x120>
movl   $0x3f,-0x24(%rbp)
jmp    1262 <decode_base64+0x142>
cmpl   $0x2b,-0x24(%rbp)
jne    1256 <decode_base64+0x136>
movl   $0x3e,-0x24(%rbp)
jmp    125d <decode_base64+0x13d>
movl   $0xffffffff,-0x24(%rbp)
jmp    1262 <decode_base64+0x142>
jmp    1267 <decode_base64+0x147>
jmp    126c <decode_base64+0x14c>
jmp    1271 <decode_base64+0x151>
cmpl   $0x40,-0x24(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
cmpl   $0xffffffff,-0x24(%rbp)
jne    12e2 <decode_base64+0x1c2>
cmpl   $0x0,-0x30(%rbp)
jne    12a3 <decode_base64+0x183>
movq   $0x0,-0x8(%rbp)
jmp    1410 <decode_base64+0x2f0>
jmp    12a8 <decode_base64+0x188>
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
je     12dd <decode_base64+0x1bd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
movb   $0x0,-0x28(%rbp,%rax,1)
jmp    12a8 <decode_base64+0x188>
jmp    130c <decode_base64+0x1ec>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x2c(%rbp),%eax
mov    $0x4,%esi
cltd
idiv   %esi
movslq %edx,%rax
mov    %cl,-0x28(%rbp,%rax,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
jne    13a5 <decode_base64+0x285>
movsbl -0x28(%rbp),%eax
shl    $0x2,%eax
movsbl -0x27(%rbp),%ecx
and    $0x30,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movsbl -0x27(%rbp),%eax
and    $0xf,%eax
shl    $0x4,%eax
movsbl -0x26(%rbp),%ecx
and    $0x3c,%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movsbl -0x26(%rbp),%eax
and    $0x3,%eax
shl    $0x6,%eax
movsbl -0x25(%rbp),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
lea    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1161 <decode_base64+0x41>
mov    -0x38(%rbp),%rax
shr    $0x2,%rax
imul   $0x3,%eax,%eax
movslq %eax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
and    $0x3,%rax
cmp    $0x2,%rax
jne    13e8 <decode_base64+0x2c8>
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
and    $0x3,%rax
cmp    $0x3,%rax
jne    1408 <decode_base64+0x2e8>
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
add    $0x2,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_base64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r15
movl   $0x0,0xc(%rsp)
mov    (%rsi),%al
test   %al,%al
je     1307 <decode_base64+0x1e7>
mov    %rsi,%rbx
xor    %r13d,%r13d
xor    %r12d,%r12d
xor    %ebp,%ebp
xor    %r14d,%r14d
mov    %rdx,0x10(%rsp)
jmp    1172 <decode_base64+0x52>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdx
add    $0x1,%ebp
mov    (%rbx),%al
test   %al,%al
je     130a <decode_base64+0x1ea>
cmp    (%rdx),%ebp
jge    130a <decode_base64+0x1ea>
cmp    $0xffffffff,%r14d
je     130a <decode_base64+0x1ea>
movsbl %al,%r14d
lea    -0x41(%r14),%ecx
cmp    $0x19,%cl
ja     11a0 <decode_base64+0x80>
add    $0xffffffbf,%r14d
jmp    11f0 <decode_base64+0xd0>
nopw   0x0(%rax,%rax,1)
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     11b0 <decode_base64+0x90>
add    $0xffffffb9,%r14d
jmp    11f0 <decode_base64+0xd0>
xchg   %ax,%ax
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     11be <decode_base64+0x9e>
add    $0x4,%r14d
jmp    11f0 <decode_base64+0xd0>
cmp    $0x2b,%al
mov    $0xffffffff,%r14d
mov    $0x3e,%ecx
cmove  %ecx,%r14d
cmp    $0x2f,%al
jne    11f0 <decode_base64+0xd0>
mov    $0x1,%edi
call   1040 <assert@plt>
mov    $0x3f,%r14d
jmp    1200 <decode_base64+0xe0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%edi
call   1040 <assert@plt>
cmp    $0xffffffff,%r14d
je     1230 <decode_base64+0x110>
lea    0x3(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
and    $0xfffffffc,%eax
mov    %ebp,%ecx
sub    %eax,%ecx
movslq %ecx,%rax
mov    %r14b,0xc(%rsp,%rax,1)
add    $0x1,%r13
mov    $0x1,%r12d
jmp    1290 <decode_base64+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r12d,%r12d
je     134f <decode_base64+0x22f>
lea    0x3(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
and    $0xfffffffc,%eax
mov    %ebp,%ecx
sub    %eax,%ecx
mov    $0xffffffff,%r14d
cmp    $0x3,%ecx
je     1290 <decode_base64+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%eax
lea    0x1(%rax),%ebp
lea    0x4(%rax),%ecx
test   %ebp,%ebp
cmovns %ebp,%ecx
and    $0xfffffffc,%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
movb   $0x0,0xc(%rsp,%rax,1)
cmp    $0x3,%eax
jne    1260 <decode_base64+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
lea    0x3(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
and    $0xfffffffc,%eax
mov    %ebp,%ecx
sub    %eax,%ecx
cmp    $0x3,%ecx
jne    1160 <decode_base64+0x40>
mov    0xc(%rsp),%al
mov    0xd(%rsp),%cl
shl    $0x2,%al
shr    $0x4,%cl
and    $0x3,%cl
or     %al,%cl
mov    %cl,(%r15)
mov    0xd(%rsp),%al
mov    0xe(%rsp),%cl
shl    $0x4,%al
shr    $0x2,%cl
and    $0xf,%cl
or     %al,%cl
mov    %cl,0x1(%r15)
mov    0xe(%rsp),%al
mov    0xf(%rsp),%cl
shl    $0x6,%al
and    $0x3f,%cl
or     %al,%cl
mov    %cl,0x2(%r15)
add    $0x3,%r15
lea    0xc(%rsp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
jmp    1160 <decode_base64+0x40>
xor    %r13d,%r13d
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
shl    $0x1e,%rax
lea    (%rax,%rax,2),%rcx
sar    $0x20,%rcx
and    $0x3,%r13d
xor    %eax,%eax
cmp    $0x2,%r13
sete   %al
add    %rcx,%rax
mov    %rax,(%rdx)
cmp    $0x3,%r13
jne    133d <decode_base64+0x21d>
add    $0x2,%rax
mov    %rax,(%rdx)
mov    %r15,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r15d,%r15d
jmp    133d <decode_base64+0x21d>

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

LLVM IR (-O2):
define i8* @decode_base64(i8* writeonly %0, i8* nocapture %1, i64* nocapture %2) {
%4 = alloca i32
%5 = bitcast i32* %4 to [4 x i8]*
%6 = bitcast i32* %4 to i8*
store i32 0, i32* %4
%7 = load i8, i8* %1
%8 = icmp eq i8 %7, 0
br i1 %8, label %106, label %9
9: ; preds = %3
%10 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 1
%11 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 2
%12 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 3
br label %13
13: ; preds = %9, %101
%14 = phi i8 [ %7, %9 ], [ %104, %101 ]
%15 = phi i64 [ 0, %9 ], [ %76, %101 ]
%16 = phi i32 [ 0, %9 ], [ %75, %101 ]
%17 = phi i32 [ 0, %9 ], [ %103, %101 ]
%18 = phi i32 [ 0, %9 ], [ %73, %101 ]
%19 = phi i8* [ %1, %9 ], [ %28, %101 ]
%20 = phi i8* [ %0, %9 ], [ %102, %101 ]
%21 = sext i8 %14 to i32
%22 = load i64, i64* %2
%23 = trunc i64 %22 to i32
%24 = icmp slt i32 %17, %23
%25 = icmp ne i32 %18, -1
%26 = select i1 %24, i1 %25, i1 false
br i1 %26, label %27, label %106
27: ; preds = %13
%28 = getelementptr inbounds i8, i8* %19, i64 1
%29 = add i8 %14, -65
%30 = icmp ult i8 %29, 26
br i1 %30, label %31, label %33
31: ; preds = %27
%32 = add nsw i32 %21, -65
br label %49
33: ; preds = %27
%34 = add i8 %14, -97
%35 = icmp ult i8 %34, 26
br i1 %35, label %36, label %38
36: ; preds = %33
%37 = add nsw i32 %21, -71
br label %49
38: ; preds = %33
%39 = add i8 %14, -48
%40 = icmp ult i8 %39, 10
br i1 %40, label %41, label %43
41: ; preds = %38
%42 = add nsw i32 %21, 4
br label %49
43: ; preds = %38
%44 = icmp eq i8 %14, 43
%45 = select i1 %44, i32 62, i32 -1
%46 = icmp eq i8 %14, 47
br i1 %46, label %47, label %49
47: ; preds = %43
%48 = call i32 @assert(i32 1)
br label %65
49: ; preds = %43, %36, %41, %31
%50 = phi i32 [ %32, %31 ], [ %37, %36 ], [ %42, %41 ], [ %45, %43 ]
%51 = call i32 @assert(i32 1)
%52 = icmp eq i32 %50, -1
br i1 %52, label %53, label %65
53: ; preds = %49
%54 = icmp eq i32 %16, 0
br i1 %54, label %119, label %55
55: ; preds = %53
%56 = srem i32 %17, 4
%57 = icmp eq i32 %56, 3
br i1 %57, label %72, label %58
58: ; preds = %55, %58
%59 = phi i32 [ %60, %58 ], [ %17, %55 ]
%60 = add nsw i32 %59, 1
%61 = srem i32 %60, 4
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 %62
store i8 0, i8* %63
%64 = icmp eq i32 %61, 3
br i1 %64, label %72, label %58
65: ; preds = %47, %49
%66 = phi i32 [ 63, %47 ], [ %50, %49 ]
%67 = trunc i32 %66 to i8
%68 = srem i32 %17, 4
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 %69
store i8 %67, i8* %70
%71 = add i64 %15, 1
br label %72
72: ; preds = %58, %55, %65
%73 = phi i32 [ %66, %65 ], [ -1, %55 ], [ -1, %58 ]
%74 = phi i32 [ %17, %65 ], [ %17, %55 ], [ %60, %58 ]
%75 = phi i32 [ 1, %65 ], [ %16, %55 ], [ %16, %58 ]
%76 = phi i64 [ %71, %65 ], [ %15, %55 ], [ %15, %58 ]
%77 = srem i32 %74, 4
%78 = icmp eq i32 %77, 3
br i1 %78, label %79, label %101
79: ; preds = %72
%80 = load i8, i8* %6
%81 = shl i8 %80, 2
%82 = load i8, i8* %10
%83 = lshr i8 %82, 4
%84 = and i8 %83, 3
%85 = or i8 %84, %81
%86 = getelementptr inbounds i8, i8* %20, i64 1
store i8 %85, i8* %20
%87 = load i8, i8* %10
%88 = shl i8 %87, 4
%89 = load i8, i8* %11
%90 = lshr i8 %89, 2
%91 = and i8 %90, 15
%92 = or i8 %91, %88
%93 = getelementptr inbounds i8, i8* %20, i64 2
store i8 %92, i8* %86
%94 = load i8, i8* %11
%95 = shl i8 %94, 6
%96 = load i8, i8* %12
%97 = and i8 %96, 63
%98 = or i8 %97, %95
%99 = getelementptr inbounds i8, i8* %20, i64 3
store i8 %98, i8* %93
%100 = call i32 @memset(i8* %6, i32 0, i32 4)
br label %101
101: ; preds = %79, %72
%102 = phi i8* [ %99, %79 ], [ %20, %72 ]
%103 = add nsw i32 %74, 1
%104 = load i8, i8* %28
%105 = icmp eq i8 %104, 0
br i1 %105, label %106, label %13
106: ; preds = %13, %101, %3
%107 = phi i8* [ %0, %3 ], [ %102, %101 ], [ %20, %13 ]
%108 = phi i64 [ 0, %3 ], [ %76, %101 ], [ %15, %13 ]
%109 = lshr i64 %108, 2
%110 = mul i64 %109, 12884901888
%111 = ashr exact i64 %110, 32
%112 = and i64 %108, 3
%113 = icmp eq i64 %112, 2
%114 = zext i1 %113 to i64
%115 = add nsw i64 %111, %114
store i64 %115, i64* %2
%116 = icmp eq i64 %112, 3
br i1 %116, label %117, label %119
117: ; preds = %106
%118 = add nsw i64 %115, 2
store i64 %118, i64* %2
br label %119
119: ; preds = %53, %106, %117
%120 = phi i8* [ %107, %117 ], [ %107, %106 ], [ null, %53 ]
ret i8* %120
}