#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 */
typedef int /*<<< orphan*/ uint8_t;
typedef int uint32_t;
typedef int ssize_t;
typedef int int8_t;
typedef int /*<<< orphan*/ DECODE;

/* Variables and functions */
int /*<<< orphan*/ assert(int /*<<< orphan*/);
ssize_t base64_decode_string(size_t s_sz, const char *s, size_t blob_sz,
                             void *blob) {
  uint32_t x;
  size_t i, j;
  uint8_t *p, *begin;
  static const int8_t DECODE[] = {
      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
      52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
      -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
      15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
      -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
      41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
  };
  assert(s_sz == 0 || s);
  assert(blob_sz == 0 || blob);
  p = begin = blob;
  for (i = 0; i < s_sz; i += 4) {
    x = 0;
    for (j = i; j < i + 4 && j < s_sz; j++) {
      char c = s[j];
      if (!(0 <= c && c < sizeof(DECODE))) {
        return -1;
      } else if (-1 == DECODE[(int)c]) {
        return -1;
      }
      x <<= 6;
      x |= DECODE[(int)c];
    }
    switch (j % 4) {
    case 0:
      *p++ = x >> 16;
      *p++ = x >> 8;
      *p++ = x;
      break;
    case 3:
      *p++ = x >> 10;
      *p++ = x >> 2;
      break;
    case 2:
      *p++ = x >> 4;
      break;
    case 1:
      return -1;
    }
  }
  return p - begin;
}


x86 assembly (clang, -O0):
<base64_decode_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    $0x1,%al
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x52(%rbp)
je     1143 <base64_decode_string+0x33>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    $0x1,%al
cmpq   $0x0,-0x20(%rbp)
mov    %al,-0x53(%rbp)
je     116b <base64_decode_string+0x5b>
cmpq   $0x0,-0x28(%rbp)
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1359 <base64_decode_string+0x249>
movl   $0x0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rdx
add    $0x4,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x54(%rbp)
jae    11d1 <base64_decode_string+0xc1>
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
setb   %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
test   $0x1,%al
jne    11e1 <base64_decode_string+0xd1>
jmp    1278 <base64_decode_string+0x168>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x51(%rbp)
movsbl -0x51(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jg     120e <base64_decode_string+0xfe>
movsbq -0x51(%rbp),%rax
cmp    $0x200,%rax
jb     121a <base64_decode_string+0x10a>
movl   $0xffffffff,-0x4(%rbp)
jmp    136b <base64_decode_string+0x25b>
movsbl -0x51(%rbp),%eax
movslq %eax,%rdx
mov    $0xffffffff,%eax
lea    0xde3(%rip),%rcx
cmp    (%rcx,%rdx,4),%eax
jne    1242 <base64_decode_string+0x132>
movl   $0xffffffff,-0x4(%rbp)
jmp    136b <base64_decode_string+0x25b>
jmp    1247 <base64_decode_string+0x137>
mov    -0x2c(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x2c(%rbp)
movsbl -0x51(%rbp),%eax
movslq %eax,%rcx
lea    0xdb2(%rip),%rax
mov    (%rax,%rcx,4),%eax
or     -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11a9 <base64_decode_string+0x99>
mov    -0x40(%rbp),%rax
and    $0x3,%eax
mov    %rax,-0x60(%rbp)
sub    $0x3,%rax
ja     1343 <base64_decode_string+0x233>
mov    -0x60(%rbp),%rax
lea    0xd68(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x2c(%rbp),%ecx
sar    $0x10,%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
sar    $0x8,%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
jmp    1343 <base64_decode_string+0x233>
mov    -0x2c(%rbp),%ecx
sar    $0xa,%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
sar    $0x2,%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
jmp    1343 <base64_decode_string+0x233>
mov    -0x2c(%rbp),%ecx
sar    $0x4,%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x48(%rbp)
mov    %ecx,(%rax)
jmp    1343 <base64_decode_string+0x233>
movl   $0xffffffff,-0x4(%rbp)
jmp    136b <base64_decode_string+0x25b>
jmp    1348 <base64_decode_string+0x238>
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
jmp    118c <base64_decode_string+0x7c>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64_decode_string>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r14
mov    %rdx,%r12
mov    %rsi,%r15
mov    %rdi,%r13
test   %rdi,%rdi
sete   %al
test   %rsi,%rsi
setne  %cl
or     %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
test   %r12,%r12
sete   %al
test   %r14,%r14
setne  %cl
or     %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
test   %r13,%r13
je     12be <base64_decode_string+0x1ae>
mov    $0x2,%edx
xor    %esi,%esi
lea    0xea8(%rip),%r8
lea    0xe91(%rip),%r9
mov    %r14,%r10
jmp    11b1 <base64_decode_string+0xa1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%eax
sar    $0x10,%eax
mov    %eax,(%r10)
mov    %edi,%eax
sar    $0x8,%eax
mov    %eax,0x4(%r10)
mov    %edi,0x8(%r10)
add    $0xc,%r10
lea    0x4(%rdx),%rax
add    $0x2,%rdx
add    $0x4,%rsi
cmp    %r13,%rdx
mov    %rax,%rdx
jae    12c1 <base64_decode_string+0x1b1>
mov    $0x0,%edi
cmp    $0xfffffffffffffffe,%rdx
je     1180 <base64_decode_string+0x70>
movzbl -0x2(%r15,%rdx,1),%ecx
mov    $0xffffffff,%eax
test   %cl,%cl
js     12cb <base64_decode_string+0x1bb>
mov    (%r8,%rcx,4),%edi
cmp    $0xffffffff,%edi
je     12cb <base64_decode_string+0x1bb>
lea    0x2(%rdx),%r12
mov    %rsi,%rcx
or     $0x1,%rcx
lea    -0x1(%rdx),%rbx
cmp    %r12,%rbx
jae    1280 <base64_decode_string+0x170>
cmp    %r13,%rbx
jae    1280 <base64_decode_string+0x170>
movzbl -0x1(%r15,%rdx,1),%ecx
test   %cl,%cl
js     12cb <base64_decode_string+0x1bb>
mov    (%r8,%rcx,4),%ecx
cmp    $0xffffffff,%ecx
je     12cb <base64_decode_string+0x1bb>
shl    $0x6,%edi
or     %edi,%ecx
mov    %rsi,%r11
or     $0x2,%r11
cmp    %r12,%rdx
jae    1285 <base64_decode_string+0x175>
cmp    %r13,%rdx
jae    1285 <base64_decode_string+0x175>
movzbl (%r15,%rdx,1),%edi
test   %dil,%dil
js     12cb <base64_decode_string+0x1bb>
mov    (%r8,%rdi,4),%edi
cmp    $0xffffffff,%edi
je     12cb <base64_decode_string+0x1bb>
shl    $0x6,%ecx
or     %ecx,%edi
mov    %rsi,%rcx
or     $0x3,%rcx
lea    0x1(%rdx),%rbx
cmp    %r12,%rbx
jae    1280 <base64_decode_string+0x170>
cmp    %r13,%rbx
jae    1280 <base64_decode_string+0x170>
movzbl 0x1(%r15,%rdx,1),%ecx
test   %cl,%cl
js     12cb <base64_decode_string+0x1bb>
mov    (%r8,%rcx,4),%ecx
cmp    $0xffffffff,%ecx
je     12cb <base64_decode_string+0x1bb>
shl    $0x6,%edi
or     %ecx,%edi
jmp    128a <base64_decode_string+0x17a>
nopl   (%rax)
mov    %rcx,%r12
jmp    128a <base64_decode_string+0x17a>
mov    %ecx,%edi
mov    %r11,%r12
and    $0x3,%r12d
movslq (%r9,%r12,4),%rcx
add    %r9,%rcx
jmp    *%rcx
sar    $0x4,%edi
mov    %edi,(%r10)
add    $0x4,%r10
jmp    1199 <base64_decode_string+0x89>
mov    %edi,%eax
sar    $0xa,%eax
mov    %eax,(%r10)
sar    $0x2,%edi
mov    %edi,0x4(%r10)
add    $0x8,%r10
jmp    1199 <base64_decode_string+0x89>
mov    %r14,%r10
sub    %r14,%r10
shr    $0x2,%r10
mov    %r10d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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