int base64decode(const char *src, unsigned char *dest, int destsize) {
  unsigned char *olddest = dest;
  int accum = 0;
  int nbits = 0;
  while (*src) {
    int x = 0;
    char c = *src++;
    if (c >= 'A' && c <= 'Z')
      x = c - 'A';
    else if (c >= 'a' && c <= 'z')
      x = c - 'a' + 26;
    else if (c >= '0' && c <= '9')
      x = c - '0' + 52;
    else if (c == '+')
      x = 62;
    else if (c == '/')
      x = 63;
    else
      break;
    accum <<= 6;
    accum |= x;
    nbits += 6;
    while (nbits >= 8) {
      if (--destsize < 0)
        break;
      nbits -= 8;
      *dest++ = (char)((accum >> nbits) & 0xff);
    }
  }
  return dest - olddest;
}


x86 assembly (clang, -O0):
<base64decode>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     1288 <base64decode+0x188>
movl   $0x0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%al
mov    %al,-0x2d(%rbp)
movsbl -0x2d(%rbp),%eax
cmp    $0x41,%eax
jl     1176 <base64decode+0x76>
movsbl -0x2d(%rbp),%eax
cmp    $0x5a,%eax
jg     1176 <base64decode+0x76>
movsbl -0x2d(%rbp),%eax
sub    $0x41,%eax
mov    %eax,-0x2c(%rbp)
jmp    1219 <base64decode+0x119>
movsbl -0x2d(%rbp),%eax
cmp    $0x61,%eax
jl     11a2 <base64decode+0xa2>
movsbl -0x2d(%rbp),%eax
cmp    $0x7a,%eax
jg     11a2 <base64decode+0xa2>
movsbl -0x2d(%rbp),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0x2c(%rbp)
jmp    1214 <base64decode+0x114>
movsbl -0x2d(%rbp),%eax
cmp    $0x30,%eax
jl     11ce <base64decode+0xce>
movsbl -0x2d(%rbp),%eax
cmp    $0x39,%eax
jg     11ce <base64decode+0xce>
movsbl -0x2d(%rbp),%eax
sub    $0x30,%eax
add    $0x34,%eax
mov    %eax,-0x2c(%rbp)
jmp    120f <base64decode+0x10f>
movsbl -0x2d(%rbp),%eax
cmp    $0x2b,%eax
jne    11e7 <base64decode+0xe7>
movl   $0x3e,-0x2c(%rbp)
jmp    120a <base64decode+0x10a>
movsbl -0x2d(%rbp),%eax
cmp    $0x2f,%eax
jne    1200 <base64decode+0x100>
movl   $0x3f,-0x2c(%rbp)
jmp    1205 <base64decode+0x105>
jmp    1288 <base64decode+0x188>
jmp    120a <base64decode+0x10a>
jmp    120f <base64decode+0x10f>
jmp    1214 <base64decode+0x114>
jmp    1219 <base64decode+0x119>
mov    -0x24(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
or     -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jl     1283 <base64decode+0x183>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
jge    1255 <base64decode+0x155>
jmp    1283 <base64decode+0x183>
mov    -0x28(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
sar    %cl,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1234 <base64decode+0x134>
jmp    1125 <base64decode+0x25>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64decode>:
push   %r14
push   %rbx
mov    (%rdi),%r11b
mov    %rsi,%rax
test   %r11b,%r11b
je     143a <base64decode+0x33a>
xor    %r14d,%r14d
mov    $0x10,%r8d
movdqa 0xf1d(%rip),%xmm2
movaps 0xf25(%rip),%xmm13
movdqa 0xf2c(%rip),%xmm14
xor    %r9d,%r9d
mov    %rsi,%rax
jmp    115a <base64decode+0x5a>
nopl   0x0(%rax)
mov    %r10d,%ecx
add    $0xffffffff,%ebx
mov    %ecx,%r10d
mov    %ebx,%edx
mov    (%rdi),%r11b
mov    %r10d,%r14d
test   %r11b,%r11b
je     143a <base64decode+0x33a>
movsbl %r11b,%r10d
lea    -0x41(%r10),%ecx
cmp    $0x19,%cl
ja     1170 <base64decode+0x70>
add    $0xffffffbf,%r10d
jmp    11b0 <base64decode+0xb0>
nopl   (%rax)
lea    -0x61(%r11),%ecx
cmp    $0x19,%cl
ja     1180 <base64decode+0x80>
add    $0xffffffb9,%r10d
jmp    11b0 <base64decode+0xb0>
nop
lea    -0x30(%r11),%ecx
cmp    $0x9,%cl
ja     118f <base64decode+0x8f>
add    $0x4,%r10d
jmp    11b0 <base64decode+0xb0>
mov    $0x3e,%r10d
cmp    $0x2b,%r11b
je     11b0 <base64decode+0xb0>
cmp    $0x2f,%r11b
jne    143a <base64decode+0x33a>
mov    $0x3f,%r10d
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
shl    $0x6,%r9d
or     %r10d,%r9d
lea    0x6(%r14),%r10d
cmp    $0x2,%r14d
jl     114b <base64decode+0x4b>
cmp    $0xf,%r10d
mov    $0xf,%ecx
cmovl  %r10d,%ecx
sub    %ecx,%r14d
add    $0xd,%r14d
shr    $0x3,%r14d
test   %edx,%edx
mov    $0x0,%ebx
cmovs  %edx,%ebx
mov    %edx,%ecx
sub    %ebx,%ecx
cmp    %ecx,%r14d
cmovb  %r14d,%ecx
cmp    $0x10,%ecx
jb     1410 <base64decode+0x310>
add    $0x1,%ecx
mov    %ecx,%ebx
and    $0xf,%ebx
test   %rbx,%rbx
cmove  %r8,%rbx
sub    %rbx,%rcx
lea    0x0(,%rcx,8),%ebx
lea    (%rax,%rcx,1),%r11
sub    %ecx,%edx
movd   %r10d,%xmm0
sub    %ebx,%r10d
pshufd $0x0,%xmm0,%xmm11
movdqa %xmm11,%xmm12
paddd  0xdca(%rip),%xmm12
movdqa %xmm11,%xmm15
paddd  0xdcc(%rip),%xmm15
movdqa %xmm11,%xmm9
paddd  0xdce(%rip),%xmm9
paddd  0xdd5(%rip),%xmm11
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm8
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqa %xmm11,%xmm1
paddd  %xmm2,%xmm1
movdqa %xmm9,%xmm0
paddd  %xmm2,%xmm0
movdqa %xmm15,%xmm4
movdqa %xmm12,%xmm3
paddd  %xmm2,%xmm3
pshuflw $0xfe,%xmm3,%xmm5
movdqa %xmm8,%xmm6
psrad  %xmm5,%xmm6
paddd  %xmm2,%xmm4
pshuflw $0x54,%xmm3,%xmm10
movdqa %xmm8,%xmm5
psrad  %xmm10,%xmm5
pshufd $0xee,%xmm3,%xmm3
pshuflw $0xfe,%xmm3,%xmm7
movdqa %xmm2,%xmm10
movdqa %xmm8,%xmm2
psrad  %xmm7,%xmm2
punpcklqdq %xmm6,%xmm5
pshuflw $0x54,%xmm3,%xmm3
movdqa %xmm8,%xmm6
psrad  %xmm3,%xmm6
punpckhqdq %xmm2,%xmm6
pshuflw $0xfe,%xmm4,%xmm2
movdqa %xmm8,%xmm7
psrad  %xmm2,%xmm7
shufps $0xcc,%xmm6,%xmm5
pshuflw $0x54,%xmm4,%xmm2
movdqa %xmm8,%xmm3
psrad  %xmm2,%xmm3
pshufd $0xee,%xmm4,%xmm2
pshuflw $0xfe,%xmm2,%xmm4
movdqa %xmm8,%xmm6
psrad  %xmm4,%xmm6
punpcklqdq %xmm7,%xmm3
pshuflw $0x54,%xmm2,%xmm2
movdqa %xmm8,%xmm4
psrad  %xmm2,%xmm4
punpckhqdq %xmm6,%xmm4
pshuflw $0xfe,%xmm0,%xmm2
movdqa %xmm8,%xmm6
psrad  %xmm2,%xmm6
shufps $0xcc,%xmm4,%xmm3
pshuflw $0x54,%xmm0,%xmm2
movdqa %xmm8,%xmm4
psrad  %xmm2,%xmm4
pshufd $0xee,%xmm0,%xmm0
pshuflw $0xfe,%xmm0,%xmm2
movdqa %xmm8,%xmm7
psrad  %xmm2,%xmm7
punpcklqdq %xmm6,%xmm4
pshuflw $0x54,%xmm0,%xmm0
movdqa %xmm8,%xmm2
psrad  %xmm0,%xmm2
punpckhqdq %xmm7,%xmm2
pshuflw $0xfe,%xmm1,%xmm0
movdqa %xmm8,%xmm6
psrad  %xmm0,%xmm6
shufps $0xcc,%xmm2,%xmm4
pshuflw $0x54,%xmm1,%xmm0
movdqa %xmm8,%xmm2
psrad  %xmm0,%xmm2
pshufd $0xee,%xmm1,%xmm0
pshuflw $0xfe,%xmm0,%xmm1
movdqa %xmm8,%xmm7
psrad  %xmm1,%xmm7
punpcklqdq %xmm6,%xmm2
pshuflw $0x54,%xmm0,%xmm0
movdqa %xmm8,%xmm1
psrad  %xmm0,%xmm1
punpckhqdq %xmm7,%xmm1
shufps $0xcc,%xmm1,%xmm2
andps  %xmm13,%xmm2
andps  %xmm13,%xmm4
packuswb %xmm4,%xmm2
andps  %xmm13,%xmm3
andps  %xmm13,%xmm5
packuswb %xmm5,%xmm3
packuswb %xmm3,%xmm2
movdqu %xmm2,(%rax,%rbx,1)
movdqa %xmm10,%xmm2
add    $0x10,%rbx
paddd  %xmm14,%xmm11
paddd  %xmm14,%xmm9
paddd  %xmm14,%xmm15
paddd  %xmm14,%xmm12
cmp    %rbx,%rcx
jne    1270 <base64decode+0x170>
mov    %r11,%rax
nopl   0x0(%rax)
mov    %edx,%ebx
test   %edx,%edx
jle    1140 <base64decode+0x40>
lea    -0x8(%r10),%ecx
mov    %r9d,%edx
sar    %cl,%edx
mov    %dl,(%rax)
add    $0x1,%rax
lea    -0x1(%rbx),%edx
cmp    $0xf,%r10d
mov    %ecx,%r10d
jg     1410 <base64decode+0x310>
jmp    1143 <base64decode+0x43>
sub    %esi,%eax
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @base64decode(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%12 = load i8*, i8** %5
store i8* %12, i8** %7
store i32 0, i32* %8
store i32 0, i32* %9
br label %13
13: ; preds = %99, %3
%14 = load i8*, i8** %4
%15 = load i8, i8* %14
%16 = icmp ne i8 %15, 0
br i1 %16, label %17, label %100
17: ; preds = %13
store i32 0, i32* %10
%18 = load i8*, i8** %4
%19 = getelementptr inbounds i8, i8* %18, i32 1
store i8* %19, i8** %4
%20 = load i8, i8* %18
store i8 %20, i8* %11
%21 = load i8, i8* %11
%22 = sext i8 %21 to i32
%23 = icmp sge i32 %22, 65
br i1 %23, label %24, label %32
24: ; preds = %17
%25 = load i8, i8* %11
%26 = sext i8 %25 to i32
%27 = icmp sle i32 %26, 90
br i1 %27, label %28, label %32
28: ; preds = %24
%29 = load i8, i8* %11
%30 = sext i8 %29 to i32
%31 = sub nsw i32 %30, 65
store i32 %31, i32* %10
br label %73
32: ; preds = %24, %17
%33 = load i8, i8* %11
%34 = sext i8 %33 to i32
%35 = icmp sge i32 %34, 97
br i1 %35, label %36, label %45
36: ; preds = %32
%37 = load i8, i8* %11
%38 = sext i8 %37 to i32
%39 = icmp sle i32 %38, 122
br i1 %39, label %40, label %45
40: ; preds = %36
%41 = load i8, i8* %11
%42 = sext i8 %41 to i32
%43 = sub nsw i32 %42, 97
%44 = add nsw i32 %43, 26
store i32 %44, i32* %10
br label %72
45: ; preds = %36, %32
%46 = load i8, i8* %11
%47 = sext i8 %46 to i32
%48 = icmp sge i32 %47, 48
br i1 %48, label %49, label %58
49: ; preds = %45
%50 = load i8, i8* %11
%51 = sext i8 %50 to i32
%52 = icmp sle i32 %51, 57
br i1 %52, label %53, label %58
53: ; preds = %49
%54 = load i8, i8* %11
%55 = sext i8 %54 to i32
%56 = sub nsw i32 %55, 48
%57 = add nsw i32 %56, 52
store i32 %57, i32* %10
br label %71
58: ; preds = %49, %45
%59 = load i8, i8* %11
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 43
br i1 %61, label %62, label %63
62: ; preds = %58
store i32 62, i32* %10
br label %70
63: ; preds = %58
%64 = load i8, i8* %11
%65 = sext i8 %64 to i32
%66 = icmp eq i32 %65, 47
br i1 %66, label %67, label %68
67: ; preds = %63
store i32 63, i32* %10
br label %69
68: ; preds = %63
br label %100
69: ; preds = %67
br label %70
70: ; preds = %69, %62
br label %71
71: ; preds = %70, %53
br label %72
72: ; preds = %71, %40
br label %73
73: ; preds = %72, %28
%74 = load i32, i32* %8
%75 = shl i32 %74, 6
store i32 %75, i32* %8
%76 = load i32, i32* %10
%77 = load i32, i32* %8
%78 = or i32 %77, %76
store i32 %78, i32* %8
%79 = load i32, i32* %9
%80 = add nsw i32 %79, 6
store i32 %80, i32* %9
br label %81
81: ; preds = %89, %73
%82 = load i32, i32* %9
%83 = icmp sge i32 %82, 8
br i1 %83, label %84, label %99
84: ; preds = %81
%85 = load i32, i32* %6
%86 = add nsw i32 %85, -1
store i32 %86, i32* %6
%87 = icmp slt i32 %86, 0
br i1 %87, label %88, label %89
88: ; preds = %84
br label %99
89: ; preds = %84
%90 = load i32, i32* %9
%91 = sub nsw i32 %90, 8
store i32 %91, i32* %9
%92 = load i32, i32* %8
%93 = load i32, i32* %9
%94 = ashr i32 %92, %93
%95 = and i32 %94, 255
%96 = trunc i32 %95 to i8
%97 = load i8*, i8** %5
%98 = getelementptr inbounds i8, i8* %97, i32 1
store i8* %98, i8** %5
store i8 %96, i8* %97
br label %81
99: ; preds = %88, %81
br label %13
100: ; preds = %68, %13
%101 = load i8*, i8** %5
%102 = load i8*, i8** %7
%103 = ptrtoint i8* %101 to i64
%104 = ptrtoint i8* %102 to i64
%105 = sub i64 %103, %104
%106 = trunc i64 %105 to i32
ret i32 %106
}

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