void base64_unmap(char *in_block) {
  int i;
  char *c;
  for (i = 0; i < 4; i++) {
    c = in_block + i;
    if (*c >= 'A' && *c <= 'Z') {
      *c -= 'A';
      continue;
    }
    if (*c >= 'a' && *c <= 'z') {
      *c -= 'a';
      *c += 26;
      continue;
    }
    if (*c == '+') {
      *c = 62;
      continue;
    }
    if (*c == '/') {
      *c = 63;
      continue;
    }
    if (*c >= '0' && *c <= '9') {
      *c -= '0';
      *c += 52;
      continue;
    }
    *c = 0;
  }
}


x86 assembly (clang, -O0):
<base64_unmap>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    1220 <base64_unmap+0x120>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1159 <base64_unmap+0x59>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     1159 <base64_unmap+0x59>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
sub    $0x41,%ecx
mov    %cl,(%rax)
jmp    1212 <base64_unmap+0x112>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1196 <base64_unmap+0x96>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     1196 <base64_unmap+0x96>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
sub    $0x61,%ecx
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
add    $0x1a,%ecx
mov    %cl,(%rax)
jmp    1212 <base64_unmap+0x112>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    11b2 <base64_unmap+0xb2>
mov    -0x18(%rbp),%rax
movb   $0x3e,(%rax)
jmp    1212 <base64_unmap+0x112>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    11ce <base64_unmap+0xce>
mov    -0x18(%rbp),%rax
movb   $0x3f,(%rax)
jmp    1212 <base64_unmap+0x112>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     120b <base64_unmap+0x10b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     120b <base64_unmap+0x10b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
sub    $0x30,%ecx
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
add    $0x34,%ecx
mov    %cl,(%rax)
jmp    1212 <base64_unmap+0x112>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <base64_unmap+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64_unmap>:
mov    (%rdi),%al
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jb     1138 <base64_unmap+0x38>
lea    -0x61(%rax),%ecx
cmp    $0x19,%cl
ja     1118 <base64_unmap+0x18>
add    $0xb9,%al
mov    %eax,%ecx
jmp    1138 <base64_unmap+0x38>
cmp    $0x2b,%al
je     1124 <base64_unmap+0x24>
cmp    $0x2f,%al
jne    1128 <base64_unmap+0x28>
mov    $0x3f,%cl
jmp    1138 <base64_unmap+0x38>
mov    $0x3e,%cl
jmp    1138 <base64_unmap+0x38>
lea    -0x30(%rax),%ecx
add    $0x4,%al
xor    %edx,%edx
cmp    $0xa,%cl
movzbl %al,%ecx
cmovae %edx,%ecx
mov    %cl,(%rdi)
mov    0x1(%rdi),%al
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jb     1173 <base64_unmap+0x73>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    1153 <base64_unmap+0x53>
add    $0xb9,%al
mov    %eax,%ecx
jmp    1173 <base64_unmap+0x73>
cmp    $0x2f,%al
je     115f <base64_unmap+0x5f>
cmp    $0x2b,%al
jne    1163 <base64_unmap+0x63>
mov    $0x3e,%cl
jmp    1173 <base64_unmap+0x73>
mov    $0x3f,%cl
jmp    1173 <base64_unmap+0x73>
lea    -0x30(%rax),%ecx
add    $0x4,%al
xor    %edx,%edx
cmp    $0xa,%cl
movzbl %al,%ecx
cmovae %edx,%ecx
mov    %cl,0x1(%rdi)
mov    0x2(%rdi),%al
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jb     11af <base64_unmap+0xaf>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    118f <base64_unmap+0x8f>
add    $0xb9,%al
mov    %eax,%ecx
jmp    11af <base64_unmap+0xaf>
cmp    $0x2f,%al
je     119b <base64_unmap+0x9b>
cmp    $0x2b,%al
jne    119f <base64_unmap+0x9f>
mov    $0x3e,%cl
jmp    11af <base64_unmap+0xaf>
mov    $0x3f,%cl
jmp    11af <base64_unmap+0xaf>
lea    -0x30(%rax),%ecx
add    $0x4,%al
xor    %edx,%edx
cmp    $0xa,%cl
movzbl %al,%ecx
cmovae %edx,%ecx
mov    %cl,0x2(%rdi)
mov    0x3(%rdi),%al
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jb     11c9 <base64_unmap+0xc9>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    11cd <base64_unmap+0xcd>
add    $0xb9,%al
mov    %eax,%ecx
mov    %cl,0x3(%rdi)
ret
cmp    $0x2f,%al
je     11db <base64_unmap+0xdb>
cmp    $0x2b,%al
jne    11e1 <base64_unmap+0xe1>
mov    $0x3e,%cl
mov    %cl,0x3(%rdi)
ret
mov    $0x3f,%cl
mov    %cl,0x3(%rdi)
ret
lea    -0x30(%rax),%ecx
add    $0x4,%al
xor    %edx,%edx
cmp    $0xa,%cl
movzbl %al,%ecx
cmovae %edx,%ecx
mov    %cl,0x3(%rdi)
ret

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

LLVM IR (-O2):
define void @base64_unmap(i8* nocapture %0) {
%2 = load i8, i8* %0
%3 = add i8 %2, -65
%4 = icmp ult i8 %3, 26
br i1 %4, label %17, label %5
5: ; preds = %1
%6 = add i8 %2, -97
%7 = icmp ult i8 %6, 26
br i1 %7, label %8, label %10
8: ; preds = %5
%9 = add nsw i8 %2, -71
br label %17
10: ; preds = %5
switch i8 %2, label %12 [
i8 43, label %17
i8 47, label %11
]
11: ; preds = %10
br label %17
12: ; preds = %10
%13 = add i8 %2, -48
%14 = icmp ult i8 %13, 10
%15 = add nuw nsw i8 %2, 4
%16 = select i1 %14, i8 %15, i8 0
br label %17
17: ; preds = %12, %10, %1, %11, %8
%18 = phi i8 [ 63, %11 ], [ %9, %8 ], [ %3, %1 ], [ 62, %10 ], [ %16, %12 ]
store i8 %18, i8* %0
%19 = getelementptr inbounds i8, i8* %0, i64 1
%20 = load i8, i8* %19
%21 = add i8 %20, -65
%22 = icmp ult i8 %21, 26
br i1 %22, label %35, label %23
23: ; preds = %17
%24 = add i8 %20, -97
%25 = icmp ult i8 %24, 26
br i1 %25, label %33, label %26
26: ; preds = %23
switch i8 %20, label %28 [
i8 43, label %27
i8 47, label %35
]
27: ; preds = %26
br label %35
28: ; preds = %26
%29 = add i8 %20, -48
%30 = icmp ult i8 %29, 10
%31 = add nuw nsw i8 %20, 4
%32 = select i1 %30, i8 %31, i8 0
br label %35
33: ; preds = %23
%34 = add nsw i8 %20, -71
br label %35
35: ; preds = %28, %17, %26, %33, %27
%36 = phi i8 [ %34, %33 ], [ 62, %27 ], [ 63, %26 ], [ %21, %17 ], [ %32, %28 ]
store i8 %36, i8* %19
%37 = getelementptr inbounds i8, i8* %0, i64 2
%38 = load i8, i8* %37
%39 = add i8 %38, -65
%40 = icmp ult i8 %39, 26
br i1 %40, label %53, label %41
41: ; preds = %35
%42 = add i8 %38, -97
%43 = icmp ult i8 %42, 26
br i1 %43, label %51, label %44
44: ; preds = %41
switch i8 %38, label %46 [
i8 43, label %45
i8 47, label %53
]
45: ; preds = %44
br label %53
46: ; preds = %44
%47 = add i8 %38, -48
%48 = icmp ult i8 %47, 10
%49 = add nuw nsw i8 %38, 4
%50 = select i1 %48, i8 %49, i8 0
br label %53
51: ; preds = %41
%52 = add nsw i8 %38, -71
br label %53
53: ; preds = %46, %35, %44, %51, %45
%54 = phi i8 [ %52, %51 ], [ 62, %45 ], [ 63, %44 ], [ %39, %35 ], [ %50, %46 ]
store i8 %54, i8* %37
%55 = getelementptr inbounds i8, i8* %0, i64 3
%56 = load i8, i8* %55
%57 = add i8 %56, -65
%58 = icmp ult i8 %57, 26
br i1 %58, label %71, label %59
59: ; preds = %53
%60 = add i8 %56, -97
%61 = icmp ult i8 %60, 26
br i1 %61, label %69, label %62
62: ; preds = %59
switch i8 %56, label %64 [
i8 43, label %63
i8 47, label %71
]
63: ; preds = %62
br label %71
64: ; preds = %62
%65 = add i8 %56, -48
%66 = icmp ult i8 %65, 10
%67 = add nuw nsw i8 %56, 4
%68 = select i1 %66, i8 %67, i8 0
br label %71
69: ; preds = %59
%70 = add nsw i8 %56, -71
br label %71
71: ; preds = %64, %53, %62, %69, %63
%72 = phi i8 [ %70, %69 ], [ 62, %63 ], [ 63, %62 ], [ %57, %53 ], [ %68, %64 ]
store i8 %72, i8* %55
ret void
}