void str_decode(dst, src) register unsigned char *dst, *src;
{
  register int is_qp, is_base64, is_done;
  register int c1, c2, c3, c4;
  char *dsttmp;
  char *srctmp;
  char srcbuf[256];
  int pos;
  if (ignorestr(src)) {
    strcpy(dst, src);
    return;
  }
  memcpy(srcbuf, src, 256);
  dsttmp = dst;
  srctmp = src;
  pos = (int)src - (int)srctmp;
  for (is_done = is_qp = is_base64 = 0; c1 = *src; src++) {
    pos = (int)src - (int)srctmp;
    if (pos > 254) {
      memcpy(dsttmp, srcbuf, 256);
      return;
    }
    if (c1 == '?' && src[1] == '=') {
      src++;
      continue;
    } else if (c1 == '\n') {
      src++;
      is_done = is_qp = is_base64 = 0;
      continue;
    } else if (is_qp && c1 == '=') {
      pos = (int)src - (int)srctmp;
      if (pos > 254) {
        memcpy(dsttmp, srcbuf, 256);
        return;
      }
      c1 = *++src;
      pos = (int)src - (int)srctmp;
      if (pos > 254) {
        memcpy(dsttmp, srcbuf, 256);
        return;
      }
      c2 = *++src;
      *dst++ = (qp_code(c1) << 4) | qp_code(c2);
    } else if (is_base64 && !is_done) {
      while (isspace(c1)) {
        pos = (int)src - (int)srctmp;
        if (pos > 254) {
          memcpy(dsttmp, srcbuf, 256);
          return;
        }
        c1 = *++src;
      }
      if (!c1)
        break;
      do {
        pos = (int)src - (int)srctmp;
        if (pos > 254) {
          memcpy(dsttmp, srcbuf, 256);
          return;
        }
        c2 = *++src;
      } while (isspace(c2));
      if (!c2)
        break;
      do {
        pos = (int)src - (int)srctmp;
        if (pos > 254) {
          memcpy(dsttmp, srcbuf, 256);
          return;
        }
        c3 = *++src;
      } while (isspace(c3));
      if (!c3)
        break;
      do {
        pos = (int)src - (int)srctmp;
        if (pos > 254) {
          memcpy(dsttmp, srcbuf, 256);
          return;
        }
        c4 = *++src;
      } while (isspace(c4));
      if (!c4)
        break;
      if (c1 == '=' || c2 == '=') {
        is_done = 1;
        continue;
      }
      c2 = base64_code(c2);
      *dst++ = (base64_code(c1) << 2) | ((c2 & 0x30) >> 4);
      if (c3 == '=')
        is_done = 1;
      else {
        c3 = base64_code(c3);
        *dst++ = ((c2 & 0xF) << 4) | ((c3 & 0x3c) >> 2);
        if (c4 == '=')
          is_done = 1;
        else {
          *dst++ = ((c3 & 0x03) << 6) | base64_code(c4);
        }
      }
    } else if ((c1 == '=') && (src[1] == '?')) {
      c2 = c3 = 0;
      for (;;) {
        pos = (int)src - (int)srctmp;
        if (pos > 254) {
          memcpy(dsttmp, srcbuf, 256);
          return;
        }
        c1 = *++src;
        if (c1 != '?') {
          if (c2 == 2)
            c3 = c1 | 0x20;
        } else {
          if (++c2 >= 3)
            break;
        }
      }
      if (c3 == 'q')
        is_qp = 1;
      else if (c3 == 'b')
        is_base64 = 1;
    } else
      *dst++ = c1;
  }
  *dst = '\0';
}


x86 assembly (clang, -O0):
<str_decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
mov    $0x0,%al
call   1050 <ignorestr@plt>
cmp    $0x0,%eax
je     1199 <str_decode+0x39>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <strcpy@plt>
jmp    1798 <str_decode+0x638>
lea    -0x140(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
je     1791 <str_decode+0x631>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    1230 <str_decode+0xd0>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
cmpl   $0x3f,-0x20(%rbp)
jne    125c <str_decode+0xfc>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x3d,%eax
jne    125c <str_decode+0xfc>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1780 <str_decode+0x620>
cmpl   $0xa,-0x20(%rbp)
jne    128c <str_decode+0x12c>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
jmp    1780 <str_decode+0x620>
cmpl   $0x0,-0x14(%rbp)
je     137f <str_decode+0x21f>
cmpl   $0x3d,-0x20(%rbp)
jne    137f <str_decode+0x21f>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    12da <str_decode+0x17a>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    132a <str_decode+0x1ca>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <qp_code@plt>
shl    $0x4,%eax
mov    %eax,-0x148(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x0,%al
call   1070 <qp_code@plt>
mov    %eax,%ecx
mov    -0x148(%rbp),%eax
or     %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    1771 <str_decode+0x611>
cmpl   $0x0,-0x18(%rbp)
je     1664 <str_decode+0x504>
cmpl   $0x0,-0x1c(%rbp)
jne    1664 <str_decode+0x504>
jmp    1398 <str_decode+0x238>
mov    -0x20(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%eax
je     13fe <str_decode+0x29e>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    13e3 <str_decode+0x283>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x20(%rbp)
jmp    1398 <str_decode+0x238>
cmpl   $0x0,-0x20(%rbp)
jne    140d <str_decode+0x2ad>
jmp    1791 <str_decode+0x631>
jmp    1412 <str_decode+0x2b2>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    144c <str_decode+0x2ec>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%eax
jne    1412 <str_decode+0x2b2>
cmpl   $0x0,-0x24(%rbp)
jne    1482 <str_decode+0x322>
jmp    1791 <str_decode+0x631>
jmp    1487 <str_decode+0x327>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    14c1 <str_decode+0x361>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%eax
jne    1487 <str_decode+0x327>
cmpl   $0x0,-0x28(%rbp)
jne    14f7 <str_decode+0x397>
jmp    1791 <str_decode+0x631>
jmp    14fc <str_decode+0x39c>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    1536 <str_decode+0x3d6>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edi
call   1060 <isspace@plt>
cmp    $0x0,%eax
jne    14fc <str_decode+0x39c>
cmpl   $0x0,-0x2c(%rbp)
jne    156c <str_decode+0x40c>
jmp    1791 <str_decode+0x631>
cmpl   $0x3d,-0x20(%rbp)
je     1580 <str_decode+0x420>
cmpl   $0x3d,-0x24(%rbp)
jne    158c <str_decode+0x42c>
movl   $0x1,-0x1c(%rbp)
jmp    1780 <str_decode+0x620>
mov    -0x24(%rbp),%edi
mov    $0x0,%al
call   1030 <base64_code@plt>
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <base64_code@plt>
shl    $0x2,%eax
mov    -0x24(%rbp),%ecx
and    $0x30,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
cmpl   $0x3d,-0x28(%rbp)
jne    15da <str_decode+0x47a>
movl   $0x1,-0x1c(%rbp)
jmp    165f <str_decode+0x4ff>
mov    -0x28(%rbp),%edi
mov    $0x0,%al
call   1030 <base64_code@plt>
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
and    $0xf,%eax
shl    $0x4,%eax
mov    -0x28(%rbp),%ecx
and    $0x3c,%ecx
sar    $0x2,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
cmpl   $0x3d,-0x2c(%rbp)
jne    1624 <str_decode+0x4c4>
movl   $0x1,-0x1c(%rbp)
jmp    165a <str_decode+0x4fa>
mov    -0x28(%rbp),%eax
and    $0x3,%eax
shl    $0x6,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x0,%al
call   1030 <base64_code@plt>
mov    %eax,%ecx
mov    -0x14c(%rbp),%eax
or     %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    165f <str_decode+0x4ff>
jmp    176c <str_decode+0x60c>
cmpl   $0x3d,-0x20(%rbp)
jne    1751 <str_decode+0x5f1>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1751 <str_decode+0x5f1>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0xfe,-0x144(%rbp)
jle    16c7 <str_decode+0x567>
mov    -0x38(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
jmp    1798 <str_decode+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl 0x1(%rax),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3f,-0x20(%rbp)
je     16ff <str_decode+0x59f>
cmpl   $0x2,-0x24(%rbp)
jne    16fa <str_decode+0x59a>
mov    -0x20(%rbp),%eax
or     $0x20,%eax
mov    %eax,-0x28(%rbp)
jmp    171b <str_decode+0x5bb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x3,%eax
jl     1716 <str_decode+0x5b6>
jmp    1720 <str_decode+0x5c0>
jmp    171b <str_decode+0x5bb>
jmp    168d <str_decode+0x52d>
cmpl   $0x71,-0x28(%rbp)
jne    1736 <str_decode+0x5d6>
movl   $0x1,-0x14(%rbp)
jmp    174c <str_decode+0x5ec>
cmpl   $0x62,-0x28(%rbp)
jne    1747 <str_decode+0x5e7>
movl   $0x1,-0x18(%rbp)
jmp    174c <str_decode+0x5ec>
jmp    1767 <str_decode+0x607>
mov    -0x20(%rbp),%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    176c <str_decode+0x60c>
jmp    1771 <str_decode+0x611>
jmp    1776 <str_decode+0x616>
jmp    177b <str_decode+0x61b>
jmp    1780 <str_decode+0x620>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11e3 <str_decode+0x83>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str_decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %rsi,%r14
mov    %rdi,0x10(%rsp)
mov    %rsi,%rdi
xor    %eax,%eax
call   1050 <ignorestr@plt>
test   %eax,%eax
je     11a5 <str_decode+0x45>
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <strcpy@plt>
lea    0x50(%rsp),%rdi
mov    $0x100,%edx
mov    %r14,%rsi
call   1080 <memcpy@plt>
mov    (%r14),%r13b
test   %r13b,%r13b
je     15cc <str_decode+0x46c>
mov    %r14d,%ebp
neg    %ebp
mov    $0x1,%eax
sub    %r14d,%eax
mov    %rax,0x40(%rsp)
mov    $0x2,%eax
sub    %r14d,%eax
mov    %rax,0x48(%rsp)
mov    0x10(%rsp),%rbx
mov    %r14,%r15
xor    %esi,%esi
xor    %r8d,%r8d
xor    %r12d,%r12d
jmp    121d <str_decode+0xbd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
xor    %r12d,%r12d
xor    %r8d,%r8d
xor    %esi,%esi
mov    0x1(%r15),%r13b
add    $0x1,%r15
test   %r13b,%r13b
je     15d1 <str_decode+0x471>
mov    %r15d,%eax
sub    %r14d,%eax
cmp    $0xff,%eax
jge    15b6 <str_decode+0x456>
cmp    $0xa,%r13b
je     1200 <str_decode+0xa0>
cmp    $0x3f,%r13b
jne    1250 <str_decode+0xf0>
cmpb   $0x3d,0x1(%r15)
jne    12c9 <str_decode+0x169>
add    $0x1,%r15
jmp    120c <str_decode+0xac>
nopl   0x0(%rax,%rax,1)
test   %esi,%esi
je     12dc <str_decode+0x17c>
cmp    $0x3d,%r13b
jne    12dc <str_decode+0x17c>
mov    %r15d,%eax
sub    %r14d,%eax
add    $0x1,%eax
cmp    $0xff,%eax
jge    15b6 <str_decode+0x456>
movzbl 0x1(%r15),%edi
movzbl 0x2(%r15),%eax
mov    %eax,0x18(%rsp)
add    $0x2,%r15
xor    %eax,%eax
mov    %r8d,%r13d
call   1070 <qp_code@plt>
mov    %rbx,0x20(%rsp)
mov    %r12d,%ebx
mov    %rbp,%r12
mov    %eax,%ebp
shl    $0x4,%ebp
mov    0x18(%rsp),%edi
xor    %eax,%eax
call   1070 <qp_code@plt>
mov    %r13d,%r8d
or     %ebp,%eax
mov    %r12,%rbp
mov    %ebx,%r12d
mov    0x20(%rsp),%rbx
mov    %al,(%rbx)
add    $0x1,%rbx
mov    $0x1,%esi
jmp    120c <str_decode+0xac>
test   %r12d,%r12d
je     13da <str_decode+0x27a>
test   %r8d,%r8d
je     12ea <str_decode+0x18a>
jmp    13da <str_decode+0x27a>
test   %r12d,%r12d
je     1363 <str_decode+0x203>
test   %r8d,%r8d
jne    1363 <str_decode+0x203>
mov    %rbp,0x18(%rsp)
mov    %esi,0xc(%rsp)
movzbl %r13b,%ebp
mov    %ebp,%edi
call   1060 <isspace@plt>
test   %eax,%eax
mov    %rbx,0x20(%rsp)
je     13e6 <str_decode+0x286>
mov    %r12d,%ebp
mov    0x18(%rsp),%rax
lea    (%rax,%r15,1),%ebx
nopw   0x0(%rax,%rax,1)
cmp    $0xff,%ebx
jge    15b6 <str_decode+0x456>
movzbl 0x1(%r15),%r13d
add    $0x1,%r15
movzbl %r13b,%r12d
mov    %r12d,%edi
call   1060 <isspace@plt>
add    $0x1,%ebx
test   %eax,%eax
jne    1320 <str_decode+0x1c0>
mov    %r12d,0x34(%rsp)
test   %r13b,%r13b
mov    0x20(%rsp),%rbx
mov    %ebp,%r12d
jne    13ea <str_decode+0x28a>
jmp    15d1 <str_decode+0x471>
cmp    $0x3d,%r13b
jne    13da <str_decode+0x27a>
cmpb   $0x3f,0x1(%r15)
jne    13da <str_decode+0x27a>
mov    %rbx,%rdi
mov    0x40(%rsp),%rax
lea    (%rax,%r15,1),%ecx
add    $0x1,%r15
xor    %eax,%eax
mov    $0x3f,%bl
xor    %edx,%edx
cmp    $0x3f,%bl
je     13b0 <str_decode+0x250>
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%edx
jne    13bc <str_decode+0x25c>
or     $0x20,%bl
movzbl %bl,%eax
mov    $0x2,%edx
jmp    13bc <str_decode+0x25c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x1,%edx
jg     150b <str_decode+0x3ab>
add    $0x1,%edx
cmp    $0xfe,%ecx
jg     15b6 <str_decode+0x456>
mov    0x1(%r15),%bl
add    $0x1,%r15
add    $0x1,%ecx
cmp    $0x3f,%bl
jne    1390 <str_decode+0x230>
jmp    13b0 <str_decode+0x250>
mov    %r13b,(%rbx)
add    $0x1,%rbx
jmp    120c <str_decode+0xac>
mov    %ebp,0x34(%rsp)
mov    %r12d,0x3c(%rsp)
mov    %r14,0x28(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%r15,1),%ebx
mov    0x40(%rsp),%rax
lea    (%rax,%r15,1),%ecx
mov    0x48(%rsp),%rax
lea    (%rax,%r15,1),%edx
nop
cmp    $0xff,%ebx
jge    15b6 <str_decode+0x456>
mov    %ecx,%ebp
mov    %edx,%r12d
movzbl 0x1(%r15),%r14d
add    $0x1,%r15
mov    %r14d,%edi
call   1060 <isspace@plt>
add    $0x1,%ebx
lea    0x1(%rbp),%ecx
lea    0x1(%r12),%edx
test   %eax,%eax
jne    1410 <str_decode+0x2b0>
test   %r14d,%r14d
je     15e6 <str_decode+0x486>
mov    %r13b,0xb(%rsp)
nop
cmp    $0xff,%ebp
jge    15b6 <str_decode+0x456>
mov    %r12d,%r13d
movzbl 0x1(%r15),%ebx
add    $0x1,%r15
mov    %ebx,%edi
call   1060 <isspace@plt>
add    $0x1,%ebp
lea    0x1(%r13),%r12d
test   %eax,%eax
jne    1450 <str_decode+0x2f0>
test   %ebx,%ebx
je     15e6 <str_decode+0x486>
mov    %ebx,0x38(%rsp)
mov    0x3c(%rsp),%r12d
nopl   0x0(%rax,%rax,1)
cmp    $0xff,%r13d
jge    15b6 <str_decode+0x456>
movzbl 0x1(%r15),%ebp
add    $0x1,%r15
mov    %ebp,%edi
call   1060 <isspace@plt>
add    $0x1,%r13d
test   %eax,%eax
jne    1490 <str_decode+0x330>
test   %ebp,%ebp
je     15e6 <str_decode+0x486>
mov    $0x1,%r8d
cmpb   $0x3d,0xb(%rsp)
je     1526 <str_decode+0x3c6>
cmp    $0x3d,%r14b
je     1526 <str_decode+0x3c6>
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <base64_code@plt>
mov    %eax,%r14d
mov    0x34(%rsp),%edi
xor    %eax,%eax
call   1030 <base64_code@plt>
mov    %r14d,%ecx
shr    $0x4,%ecx
and    $0x3,%ecx
lea    (%rcx,%rax,4),%eax
mov    0x20(%rsp),%rbx
mov    %al,(%rbx)
mov    0x38(%rsp),%edi
cmp    $0x3d,%dil
jne    153e <str_decode+0x3de>
add    $0x1,%rbx
jmp    1562 <str_decode+0x402>
cmp    $0x62,%eax
je     157b <str_decode+0x41b>
cmp    $0x71,%eax
mov    %rdi,%rbx
jne    120c <str_decode+0xac>
mov    $0x1,%esi
jmp    120c <str_decode+0xac>
mov    0x28(%rsp),%r14
mov    0x18(%rsp),%rbp
mov    0xc(%rsp),%esi
mov    0x20(%rsp),%rbx
jmp    120c <str_decode+0xac>
xor    %eax,%eax
call   1030 <base64_code@plt>
mov    %eax,%r13d
shl    $0x4,%r14d
shr    $0x2,%eax
and    $0xf,%eax
or     %r14d,%eax
mov    %al,0x1(%rbx)
cmp    $0x3d,%bpl
jne    1589 <str_decode+0x429>
add    $0x2,%rbx
mov    0x28(%rsp),%r14
mov    0x18(%rsp),%rbp
mov    0xc(%rsp),%esi
mov    $0x1,%r8d
jmp    120c <str_decode+0xac>
mov    $0x1,%r12d
mov    %rdi,%rbx
jmp    120c <str_decode+0xac>
shl    $0x6,%r13d
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <base64_code@plt>
xor    %r8d,%r8d
or     %r13d,%eax
mov    %al,0x2(%rbx)
add    $0x3,%rbx
mov    0x28(%rsp),%r14
mov    0x18(%rsp),%rbp
mov    0xc(%rsp),%esi
jmp    120c <str_decode+0xac>
lea    0x50(%rsp),%rsi
mov    $0x100,%edx
mov    0x10(%rsp),%rdi
call   1080 <memcpy@plt>
jmp    15d4 <str_decode+0x474>
mov    0x10(%rsp),%rbx
movb   $0x0,(%rbx)
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rbx
jmp    15d1 <str_decode+0x471>

LLVM IR (-O0):
define void @str_decode(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca [256 x i8]
%15 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
%16 = load i8*, i8** %4
%17 = call i32 (i8*, ...) bitcast (i32 (...)* @ignorestr to i32 (i8*, ...)*)(i8* %16)
%18 = icmp ne i32 %17, 0
br i1 %18, label %19, label %23
19: ; preds = %2
%20 = load i8*, i8** %3
%21 = load i8*, i8** %4
%22 = call i8* @strcpy(i8* %20, i8* %21)
br label %337
23: ; preds = %2
%24 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
%25 = load i8*, i8** %4
%26 = load i8*, i8** %3
store i8* %26, i8** %12
%27 = load i8*, i8** %4
store i8* %27, i8** %13
%28 = load i8*, i8** %4
%29 = ptrtoint i8* %28 to i32
%30 = load i8*, i8** %13
%31 = ptrtoint i8* %30 to i32
%32 = sub nsw i32 %29, %31
store i32 %32, i32* %15
store i32 0, i32* %6
store i32 0, i32* %5
store i32 0, i32* %7
br label %33
33: ; preds = %332, %23
%34 = load i8*, i8** %4
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
store i32 %36, i32* %8
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %335
38: ; preds = %33
%39 = load i8*, i8** %4
%40 = ptrtoint i8* %39 to i32
%41 = load i8*, i8** %13
%42 = ptrtoint i8* %41 to i32
%43 = sub nsw i32 %40, %42
store i32 %43, i32* %15
%44 = load i32, i32* %15
%45 = icmp sgt i32 %44, 254
br i1 %45, label %46, label %49
46: ; preds = %38
%47 = load i8*, i8** %12
%48 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
49: ; preds = %38
%50 = load i32, i32* %8
%51 = icmp eq i32 %50, 63
br i1 %51, label %52, label %61
52: ; preds = %49
%53 = load i8*, i8** %4
%54 = getelementptr inbounds i8, i8* %53, i64 1
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = icmp eq i32 %56, 61
br i1 %57, label %58, label %61
58: ; preds = %52
%59 = load i8*, i8** %4
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %4
br label %332
61: ; preds = %52, %49
%62 = load i32, i32* %8
%63 = icmp eq i32 %62, 10
br i1 %63, label %64, label %67
64: ; preds = %61
%65 = load i8*, i8** %4
%66 = getelementptr inbounds i8, i8* %65, i32 1
store i8* %66, i8** %4
store i32 0, i32* %6
store i32 0, i32* %5
store i32 0, i32* %7
br label %332
67: ; preds = %61
%68 = load i32, i32* %5
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %113
70: ; preds = %67
%71 = load i32, i32* %8
%72 = icmp eq i32 %71, 61
br i1 %72, label %73, label %113
73: ; preds = %70
%74 = load i8*, i8** %4
%75 = ptrtoint i8* %74 to i32
%76 = load i8*, i8** %13
%77 = ptrtoint i8* %76 to i32
%78 = sub nsw i32 %75, %77
store i32 %78, i32* %15
%79 = load i32, i32* %15
%80 = icmp sgt i32 %79, 254
br i1 %80, label %81, label %84
81: ; preds = %73
%82 = load i8*, i8** %12
%83 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
84: ; preds = %73
%85 = load i8*, i8** %4
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %4
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
store i32 %88, i32* %8
%89 = load i8*, i8** %4
%90 = ptrtoint i8* %89 to i32
%91 = load i8*, i8** %13
%92 = ptrtoint i8* %91 to i32
%93 = sub nsw i32 %90, %92
store i32 %93, i32* %15
%94 = load i32, i32* %15
%95 = icmp sgt i32 %94, 254
br i1 %95, label %96, label %99
96: ; preds = %84
%97 = load i8*, i8** %12
%98 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
99: ; preds = %84
%100 = load i8*, i8** %4
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %4
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
store i32 %103, i32* %9
%104 = load i32, i32* %8
%105 = call i32 (i32, ...) bitcast (i32 (...)* @qp_code to i32 (i32, ...)*)(i32 %104)
%106 = shl i32 %105, 4
%107 = load i32, i32* %9
%108 = call i32 (i32, ...) bitcast (i32 (...)* @qp_code to i32 (i32, ...)*)(i32 %107)
%109 = or i32 %106, %108
%110 = trunc i32 %109 to i8
%111 = load i8*, i8** %3
%112 = getelementptr inbounds i8, i8* %111, i32 1
store i8* %112, i8** %3
store i8 %110, i8* %111
br label %329
113: ; preds = %70, %67
%114 = load i32, i32* %6
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %270
116: ; preds = %113
%117 = load i32, i32* %7
%118 = icmp ne i32 %117, 0
br i1 %118, label %270, label %119
119: ; preds = %116
br label %120
120: ; preds = %135, %119
%121 = load i32, i32* %8
%122 = call i32 @isspace(i32 %121)
%123 = icmp ne i32 %122, 0
br i1 %123, label %124, label %140
124: ; preds = %120
%125 = load i8*, i8** %4
%126 = ptrtoint i8* %125 to i32
%127 = load i8*, i8** %13
%128 = ptrtoint i8* %127 to i32
%129 = sub nsw i32 %126, %128
store i32 %129, i32* %15
%130 = load i32, i32* %15
%131 = icmp sgt i32 %130, 254
br i1 %131, label %132, label %135
132: ; preds = %124
%133 = load i8*, i8** %12
%134 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
135: ; preds = %124
%136 = load i8*, i8** %4
%137 = getelementptr inbounds i8, i8* %136, i32 1
store i8* %137, i8** %4
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
store i32 %139, i32* %8
br label %120
140: ; preds = %120
%141 = load i32, i32* %8
%142 = icmp ne i32 %141, 0
br i1 %142, label %144, label %143
143: ; preds = %140
br label %335
144: ; preds = %140
br label %145
145: ; preds = %161, %144
%146 = load i8*, i8** %4
%147 = ptrtoint i8* %146 to i32
%148 = load i8*, i8** %13
%149 = ptrtoint i8* %148 to i32
%150 = sub nsw i32 %147, %149
store i32 %150, i32* %15
%151 = load i32, i32* %15
%152 = icmp sgt i32 %151, 254
br i1 %152, label %153, label %156
153: ; preds = %145
%154 = load i8*, i8** %12
%155 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
156: ; preds = %145
%157 = load i8*, i8** %4
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %4
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
store i32 %160, i32* %9
br label %161
161: ; preds = %156
%162 = load i32, i32* %9
%163 = call i32 @isspace(i32 %162)
%164 = icmp ne i32 %163, 0
br i1 %164, label %145, label %165
165: ; preds = %161
%166 = load i32, i32* %9
%167 = icmp ne i32 %166, 0
br i1 %167, label %169, label %168
168: ; preds = %165
br label %335
169: ; preds = %165
br label %170
170: ; preds = %186, %169
%171 = load i8*, i8** %4
%172 = ptrtoint i8* %171 to i32
%173 = load i8*, i8** %13
%174 = ptrtoint i8* %173 to i32
%175 = sub nsw i32 %172, %174
store i32 %175, i32* %15
%176 = load i32, i32* %15
%177 = icmp sgt i32 %176, 254
br i1 %177, label %178, label %181
178: ; preds = %170
%179 = load i8*, i8** %12
%180 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
181: ; preds = %170
%182 = load i8*, i8** %4
%183 = getelementptr inbounds i8, i8* %182, i32 1
store i8* %183, i8** %4
%184 = load i8, i8* %183
%185 = zext i8 %184 to i32
store i32 %185, i32* %10
br label %186
186: ; preds = %181
%187 = load i32, i32* %10
%188 = call i32 @isspace(i32 %187)
%189 = icmp ne i32 %188, 0
br i1 %189, label %170, label %190
190: ; preds = %186
%191 = load i32, i32* %10
%192 = icmp ne i32 %191, 0
br i1 %192, label %194, label %193
193: ; preds = %190
br label %335
194: ; preds = %190
br label %195
195: ; preds = %211, %194
%196 = load i8*, i8** %4
%197 = ptrtoint i8* %196 to i32
%198 = load i8*, i8** %13
%199 = ptrtoint i8* %198 to i32
%200 = sub nsw i32 %197, %199
store i32 %200, i32* %15
%201 = load i32, i32* %15
%202 = icmp sgt i32 %201, 254
br i1 %202, label %203, label %206
203: ; preds = %195
%204 = load i8*, i8** %12
%205 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
206: ; preds = %195
%207 = load i8*, i8** %4
%208 = getelementptr inbounds i8, i8* %207, i32 1
store i8* %208, i8** %4
%209 = load i8, i8* %208
%210 = zext i8 %209 to i32
store i32 %210, i32* %11
br label %211
211: ; preds = %206
%212 = load i32, i32* %11
%213 = call i32 @isspace(i32 %212)
%214 = icmp ne i32 %213, 0
br i1 %214, label %195, label %215
215: ; preds = %211
%216 = load i32, i32* %11
%217 = icmp ne i32 %216, 0
br i1 %217, label %219, label %218
218: ; preds = %215
br label %335
219: ; preds = %215
%220 = load i32, i32* %8
%221 = icmp eq i32 %220, 61
br i1 %221, label %225, label %222
222: ; preds = %219
%223 = load i32, i32* %9
%224 = icmp eq i32 %223, 61
br i1 %224, label %225, label %226
225: ; preds = %222, %219
store i32 1, i32* %7
br label %332
226: ; preds = %222
%227 = load i32, i32* %9
%228 = call i32 (i32, ...) bitcast (i32 (...)* @base64_code to i32 (i32, ...)*)(i32 %227)
store i32 %228, i32* %9
%229 = load i32, i32* %8
%230 = call i32 (i32, ...) bitcast (i32 (...)* @base64_code to i32 (i32, ...)*)(i32 %229)
%231 = shl i32 %230, 2
%232 = load i32, i32* %9
%233 = and i32 %232, 48
%234 = ashr i32 %233, 4
%235 = or i32 %231, %234
%236 = trunc i32 %235 to i8
%237 = load i8*, i8** %3
%238 = getelementptr inbounds i8, i8* %237, i32 1
store i8* %238, i8** %3
store i8 %236, i8* %237
%239 = load i32, i32* %10
%240 = icmp eq i32 %239, 61
br i1 %240, label %241, label %242
241: ; preds = %226
store i32 1, i32* %7
br label %269
242: ; preds = %226
%243 = load i32, i32* %10
%244 = call i32 (i32, ...) bitcast (i32 (...)* @base64_code to i32 (i32, ...)*)(i32 %243)
store i32 %244, i32* %10
%245 = load i32, i32* %9
%246 = and i32 %245, 15
%247 = shl i32 %246, 4
%248 = load i32, i32* %10
%249 = and i32 %248, 60
%250 = ashr i32 %249, 2
%251 = or i32 %247, %250
%252 = trunc i32 %251 to i8
%253 = load i8*, i8** %3
%254 = getelementptr inbounds i8, i8* %253, i32 1
store i8* %254, i8** %3
store i8 %252, i8* %253
%255 = load i32, i32* %11
%256 = icmp eq i32 %255, 61
br i1 %256, label %257, label %258
257: ; preds = %242
store i32 1, i32* %7
br label %268
258: ; preds = %242
%259 = load i32, i32* %10
%260 = and i32 %259, 3
%261 = shl i32 %260, 6
%262 = load i32, i32* %11
%263 = call i32 (i32, ...) bitcast (i32 (...)* @base64_code to i32 (i32, ...)*)(i32 %262)
%264 = or i32 %261, %263
%265 = trunc i32 %264 to i8
%266 = load i8*, i8** %3
%267 = getelementptr inbounds i8, i8* %266, i32 1
store i8* %267, i8** %3
store i8 %265, i8* %266
br label %268
268: ; preds = %258, %257
br label %269
269: ; preds = %268, %241
br label %328
270: ; preds = %116, %113
%271 = load i32, i32* %8
%272 = icmp eq i32 %271, 61
br i1 %272, label %273, label %322
273: ; preds = %270
%274 = load i8*, i8** %4
%275 = getelementptr inbounds i8, i8* %274, i64 1
%276 = load i8, i8* %275
%277 = zext i8 %276 to i32
%278 = icmp eq i32 %277, 63
br i1 %278, label %279, label %322
279: ; preds = %273
store i32 0, i32* %10
store i32 0, i32* %9
br label %280
280: ; preds = %311, %279
%281 = load i8*, i8** %4
%282 = ptrtoint i8* %281 to i32
%283 = load i8*, i8** %13
%284 = ptrtoint i8* %283 to i32
%285 = sub nsw i32 %282, %284
store i32 %285, i32* %15
%286 = load i32, i32* %15
%287 = icmp sgt i32 %286, 254
br i1 %287, label %288, label %291
288: ; preds = %280
%289 = load i8*, i8** %12
%290 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
br label %337
291: ; preds = %280
%292 = load i8*, i8** %4
%293 = getelementptr inbounds i8, i8* %292, i32 1
store i8* %293, i8** %4
%294 = load i8, i8* %293
%295 = zext i8 %294 to i32
store i32 %295, i32* %8
%296 = load i32, i32* %8
%297 = icmp ne i32 %296, 63
br i1 %297, label %298, label %305
298: ; preds = %291
%299 = load i32, i32* %9
%300 = icmp eq i32 %299, 2
br i1 %300, label %301, label %304
301: ; preds = %298
%302 = load i32, i32* %8
%303 = or i32 %302, 32
store i32 %303, i32* %10
br label %304
304: ; preds = %301, %298
br label %311
305: ; preds = %291
%306 = load i32, i32* %9
%307 = add nsw i32 %306, 1
store i32 %307, i32* %9
%308 = icmp sge i32 %307, 3
br i1 %308, label %309, label %310
309: ; preds = %305
br label %312
310: ; preds = %305
br label %311
311: ; preds = %310, %304
br label %280
312: ; preds = %309
%313 = load i32, i32* %10
%314 = icmp eq i32 %313, 113
br i1 %314, label %315, label %316
315: ; preds = %312
store i32 1, i32* %5
br label %321
316: ; preds = %312
%317 = load i32, i32* %10
%318 = icmp eq i32 %317, 98
br i1 %318, label %319, label %320
319: ; preds = %316
store i32 1, i32* %6
br label %320
320: ; preds = %319, %316
br label %321
321: ; preds = %320, %315
br label %327
322: ; preds = %273, %270
%323 = load i32, i32* %8
%324 = trunc i32 %323 to i8
%325 = load i8*, i8** %3
%326 = getelementptr inbounds i8, i8* %325, i32 1
store i8* %326, i8** %3
store i8 %324, i8* %325
br label %327
327: ; preds = %322, %321
br label %328
328: ; preds = %327, %269
br label %329
329: ; preds = %328, %99
br label %330
330: ; preds = %329
br label %331
331: ; preds = %330
br label %332
332: ; preds = %331, %225, %64, %58
%333 = load i8*, i8** %4
%334 = getelementptr inbounds i8, i8* %333, i32 1
store i8* %334, i8** %4
br label %33
335: ; preds = %218, %193, %168, %143, %33
%336 = load i8*, i8** %3
store i8 0, i8* %336
br label %337
337: ; preds = %335, %288, %203, %178, %153, %132, %96, %81, %46, %19
ret void
}

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