#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 */
scalar_t__ isspace(int);
int copy_of_mtev_b64_decode(const char *src, size_t src_len,
                            unsigned char *dest, size_t dest_len) {
  const unsigned char *cp = (unsigned char *)src;
  unsigned char *dcp = dest;
  unsigned char ch, in[4], out[3];
  int ib = 0, ob = 3, needed = (((src_len / 4) * 3) - 2);
  if (dest_len < needed)
    return 0;
  while (cp <= ((unsigned char *)src + src_len)) {
    if ((*cp >= 'A') && (*cp <= 'Z'))
      ch = *cp - 'A';
    else if ((*cp >= 'a') && (*cp <= 'z'))
      ch = *cp - 'a' + 26;
    else if ((*cp >= '0') && (*cp <= '9'))
      ch = *cp - '0' + 52;
    else if (*cp == '+')
      ch = 62;
    else if (*cp == '/')
      ch = 63;
    else if (*cp == '=')
      ch = 0xff;
    else if (isspace((int)*cp)) {
      cp++;
      continue;
    } else
      break;
    cp++;
    if (ch == 0xff) {
      if (ib == 0)
        break;
      if (ib == 1 || ib == 2)
        ob = 1;
      else
        ob = 2;
      while (ib < 3)
        in[ib++] = '\0';
    }
    in[ib++] = ch;
    if (ib == 4) {
      out[0] = (in[0] << 2) | ((in[1] & 0x30) >> 4);
      out[1] = ((in[1] & 0x0f) << 4) | ((in[2] & 0x3c) >> 2);
      out[2] = ((in[2] & 0x03) << 6) | (in[3] & 0x3f);
      for (ib = 0; ib < ob; ib++)
        *dcp++ = out[ib];
      ib = 0;
    }
  }
  return dcp - (unsigned char *)dest;
}


x86 assembly (clang, -O0):
<copy_of_mtev_b64_decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x3,-0x48(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
imul   $0x3,%rax,%rax
sub    $0x2,%rax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmp    %rcx,%rax
jae    1176 <copy_of_mtev_b64_decode+0x66>
movl   $0x0,-0x4(%rbp)
jmp    13ef <copy_of_mtev_b64_decode+0x2df>
jmp    117b <copy_of_mtev_b64_decode+0x6b>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
ja     13e1 <copy_of_mtev_b64_decode+0x2d1>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x41,%eax
jl     11c2 <copy_of_mtev_b64_decode+0xb2>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x5a,%eax
jg     11c2 <copy_of_mtev_b64_decode+0xb2>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
sub    $0x41,%eax
mov    %al,-0x39(%rbp)
jmp    12bc <copy_of_mtev_b64_decode+0x1ac>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x61,%eax
jl     11f7 <copy_of_mtev_b64_decode+0xe7>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x7a,%eax
jg     11f7 <copy_of_mtev_b64_decode+0xe7>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %al,-0x39(%rbp)
jmp    12b7 <copy_of_mtev_b64_decode+0x1a7>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
jl     122c <copy_of_mtev_b64_decode+0x11c>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x39,%eax
jg     122c <copy_of_mtev_b64_decode+0x11c>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
add    $0x34,%eax
mov    %al,-0x39(%rbp)
jmp    12b2 <copy_of_mtev_b64_decode+0x1a2>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2b,%eax
jne    1245 <copy_of_mtev_b64_decode+0x135>
movb   $0x3e,-0x39(%rbp)
jmp    12ad <copy_of_mtev_b64_decode+0x19d>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x2f,%eax
jne    125e <copy_of_mtev_b64_decode+0x14e>
movb   $0x3f,-0x39(%rbp)
jmp    12a8 <copy_of_mtev_b64_decode+0x198>
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x3d,%eax
jne    1277 <copy_of_mtev_b64_decode+0x167>
movb   $0xff,-0x39(%rbp)
jmp    12a3 <copy_of_mtev_b64_decode+0x193>
mov    -0x30(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
je     129e <copy_of_mtev_b64_decode+0x18e>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    117b <copy_of_mtev_b64_decode+0x6b>
jmp    13e1 <copy_of_mtev_b64_decode+0x2d1>
jmp    12a8 <copy_of_mtev_b64_decode+0x198>
jmp    12ad <copy_of_mtev_b64_decode+0x19d>
jmp    12b2 <copy_of_mtev_b64_decode+0x1a2>
jmp    12b7 <copy_of_mtev_b64_decode+0x1a7>
jmp    12bc <copy_of_mtev_b64_decode+0x1ac>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
movzbl -0x39(%rbp),%eax
cmp    $0xff,%eax
jne    1338 <copy_of_mtev_b64_decode+0x228>
cmpl   $0x0,-0x44(%rbp)
jne    12e6 <copy_of_mtev_b64_decode+0x1d6>
jmp    13e1 <copy_of_mtev_b64_decode+0x2d1>
cmpl   $0x1,-0x44(%rbp)
je     12fa <copy_of_mtev_b64_decode+0x1ea>
cmpl   $0x2,-0x44(%rbp)
jne    1306 <copy_of_mtev_b64_decode+0x1f6>
movl   $0x1,-0x48(%rbp)
jmp    130d <copy_of_mtev_b64_decode+0x1fd>
movl   $0x2,-0x48(%rbp)
jmp    1312 <copy_of_mtev_b64_decode+0x202>
cmpl   $0x3,-0x44(%rbp)
jge    1333 <copy_of_mtev_b64_decode+0x223>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x0,-0x3d(%rbp,%rax,1)
jmp    1312 <copy_of_mtev_b64_decode+0x202>
jmp    1338 <copy_of_mtev_b64_decode+0x228>
mov    -0x39(%rbp),%cl
mov    -0x44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
cltq
mov    %cl,-0x3d(%rbp,%rax,1)
cmpl   $0x4,-0x44(%rbp)
jne    13dc <copy_of_mtev_b64_decode+0x2cc>
movzbl -0x3d(%rbp),%eax
shl    $0x2,%eax
movzbl -0x3c(%rbp),%ecx
and    $0x30,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,-0x40(%rbp)
movzbl -0x3c(%rbp),%eax
and    $0xf,%eax
shl    $0x4,%eax
movzbl -0x3b(%rbp),%ecx
and    $0x3c,%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,-0x3f(%rbp)
movzbl -0x3b(%rbp),%eax
and    $0x3,%eax
shl    $0x6,%eax
movzbl -0x3a(%rbp),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %al,-0x3e(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    13d5 <copy_of_mtev_b64_decode+0x2c5>
movslq -0x44(%rbp),%rax
mov    -0x40(%rbp,%rax,1),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13a2 <copy_of_mtev_b64_decode+0x292>
movl   $0x0,-0x44(%rbp)
jmp    117b <copy_of_mtev_b64_decode+0x6b>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_of_mtev_b64_decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r13
mov    %rsi,%rax
shr    $0x2,%rax
lea    (%rax,%rax,2),%rax
add    $0xfffffffe,%eax
movslq %eax,%rdx
xor    %eax,%eax
cmp    %rcx,%rdx
ja     1460 <copy_of_mtev_b64_decode+0x340>
mov    %rsi,%r15
mov    %r13,%rax
test   %rsi,%rsi
js     145d <copy_of_mtev_b64_decode+0x33d>
mov    %rdi,%rbx
add    %rdi,%r15
xor    %r12d,%r12d
mov    $0x3,%ebp
mov    %r13,%r14
jmp    117f <copy_of_mtev_b64_decode+0x5f>
nopl   0x0(%rax)
mov    %r14,%rax
mov    %rax,%r14
cmp    %r15,%rbx
ja     145d <copy_of_mtev_b64_decode+0x33d>
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0x1(%rbx),%edi
lea    -0x41(%rdi),%eax
cmp    $0x1a,%al
jb     1240 <copy_of_mtev_b64_decode+0x120>
lea    -0x61(%rdi),%eax
cmp    $0x19,%al
jbe    11de <copy_of_mtev_b64_decode+0xbe>
lea    -0x30(%rdi),%eax
cmp    $0x9,%al
jbe    11e4 <copy_of_mtev_b64_decode+0xc4>
cmp    $0x2b,%dil
je     11ec <copy_of_mtev_b64_decode+0xcc>
cmp    $0x2f,%dil
je     11f0 <copy_of_mtev_b64_decode+0xd0>
cmp    $0x3d,%dil
je     11f4 <copy_of_mtev_b64_decode+0xd4>
call   1040 <isspace@plt>
test   %rax,%rax
je     145a <copy_of_mtev_b64_decode+0x33a>
lea    0x1(%rbx),%rax
cmp    %r15,%rbx
mov    %rax,%rbx
jbe    1190 <copy_of_mtev_b64_decode+0x70>
jmp    145a <copy_of_mtev_b64_decode+0x33a>
add    $0xb9,%dil
jmp    11e8 <copy_of_mtev_b64_decode+0xc8>
add    $0x4,%dil
mov    %edi,%eax
jmp    1240 <copy_of_mtev_b64_decode+0x120>
mov    $0x3e,%al
jmp    1240 <copy_of_mtev_b64_decode+0x120>
mov    $0x3f,%al
jmp    1240 <copy_of_mtev_b64_decode+0x120>
test   %r12d,%r12d
je     145a <copy_of_mtev_b64_decode+0x33a>
lea    -0x1(%r12),%eax
cmp    $0x2,%eax
mov    $0x2,%ebp
sbb    $0x0,%ebp
mov    $0xff,%al
cmp    $0x2,%r12d
jg     1240 <copy_of_mtev_b64_decode+0x120>
movslq %r12d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x4,%rdi
mov    $0x2,%edx
sub    %r12d,%edx
add    $0x1,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movb   $0xff,0x7(%rsp)
jmp    1255 <copy_of_mtev_b64_decode+0x135>
nopw   0x0(%rax,%rax,1)
movslq %r12d,%rcx
add    $0x1,%r12d
mov    %al,0x4(%rsp,%rcx,1)
cmp    $0x4,%r12d
jne    1170 <copy_of_mtev_b64_decode+0x50>
mov    0x4(%rsp),%al
mov    0x5(%rsp),%sil
shl    $0x2,%al
mov    %esi,%edx
shr    $0x4,%dl
and    $0x3,%dl
or     %al,%dl
mov    %dl,0x1(%rsp)
shl    $0x4,%sil
mov    0x6(%rsp),%cl
mov    %ecx,%eax
shr    $0x2,%al
and    $0xf,%al
or     %sil,%al
mov    %al,0x2(%rsp)
shl    $0x6,%cl
mov    0x7(%rsp),%al
and    $0x3f,%al
or     %cl,%al
mov    %al,0x3(%rsp)
lea    0x1(%r14),%rax
mov    %dl,(%r14)
xor    %r12d,%r12d
cmp    $0x1,%ebp
je     1173 <copy_of_mtev_b64_decode+0x53>
mov    %ebp,%r9d
lea    -0x1(%r9),%r8
mov    $0x1,%edx
mov    %ebp,%r10d
cmp    $0x20,%r8
jb     13b7 <copy_of_mtev_b64_decode+0x297>
lea    (%rsp,%r9,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rax
jae    12df <copy_of_mtev_b64_decode+0x1bf>
lea    (%r14,%r9,1),%rsi
lea    0x2(%rsp),%rcx
cmp    %rsi,%rcx
jb     13b7 <copy_of_mtev_b64_decode+0x297>
mov    %r8,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rbp
jae    1304 <copy_of_mtev_b64_decode+0x1e4>
xor    %ebp,%ebp
jmp    1372 <copy_of_mtev_b64_decode+0x252>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups 0x2(%rsp,%rbp,1),%xmm0
movups 0x12(%rsp,%rbp,1),%xmm1
movups %xmm0,0x1(%r14,%rbp,1)
movups %xmm1,0x11(%r14,%rbp,1)
movups 0x22(%rsp,%rbp,1),%xmm0
movups 0x32(%rsp,%rbp,1),%xmm1
movups %xmm0,0x21(%r14,%rbp,1)
movups %xmm1,0x31(%r14,%rbp,1)
movups 0x42(%rsp,%rbp,1),%xmm0
movups 0x52(%rsp,%rbp,1),%xmm1
movups %xmm0,0x41(%r14,%rbp,1)
movups %xmm1,0x51(%r14,%rbp,1)
movups 0x62(%rsp,%rbp,1),%xmm0
movups 0x72(%rsp,%rbp,1),%xmm1
movups %xmm0,0x61(%r14,%rbp,1)
movups %xmm1,0x71(%r14,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1310 <copy_of_mtev_b64_decode+0x1f0>
test   %rsi,%rsi
je     13a7 <copy_of_mtev_b64_decode+0x287>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rdi
or     $0x1,%rdi
movups 0x1(%rsp,%rdi,1),%xmm0
movups 0x11(%rsp,%rdi,1),%xmm1
movups %xmm0,0x1(%r14,%rbp,1)
movups %xmm1,0x11(%r14,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffff,%rsi
jne    1380 <copy_of_mtev_b64_decode+0x260>
add    %rdx,%rax
cmp    %rdx,%r8
je     1452 <copy_of_mtev_b64_decode+0x332>
or     $0x1,%rdx
mov    %r9d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
and    $0x7,%rdi
je     13e5 <copy_of_mtev_b64_decode+0x2c5>
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rsp,%rdx,1),%ecx
mov    %cl,(%rax)
add    $0x1,%rax
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    13d0 <copy_of_mtev_b64_decode+0x2b0>
cmp    $0x7,%rsi
jb     1452 <copy_of_mtev_b64_decode+0x332>
sub    %rdx,%r9
lea    0x8(%rsp),%rcx
add    %rcx,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl -0x7(%rdx,%rsi,1),%ecx
mov    %cl,(%rax,%rsi,1)
movzbl -0x6(%rdx,%rsi,1),%ecx
mov    %cl,0x1(%rax,%rsi,1)
movzbl -0x5(%rdx,%rsi,1),%ecx
mov    %cl,0x2(%rax,%rsi,1)
movzbl -0x4(%rdx,%rsi,1),%ecx
mov    %cl,0x3(%rax,%rsi,1)
movzbl -0x3(%rdx,%rsi,1),%ecx
mov    %cl,0x4(%rax,%rsi,1)
movzbl -0x2(%rdx,%rsi,1),%ecx
mov    %cl,0x5(%rax,%rsi,1)
movzbl -0x1(%rdx,%rsi,1),%ecx
mov    %cl,0x6(%rax,%rsi,1)
movzbl (%rdx,%rsi,1),%ecx
mov    %cl,0x7(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1400 <copy_of_mtev_b64_decode+0x2e0>
add    %rsi,%rax
mov    %r10d,%ebp
jmp    1173 <copy_of_mtev_b64_decode+0x53>
mov    %r14,%rax
sub    %r13d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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