int base64_decode(char **in, int *ilen, char **out, int *olen) {
  int n;
  while (*ilen >= 4 && *olen >= 3) {
    {
      register char *_i_ = (char *)(*in);
      register unsigned char *_o_ = (unsigned char *)(*out);
      register unsigned char _h_, _l_;
      do {
        if ((_l_ = ((
                 unsigned char)((((_i_[0])) >= 'A' && ((_i_[0])) <= 'Z')
                                    ? (((_i_[0])) - 'A')
                                    : (((((_i_[0]))) >= 'a' &&
                                        (((_i_[0]))) <= 'z')
                                           ? ((((_i_[0]))) - 'a' + 26)
                                           : ((((((_i_[0])))) >= '0' &&
                                               ((((_i_[0])))) <= '9')
                                                  ? (((((_i_[0])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[0]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[0])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -1;
          break;
        }
        _h_ = (_l_ << 2);
        if ((_l_ = ((
                 unsigned char)((((_i_[1])) >= 'A' && ((_i_[1])) <= 'Z')
                                    ? (((_i_[1])) - 'A')
                                    : (((((_i_[1]))) >= 'a' &&
                                        (((_i_[1]))) <= 'z')
                                           ? ((((_i_[1]))) - 'a' + 26)
                                           : ((((((_i_[1])))) >= '0' &&
                                               ((((_i_[1])))) <= '9')
                                                  ? (((((_i_[1])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[1]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[1])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -2;
          break;
        }
        _o_[0] = _h_ | (_l_ >> 4);
        _h_ = (_l_ << 4);
        if (_i_[2] == '=' && _i_[3] == '=') {
          (n) = 1;
          break;
        }
        if ((_l_ = ((
                 unsigned char)((((_i_[2])) >= 'A' && ((_i_[2])) <= 'Z')
                                    ? (((_i_[2])) - 'A')
                                    : (((((_i_[2]))) >= 'a' &&
                                        (((_i_[2]))) <= 'z')
                                           ? ((((_i_[2]))) - 'a' + 26)
                                           : ((((((_i_[2])))) >= '0' &&
                                               ((((_i_[2])))) <= '9')
                                                  ? (((((_i_[2])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[2]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[2])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -3;
          break;
        }
        _o_[1] = _h_ | (_l_ >> 2);
        _h_ = (_l_ << 6);
        if (_i_[3] == '=') {
          (n) = 2;
          break;
        }
        if ((_l_ = ((
                 unsigned char)((((_i_[3])) >= 'A' && ((_i_[3])) <= 'Z')
                                    ? (((_i_[3])) - 'A')
                                    : (((((_i_[3]))) >= 'a' &&
                                        (((_i_[3]))) <= 'z')
                                           ? ((((_i_[3]))) - 'a' + 26)
                                           : ((((((_i_[3])))) >= '0' &&
                                               ((((_i_[3])))) <= '9')
                                                  ? (((((_i_[3])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[3]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[3])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -4;
          break;
        }
        _o_[2] = _h_ | _l_;
        (n) = 3;
      } while (0);
    }
    if (n <= 0)
      return -1;
    *out += n;
    *olen -= n;
    *in += 4;
    *ilen -= 4;
    if (n < 3)
      return 0;
  }
  if (*ilen <= 0)
    return 0;
  if (*ilen < 4)
    return -1;
  if (*olen > 0) {
    char *s = *in;
    char *t, temp[3];
    t = temp;
    {
      register char *_i_ = (char *)(s);
      register unsigned char *_o_ = (unsigned char *)(t);
      register unsigned char _h_, _l_;
      do {
        if ((_l_ = ((
                 unsigned char)((((_i_[0])) >= 'A' && ((_i_[0])) <= 'Z')
                                    ? (((_i_[0])) - 'A')
                                    : (((((_i_[0]))) >= 'a' &&
                                        (((_i_[0]))) <= 'z')
                                           ? ((((_i_[0]))) - 'a' + 26)
                                           : ((((((_i_[0])))) >= '0' &&
                                               ((((_i_[0])))) <= '9')
                                                  ? (((((_i_[0])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[0]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[0])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -1;
          break;
        }
        _h_ = (_l_ << 2);
        if ((_l_ = ((
                 unsigned char)((((_i_[1])) >= 'A' && ((_i_[1])) <= 'Z')
                                    ? (((_i_[1])) - 'A')
                                    : (((((_i_[1]))) >= 'a' &&
                                        (((_i_[1]))) <= 'z')
                                           ? ((((_i_[1]))) - 'a' + 26)
                                           : ((((((_i_[1])))) >= '0' &&
                                               ((((_i_[1])))) <= '9')
                                                  ? (((((_i_[1])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[1]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[1])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -2;
          break;
        }
        _o_[0] = _h_ | (_l_ >> 4);
        _h_ = (_l_ << 4);
        if (_i_[2] == '=' && _i_[3] == '=') {
          (n) = 1;
          break;
        }
        if ((_l_ = ((
                 unsigned char)((((_i_[2])) >= 'A' && ((_i_[2])) <= 'Z')
                                    ? (((_i_[2])) - 'A')
                                    : (((((_i_[2]))) >= 'a' &&
                                        (((_i_[2]))) <= 'z')
                                           ? ((((_i_[2]))) - 'a' + 26)
                                           : ((((((_i_[2])))) >= '0' &&
                                               ((((_i_[2])))) <= '9')
                                                  ? (((((_i_[2])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[2]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[2])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -3;
          break;
        }
        _o_[1] = _h_ | (_l_ >> 2);
        _h_ = (_l_ << 6);
        if (_i_[3] == '=') {
          (n) = 2;
          break;
        }
        if ((_l_ = ((
                 unsigned char)((((_i_[3])) >= 'A' && ((_i_[3])) <= 'Z')
                                    ? (((_i_[3])) - 'A')
                                    : (((((_i_[3]))) >= 'a' &&
                                        (((_i_[3]))) <= 'z')
                                           ? ((((_i_[3]))) - 'a' + 26)
                                           : ((((((_i_[3])))) >= '0' &&
                                               ((((_i_[3])))) <= '9')
                                                  ? (((((_i_[3])))) - '0' + 26 +
                                                     26)
                                                  : (((((((_i_[3]))))) == '+')
                                                         ? (26 + 26 + 10)
                                                         : ((((((((
                                                                 _i_[3])))))) ==
                                                             '/')
                                                                ? (26 + 26 +
                                                                   10 + 1)
                                                                : 0xFF))))))) >=
            64) {
          (n) = -4;
          break;
        }
        _o_[2] = _h_ | _l_;
        (n) = 3;
      } while (0);
    }
    if (n <= 0)
      return -1;
    if (n <= *olen) {
      (void)memcpy(*out, temp, n);
      *out += n;
      *olen -= n;
      *in += 4;
      *ilen -= 4;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<base64_decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmpl   $0x4,(%rcx)
mov    %al,-0x73(%rbp)
jl     114a <base64_decode+0x3a>
mov    -0x28(%rbp),%rax
cmpl   $0x3,(%rax)
setge  %al
mov    %al,-0x73(%rbp)
mov    -0x73(%rbp),%al
test   $0x1,%al
jne    115a <base64_decode+0x4a>
jmp    1736 <base64_decode+0x626>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     11a2 <base64_decode+0x92>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     11a2 <base64_decode+0x92>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
mov    %eax,-0x78(%rbp)
jmp    1261 <base64_decode+0x151>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     11d7 <base64_decode+0xc7>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     11d7 <base64_decode+0xc7>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0x7c(%rbp)
jmp    125b <base64_decode+0x14b>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     120f <base64_decode+0xff>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     120f <base64_decode+0xff>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0x80(%rbp)
jmp    1255 <base64_decode+0x145>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    122f <base64_decode+0x11f>
mov    $0x3e,%eax
mov    %eax,-0x84(%rbp)
jmp    124c <base64_decode+0x13c>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %al,-0x42(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     127f <base64_decode+0x16f>
movl   $0xffffffff,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
movzbl -0x42(%rbp),%eax
shl    $0x2,%eax
mov    %al,-0x41(%rbp)
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x41,%eax
jl     12c1 <base64_decode+0x1b1>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x5a,%eax
jg     12c1 <base64_decode+0x1b1>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0x88(%rbp)
jmp    139d <base64_decode+0x28d>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x61,%eax
jl     12fc <base64_decode+0x1ec>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x7a,%eax
jg     12fc <base64_decode+0x1ec>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0x8c(%rbp)
jmp    1391 <base64_decode+0x281>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x30,%eax
jl     133a <base64_decode+0x22a>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x39,%eax
jg     133a <base64_decode+0x22a>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0x90(%rbp)
jmp    1385 <base64_decode+0x275>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2b,%eax
jne    135b <base64_decode+0x24b>
mov    $0x3e,%eax
mov    %eax,-0x94(%rbp)
jmp    1379 <base64_decode+0x269>
mov    -0x38(%rbp),%rax
movsbl 0x1(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %al,-0x42(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     13be <base64_decode+0x2ae>
movl   $0xfffffffe,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
movzbl -0x41(%rbp),%eax
movzbl -0x42(%rbp),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
movzbl -0x42(%rbp),%eax
shl    $0x4,%eax
mov    %al,-0x41(%rbp)
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x3d,%eax
jne    140b <base64_decode+0x2fb>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x3d,%eax
jne    140b <base64_decode+0x2fb>
movl   $0x1,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x41,%eax
jl     1443 <base64_decode+0x333>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x5a,%eax
jg     1443 <base64_decode+0x333>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0x98(%rbp)
jmp    151f <base64_decode+0x40f>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x61,%eax
jl     147e <base64_decode+0x36e>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x7a,%eax
jg     147e <base64_decode+0x36e>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0x9c(%rbp)
jmp    1513 <base64_decode+0x403>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x30,%eax
jl     14bc <base64_decode+0x3ac>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x39,%eax
jg     14bc <base64_decode+0x3ac>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xa0(%rbp)
jmp    1507 <base64_decode+0x3f7>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x2b,%eax
jne    14dd <base64_decode+0x3cd>
mov    $0x3e,%eax
mov    %eax,-0xa4(%rbp)
jmp    14fb <base64_decode+0x3eb>
mov    -0x38(%rbp),%rax
movsbl 0x2(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %al,-0x42(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     1540 <base64_decode+0x430>
movl   $0xfffffffd,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
movzbl -0x41(%rbp),%eax
movzbl -0x42(%rbp),%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0x42(%rbp),%eax
shl    $0x6,%eax
mov    %al,-0x41(%rbp)
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x3d,%eax
jne    157d <base64_decode+0x46d>
movl   $0x2,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x41,%eax
jl     15b5 <base64_decode+0x4a5>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x5a,%eax
jg     15b5 <base64_decode+0x4a5>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0xa8(%rbp)
jmp    1691 <base64_decode+0x581>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x61,%eax
jl     15f0 <base64_decode+0x4e0>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x7a,%eax
jg     15f0 <base64_decode+0x4e0>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0xac(%rbp)
jmp    1685 <base64_decode+0x575>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x30,%eax
jl     162e <base64_decode+0x51e>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x39,%eax
jg     162e <base64_decode+0x51e>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xb0(%rbp)
jmp    1679 <base64_decode+0x569>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x2b,%eax
jne    164f <base64_decode+0x53f>
mov    $0x3e,%eax
mov    %eax,-0xb4(%rbp)
jmp    166d <base64_decode+0x55d>
mov    -0x38(%rbp),%rax
movsbl 0x3(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    %al,-0x42(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     16b2 <base64_decode+0x5a2>
movl   $0xfffffffc,-0x2c(%rbp)
jmp    16cc <base64_decode+0x5bc>
movzbl -0x41(%rbp),%eax
movzbl -0x42(%rbp),%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %cl,0x2(%rax)
movl   $0x3,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jg     16e2 <base64_decode+0x5d2>
movl   $0xffffffff,-0x4(%rbp)
jmp    1d8d <base64_decode+0xc7d>
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x4,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
sub    $0x4,%ecx
mov    %ecx,(%rax)
cmpl   $0x3,-0x2c(%rbp)
jge    1731 <base64_decode+0x621>
movl   $0x0,-0x4(%rbp)
jmp    1d8d <base64_decode+0xc7d>
jmp    112b <base64_decode+0x1b>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jg     174f <base64_decode+0x63f>
movl   $0x0,-0x4(%rbp)
jmp    1d8d <base64_decode+0xc7d>
mov    -0x18(%rbp),%rax
cmpl   $0x4,(%rax)
jge    1768 <base64_decode+0x658>
movl   $0xffffffff,-0x4(%rbp)
jmp    1d8d <base64_decode+0xc7d>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1d86 <base64_decode+0xc76>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
lea    -0x5b(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     17cd <base64_decode+0x6bd>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     17cd <base64_decode+0x6bd>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
mov    %eax,-0xb8(%rbp)
jmp    18a1 <base64_decode+0x791>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1805 <base64_decode+0x6f5>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     1805 <base64_decode+0x6f5>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0xbc(%rbp)
jmp    1895 <base64_decode+0x785>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     1840 <base64_decode+0x730>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jg     1840 <base64_decode+0x730>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xc0(%rbp)
jmp    1889 <base64_decode+0x779>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    1860 <base64_decode+0x750>
mov    $0x3e,%eax
mov    %eax,-0xc4(%rbp)
jmp    187d <base64_decode+0x76d>
mov    -0x68(%rbp),%rax
movsbl (%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %al,-0x72(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     18c2 <base64_decode+0x7b2>
movl   $0xffffffff,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
movzbl -0x72(%rbp),%eax
shl    $0x2,%eax
mov    %al,-0x71(%rbp)
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x41,%eax
jl     1904 <base64_decode+0x7f4>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x5a,%eax
jg     1904 <base64_decode+0x7f4>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0xc8(%rbp)
jmp    19e0 <base64_decode+0x8d0>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x61,%eax
jl     193f <base64_decode+0x82f>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x7a,%eax
jg     193f <base64_decode+0x82f>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0xcc(%rbp)
jmp    19d4 <base64_decode+0x8c4>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x30,%eax
jl     197d <base64_decode+0x86d>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x39,%eax
jg     197d <base64_decode+0x86d>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xd0(%rbp)
jmp    19c8 <base64_decode+0x8b8>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2b,%eax
jne    199e <base64_decode+0x88e>
mov    $0x3e,%eax
mov    %eax,-0xd4(%rbp)
jmp    19bc <base64_decode+0x8ac>
mov    -0x68(%rbp),%rax
movsbl 0x1(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %al,-0x72(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     1a01 <base64_decode+0x8f1>
movl   $0xfffffffe,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
movzbl -0x71(%rbp),%eax
movzbl -0x72(%rbp),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x70(%rbp),%rax
mov    %cl,(%rax)
movzbl -0x72(%rbp),%eax
shl    $0x4,%eax
mov    %al,-0x71(%rbp)
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x3d,%eax
jne    1a4e <base64_decode+0x93e>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x3d,%eax
jne    1a4e <base64_decode+0x93e>
movl   $0x1,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x41,%eax
jl     1a86 <base64_decode+0x976>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x5a,%eax
jg     1a86 <base64_decode+0x976>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0xd8(%rbp)
jmp    1b62 <base64_decode+0xa52>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x61,%eax
jl     1ac1 <base64_decode+0x9b1>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x7a,%eax
jg     1ac1 <base64_decode+0x9b1>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0xdc(%rbp)
jmp    1b56 <base64_decode+0xa46>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x30,%eax
jl     1aff <base64_decode+0x9ef>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x39,%eax
jg     1aff <base64_decode+0x9ef>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xe0(%rbp)
jmp    1b4a <base64_decode+0xa3a>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x2b,%eax
jne    1b20 <base64_decode+0xa10>
mov    $0x3e,%eax
mov    %eax,-0xe4(%rbp)
jmp    1b3e <base64_decode+0xa2e>
mov    -0x68(%rbp),%rax
movsbl 0x2(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    %al,-0x72(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     1b83 <base64_decode+0xa73>
movl   $0xfffffffd,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
movzbl -0x71(%rbp),%eax
movzbl -0x72(%rbp),%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x70(%rbp),%rax
mov    %cl,0x1(%rax)
movzbl -0x72(%rbp),%eax
shl    $0x6,%eax
mov    %al,-0x71(%rbp)
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x3d,%eax
jne    1bc0 <base64_decode+0xab0>
movl   $0x2,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x41,%eax
jl     1bf8 <base64_decode+0xae8>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x5a,%eax
jg     1bf8 <base64_decode+0xae8>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x41,%eax
mov    %eax,-0xe8(%rbp)
jmp    1cd4 <base64_decode+0xbc4>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x61,%eax
jl     1c33 <base64_decode+0xb23>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x7a,%eax
jg     1c33 <base64_decode+0xb23>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x61,%eax
add    $0x1a,%eax
mov    %eax,-0xec(%rbp)
jmp    1cc8 <base64_decode+0xbb8>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x30,%eax
jl     1c71 <base64_decode+0xb61>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x39,%eax
jg     1c71 <base64_decode+0xb61>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x30,%eax
add    $0x1a,%eax
add    $0x1a,%eax
mov    %eax,-0xf0(%rbp)
jmp    1cbc <base64_decode+0xbac>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x2b,%eax
jne    1c92 <base64_decode+0xb82>
mov    $0x3e,%eax
mov    %eax,-0xf4(%rbp)
jmp    1cb0 <base64_decode+0xba0>
mov    -0x68(%rbp),%rax
movsbl 0x3(%rax),%edx
mov    $0xff,%eax
mov    $0x3f,%ecx
cmp    $0x2f,%edx
cmove  %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xec(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
mov    %al,-0x72(%rbp)
movzbl %al,%eax
cmp    $0x40,%eax
jl     1cf5 <base64_decode+0xbe5>
movl   $0xfffffffc,-0x2c(%rbp)
jmp    1d0f <base64_decode+0xbff>
movzbl -0x71(%rbp),%eax
movzbl -0x72(%rbp),%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x70(%rbp),%rax
mov    %cl,0x2(%rax)
movl   $0x3,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jg     1d25 <base64_decode+0xc15>
movl   $0xffffffff,-0x4(%rbp)
jmp    1d8d <base64_decode+0xc7d>
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1d81 <base64_decode+0xc71>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
lea    -0x5b(%rbp),%rsi
movslq -0x2c(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x4,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
sub    $0x4,%ecx
mov    %ecx,(%rax)
jmp    1d86 <base64_decode+0xc76>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64_decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,%r14
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%r15
mov    (%rsi),%ecx
jmp    1157 <base64_decode+0x47>
xchg   %ax,%ax
mov    $0x2,%ecx
mov    $0x1,%al
mov    %ecx,%edx
add    %rdx,(%r12)
sub    %ecx,(%r14)
addq   $0x4,(%r15)
mov    0x0(%r13),%ecx
add    $0xfffffffc,%ecx
mov    %ecx,0x0(%r13)
test   %al,%al
jne    133e <base64_decode+0x22e>
cmp    $0x4,%ecx
jl     1307 <base64_decode+0x1f7>
mov    (%r14),%eax
cmp    $0x3,%eax
jl     1316 <base64_decode+0x206>
mov    (%r15),%rcx
mov    (%r12),%rax
movzbl (%rcx),%edx
lea    -0x41(%rdx),%esi
cmp    $0x1a,%sil
jb     11c0 <base64_decode+0xb0>
lea    -0x61(%rdx),%esi
cmp    $0x19,%sil
ja     1190 <base64_decode+0x80>
add    $0xb9,%dl
mov    %edx,%esi
jmp    11c0 <base64_decode+0xb0>
nop
lea    -0x30(%rdx),%esi
cmp    $0x9,%sil
ja     11a0 <base64_decode+0x90>
add    $0x4,%dl
mov    %edx,%esi
jmp    11c0 <base64_decode+0xb0>
mov    $0x3e,%sil
cmp    $0x2b,%dl
je     11c0 <base64_decode+0xb0>
cmp    $0x2f,%dl
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%sil
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x1(%rcx),%edi
lea    -0x41(%rdi),%edx
cmp    $0x1a,%dl
jb     1210 <base64_decode+0x100>
lea    -0x61(%rdi),%edx
cmp    $0x19,%dl
ja     11e0 <base64_decode+0xd0>
add    $0xb9,%dil
mov    %edi,%edx
jmp    1210 <base64_decode+0x100>
nopl   0x0(%rax)
lea    -0x30(%rdi),%edx
cmp    $0x9,%dl
ja     11f0 <base64_decode+0xe0>
add    $0x4,%dil
mov    %edi,%edx
jmp    1210 <base64_decode+0x100>
mov    $0x3e,%dl
cmp    $0x2b,%dil
je     1210 <base64_decode+0x100>
cmp    $0x2f,%dil
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%dl
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
shl    $0x2,%sil
mov    %edx,%ebx
shr    $0x4,%bl
or     %sil,%bl
mov    %bl,(%rax)
movzbl 0x2(%rcx),%edi
cmp    $0x3d,%dil
jne    1240 <base64_decode+0x130>
cmpb   $0x3d,0x3(%rcx)
jne    13d1 <base64_decode+0x2c1>
mov    $0x1,%ecx
jmp    1135 <base64_decode+0x25>
nopl   0x0(%rax)
lea    -0x41(%rdi),%esi
cmp    $0x1a,%sil
jb     1290 <base64_decode+0x180>
lea    -0x61(%rdi),%esi
cmp    $0x19,%sil
ja     125a <base64_decode+0x14a>
add    $0xb9,%dil
mov    %edi,%esi
jmp    1290 <base64_decode+0x180>
lea    -0x30(%rdi),%esi
cmp    $0x9,%sil
ja     126b <base64_decode+0x15b>
add    $0x4,%dil
mov    %edi,%esi
jmp    1290 <base64_decode+0x180>
mov    $0x3e,%sil
cmp    $0x2b,%dil
je     1290 <base64_decode+0x180>
cmp    $0x2f,%dil
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%sil
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
shl    $0x4,%dl
mov    %esi,%ebx
shr    $0x2,%bl
or     %dl,%bl
mov    %bl,0x1(%rax)
movzbl 0x3(%rcx),%ecx
cmp    $0x3d,%cl
je     1130 <base64_decode+0x20>
lea    -0x41(%rcx),%edx
cmp    $0x1a,%dl
jb     12f0 <base64_decode+0x1e0>
lea    -0x61(%rcx),%edx
cmp    $0x19,%dl
ja     12c1 <base64_decode+0x1b1>
add    $0xb9,%cl
mov    %ecx,%edx
jmp    12f0 <base64_decode+0x1e0>
lea    -0x30(%rcx),%edx
cmp    $0x9,%dl
ja     12d0 <base64_decode+0x1c0>
add    $0x4,%cl
mov    %ecx,%edx
jmp    12f0 <base64_decode+0x1e0>
mov    $0x3e,%dl
cmp    $0x2b,%cl
je     12f0 <base64_decode+0x1e0>
cmp    $0x2f,%cl
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%dl
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
shl    $0x6,%sil
or     %dl,%sil
mov    %sil,0x2(%rax)
mov    $0x3,%ecx
xor    %eax,%eax
jmp    1137 <base64_decode+0x27>
xor    %ebp,%ebp
test   %ecx,%ecx
setg   %bpl
neg    %ebp
jmp    13d6 <base64_decode+0x2c6>
xor    %ebp,%ebp
test   %eax,%eax
jle    13d6 <base64_decode+0x2c6>
mov    (%r15),%rcx
mov    (%rcx),%sil
lea    -0x41(%rsi),%edx
cmp    $0x1a,%dl
jb     1367 <base64_decode+0x257>
lea    -0x61(%rsi),%edx
cmp    $0x19,%dl
ja     1345 <base64_decode+0x235>
add    $0xb9,%sil
mov    %esi,%edx
jmp    1367 <base64_decode+0x257>
xor    %ebp,%ebp
jmp    13d6 <base64_decode+0x2c6>
lea    -0x30(%rsi),%edx
cmp    $0x9,%dl
ja     1355 <base64_decode+0x245>
add    $0x4,%sil
mov    %esi,%edx
jmp    1367 <base64_decode+0x257>
cmp    $0x2b,%sil
je     1365 <base64_decode+0x255>
cmp    $0x2f,%sil
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%dl
jmp    1367 <base64_decode+0x257>
mov    $0x3e,%dl
mov    0x1(%rcx),%dil
lea    -0x41(%rdi),%esi
cmp    $0x1a,%sil
jb     13aa <base64_decode+0x29a>
lea    -0x61(%rdi),%esi
cmp    $0x19,%sil
ja     1385 <base64_decode+0x275>
add    $0xb9,%dil
mov    %edi,%esi
jmp    13aa <base64_decode+0x29a>
lea    -0x30(%rdi),%esi
cmp    $0x9,%sil
ja     1396 <base64_decode+0x286>
add    $0x4,%dil
mov    %edi,%esi
jmp    13aa <base64_decode+0x29a>
cmp    $0x2b,%dil
je     13a7 <base64_decode+0x297>
cmp    $0x2f,%dil
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%sil
jmp    13aa <base64_decode+0x29a>
mov    $0x3e,%sil
shl    $0x2,%dl
mov    %esi,%ebx
shr    $0x4,%bl
or     %dl,%bl
mov    %bl,0xd(%rsp)
mov    0x2(%rcx),%dil
cmp    $0x3d,%dil
jne    13e7 <base64_decode+0x2d7>
mov    $0x1,%ebx
cmpb   $0x3d,0x3(%rcx)
je     148c <base64_decode+0x37c>
mov    $0xffffffff,%ebp
mov    %ebp,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x41(%rdi),%edx
cmp    $0x1a,%dl
jb     1421 <base64_decode+0x311>
lea    -0x61(%rdi),%edx
cmp    $0x19,%dl
ja     13ff <base64_decode+0x2ef>
add    $0xb9,%dil
mov    %edi,%edx
jmp    1421 <base64_decode+0x311>
lea    -0x30(%rdi),%edx
cmp    $0x9,%dl
ja     140f <base64_decode+0x2ff>
add    $0x4,%dil
mov    %edi,%edx
jmp    1421 <base64_decode+0x311>
cmp    $0x2b,%dil
je     141f <base64_decode+0x30f>
cmp    $0x2f,%dil
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%dl
jmp    1421 <base64_decode+0x311>
mov    $0x3e,%dl
shl    $0x4,%sil
mov    %edx,%ebx
shr    $0x2,%bl
or     %sil,%bl
mov    %bl,0xe(%rsp)
mov    0x3(%rcx),%cl
mov    $0x2,%ebx
cmp    $0x3d,%cl
je     148c <base64_decode+0x37c>
lea    -0x41(%rcx),%esi
cmp    $0x1a,%sil
jb     147d <base64_decode+0x36d>
lea    -0x61(%rcx),%esi
cmp    $0x19,%sil
ja     1457 <base64_decode+0x347>
add    $0xb9,%cl
mov    %ecx,%esi
jmp    147d <base64_decode+0x36d>
lea    -0x30(%rcx),%esi
cmp    $0x9,%sil
ja     1467 <base64_decode+0x357>
add    $0x4,%cl
mov    %ecx,%esi
jmp    147d <base64_decode+0x36d>
cmp    $0x2b,%cl
je     147a <base64_decode+0x36a>
cmp    $0x2f,%cl
jne    13d1 <base64_decode+0x2c1>
mov    $0x3f,%sil
jmp    147d <base64_decode+0x36d>
mov    $0x3e,%sil
shl    $0x6,%dl
or     %sil,%dl
mov    %dl,0xf(%rsp)
mov    $0x3,%ebx
cmp    %eax,%ebx
ja     13d6 <base64_decode+0x2c6>
mov    (%r12),%rdi
mov    %ebx,%edx
mov    %rdx,0x10(%rsp)
lea    0xd(%rsp),%rsi
call   1030 <memcpy@plt>
mov    0x10(%rsp),%rax
add    %rax,(%r12)
sub    %ebx,(%r14)
addq   $0x4,(%r15)
addl   $0xfffffffc,0x0(%r13)
jmp    13d6 <base64_decode+0x2c6>

LLVM IR (-O0):
define i32 @base64_decode(i8** %0, i32* %1, i8** %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8**
%7 = alloca i32*
%8 = alloca i8**
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8
%14 = alloca i8
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca [3 x i8]
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i8
%21 = alloca i8
store i8** %0, i8*** %6
store i32* %1, i32** %7
store i8** %2, i8*** %8
store i32* %3, i32** %9
br label %22
22: ; preds = %455, %4
%23 = load i32*, i32** %7
%24 = load i32, i32* %23
%25 = icmp sge i32 %24, 4
br i1 %25, label %26, label %30
26: ; preds = %22
%27 = load i32*, i32** %9
%28 = load i32, i32* %27
%29 = icmp sge i32 %28, 3
br label %30
30: ; preds = %26, %22
%31 = phi i1 [ false, %22 ], [ %29, %26 ]
br i1 %31, label %32, label %456
32: ; preds = %30
%33 = load i8**, i8*** %6
%34 = load i8*, i8** %33
store i8* %34, i8** %11
%35 = load i8**, i8*** %8
%36 = load i8*, i8** %35
store i8* %36, i8** %12
br label %37
37: ; preds = %32
%38 = load i8*, i8** %11
%39 = getelementptr inbounds i8, i8* %38, i64 0
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp sge i32 %41, 65
br i1 %42, label %43, label %55
43: ; preds = %37
%44 = load i8*, i8** %11
%45 = getelementptr inbounds i8, i8* %44, i64 0
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp sle i32 %47, 90
br i1 %48, label %49, label %55
49: ; preds = %43
%50 = load i8*, i8** %11
%51 = getelementptr inbounds i8, i8* %50, i64 0
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = sub nsw i32 %53, 65
br label %115
55: ; preds = %43, %37
%56 = load i8*, i8** %11
%57 = getelementptr inbounds i8, i8* %56, i64 0
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = icmp sge i32 %59, 97
br i1 %60, label %61, label %74
61: ; preds = %55
%62 = load i8*, i8** %11
%63 = getelementptr inbounds i8, i8* %62, i64 0
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp sle i32 %65, 122
br i1 %66, label %67, label %74
67: ; preds = %61
%68 = load i8*, i8** %11
%69 = getelementptr inbounds i8, i8* %68, i64 0
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = sub nsw i32 %71, 97
%73 = add nsw i32 %72, 26
br label %113
74: ; preds = %61, %55
%75 = load i8*, i8** %11
%76 = getelementptr inbounds i8, i8* %75, i64 0
%77 = load i8, i8* %76
%78 = sext i8 %77 to i32
%79 = icmp sge i32 %78, 48
br i1 %79, label %80, label %94
80: ; preds = %74
%81 = load i8*, i8** %11
%82 = getelementptr inbounds i8, i8* %81, i64 0
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = icmp sle i32 %84, 57
br i1 %85, label %86, label %94
86: ; preds = %80
%87 = load i8*, i8** %11
%88 = getelementptr inbounds i8, i8* %87, i64 0
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = sub nsw i32 %90, 48
%92 = add nsw i32 %91, 26
%93 = add nsw i32 %92, 26
br label %111
94: ; preds = %80, %74
%95 = load i8*, i8** %11
%96 = getelementptr inbounds i8, i8* %95, i64 0
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
%99 = icmp eq i32 %98, 43
br i1 %99, label %100, label %101
100: ; preds = %94
br label %109
101: ; preds = %94
%102 = load i8*, i8** %11
%103 = getelementptr inbounds i8, i8* %102, i64 0
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = icmp eq i32 %105, 47
%107 = zext i1 %106 to i64
%108 = select i1 %106, i32 63, i32 255
br label %109
109: ; preds = %101, %100
%110 = phi i32 [ 62, %100 ], [ %108, %101 ]
br label %111
111: ; preds = %109, %86
%112 = phi i32 [ %93, %86 ], [ %110, %109 ]
br label %113
113: ; preds = %111, %67
%114 = phi i32 [ %73, %67 ], [ %112, %111 ]
br label %115
115: ; preds = %113, %49
%116 = phi i32 [ %54, %49 ], [ %114, %113 ]
%117 = trunc i32 %116 to i8
store i8 %117, i8* %14
%118 = zext i8 %117 to i32
%119 = icmp sge i32 %118, 64
br i1 %119, label %120, label %121
120: ; preds = %115
store i32 -1, i32* %10
br label %432
121: ; preds = %115
%122 = load i8, i8* %14
%123 = zext i8 %122 to i32
%124 = shl i32 %123, 2
%125 = trunc i32 %124 to i8
store i8 %125, i8* %13
%126 = load i8*, i8** %11
%127 = getelementptr inbounds i8, i8* %126, i64 1
%128 = load i8, i8* %127
%129 = sext i8 %128 to i32
%130 = icmp sge i32 %129, 65
br i1 %130, label %131, label %143
131: ; preds = %121
%132 = load i8*, i8** %11
%133 = getelementptr inbounds i8, i8* %132, i64 1
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
%136 = icmp sle i32 %135, 90
br i1 %136, label %137, label %143
137: ; preds = %131
%138 = load i8*, i8** %11
%139 = getelementptr inbounds i8, i8* %138, i64 1
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = sub nsw i32 %141, 65
br label %203
143: ; preds = %131, %121
%144 = load i8*, i8** %11
%145 = getelementptr inbounds i8, i8* %144, i64 1
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = icmp sge i32 %147, 97
br i1 %148, label %149, label %162
149: ; preds = %143
%150 = load i8*, i8** %11
%151 = getelementptr inbounds i8, i8* %150, i64 1
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = icmp sle i32 %153, 122
br i1 %154, label %155, label %162
155: ; preds = %149
%156 = load i8*, i8** %11
%157 = getelementptr inbounds i8, i8* %156, i64 1
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = sub nsw i32 %159, 97
%161 = add nsw i32 %160, 26
br label %201
162: ; preds = %149, %143
%163 = load i8*, i8** %11
%164 = getelementptr inbounds i8, i8* %163, i64 1
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = icmp sge i32 %166, 48
br i1 %167, label %168, label %182
168: ; preds = %162
%169 = load i8*, i8** %11
%170 = getelementptr inbounds i8, i8* %169, i64 1
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp sle i32 %172, 57
br i1 %173, label %174, label %182
174: ; preds = %168
%175 = load i8*, i8** %11
%176 = getelementptr inbounds i8, i8* %175, i64 1
%177 = load i8, i8* %176
%178 = sext i8 %177 to i32
%179 = sub nsw i32 %178, 48
%180 = add nsw i32 %179, 26
%181 = add nsw i32 %180, 26
br label %199
182: ; preds = %168, %162
%183 = load i8*, i8** %11
%184 = getelementptr inbounds i8, i8* %183, i64 1
%185 = load i8, i8* %184
%186 = sext i8 %185 to i32
%187 = icmp eq i32 %186, 43
br i1 %187, label %188, label %189
188: ; preds = %182
br label %197
189: ; preds = %182
%190 = load i8*, i8** %11
%191 = getelementptr inbounds i8, i8* %190, i64 1
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp eq i32 %193, 47
%195 = zext i1 %194 to i64
%196 = select i1 %194, i32 63, i32 255
br label %197
197: ; preds = %189, %188
%198 = phi i32 [ 62, %188 ], [ %196, %189 ]
br label %199
199: ; preds = %197, %174
%200 = phi i32 [ %181, %174 ], [ %198, %197 ]
br label %201
201: ; preds = %199, %155
%202 = phi i32 [ %161, %155 ], [ %200, %199 ]
br label %203
203: ; preds = %201, %137
%204 = phi i32 [ %142, %137 ], [ %202, %201 ]
%205 = trunc i32 %204 to i8
store i8 %205, i8* %14
%206 = zext i8 %205 to i32
%207 = icmp sge i32 %206, 64
br i1 %207, label %208, label %209
208: ; preds = %203
store i32 -2, i32* %10
br label %432
209: ; preds = %203
%210 = load i8, i8* %13
%211 = zext i8 %210 to i32
%212 = load i8, i8* %14
%213 = zext i8 %212 to i32
%214 = ashr i32 %213, 4
%215 = or i32 %211, %214
%216 = trunc i32 %215 to i8
%217 = load i8*, i8** %12
%218 = getelementptr inbounds i8, i8* %217, i64 0
store i8 %216, i8* %218
%219 = load i8, i8* %14
%220 = zext i8 %219 to i32
%221 = shl i32 %220, 4
%222 = trunc i32 %221 to i8
store i8 %222, i8* %13
%223 = load i8*, i8** %11
%224 = getelementptr inbounds i8, i8* %223, i64 2
%225 = load i8, i8* %224
%226 = sext i8 %225 to i32
%227 = icmp eq i32 %226, 61
br i1 %227, label %228, label %235
228: ; preds = %209
%229 = load i8*, i8** %11
%230 = getelementptr inbounds i8, i8* %229, i64 3
%231 = load i8, i8* %230
%232 = sext i8 %231 to i32
%233 = icmp eq i32 %232, 61
br i1 %233, label %234, label %235
234: ; preds = %228
store i32 1, i32* %10
br label %432
235: ; preds = %228, %209
%236 = load i8*, i8** %11
%237 = getelementptr inbounds i8, i8* %236, i64 2
%238 = load i8, i8* %237
%239 = sext i8 %238 to i32
%240 = icmp sge i32 %239, 65
br i1 %240, label %241, label %253
241: ; preds = %235
%242 = load i8*, i8** %11
%243 = getelementptr inbounds i8, i8* %242, i64 2
%244 = load i8, i8* %243
%245 = sext i8 %244 to i32
%246 = icmp sle i32 %245, 90
br i1 %246, label %247, label %253
247: ; preds = %241
%248 = load i8*, i8** %11
%249 = getelementptr inbounds i8, i8* %248, i64 2
%250 = load i8, i8* %249
%251 = sext i8 %250 to i32
%252 = sub nsw i32 %251, 65
br label %313
253: ; preds = %241, %235
%254 = load i8*, i8** %11
%255 = getelementptr inbounds i8, i8* %254, i64 2
%256 = load i8, i8* %255
%257 = sext i8 %256 to i32
%258 = icmp sge i32 %257, 97
br i1 %258, label %259, label %272
259: ; preds = %253
%260 = load i8*, i8** %11
%261 = getelementptr inbounds i8, i8* %260, i64 2
%262 = load i8, i8* %261
%263 = sext i8 %262 to i32
%264 = icmp sle i32 %263, 122
br i1 %264, label %265, label %272
265: ; preds = %259
%266 = load i8*, i8** %11
%267 = getelementptr inbounds i8, i8* %266, i64 2
%268 = load i8, i8* %267
%269 = sext i8 %268 to i32
%270 = sub nsw i32 %269, 97
%271 = add nsw i32 %270, 26
br label %311
272: ; preds = %259, %253
%273 = load i8*, i8** %11
%274 = getelementptr inbounds i8, i8* %273, i64 2
%275 = load i8, i8* %274
%276 = sext i8 %275 to i32
%277 = icmp sge i32 %276, 48
br i1 %277, label %278, label %292
278: ; preds = %272
%279 = load i8*, i8** %11
%280 = getelementptr inbounds i8, i8* %279, i64 2
%281 = load i8, i8* %280
%282 = sext i8 %281 to i32
%283 = icmp sle i32 %282, 57
br i1 %283, label %284, label %292
284: ; preds = %278
%285 = load i8*, i8** %11
%286 = getelementptr inbounds i8, i8* %285, i64 2
%287 = load i8, i8* %286
%288 = sext i8 %287 to i32
%289 = sub nsw i32 %288, 48
%290 = add nsw i32 %289, 26
%291 = add nsw i32 %290, 26
br label %309
292: ; preds = %278, %272
%293 = load i8*, i8** %11
%294 = getelementptr inbounds i8, i8* %293, i64 2
%295 = load i8, i8* %294
%296 = sext i8 %295 to i32
%297 = icmp eq i32 %296, 43
br i1 %297, label %298, label %299
298: ; preds = %292
br label %307
299: ; preds = %292
%300 = load i8*, i8** %11
%301 = getelementptr inbounds i8, i8* %300, i64 2
%302 = load i8, i8* %301
%303 = sext i8 %302 to i32
%304 = icmp eq i32 %303, 47
%305 = zext i1 %304 to i64
%306 = select i1 %304, i32 63, i32 255
br label %307
307: ; preds = %299, %298
%308 = phi i32 [ 62, %298 ], [ %306, %299 ]
br label %309
309: ; preds = %307, %284
%310 = phi i32 [ %291, %284 ], [ %308, %307 ]
br label %311
311: ; preds = %309, %265
%312 = phi i32 [ %271, %265 ], [ %310, %309 ]
br label %313
313: ; preds = %311, %247
%314 = phi i32 [ %252, %247 ], [ %312, %311 ]
%315 = trunc i32 %314 to i8
store i8 %315, i8* %14
%316 = zext i8 %315 to i32
%317 = icmp sge i32 %316, 64
br i1 %317, label %318, label %319
318: ; preds = %313
store i32 -3, i32* %10
br label %432
319: ; preds = %313
%320 = load i8, i8* %13
%321 = zext i8 %320 to i32
%322 = load i8, i8* %14
%323 = zext i8 %322 to i32
%324 = ashr i32 %323, 2
%325 = or i32 %321, %324
%326 = trunc i32 %325 to i8
%327 = load i8*, i8** %12
%328 = getelementptr inbounds i8, i8* %327, i64 1
store i8 %326, i8* %328
%329 = load i8, i8* %14
%330 = zext i8 %329 to i32
%331 = shl i32 %330, 6
%332 = trunc i32 %331 to i8
store i8 %332, i8* %13
%333 = load i8*, i8** %11
%334 = getelementptr inbounds i8, i8* %333, i64 3
%335 = load i8, i8* %334
%336 = sext i8 %335 to i32
%337 = icmp eq i32 %336, 61
br i1 %337, label %338, label %339
338: ; preds = %319
store i32 2, i32* %10
br label %432
339: ; preds = %319
%340 = load i8*, i8** %11
%341 = getelementptr inbounds i8, i8* %340, i64 3
%342 = load i8, i8* %341
%343 = sext i8 %342 to i32
%344 = icmp sge i32 %343, 65
br i1 %344, label %345, label %357
345: ; preds = %339
%346 = load i8*, i8** %11
%347 = getelementptr inbounds i8, i8* %346, i64 3
%348 = load i8, i8* %347
%349 = sext i8 %348 to i32
%350 = icmp sle i32 %349, 90
br i1 %350, label %351, label %357
351: ; preds = %345
%352 = load i8*, i8** %11
%353 = getelementptr inbounds i8, i8* %352, i64 3
%354 = load i8, i8* %353
%355 = sext i8 %354 to i32
%356 = sub nsw i32 %355, 65
br label %417
357: ; preds = %345, %339
%358 = load i8*, i8** %11
%359 = getelementptr inbounds i8, i8* %358, i64 3
%360 = load i8, i8* %359
%361 = sext i8 %360 to i32
%362 = icmp sge i32 %361, 97
br i1 %362, label %363, label %376
363: ; preds = %357
%364 = load i8*, i8** %11
%365 = getelementptr inbounds i8, i8* %364, i64 3
%366 = load i8, i8* %365
%367 = sext i8 %366 to i32
%368 = icmp sle i32 %367, 122
br i1 %368, label %369, label %376
369: ; preds = %363
%370 = load i8*, i8** %11
%371 = getelementptr inbounds i8, i8* %370, i64 3
%372 = load i8, i8* %371
%373 = sext i8 %372 to i32
%374 = sub nsw i32 %373, 97
%375 = add nsw i32 %374, 26
br label %415
376: ; preds = %363, %357
%377 = load i8*, i8** %11
%378 = getelementptr inbounds i8, i8* %377, i64 3
%379 = load i8, i8* %378
%380 = sext i8 %379 to i32
%381 = icmp sge i32 %380, 48
br i1 %381, label %382, label %396
382: ; preds = %376
%383 = load i8*, i8** %11
%384 = getelementptr inbounds i8, i8* %383, i64 3
%385 = load i8, i8* %384
%386 = sext i8 %385 to i32
%387 = icmp sle i32 %386, 57
br i1 %387, label %388, label %396
388: ; preds = %382
%389 = load i8*, i8** %11
%390 = getelementptr inbounds i8, i8* %389, i64 3
%391 = load i8, i8* %390
%392 = sext i8 %391 to i32
%393 = sub nsw i32 %392, 48
%394 = add nsw i32 %393, 26
%395 = add nsw i32 %394, 26
br label %413
396: ; preds = %382, %376
%397 = load i8*, i8** %11
%398 = getelementptr inbounds i8, i8* %397, i64 3
%399 = load i8, i8* %398
%400 = sext i8 %399 to i32
%401 = icmp eq i32 %400, 43
br i1 %401, label %402, label %403
402: ; preds = %396
br label %411
403: ; preds = %396
%404 = load i8*, i8** %11
%405 = getelementptr inbounds i8, i8* %404, i64 3
%406 = load i8, i8* %405
%407 = sext i8 %406 to i32
%408 = icmp eq i32 %407, 47
%409 = zext i1 %408 to i64
%410 = select i1 %408, i32 63, i32 255
br label %411
411: ; preds = %403, %402
%412 = phi i32 [ 62, %402 ], [ %410, %403 ]
br label %413
413: ; preds = %411, %388
%414 = phi i32 [ %395, %388 ], [ %412, %411 ]
br label %415
415: ; preds = %413, %369
%416 = phi i32 [ %375, %369 ], [ %414, %413 ]
br label %417
417: ; preds = %415, %351
%418 = phi i32 [ %356, %351 ], [ %416, %415 ]
%419 = trunc i32 %418 to i8
store i8 %419, i8* %14
%420 = zext i8 %419 to i32
%421 = icmp sge i32 %420, 64
br i1 %421, label %422, label %423
422: ; preds = %417
store i32 -4, i32* %10
br label %432
423: ; preds = %417
%424 = load i8, i8* %13
%425 = zext i8 %424 to i32
%426 = load i8, i8* %14
%427 = zext i8 %426 to i32
%428 = or i32 %425, %427
%429 = trunc i32 %428 to i8
%430 = load i8*, i8** %12
%431 = getelementptr inbounds i8, i8* %430, i64 2
store i8 %429, i8* %431
store i32 3, i32* %10
br label %432
432: ; preds = %423, %422, %338, %318, %234, %208, %120
%433 = load i32, i32* %10
%434 = icmp sle i32 %433, 0
br i1 %434, label %435, label %436
435: ; preds = %432
store i32 -1, i32* %5
br label %903
436: ; preds = %432
%437 = load i32, i32* %10
%438 = load i8**, i8*** %8
%439 = load i8*, i8** %438
%440 = sext i32 %437 to i64
%441 = getelementptr inbounds i8, i8* %439, i64 %440
store i8* %441, i8** %438
%442 = load i32, i32* %10
%443 = load i32*, i32** %9
%444 = load i32, i32* %443
%445 = sub nsw i32 %444, %442
store i32 %445, i32* %443
%446 = load i8**, i8*** %6
%447 = load i8*, i8** %446
%448 = getelementptr inbounds i8, i8* %447, i64 4
store i8* %448, i8** %446
%449 = load i32*, i32** %7
%450 = load i32, i32* %449
%451 = sub nsw i32 %450, 4
store i32 %451, i32* %449
%452 = load i32, i32* %10
%453 = icmp slt i32 %452, 3
br i1 %453, label %454, label %455
454: ; preds = %436
store i32 0, i32* %5
br label %903
455: ; preds = %436
br label %22
456: ; preds = %30
%457 = load i32*, i32** %7
%458 = load i32, i32* %457
%459 = icmp sle i32 %458, 0
br i1 %459, label %460, label %461
460: ; preds = %456
store i32 0, i32* %5
br label %903
461: ; preds = %456
%462 = load i32*, i32** %7
%463 = load i32, i32* %462
%464 = icmp slt i32 %463, 4
br i1 %464, label %465, label %466
465: ; preds = %461
store i32 -1, i32* %5
br label %903
466: ; preds = %461
%467 = load i32*, i32** %9
%468 = load i32, i32* %467
%469 = icmp sgt i32 %468, 0
br i1 %469, label %470, label %902
470: ; preds = %466
%471 = load i8**, i8*** %6
%472 = load i8*, i8** %471
store i8* %472, i8** %15
%473 = getelementptr inbounds [3 x i8], [3 x i8]* %17, i64 0, i64 0
store i8* %473, i8** %16
%474 = load i8*, i8** %15
store i8* %474, i8** %18
%475 = load i8*, i8** %16
store i8* %475, i8** %19
br label %476
476: ; preds = %470
%477 = load i8*, i8** %18
%478 = getelementptr inbounds i8, i8* %477, i64 0
%479 = load i8, i8* %478
%480 = sext i8 %479 to i32
%481 = icmp sge i32 %480, 65
br i1 %481, label %482, label %494
482: ; preds = %476
%483 = load i8*, i8** %18
%484 = getelementptr inbounds i8, i8* %483, i64 0
%485 = load i8, i8* %484
%486 = sext i8 %485 to i32
%487 = icmp sle i32 %486, 90
br i1 %487, label %488, label %494
488: ; preds = %482
%489 = load i8*, i8** %18
%490 = getelementptr inbounds i8, i8* %489, i64 0
%491 = load i8, i8* %490
%492 = sext i8 %491 to i32
%493 = sub nsw i32 %492, 65
br label %554
494: ; preds = %482, %476
%495 = load i8*, i8** %18
%496 = getelementptr inbounds i8, i8* %495, i64 0
%497 = load i8, i8* %496
%498 = sext i8 %497 to i32
%499 = icmp sge i32 %498, 97
br i1 %499, label %500, label %513
500: ; preds = %494
%501 = load i8*, i8** %18
%502 = getelementptr inbounds i8, i8* %501, i64 0
%503 = load i8, i8* %502
%504 = sext i8 %503 to i32
%505 = icmp sle i32 %504, 122
br i1 %505, label %506, label %513
506: ; preds = %500
%507 = load i8*, i8** %18
%508 = getelementptr inbounds i8, i8* %507, i64 0
%509 = load i8, i8* %508
%510 = sext i8 %509 to i32
%511 = sub nsw i32 %510, 97
%512 = add nsw i32 %511, 26
br label %552
513: ; preds = %500, %494
%514 = load i8*, i8** %18
%515 = getelementptr inbounds i8, i8* %514, i64 0
%516 = load i8, i8* %515
%517 = sext i8 %516 to i32
%518 = icmp sge i32 %517, 48
br i1 %518, label %519, label %533
519: ; preds = %513
%520 = load i8*, i8** %18
%521 = getelementptr inbounds i8, i8* %520, i64 0
%522 = load i8, i8* %521
%523 = sext i8 %522 to i32
%524 = icmp sle i32 %523, 57
br i1 %524, label %525, label %533
525: ; preds = %519
%526 = load i8*, i8** %18
%527 = getelementptr inbounds i8, i8* %526, i64 0
%528 = load i8, i8* %527
%529 = sext i8 %528 to i32
%530 = sub nsw i32 %529, 48
%531 = add nsw i32 %530, 26
%532 = add nsw i32 %531, 26
br label %550
533: ; preds = %519, %513
%534 = load i8*, i8** %18
%535 = getelementptr inbounds i8, i8* %534, i64 0
%536 = load i8, i8* %535
%537 = sext i8 %536 to i32
%538 = icmp eq i32 %537, 43
br i1 %538, label %539, label %540
539: ; preds = %533
br label %548
540: ; preds = %533
%541 = load i8*, i8** %18
%542 = getelementptr inbounds i8, i8* %541, i64 0
%543 = load i8, i8* %542
%544 = sext i8 %543 to i32
%545 = icmp eq i32 %544, 47
%546 = zext i1 %545 to i64
%547 = select i1 %545, i32 63, i32 255
br label %548
548: ; preds = %540, %539
%549 = phi i32 [ 62, %539 ], [ %547, %540 ]
br label %550
550: ; preds = %548, %525
%551 = phi i32 [ %532, %525 ], [ %549, %548 ]
br label %552
552: ; preds = %550, %506
%553 = phi i32 [ %512, %506 ], [ %551, %550 ]
br label %554
554: ; preds = %552, %488
%555 = phi i32 [ %493, %488 ], [ %553, %552 ]
%556 = trunc i32 %555 to i8
store i8 %556, i8* %21
%557 = zext i8 %556 to i32
%558 = icmp sge i32 %557, 64
br i1 %558, label %559, label %560
559: ; preds = %554
store i32 -1, i32* %10
br label %871
560: ; preds = %554
%561 = load i8, i8* %21
%562 = zext i8 %561 to i32
%563 = shl i32 %562, 2
%564 = trunc i32 %563 to i8
store i8 %564, i8* %20
%565 = load i8*, i8** %18
%566 = getelementptr inbounds i8, i8* %565, i64 1
%567 = load i8, i8* %566
%568 = sext i8 %567 to i32
%569 = icmp sge i32 %568, 65
br i1 %569, label %570, label %582
570: ; preds = %560
%571 = load i8*, i8** %18
%572 = getelementptr inbounds i8, i8* %571, i64 1
%573 = load i8, i8* %572
%574 = sext i8 %573 to i32
%575 = icmp sle i32 %574, 90
br i1 %575, label %576, label %582
576: ; preds = %570
%577 = load i8*, i8** %18
%578 = getelementptr inbounds i8, i8* %577, i64 1
%579 = load i8, i8* %578
%580 = sext i8 %579 to i32
%581 = sub nsw i32 %580, 65
br label %642
582: ; preds = %570, %560
%583 = load i8*, i8** %18
%584 = getelementptr inbounds i8, i8* %583, i64 1
%585 = load i8, i8* %584
%586 = sext i8 %585 to i32
%587 = icmp sge i32 %586, 97
br i1 %587, label %588, label %601
588: ; preds = %582
%589 = load i8*, i8** %18
%590 = getelementptr inbounds i8, i8* %589, i64 1
%591 = load i8, i8* %590
%592 = sext i8 %591 to i32
%593 = icmp sle i32 %592, 122
br i1 %593, label %594, label %601
594: ; preds = %588
%595 = load i8*, i8** %18
%596 = getelementptr inbounds i8, i8* %595, i64 1
%597 = load i8, i8* %596
%598 = sext i8 %597 to i32
%599 = sub nsw i32 %598, 97
%600 = add nsw i32 %599, 26
br label %640
601: ; preds = %588, %582
%602 = load i8*, i8** %18
%603 = getelementptr inbounds i8, i8* %602, i64 1
%604 = load i8, i8* %603
%605 = sext i8 %604 to i32
%606 = icmp sge i32 %605, 48
br i1 %606, label %607, label %621
607: ; preds = %601
%608 = load i8*, i8** %18
%609 = getelementptr inbounds i8, i8* %608, i64 1
%610 = load i8, i8* %609
%611 = sext i8 %610 to i32
%612 = icmp sle i32 %611, 57
br i1 %612, label %613, label %621
613: ; preds = %607
%614 = load i8*, i8** %18
%615 = getelementptr inbounds i8, i8* %614, i64 1
%616 = load i8, i8* %615
%617 = sext i8 %616 to i32
%618 = sub nsw i32 %617, 48
%619 = add nsw i32 %618, 26
%620 = add nsw i32 %619, 26
br label %638
621: ; preds = %607, %601
%622 = load i8*, i8** %18
%623 = getelementptr inbounds i8, i8* %622, i64 1
%624 = load i8, i8* %623
%625 = sext i8 %624 to i32
%626 = icmp eq i32 %625, 43
br i1 %626, label %627, label %628
627: ; preds = %621
br label %636
628: ; preds = %621
%629 = load i8*, i8** %18
%630 = getelementptr inbounds i8, i8* %629, i64 1
%631 = load i8, i8* %630
%632 = sext i8 %631 to i32
%633 = icmp eq i32 %632, 47
%634 = zext i1 %633 to i64
%635 = select i1 %633, i32 63, i32 255
br label %636
636: ; preds = %628, %627
%637 = phi i32 [ 62, %627 ], [ %635, %628 ]
br label %638
638: ; preds = %636, %613
%639 = phi i32 [ %620, %613 ], [ %637, %636 ]
br label %640
640: ; preds = %638, %594
%641 = phi i32 [ %600, %594 ], [ %639, %638 ]
br label %642
642: ; preds = %640, %576
%643 = phi i32 [ %581, %576 ], [ %641, %640 ]
%644 = trunc i32 %643 to i8
store i8 %644, i8* %21
%645 = zext i8 %644 to i32
%646 = icmp sge i32 %645, 64
br i1 %646, label %647, label %648
647: ; preds = %642
store i32 -2, i32* %10
br label %871
648: ; preds = %642
%649 = load i8, i8* %20
%650 = zext i8 %649 to i32
%651 = load i8, i8* %21
%652 = zext i8 %651 to i32
%653 = ashr i32 %652, 4
%654 = or i32 %650, %653
%655 = trunc i32 %654 to i8
%656 = load i8*, i8** %19
%657 = getelementptr inbounds i8, i8* %656, i64 0
store i8 %655, i8* %657
%658 = load i8, i8* %21
%659 = zext i8 %658 to i32
%660 = shl i32 %659, 4
%661 = trunc i32 %660 to i8
store i8 %661, i8* %20
%662 = load i8*, i8** %18
%663 = getelementptr inbounds i8, i8* %662, i64 2
%664 = load i8, i8* %663
%665 = sext i8 %664 to i32
%666 = icmp eq i32 %665, 61
br i1 %666, label %667, label %674
667: ; preds = %648
%668 = load i8*, i8** %18
%669 = getelementptr inbounds i8, i8* %668, i64 3
%670 = load i8, i8* %669
%671 = sext i8 %670 to i32
%672 = icmp eq i32 %671, 61
br i1 %672, label %673, label %674
673: ; preds = %667
store i32 1, i32* %10
br label %871
674: ; preds = %667, %648
%675 = load i8*, i8** %18
%676 = getelementptr inbounds i8, i8* %675, i64 2
%677 = load i8, i8* %676
%678 = sext i8 %677 to i32
%679 = icmp sge i32 %678, 65
br i1 %679, label %680, label %692
680: ; preds = %674
%681 = load i8*, i8** %18
%682 = getelementptr inbounds i8, i8* %681, i64 2
%683 = load i8, i8* %682
%684 = sext i8 %683 to i32
%685 = icmp sle i32 %684, 90
br i1 %685, label %686, label %692
686: ; preds = %680
%687 = load i8*, i8** %18
%688 = getelementptr inbounds i8, i8* %687, i64 2
%689 = load i8, i8* %688
%690 = sext i8 %689 to i32
%691 = sub nsw i32 %690, 65
br label %752
692: ; preds = %680, %674
%693 = load i8*, i8** %18
%694 = getelementptr inbounds i8, i8* %693, i64 2
%695 = load i8, i8* %694
%696 = sext i8 %695 to i32
%697 = icmp sge i32 %696, 97
br i1 %697, label %698, label %711
698: ; preds = %692
%699 = load i8*, i8** %18
%700 = getelementptr inbounds i8, i8* %699, i64 2
%701 = load i8, i8* %700
%702 = sext i8 %701 to i32
%703 = icmp sle i32 %702, 122
br i1 %703, label %704, label %711
704: ; preds = %698
%705 = load i8*, i8** %18
%706 = getelementptr inbounds i8, i8* %705, i64 2
%707 = load i8, i8* %706
%708 = sext i8 %707 to i32
%709 = sub nsw i32 %708, 97
%710 = add nsw i32 %709, 26
br label %750
711: ; preds = %698, %692
%712 = load i8*, i8** %18
%713 = getelementptr inbounds i8, i8* %712, i64 2
%714 = load i8, i8* %713
%715 = sext i8 %714 to i32
%716 = icmp sge i32 %715, 48
br i1 %716, label %717, label %731
717: ; preds = %711
%718 = load i8*, i8** %18
%719 = getelementptr inbounds i8, i8* %718, i64 2
%720 = load i8, i8* %719
%721 = sext i8 %720 to i32
%722 = icmp sle i32 %721, 57
br i1 %722, label %723, label %731
723: ; preds = %717
%724 = load i8*, i8** %18
%725 = getelementptr inbounds i8, i8* %724, i64 2
%726 = load i8, i8* %725
%727 = sext i8 %726 to i32
%728 = sub nsw i32 %727, 48
%729 = add nsw i32 %728, 26
%730 = add nsw i32 %729, 26
br label %748
731: ; preds = %717, %711
%732 = load i8*, i8** %18
%733 = getelementptr inbounds i8, i8* %732, i64 2
%734 = load i8, i8* %733
%735 = sext i8 %734 to i32
%736 = icmp eq i32 %735, 43
br i1 %736, label %737, label %738
737: ; preds = %731
br label %746
738: ; preds = %731
%739 = load i8*, i8** %18
%740 = getelementptr inbounds i8, i8* %739, i64 2
%741 = load i8, i8* %740
%742 = sext i8 %741 to i32
%743 = icmp eq i32 %742, 47
%744 = zext i1 %743 to i64
%745 = select i1 %743, i32 63, i32 255
br label %746
746: ; preds = %738, %737
%747 = phi i32 [ 62, %737 ], [ %745, %738 ]
br label %748
748: ; preds = %746, %723
%749 = phi i32 [ %730, %723 ], [ %747, %746 ]
br label %750
750: ; preds = %748, %704
%751 = phi i32 [ %710, %704 ], [ %749, %748 ]
br label %752
752: ; preds = %750, %686
%753 = phi i32 [ %691, %686 ], [ %751, %750 ]
%754 = trunc i32 %753 to i8
store i8 %754, i8* %21
%755 = zext i8 %754 to i32
%756 = icmp sge i32 %755, 64
br i1 %756, label %757, label %758
757: ; preds = %752
store i32 -3, i32* %10
br label %871
758: ; preds = %752
%759 = load i8, i8* %20
%760 = zext i8 %759 to i32
%761 = load i8, i8* %21
%762 = zext i8 %761 to i32
%763 = ashr i32 %762, 2
%764 = or i32 %760, %763
%765 = trunc i32 %764 to i8
%766 = load i8*, i8** %19
%767 = getelementptr inbounds i8, i8* %766, i64 1
store i8 %765, i8* %767
%768 = load i8, i8* %21
%769 = zext i8 %768 to i32
%770 = shl i32 %769, 6
%771 = trunc i32 %770 to i8
store i8 %771, i8* %20
%772 = load i8*, i8** %18
%773 = getelementptr inbounds i8, i8* %772, i64 3
%774 = load i8, i8* %773
%775 = sext i8 %774 to i32
%776 = icmp eq i32 %775, 61
br i1 %776, label %777, label %778
777: ; preds = %758
store i32 2, i32* %10
br label %871
778: ; preds = %758
%779 = load i8*, i8** %18
%780 = getelementptr inbounds i8, i8* %779, i64 3
%781 = load i8, i8* %780
%782 = sext i8 %781 to i32
%783 = icmp sge i32 %782, 65
br i1 %783, label %784, label %796
784: ; preds = %778
%785 = load i8*, i8** %18
%786 = getelementptr inbounds i8, i8* %785, i64 3
%787 = load i8, i8* %786
%788 = sext i8 %787 to i32
%789 = icmp sle i32 %788, 90
br i1 %789, label %790, label %796
790: ; preds = %784
%791 = load i8*, i8** %18
%792 = getelementptr inbounds i8, i8* %791, i64 3
%793 = load i8, i8* %792
%794 = sext i8 %793 to i32
%795 = sub nsw i32 %794, 65
br label %856
796: ; preds = %784, %778
%797 = load i8*, i8** %18
%798 = getelementptr inbounds i8, i8* %797, i64 3
%799 = load i8, i8* %798
%800 = sext i8 %799 to i32
%801 = icmp sge i32 %800, 97
br i1 %801, label %802, label %815
802: ; preds = %796
%803 = load i8*, i8** %18
%804 = getelementptr inbounds i8, i8* %803, i64 3
%805 = load i8, i8* %804
%806 = sext i8 %805 to i32
%807 = icmp sle i32 %806, 122
br i1 %807, label %808, label %815
808: ; preds = %802
%809 = load i8*, i8** %18
%810 = getelementptr inbounds i8, i8* %809, i64 3
%811 = load i8, i8* %810
%812 = sext i8 %811 to i32
%813 = sub nsw i32 %812, 97
%814 = add nsw i32 %813, 26
br label %854
815: ; preds = %802, %796
%816 = load i8*, i8** %18
%817 = getelementptr inbounds i8, i8* %816, i64 3
%818 = load i8, i8* %817
%819 = sext i8 %818 to i32
%820 = icmp sge i32 %819, 48
br i1 %820, label %821, label %835
821: ; preds = %815
%822 = load i8*, i8** %18
%823 = getelementptr inbounds i8, i8* %822, i64 3
%824 = load i8, i8* %823
%825 = sext i8 %824 to i32
%826 = icmp sle i32 %825, 57
br i1 %826, label %827, label %835
827: ; preds = %821
%828 = load i8*, i8** %18
%829 = getelementptr inbounds i8, i8* %828, i64 3
%830 = load i8, i8* %829
%831 = sext i8 %830 to i32
%832 = sub nsw i32 %831, 48
%833 = add nsw i32 %832, 26
%834 = add nsw i32 %833, 26
br label %852
835: ; preds = %821, %815
%836 = load i8*, i8** %18
%837 = getelementptr inbounds i8, i8* %836, i64 3
%838 = load i8, i8* %837
%839 = sext i8 %838 to i32
%840 = icmp eq i32 %839, 43
br i1 %840, label %841, label %842
841: ; preds = %835
br label %850
842: ; preds = %835
%843 = load i8*, i8** %18
%844 = getelementptr inbounds i8, i8* %843, i64 3
%845 = load i8, i8* %844
%846 = sext i8 %845 to i32
%847 = icmp eq i32 %846, 47
%848 = zext i1 %847 to i64
%849 = select i1 %847, i32 63, i32 255
br label %850
850: ; preds = %842, %841
%851 = phi i32 [ 62, %841 ], [ %849, %842 ]
br label %852
852: ; preds = %850, %827
%853 = phi i32 [ %834, %827 ], [ %851, %850 ]
br label %854
854: ; preds = %852, %808
%855 = phi i32 [ %814, %808 ], [ %853, %852 ]
br label %856
856: ; preds = %854, %790
%857 = phi i32 [ %795, %790 ], [ %855, %854 ]
%858 = trunc i32 %857 to i8
store i8 %858, i8* %21
%859 = zext i8 %858 to i32
%860 = icmp sge i32 %859, 64
br i1 %860, label %861, label %862
861: ; preds = %856
store i32 -4, i32* %10
br label %871
862: ; preds = %856
%863 = load i8, i8* %20
%864 = zext i8 %863 to i32
%865 = load i8, i8* %21
%866 = zext i8 %865 to i32
%867 = or i32 %864, %866
%868 = trunc i32 %867 to i8
%869 = load i8*, i8** %19
%870 = getelementptr inbounds i8, i8* %869, i64 2
store i8 %868, i8* %870
store i32 3, i32* %10
br label %871
871: ; preds = %862, %861, %777, %757, %673, %647, %559
%872 = load i32, i32* %10
%873 = icmp sle i32 %872, 0
br i1 %873, label %874, label %875
874: ; preds = %871
store i32 -1, i32* %5
br label %903
875: ; preds = %871
%876 = load i32, i32* %10
%877 = load i32*, i32** %9
%878 = load i32, i32* %877
%879 = icmp sle i32 %876, %878
br i1 %879, label %880, label %901
880: ; preds = %875
%881 = load i8**, i8*** %8
%882 = load i8*, i8** %881
%883 = getelementptr inbounds [3 x i8], [3 x i8]* %17, i64 0, i64 0
%884 = load i32, i32* %10
%885 = sext i32 %884 to i64
%886 = load i32, i32* %10
%887 = load i8**, i8*** %8
%888 = load i8*, i8** %887
%889 = sext i32 %886 to i64
%890 = getelementptr inbounds i8, i8* %888, i64 %889
store i8* %890, i8** %887
%891 = load i32, i32* %10
%892 = load i32*, i32** %9
%893 = load i32, i32* %892
%894 = sub nsw i32 %893, %891
store i32 %894, i32* %892
%895 = load i8**, i8*** %6
%896 = load i8*, i8** %895
%897 = getelementptr inbounds i8, i8* %896, i64 4
store i8* %897, i8** %895
%898 = load i32*, i32** %7
%899 = load i32, i32* %898
%900 = sub nsw i32 %899, 4
store i32 %900, i32* %898
br label %901
901: ; preds = %880, %875
br label %902
902: ; preds = %901, %466
store i32 0, i32* %5
br label %903
903: ; preds = %902, %874, %465, %460, %454, %435
%904 = load i32, i32* %5
ret i32 %904
}

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