#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 char uint8_t;
typedef int int8_t;

/* Variables and functions */
size_t strlen(char const *);
size_t base64_decoder(const char *str, size_t len, uint8_t *save) {
  const uint8_t *cur;
  uint8_t *start;
  int8_t d;
  uint8_t c, phase, dlast;
  static int8_t table[] = {
      -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, 62, -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, 63,
      -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};
  if (!str)
    return 0;
  if (!len)
    len = strlen(str);
  if ((len % 4) == 1)
    return 0;
  uint8_t *out = save;
  if (!out)
    out = (uint8_t *)str;
  d = dlast = phase = 0;
  start = out;
  for (cur = (uint8_t *)str; *cur != '\0' && len; ++cur, --len) {
    if (*cur & 0x80)
      return 0;
    d = table[*cur];
    if (d < 0)
      return 0;
    switch (phase) {
    case 0:
      ++phase;
      break;
    case 1:
      c = ((dlast << 2) | ((d & 0x30) >> 4));
      if (save)
        *out = c;
      ++out;
      ++phase;
      break;
    case 2:
      c = (((dlast & 0xf) << 4) | ((d & 0x3c) >> 2));
      if (save)
        *out = c;
      ++out;
      ++phase;
      break;
    case 3:
      c = (((dlast & 0x03) << 6) | d);
      if (save)
        *out = c;
      ++out;
      phase = 0;
      break;
    }
    dlast = d;
  }
  return out - start;
}


x86 assembly (clang, -O0):
<base64_decoder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    113c <base64_decoder+0x2c>
movq   $0x0,-0x8(%rbp)
jmp    134c <base64_decoder+0x23c>
cmpq   $0x0,-0x18(%rbp)
jne    1154 <base64_decoder+0x44>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x3,%rax
cmp    $0x1,%rax
jne    1173 <base64_decoder+0x63>
movq   $0x0,-0x8(%rbp)
jmp    134c <base64_decoder+0x23c>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    118e <base64_decoder+0x7e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
movb   $0x0,-0x36(%rbp)
movb   $0x0,-0x37(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x41(%rbp)
je     11cd <base64_decoder+0xbd>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11dd <base64_decoder+0xcd>
jmp    133d <base64_decoder+0x22d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     11ff <base64_decoder+0xef>
movq   $0x0,-0x8(%rbp)
jmp    134c <base64_decoder+0x23c>
mov    -0x28(%rbp),%rax
movsbq (%rax),%rcx
lea    0x2e22(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jge    122b <base64_decoder+0x11b>
movq   $0x0,-0x8(%rbp)
jmp    134c <base64_decoder+0x23c>
movsbl -0x36(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x3,%eax
ja     131a <base64_decoder+0x20a>
mov    -0x50(%rbp),%rax
lea    0xdb7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x36(%rbp),%al
add    $0x1,%al
mov    %al,-0x36(%rbp)
jmp    131a <base64_decoder+0x20a>
movsbl -0x37(%rbp),%eax
shl    $0x2,%eax
mov    -0x34(%rbp),%ecx
and    $0x30,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,-0x35(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     1288 <base64_decoder+0x178>
mov    -0x35(%rbp),%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x36(%rbp),%al
add    $0x1,%al
mov    %al,-0x36(%rbp)
jmp    131a <base64_decoder+0x20a>
movsbl -0x37(%rbp),%eax
and    $0xf,%eax
shl    $0x4,%eax
mov    -0x34(%rbp),%ecx
and    $0x3c,%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,-0x35(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     12cd <base64_decoder+0x1bd>
mov    -0x35(%rbp),%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x36(%rbp),%al
add    $0x1,%al
mov    %al,-0x36(%rbp)
jmp    131a <base64_decoder+0x20a>
movsbl -0x37(%rbp),%eax
and    $0x3,%eax
shl    $0x6,%eax
or     -0x34(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     130a <base64_decoder+0x1fa>
mov    -0x35(%rbp),%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
movb   $0x0,-0x36(%rbp)
mov    -0x34(%rbp),%eax
mov    %al,-0x37(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    11ad <base64_decoder+0x9d>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64_decoder>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     113d <base64_decoder+0x2d>
mov    %rdx,%r14
mov    %rdi,%r15
test   %rsi,%rsi
jne    1133 <base64_decoder+0x23>
mov    %r15,%rdi
call   1030 <strlen@plt>
mov    %rax,%rsi
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x1,%eax
jne    1144 <base64_decoder+0x34>
xor    %eax,%eax
jmp    122f <base64_decoder+0x11f>
test   %r14,%r14
mov    %r14,%r10
cmove  %r15,%r10
mov    (%r15),%dl
mov    %r10,%rax
test   %dl,%dl
je     122c <base64_decoder+0x11c>
mov    %r10,%rax
test   %rsi,%rsi
je     122c <base64_decoder+0x11c>
mov    $0x1,%r12d
lea    0xe9b(%rip),%r8
lea    0xe84(%rip),%r9
mov    %r10,%rax
xor    %ebx,%ebx
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %dl,%dl
js     113d <base64_decoder+0x2d>
movzbl %dl,%ecx
mov    (%r8,%rcx,4),%ecx
test   %ecx,%ecx
js     113d <base64_decoder+0x2d>
movsbl %r11b,%edx
cmp    $0x3,%edx
ja     1210 <base64_decoder+0x100>
movslq (%r9,%rdx,4),%rdx
add    %r9,%rdx
jmp    *%rdx
add    $0x1,%r11b
jmp    1210 <base64_decoder+0x100>
test   %r14,%r14
je     11e2 <base64_decoder+0xd2>
movzbl %bl,%edx
mov    %ecx,%ebx
shr    $0x4,%ebx
and    $0x3,%ebx
lea    (%rbx,%rdx,4),%edx
mov    %dl,(%rax)
jmp    11e2 <base64_decoder+0xd2>
test   %r14,%r14
je     11e2 <base64_decoder+0xd2>
shl    $0x4,%bl
mov    %ecx,%edx
shr    $0x2,%dl
and    $0xf,%dl
or     %bl,%dl
mov    %dl,(%rax)
add    $0x1,%rax
add    $0x1,%r11b
jmp    1210 <base64_decoder+0x100>
test   %r14,%r14
je     11fa <base64_decoder+0xea>
shl    $0x6,%bl
mov    %ecx,%edx
or     %bl,%dl
mov    %dl,(%rax)
add    $0x1,%rax
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%r12,1),%edx
test   %dl,%dl
je     122c <base64_decoder+0x11c>
lea    0x1(%r12),%rdi
mov    %ecx,%ebx
cmp    %r12,%rsi
mov    %rdi,%r12
jne    1190 <base64_decoder+0x80>
sub    %r10,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@base64_decoder.table = 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 62, 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 63, 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 i64 @base64_decoder(i8* %0, i64 %1, i8* %2) {
%4 = icmp eq i8* %0, null
br i1 %4, label %80, label %5
5: ; preds = %3
%6 = icmp eq i64 %1, 0
br i1 %6, label %7, label %9
7: ; preds = %5
%8 = tail call i64 @strlen(i8* %0)
br label %9
9: ; preds = %7, %5
%10 = phi i64 [ %1, %5 ], [ %8, %7 ]
%11 = and i64 %10, 3
%12 = icmp eq i64 %11, 1
br i1 %12, label %80, label %13
13: ; preds = %9
%14 = icmp eq i8* %2, null
%15 = select i1 %14, i8* %0, i8* %2
%16 = load i8, i8* %0
%17 = icmp ne i8 %16, 0
%18 = icmp ne i64 %10, 0
%19 = select i1 %17, i1 %18, i1 false
br i1 %19, label %20, label %75
20: ; preds = %13, %65
%21 = phi i8 [ %71, %65 ], [ %16, %13 ]
%22 = phi i8* [ %67, %65 ], [ %15, %13 ]
%23 = phi i8 [ %68, %65 ], [ 0, %13 ]
%24 = phi i8 [ %66, %65 ], [ 0, %13 ]
%25 = phi i8* [ %69, %65 ], [ %0, %13 ]
%26 = phi i64 [ %70, %65 ], [ %10, %13 ]
%27 = icmp sgt i8 %21, -1
br i1 %27, label %28, label %80
28: ; preds = %20
%29 = zext i8 %21 to i64
%30 = getelementptr inbounds [128 x i32], [128 x i32]* @base64_decoder.table, i64 0, i64 %29
%31 = load i32, i32* %30
%32 = icmp slt i32 %31, 0
br i1 %32, label %80, label %33
33: ; preds = %28
%34 = sext i8 %24 to i32
switch i32 %34, label %65 [
i32 0, label %35
i32 1, label %37
i32 2, label %48
i32 3, label %58
]
35: ; preds = %33
%36 = add i8 %24, 1
br label %65
37: ; preds = %33
br i1 %14, label %45, label %38
38: ; preds = %37
%39 = sext i8 %23 to i32
%40 = shl nsw i32 %39, 2
%41 = lshr i32 %31, 4
%42 = and i32 %41, 3
%43 = or i32 %42, %40
%44 = trunc i32 %43 to i8
store i8 %44, i8* %22
br label %45
45: ; preds = %38, %37
%46 = getelementptr inbounds i8, i8* %22, i64 1
%47 = add i8 %24, 1
br label %65
48: ; preds = %33
br i1 %14, label %55, label %49
49: ; preds = %48
%50 = shl i8 %23, 4
%51 = trunc i32 %31 to i8
%52 = lshr i8 %51, 2
%53 = and i8 %52, 15
%54 = or i8 %53, %50
store i8 %54, i8* %22
br label %55
55: ; preds = %49, %48
%56 = getelementptr inbounds i8, i8* %22, i64 1
%57 = add i8 %24, 1
br label %65
58: ; preds = %33
br i1 %14, label %63, label %59
59: ; preds = %58
%60 = shl i8 %23, 6
%61 = trunc i32 %31 to i8
%62 = or i8 %60, %61
store i8 %62, i8* %22
br label %63
63: ; preds = %59, %58
%64 = getelementptr inbounds i8, i8* %22, i64 1
br label %65
65: ; preds = %33, %63, %55, %45, %35
%66 = phi i8 [ %24, %33 ], [ 0, %63 ], [ %57, %55 ], [ %47, %45 ], [ %36, %35 ]
%67 = phi i8* [ %22, %33 ], [ %64, %63 ], [ %56, %55 ], [ %46, %45 ], [ %22, %35 ]
%68 = trunc i32 %31 to i8
%69 = getelementptr inbounds i8, i8* %25, i64 1
%70 = add i64 %26, -1
%71 = load i8, i8* %69
%72 = icmp ne i8 %71, 0
%73 = icmp ne i64 %70, 0
%74 = select i1 %72, i1 %73, i1 false
br i1 %74, label %20, label %75
75: ; preds = %65, %13
%76 = phi i8* [ %15, %13 ], [ %67, %65 ]
%77 = ptrtoint i8* %76 to i64
%78 = ptrtoint i8* %15 to i64
%79 = sub i64 %77, %78
br label %80
80: ; preds = %20, %28, %75, %9, %3
%81 = phi i64 [ 0, %3 ], [ 0, %9 ], [ %79, %75 ], [ 0, %28 ], [ 0, %20 ]
ret i64 %81
}