#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;

/* Variables and functions */
int base64_decode_check(const uint8_t *in, size_t input_len) {
  unsigned int i;
  if ((input_len % 4) != 0)
    return 0;
  for (i = 0; i < input_len; i++) {
    if (!(((((((in[i]) >= 'A' && (in[i]) <= 'Z')) ||
             (((in[i]) >= 'a' && (in[i]) <= 'z')))) ||
           (((in[i]) >= '0' && (in[i]) <= '9')) || (in[i]) == '+' ||
           (in[i]) == '/' || (in[i]) == '=')))
      return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<base64_decode_check>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
je     112a <base64_decode_check+0x2a>
movl   $0x0,-0x4(%rbp)
jmp    1218 <base64_decode_check+0x118>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%rax
jae    1211 <base64_decode_check+0x111>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1166 <base64_decode_check+0x66>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jle    11fe <base64_decode_check+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     118e <base64_decode_check+0x8e>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jle    11fe <base64_decode_check+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     11b6 <base64_decode_check+0xb6>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    11fe <base64_decode_check+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
je     11fe <base64_decode_check+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
je     11fe <base64_decode_check+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3d,%eax
je     11fe <base64_decode_check+0xfe>
movl   $0x0,-0x4(%rbp)
jmp    1218 <base64_decode_check+0x118>
jmp    1203 <base64_decode_check+0x103>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1131 <base64_decode_check+0x31>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64_decode_check>:
xor    %eax,%eax
test   $0x3,%sil
je     1109 <base64_decode_check+0x9>
ret
test   %rsi,%rsi
je     114f <base64_decode_check+0x4f>
xor    %ecx,%ecx
movabs $0x2000880000000000,%r8
jmp    1128 <base64_decode_check+0x28>
nopl   0x0(%rax)
add    $0x1,%ecx
cmp    %rsi,%rcx
jae    114f <base64_decode_check+0x4f>
movzbl (%rdi,%rcx,1),%edx
mov    %edx,%eax
and    $0xdf,%al
add    $0xbf,%al
cmp    $0x1a,%al
jb     1120 <base64_decode_check+0x20>
lea    -0x30(%rdx),%eax
cmp    $0xa,%al
jb     1120 <base64_decode_check+0x20>
xor    %eax,%eax
cmp    $0x3d,%dl
ja     1108 <base64_decode_check+0x8>
movzbl %dl,%edx
bt     %rdx,%r8
jb     1120 <base64_decode_check+0x20>
jmp    1108 <base64_decode_check+0x8>
mov    $0x1,%eax
ret

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

LLVM IR (-O2):
define i32 @base64_decode_check(i8* nocapture %0, i64 %1) {
%3 = and i64 %1, 3
%4 = icmp eq i64 %3, 0
br i1 %4, label %5, label %22
5: ; preds = %2
%6 = icmp eq i64 %1, 0
br i1 %6, label %22, label %7
7: ; preds = %5, %18
%8 = phi i64 [ %20, %18 ], [ 0, %5 ]
%9 = getelementptr inbounds i8, i8* %0, i64 %8
%10 = load i8, i8* %9
%11 = and i8 %10, -33
%12 = add i8 %11, -65
%13 = icmp ult i8 %12, 26
%14 = add i8 %10, -48
%15 = icmp ult i8 %14, 10
%16 = select i1 %13, i1 true, i1 %15
br i1 %16, label %18, label %17
17: ; preds = %7
switch i8 %10, label %22 [
i8 43, label %18
i8 47, label %18
i8 61, label %18
]
18: ; preds = %17, %17, %17, %7
%19 = add nuw nsw i64 %8, 1
%20 = and i64 %19, 4294967295
%21 = icmp ult i64 %20, %1
br i1 %21, label %7, label %22
22: ; preds = %17, %18, %5, %2
%23 = phi i32 [ 0, %2 ], [ 1, %5 ], [ 0, %17 ], [ 1, %18 ]
ret i32 %23
}