void decodeRLE(void *src, int srcLen, void *dst, int dstLen, int bits) {
  long count = 0;
  long count2 = 0;
  unsigned char *s = (unsigned char *)src;
  unsigned char *d = (unsigned char *)dst;
  if (bits == 4) {
    int sswap = 0, dswap = 0;
    do {
      unsigned char c;
      if (sswap)
        c = (*(s + count) & 0xF0) | (*(s + count + 1) & 0xF);
      else
        c = *(s + count);
      count++;
      if (c & 0x80) {
        unsigned char a;
        if (sswap ^= 1)
          a = (*(s + count) & 0xF);
        else
          a = (*(s + count++) >> 4);
        c = (c & 0x7F) + 1;
        if (dswap) {
          *(d + count2++) |= (a << 4);
          c--;
          dswap = 0;
        }
        for (; c > 1; c -= 2)
          *(d + count2++) = (a | a << 4);
        if (c) {
          dswap = 1;
          *(d + count2) = a;
        }
      } else {
        c++;
        if (sswap == dswap) {
          if (sswap) {
            *(d + count2++) |= *(s + count++) & 0xF0;
            c--;
          }
          for (; c > 1; c -= 2)
            *(d + count2++) = *(s + count++);
          if (c) {
            *(d + count2) = *(s + count) & 0xF;
            dswap = sswap = 1;
          }
        } else {
          for (; c > 0; c--)
            if (dswap ^= 1)
              *(d + count2) = *(s + count++) >> 4;
            else
              *(d + count2++) |= *(s + count) << 4;
          sswap = dswap ^ 1;
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 8) {
    do {
      unsigned char c = *(s + count++);
      if (c & 0x80) {
        c = (c & 0x7F);
        unsigned char a = *(s + count++);
        for (c++; c > 0; c--)
          *(d + count2++) = a;
      } else {
        for (c++; c > 0; c--)
          *(d + count2++) = *(s + count++);
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 16) {
    do {
      unsigned char c = *(s + count++);
      if (c & 0x80) {
        unsigned char b1 = *(s + count++);
        unsigned char b2 = *(s + count++);
        c = (c & 0x7F);
        for (c++; c > 0; c--) {
          *(d + count2++) = b1;
          *(d + count2++) = b2;
        }
      } else {
        for (c++; c > 0; c--) {
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 24) {
    do {
      unsigned char c = *(s + count++);
      if (c & 0x80) {
        unsigned char t[3];
        t[0] = *(s + count++);
        t[1] = *(s + count++);
        t[2] = *(s + count++);
        c = (c & 0x7F);
        for (c++; c > 0; c--) {
          *(d + count2++) = t[0];
          *(d + count2++) = t[1];
          *(d + count2++) = t[2];
        }
      } else {
        for (c++; c > 0; c--) {
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 32) {
    do {
      unsigned char c = *(s + count++);
      if (c & 0x80) {
        unsigned char w[4];
        w[0] = *(s + count++);
        w[1] = *(s + count++);
        w[2] = *(s + count++);
        w[3] = *(s + count++);
        c = (c & 0x7F);
        for (c++; c > 0; c--) {
          *(d + count2++) = w[0];
          *(d + count2++) = w[1];
          *(d + count2++) = w[2];
          *(d + count2++) = w[3];
        }
      } else {
        for (c++; c > 0; c--) {
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
          *(d + count2++) = *(s + count++);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  }
}


x86 assembly (clang, -O0):
<decodeRLE>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x4,-0x20(%rbp)
jne    1464 <decodeRLE+0x364>
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     1183 <decodeRLE+0x83>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf0,%eax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,-0x49(%rbp)
jmp    1191 <decodeRLE+0x91>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x49(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movzbl -0x49(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     12a8 <decodeRLE+0x1a8>
mov    -0x44(%rbp),%eax
xor    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmp    $0x0,%eax
je     11d8 <decodeRLE+0xd8>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %al,-0x4a(%rbp)
jmp    11f5 <decodeRLE+0xf5>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,-0x4a(%rbp)
movzbl -0x49(%rbp),%eax
and    $0x7f,%eax
add    $0x1,%eax
mov    %al,-0x49(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     123e <decodeRLE+0x13e>
movzbl -0x4a(%rbp),%esi
shl    $0x4,%esi
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x49(%rbp),%al
add    $0xff,%al
mov    %al,-0x49(%rbp)
movl   $0x0,-0x48(%rbp)
jmp    1243 <decodeRLE+0x143>
movzbl -0x49(%rbp),%eax
cmp    $0x1,%eax
jle    1284 <decodeRLE+0x184>
movzbl -0x4a(%rbp),%eax
movzbl -0x4a(%rbp),%ecx
shl    $0x4,%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
movzbl -0x49(%rbp),%eax
sub    $0x2,%eax
mov    %al,-0x49(%rbp)
jmp    1243 <decodeRLE+0x143>
cmpb   $0x0,-0x49(%rbp)
je     12a3 <decodeRLE+0x1a3>
movl   $0x1,-0x48(%rbp)
mov    -0x4a(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1428 <decodeRLE+0x328>
mov    -0x49(%rbp),%al
add    $0x1,%al
mov    %al,-0x49(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jne    138d <decodeRLE+0x28d>
cmpl   $0x0,-0x44(%rbp)
je     1307 <decodeRLE+0x207>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movzbl (%rax,%rcx,1),%esi
and    $0xf0,%esi
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x49(%rbp),%al
add    $0xff,%al
mov    %al,-0x49(%rbp)
jmp    130c <decodeRLE+0x20c>
movzbl -0x49(%rbp),%eax
cmp    $0x1,%eax
jle    1354 <decodeRLE+0x254>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
movzbl -0x49(%rbp),%eax
sub    $0x2,%eax
mov    %al,-0x49(%rbp)
jmp    130c <decodeRLE+0x20c>
cmpb   $0x0,-0x49(%rbp)
je     1388 <decodeRLE+0x288>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x44(%rbp)
movl   $0x1,-0x48(%rbp)
jmp    1423 <decodeRLE+0x323>
jmp    1392 <decodeRLE+0x292>
movzbl -0x49(%rbp),%eax
cmp    $0x0,%eax
jle    141a <decodeRLE+0x31a>
mov    -0x48(%rbp),%eax
xor    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
je     13dd <decodeRLE+0x2dd>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1408 <decodeRLE+0x308>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
shl    $0x4,%esi
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    140d <decodeRLE+0x30d>
mov    -0x49(%rbp),%al
add    $0xff,%al
mov    %al,-0x49(%rbp)
jmp    1392 <decodeRLE+0x292>
mov    -0x48(%rbp),%eax
xor    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <decodeRLE+0x328>
jmp    142d <decodeRLE+0x32d>
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x59(%rbp)
jge    1454 <decodeRLE+0x354>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    114e <decodeRLE+0x4e>
jmp    1b5c <decodeRLE+0xa5c>
cmpl   $0x8,-0x20(%rbp)
jne    1590 <decodeRLE+0x490>
jmp    1473 <decodeRLE+0x373>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x4b(%rbp)
movzbl -0x4b(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1501 <decodeRLE+0x401>
movzbl -0x4b(%rbp),%eax
and    $0x7f,%eax
mov    %al,-0x4b(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x4c(%rbp)
mov    -0x4b(%rbp),%al
add    $0x1,%al
mov    %al,-0x4b(%rbp)
movzbl -0x4b(%rbp),%eax
cmp    $0x0,%eax
jle    14fc <decodeRLE+0x3fc>
mov    -0x4c(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x4b(%rbp),%al
add    $0xff,%al
mov    %al,-0x4b(%rbp)
jmp    14c9 <decodeRLE+0x3c9>
jmp    1554 <decodeRLE+0x454>
mov    -0x4b(%rbp),%al
add    $0x1,%al
mov    %al,-0x4b(%rbp)
movzbl -0x4b(%rbp),%eax
cmp    $0x0,%eax
jle    154f <decodeRLE+0x44f>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x4b(%rbp),%al
add    $0xff,%al
mov    %al,-0x4b(%rbp)
jmp    1509 <decodeRLE+0x409>
jmp    1554 <decodeRLE+0x454>
jmp    1559 <decodeRLE+0x459>
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x5a(%rbp)
jge    1580 <decodeRLE+0x480>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x5a(%rbp)
mov    -0x5a(%rbp),%al
test   $0x1,%al
jne    1473 <decodeRLE+0x373>
jmp    1b57 <decodeRLE+0xa57>
cmpl   $0x10,-0x20(%rbp)
jne    171a <decodeRLE+0x61a>
jmp    159f <decodeRLE+0x49f>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x4d(%rbp)
movzbl -0x4d(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     165f <decodeRLE+0x55f>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x4e(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x4f(%rbp)
movzbl -0x4d(%rbp),%eax
and    $0x7f,%eax
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
add    $0x1,%al
mov    %al,-0x4d(%rbp)
movzbl -0x4d(%rbp),%eax
cmp    $0x0,%eax
jle    165a <decodeRLE+0x55a>
mov    -0x4e(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x4f(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x4d(%rbp),%al
add    $0xff,%al
mov    %al,-0x4d(%rbp)
jmp    160e <decodeRLE+0x50e>
jmp    16de <decodeRLE+0x5de>
mov    -0x4d(%rbp),%al
add    $0x1,%al
mov    %al,-0x4d(%rbp)
movzbl -0x4d(%rbp),%eax
cmp    $0x0,%eax
jle    16d9 <decodeRLE+0x5d9>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x4d(%rbp),%al
add    $0xff,%al
mov    %al,-0x4d(%rbp)
jmp    1667 <decodeRLE+0x567>
jmp    16de <decodeRLE+0x5de>
jmp    16e3 <decodeRLE+0x5e3>
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x5b(%rbp)
jge    170a <decodeRLE+0x60a>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x5b(%rbp)
mov    -0x5b(%rbp),%al
test   $0x1,%al
jne    159f <decodeRLE+0x49f>
jmp    1b52 <decodeRLE+0xa52>
cmpl   $0x18,-0x20(%rbp)
jne    1902 <decodeRLE+0x802>
jmp    1729 <decodeRLE+0x629>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x50(%rbp)
movzbl -0x50(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     181b <decodeRLE+0x71b>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x53(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x52(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x51(%rbp)
movzbl -0x50(%rbp),%eax
and    $0x7f,%eax
mov    %al,-0x50(%rbp)
mov    -0x50(%rbp),%al
add    $0x1,%al
mov    %al,-0x50(%rbp)
movzbl -0x50(%rbp),%eax
cmp    $0x0,%eax
jle    1816 <decodeRLE+0x716>
mov    -0x53(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x52(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x51(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%al
add    $0xff,%al
mov    %al,-0x50(%rbp)
jmp    17b1 <decodeRLE+0x6b1>
jmp    18c6 <decodeRLE+0x7c6>
mov    -0x50(%rbp),%al
add    $0x1,%al
mov    %al,-0x50(%rbp)
movzbl -0x50(%rbp),%eax
cmp    $0x0,%eax
jle    18c1 <decodeRLE+0x7c1>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%al
add    $0xff,%al
mov    %al,-0x50(%rbp)
jmp    1823 <decodeRLE+0x723>
jmp    18c6 <decodeRLE+0x7c6>
jmp    18cb <decodeRLE+0x7cb>
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x5c(%rbp)
jge    18f2 <decodeRLE+0x7f2>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x5c(%rbp)
mov    -0x5c(%rbp),%al
test   $0x1,%al
jne    1729 <decodeRLE+0x629>
jmp    1b4d <decodeRLE+0xa4d>
cmpl   $0x20,-0x20(%rbp)
jne    1b48 <decodeRLE+0xa48>
jmp    1911 <decodeRLE+0x811>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x54(%rbp)
movzbl -0x54(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1a35 <decodeRLE+0x935>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x57(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x56(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x55(%rbp)
movzbl -0x54(%rbp),%eax
and    $0x7f,%eax
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
add    $0x1,%al
mov    %al,-0x54(%rbp)
movzbl -0x54(%rbp),%eax
cmp    $0x0,%eax
jle    1a30 <decodeRLE+0x930>
mov    -0x58(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x57(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x56(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x55(%rbp),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%al
add    $0xff,%al
mov    %al,-0x54(%rbp)
jmp    19b2 <decodeRLE+0x8b2>
jmp    1b0c <decodeRLE+0xa0c>
mov    -0x54(%rbp),%al
add    $0x1,%al
mov    %al,-0x54(%rbp)
movzbl -0x54(%rbp),%eax
cmp    $0x0,%eax
jle    1b07 <decodeRLE+0xa07>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%al
add    $0xff,%al
mov    %al,-0x54(%rbp)
jmp    1a3d <decodeRLE+0x93d>
jmp    1b0c <decodeRLE+0xa0c>
jmp    1b11 <decodeRLE+0xa11>
mov    -0x28(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x5d(%rbp)
jge    1b38 <decodeRLE+0xa38>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x5d(%rbp)
mov    -0x5d(%rbp),%al
test   $0x1,%al
jne    1911 <decodeRLE+0x811>
jmp    1b48 <decodeRLE+0xa48>
jmp    1b4d <decodeRLE+0xa4d>
jmp    1b52 <decodeRLE+0xa52>
jmp    1b57 <decodeRLE+0xa57>
jmp    1b5c <decodeRLE+0xa5c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<decodeRLE>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
add    $0xfffffffc,%r8d
rol    $0x1e,%r8d
cmp    $0x7,%r8d
ja     1ac3 <decodeRLE+0x9b3>
mov    %rdx,%r14
mov    %rdi,%rbx
lea    0xec3(%rip),%rax
movslq (%rax,%r8,4),%rdx
add    %rax,%rdx
jmp    *%rdx
movslq %esi,%r11
movslq %ecx,%r8
lea    0x1(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x30(%rsp)
lea    0x30(%rbx),%rax
mov    %rax,0x40(%rsp)
lea    0x30(%r14),%rax
mov    %rax,0x38(%rsp)
xor    %ebp,%ebp
xor    %esi,%esi
xor    %r13d,%r13d
xor    %ecx,%ecx
mov    %r8,0x8(%rsp)
xchg   %ax,%ax
mov    (%rbx,%rcx,1),%r12b
test   %esi,%esi
je     1199 <decodeRLE+0x89>
and    $0xf0,%r12b
mov    0x1(%rbx,%rcx,1),%dl
and    $0xf,%dl
or     %r12b,%dl
mov    %edx,%r12d
lea    0x1(%rcx),%r15
test   %r12b,%r12b
js     11e0 <decodeRLE+0xd0>
lea    0x1(%r12),%edx
cmp    %ebp,%esi
jne    11f0 <decodeRLE+0xe0>
test   %esi,%esi
je     12c6 <decodeRLE+0x1b6>
mov    0x1(%rbx,%rcx,1),%dl
add    $0x2,%rcx
and    $0xf0,%dl
or     %dl,(%r14,%r13,1)
add    $0x1,%r13
mov    %rcx,%r15
cmp    $0x2,%r12b
jae    12d3 <decodeRLE+0x1c3>
jmp    13eb <decodeRLE+0x2db>
nopl   0x0(%rax,%rax,1)
xor    $0x1,%esi
je     1230 <decodeRLE+0x120>
mov    (%rbx,%r15,1),%dl
and    $0xf,%dl
jmp    123e <decodeRLE+0x12e>
xchg   %ax,%ax
mov    %r15,%rcx
jmp    1218 <decodeRLE+0x108>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rcx,1),%eax
shl    $0x4,%al
or     %al,(%r14,%r13,1)
add    $0x1,%r13
add    $0xff,%dl
je     1413 <decodeRLE+0x303>
mov    %ebp,%esi
xor    $0x1,%ebp
je     1200 <decodeRLE+0xf0>
movzbl (%rbx,%rcx,1),%eax
add    $0x1,%rcx
shr    $0x4,%al
mov    %al,(%r14,%r13,1)
jmp    120f <decodeRLE+0xff>
mov    0x1(%rbx,%rcx,1),%dl
add    $0x2,%rcx
shr    $0x4,%dl
mov    %rcx,%r15
and    $0x7f,%r12b
test   %ebp,%ebp
je     12ba <decodeRLE+0x1aa>
mov    %edx,%eax
shl    $0x4,%al
or     %al,(%r14,%r13,1)
add    $0x1,%r13
cmp    $0x2,%r12b
jb     12aa <decodeRLE+0x19a>
movzbl %dl,%eax
mov    %esi,0x20(%rsp)
mov    %eax,%esi
shl    $0x4,%esi
or     %eax,%esi
lea    (%r14,%r13,1),%rdi
lea    -0x2(%r12),%eax
shr    %al
movzbl %al,%eax
mov    %rax,0x10(%rsp)
mov    %dl,0x18(%rsp)
lea    0x1(%rax),%rdx
mov    %r11,%rbp
call   1030 <memset@plt>
mov    0x18(%rsp),%dl
mov    0x20(%rsp),%esi
mov    0x8(%rsp),%r8
mov    %rbp,%r11
mov    0x10(%rsp),%rax
add    %rax,%r13
add    $0x1,%r13
and    $0x1,%r12b
test   %r12b,%r12b
jne    13fc <decodeRLE+0x2ec>
xor    %ebp,%ebp
jmp    1410 <decodeRLE+0x300>
add    $0x1,%r12b
cmp    $0x2,%r12b
jae    1259 <decodeRLE+0x149>
jmp    12aa <decodeRLE+0x19a>
mov    %edx,%r12d
cmp    $0x2,%r12b
jb     13eb <decodeRLE+0x2db>
lea    -0x2(%r12),%ecx
cmp    $0x3e,%cl
jb     13d0 <decodeRLE+0x2c0>
shr    %cl
lea    (%r14,%r13,1),%rsi
movzbl %cl,%edx
lea    (%r15,%rdx,1),%rdi
add    0x30(%rsp),%rdi
cmp    %rdi,%rsi
jae    130d <decodeRLE+0x1fd>
add    %r13,%rdx
add    0x28(%rsp),%rdx
lea    (%rbx,%r15,1),%rsi
cmp    %rdx,%rsi
jb     13d0 <decodeRLE+0x2c0>
add    $0x1,%cl
movzbl %cl,%r8d
mov    %r8d,%r9d
and    $0xffffffe0,%r9d
lea    -0x20(%r9),%rcx
mov    %rcx,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1386 <decodeRLE+0x276>
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x40(%rsp),%rax
lea    (%rax,%r15,1),%rdx
mov    0x38(%rsp),%rax
lea    (%rax,%r13,1),%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rdi,1),%xmm0
movups -0x20(%rdx,%rdi,1),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,1)
movups %xmm1,-0x20(%rcx,%rdi,1)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm1,(%rcx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1350 <decodeRLE+0x240>
jmp    1388 <decodeRLE+0x278>
xor    %edi,%edi
lea    (%r9,%r9,1),%ecx
test   $0x1,%r10b
je     13b1 <decodeRLE+0x2a1>
lea    (%r15,%rdi,1),%rdx
add    %r13,%rdi
movdqu (%rbx,%rdx,1),%xmm0
movdqu 0x10(%rbx,%rdx,1),%xmm1
movdqu %xmm0,(%r14,%rdi,1)
movdqu %xmm1,0x10(%r14,%rdi,1)
add    %r9,%r15
add    %r9,%r13
sub    %cl,%r12b
cmp    %r8,%r9
mov    0x8(%rsp),%r8
je     13eb <decodeRLE+0x2db>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%r15,1),%ecx
add    $0x1,%r15
mov    %cl,(%r14,%r13,1)
add    $0x1,%r13
add    $0xfe,%r12b
cmp    $0x1,%r12b
ja     13d0 <decodeRLE+0x2c0>
test   %r12b,%r12b
je     1407 <decodeRLE+0x2f7>
mov    (%rbx,%r15,1),%dl
and    $0xf,%dl
mov    $0x1,%esi
mov    %dl,(%r14,%r13,1)
mov    $0x1,%ebp
jmp    1410 <decodeRLE+0x300>
mov    %ebp,%esi
nopl   0x0(%rax)
mov    %r15,%rcx
cmp    %r11,%rcx
jge    1ac3 <decodeRLE+0x9b3>
cmp    %r8,%r13
jl     1180 <decodeRLE+0x70>
jmp    1ac3 <decodeRLE+0x9b3>
movslq %esi,%rbp
movslq %ecx,%r11
lea    0x1(%r14),%rax
mov    %rax,0x10(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x8(%rsp)
lea    0x2(%rbx),%rax
mov    %rax,0x18(%rsp)
xor    %r13d,%r13d
xor    %r12d,%r12d
mov    %r11,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
movzbl (%rbx,%r12,1),%r15d
test   %r15b,%r15b
js     1550 <decodeRLE+0x440>
lea    0x1(%r12),%r8
lea    0x1(%r15),%ecx
cmp    $0x1f,%r15b
jb     1580 <decodeRLE+0x470>
lea    (%r14,%r13,1),%rax
lea    (%r12,%r15,1),%rdx
add    0x18(%rsp),%rdx
cmp    %rdx,%rax
jae    14ad <decodeRLE+0x39d>
lea    (%r15,%r13,1),%rax
add    0x10(%rsp),%rax
mov    0x8(%rsp),%rdx
add    %r12,%rdx
cmp    %rax,%rdx
jb     1580 <decodeRLE+0x470>
add    $0x1,%r15
mov    %r15d,%edx
and    $0xffffffe0,%edx
movdqu (%rbx,%r8,1),%xmm0
movdqu 0x10(%rbx,%r8,1),%xmm1
movdqu %xmm0,(%r14,%r13,1)
movdqu %xmm1,0x10(%r14,%r13,1)
cmp    $0x20,%rdx
je     1535 <decodeRLE+0x425>
movdqu 0x21(%r12,%rbx,1),%xmm0
movdqu 0x31(%r12,%rbx,1),%xmm1
movdqu %xmm0,0x20(%r13,%r14,1)
movdqu %xmm1,0x30(%r13,%r14,1)
cmp    $0x40,%edx
je     1535 <decodeRLE+0x425>
movdqu 0x41(%r12,%rbx,1),%xmm0
movdqu 0x51(%r12,%rbx,1),%xmm1
movdqu %xmm0,0x40(%r13,%r14,1)
movdqu %xmm1,0x50(%r13,%r14,1)
cmp    $0x60,%edx
je     1535 <decodeRLE+0x425>
movdqu 0x61(%r12,%rbx,1),%xmm0
movdqu 0x71(%r12,%rbx,1),%xmm1
movdqu %xmm0,0x60(%r13,%r14,1)
movdqu %xmm1,0x70(%r13,%r14,1)
add    %rdx,%r8
add    %rdx,%r13
cmp    %rdx,%r15
jne    157c <decodeRLE+0x46c>
mov    %r8,%r12
jmp    1617 <decodeRLE+0x507>
nopl   0x0(%rax,%rax,1)
lea    (%r14,%r13,1),%rdi
and    $0x7f,%r15d
lea    0x1(%r15),%rdx
movzbl 0x1(%rbx,%r12,1),%esi
call   1030 <memset@plt>
mov    0x20(%rsp),%r11
add    $0x2,%r12
add    %r15,%r13
add    $0x1,%r13
jmp    1617 <decodeRLE+0x507>
sub    %dl,%cl
xchg   %ax,%ax
lea    -0x1(%rcx),%r9d
test   $0x3,%cl
je     15d0 <decodeRLE+0x4c0>
mov    %rbp,%r10
lea    (%rbx,%r8,1),%rsi
lea    (%r14,%r13,1),%rdi
movzbl %cl,%ecx
mov    %ecx,%eax
and    $0x3,%eax
xor    %ebp,%ebp
xchg   %ax,%ax
movzbl (%rsi,%rbp,1),%edx
mov    %dl,(%rdi,%rbp,1)
add    $0x1,%rbp
cmp    %bpl,%al
jne    15a0 <decodeRLE+0x490>
add    %rbp,%r8
add    %rbp,%r13
sub    %ebp,%ecx
mov    %r8,%r12
mov    %r10,%rbp
cmp    $0x3,%r9b
jae    15d6 <decodeRLE+0x4c6>
jmp    1617 <decodeRLE+0x507>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x3,%r9b
jb     1617 <decodeRLE+0x507>
mov    %r8,%r12
nopl   0x0(%rax)
movzbl (%rbx,%r12,1),%eax
mov    %al,(%r14,%r13,1)
movzbl 0x1(%rbx,%r12,1),%eax
mov    %al,0x1(%r14,%r13,1)
movzbl 0x2(%rbx,%r12,1),%eax
mov    %al,0x2(%r14,%r13,1)
movzbl 0x3(%rbx,%r12,1),%eax
add    $0x4,%r12
mov    %al,0x3(%r14,%r13,1)
add    $0x4,%r13
add    $0xfc,%cl
jne    15e0 <decodeRLE+0x4d0>
cmp    %rbp,%r12
jge    1ac3 <decodeRLE+0x9b3>
cmp    %r11,%r13
jl     1460 <decodeRLE+0x350>
jmp    1ac3 <decodeRLE+0x9b3>
movslq %esi,%r13
movslq %ecx,%r11
lea    0x2(%r14),%rax
mov    %rax,0x18(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x10(%rsp)
lea    0x3(%rbx),%rax
mov    %rax,0x20(%rsp)
lea    0x30(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x30(%rsp)
xor    %ebp,%ebp
xor    %esi,%esi
mov    %r11,0x8(%rsp)
nopw   0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%r8d
test   %r8b,%r8b
js     1720 <decodeRLE+0x610>
lea    0x1(%rsi),%rdx
lea    0x1(%r8),%r10d
cmp    $0x7,%r8b
jb     1700 <decodeRLE+0x5f0>
lea    (%r14,%rbp,1),%rax
lea    (%rsi,%r8,2),%rcx
add    0x20(%rsp),%rcx
cmp    %rcx,%rax
jae    16bb <decodeRLE+0x5ab>
lea    0x0(,%r8,2),%rcx
add    %rbp,%rcx
add    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdi
add    %rsi,%rdi
cmp    %rcx,%rdi
jb     1700 <decodeRLE+0x5f0>
add    $0x1,%r8
mov    %r8d,%r9d
and    $0xfffffff8,%r9d
lea    (%rdx,%r9,2),%rdx
lea    0x0(%rbp,%r9,2),%rbp
sub    %r9b,%r10b
add    0x30(%rsp),%rsi
lea    (%r8,%r8,1),%ecx
and    $0xfffffff0,%ecx
xor    %edi,%edi
movdqu -0xf(%rsi,%rdi,1),%xmm0
movdqu %xmm0,(%rax,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rcx
jne    16e0 <decodeRLE+0x5d0>
cmp    %r9,%r8
je     1882 <decodeRLE+0x772>
nopl   (%rax)
test   $0x1,%r10b
jne    1820 <decodeRLE+0x710>
mov    %r10d,%eax
cmp    $0x1,%r10b
jne    1850 <decodeRLE+0x740>
jmp    1882 <decodeRLE+0x772>
nopl   0x0(%rax)
mov    0x1(%rbx,%rsi,1),%dl
mov    0x2(%rbx,%rsi,1),%cl
mov    %r8d,%eax
and    $0x7f,%al
add    $0x1,%al
and    $0x7f,%r8d
cmp    $0xf,%r8b
jb     1800 <decodeRLE+0x6f0>
add    $0x1,%r8
mov    %r8d,%r12d
and    $0xfffffff0,%r12d
movzbl %dl,%edi
movd   %edi,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movzbl %cl,%edi
movd   %edi,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
punpcklbw %xmm1,%xmm0
lea    -0x10(%r12),%rdi
mov    %rdi,%r11
shr    $0x4,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     189c <decodeRLE+0x78c>
mov    %r11,%r9
and    $0xfffffffffffffffe,%r9
mov    0x28(%rsp),%rdi
lea    (%rdi,%rbp,1),%r15
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x30(%r15,%r10,2)
movdqu %xmm0,-0x20(%r15,%r10,2)
movdqu %xmm0,-0x10(%r15,%r10,2)
movdqu %xmm0,(%r15,%r10,2)
add    $0x20,%r10
add    $0xfffffffffffffffe,%r9
jne    17a0 <decodeRLE+0x690>
test   $0x1,%r11b
je     17e3 <decodeRLE+0x6d3>
lea    0x0(,%r10,2),%rdi
add    %rbp,%rdi
movdqu %xmm0,(%r14,%rdi,1)
movdqu %xmm0,0x10(%r14,%rdi,1)
lea    0x0(%rbp,%r12,2),%rbp
cmp    %r8,%r12
mov    0x8(%rsp),%r11
je     1811 <decodeRLE+0x701>
sub    %r12b,%al
cs nopw 0x0(%rax,%rax,1)
nop
mov    %dl,(%r14,%rbp,1)
mov    %cl,0x1(%r14,%rbp,1)
add    $0x2,%rbp
add    $0xff,%al
jne    1800 <decodeRLE+0x6f0>
add    $0x3,%rsi
mov    %rsi,%rdx
jmp    1882 <decodeRLE+0x772>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,1),%al
mov    %al,(%r14,%rbp,1)
mov    0x1(%rbx,%rdx,1),%al
add    $0x2,%rdx
mov    %al,0x1(%r14,%rbp,1)
add    $0x2,%rbp
lea    -0x1(%r10),%eax
cmp    $0x1,%r10b
je     1882 <decodeRLE+0x772>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx,%rdx,1),%ecx
mov    %cl,(%r14,%rbp,1)
movzbl 0x1(%rbx,%rdx,1),%ecx
mov    %cl,0x1(%r14,%rbp,1)
movzbl 0x2(%rbx,%rdx,1),%ecx
mov    %cl,0x2(%r14,%rbp,1)
movzbl 0x3(%rbx,%rdx,1),%ecx
add    $0x4,%rdx
mov    %cl,0x3(%r14,%rbp,1)
add    $0x4,%rbp
add    $0xfe,%al
jne    1850 <decodeRLE+0x740>
cmp    %r13,%rdx
jge    1ac3 <decodeRLE+0x9b3>
mov    %rdx,%rsi
cmp    %r11,%rbp
jl     1670 <decodeRLE+0x560>
jmp    1ac3 <decodeRLE+0x9b3>
xor    %r10d,%r10d
test   $0x1,%r11b
jne    17cb <decodeRLE+0x6bb>
jmp    17e3 <decodeRLE+0x6d3>
movslq %esi,%r10
movslq %ecx,%r8
xor    %edx,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,1),%dil
test   %dil,%dil
js     1920 <decodeRLE+0x810>
add    $0x1,%rsi
add    $0x1,%dil
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%eax
mov    %al,(%r14,%rdx,1)
movzbl 0x1(%rbx,%rsi,1),%eax
mov    %al,0x1(%r14,%rdx,1)
movzbl 0x2(%rbx,%rsi,1),%eax
add    $0x3,%rsi
mov    %al,0x2(%r14,%rdx,1)
add    $0x3,%rdx
add    $0xff,%dil
jne    18e0 <decodeRLE+0x7d0>
cmp    %r10,%rsi
jl     1994 <decodeRLE+0x884>
jmp    1ac3 <decodeRLE+0x9b3>
nopl   0x0(%rax,%rax,1)
mov    0x1(%rbx,%rsi,1),%r9b
mov    0x2(%rbx,%rsi,1),%al
mov    0x3(%rbx,%rsi,1),%cl
and    $0x7f,%dil
lea    0x1(%rdi),%ebp
test   $0x1,%bpl
je     194e <decodeRLE+0x83e>
mov    %r9b,(%r14,%rdx,1)
mov    %al,0x1(%r14,%rdx,1)
mov    %cl,0x2(%r14,%rdx,1)
add    $0x3,%rdx
mov    %edi,%ebp
test   %dil,%dil
je     1987 <decodeRLE+0x877>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9b,(%r14,%rdx,1)
mov    %al,0x1(%r14,%rdx,1)
mov    %cl,0x2(%r14,%rdx,1)
mov    %r9b,0x3(%r14,%rdx,1)
mov    %al,0x4(%r14,%rdx,1)
mov    %cl,0x5(%r14,%rdx,1)
add    $0x6,%rdx
add    $0xfe,%bpl
jne    1960 <decodeRLE+0x850>
add    $0x4,%rsi
cmp    %r10,%rsi
jge    1ac3 <decodeRLE+0x9b3>
cmp    %r8,%rdx
jl     18c0 <decodeRLE+0x7b0>
jmp    1ac3 <decodeRLE+0x9b3>
movslq %esi,%r15
movslq %ecx,%r10
lea    0x4(%rbx),%r8
lea    0x3(%r14),%r9
xor    %edi,%edi
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%r12,1),%sil
test   %sil,%sil
js     1a40 <decodeRLE+0x930>
mov    %rbx,%r11
add    $0x1,%sil
lea    (%r8,%r12,1),%rax
add    $0x1,%r12
lea    (%r9,%rdi,1),%rdx
movzbl %sil,%esi
xor    %ecx,%ecx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%rax,%rbp,4),%ebx
mov    %bl,-0x3(%rdx,%rbp,4)
movzbl -0x2(%rax,%rbp,4),%ebx
mov    %bl,-0x2(%rdx,%rbp,4)
movzbl -0x1(%rax,%rbp,4),%ebx
mov    %bl,-0x1(%rdx,%rbp,4)
movzbl (%rax,%rbp,4),%ebx
mov    %bl,(%rdx,%rbp,4)
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rcx
cmp    %bpl,%sil
jne    19f0 <decodeRLE+0x8e0>
sub    %rcx,%r12
sub    %rcx,%rdi
mov    %r11,%rbx
cmp    %r15,%r12
jl     1aba <decodeRLE+0x9aa>
jmp    1ac3 <decodeRLE+0x9b3>
cs nopw 0x0(%rax,%rax,1)
mov    0x1(%rbx,%r12,1),%r11b
mov    0x2(%rbx,%r12,1),%cl
mov    0x3(%rbx,%r12,1),%al
mov    0x4(%rbx,%r12,1),%dl
and    $0x7f,%sil
lea    0x1(%rsi),%ebp
test   $0x1,%bpl
je     1a7a <decodeRLE+0x96a>
mov    %r11b,(%r14,%rdi,1)
mov    %cl,0x1(%r14,%rdi,1)
mov    %al,0x2(%r14,%rdi,1)
mov    %dl,0x3(%r14,%rdi,1)
add    $0x4,%rdi
mov    %esi,%ebp
test   %sil,%sil
je     1ab1 <decodeRLE+0x9a1>
nop
mov    %r11b,(%r14,%rdi,1)
mov    %cl,0x1(%r14,%rdi,1)
mov    %al,0x2(%r14,%rdi,1)
mov    %dl,0x3(%r14,%rdi,1)
mov    %r11b,0x4(%r14,%rdi,1)
mov    %cl,0x5(%r14,%rdi,1)
mov    %al,0x6(%r14,%rdi,1)
mov    %dl,0x7(%r14,%rdi,1)
add    $0x8,%rdi
add    $0xfe,%bpl
jne    1a80 <decodeRLE+0x970>
add    $0x5,%r12
cmp    %r15,%r12
jge    1ac3 <decodeRLE+0x9b3>
cmp    %r10,%rdi
jl     19c0 <decodeRLE+0x8b0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @decodeRLE(i8* %0, i32 %1, i8* %2, i32 %3, i32 %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8
%18 = alloca i8
%19 = alloca i8
%20 = alloca i8
%21 = alloca i8
%22 = alloca i8
%23 = alloca i8
%24 = alloca i8
%25 = alloca [3 x i8]
%26 = alloca i8
%27 = alloca [4 x i8]
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i64 0, i64* %11
store i64 0, i64* %12
%28 = load i8*, i8** %6
store i8* %28, i8** %13
%29 = load i8*, i8** %8
store i8* %29, i8** %14
%30 = load i32, i32* %10
%31 = icmp eq i32 %30, 4
br i1 %31, label %32, label %258
32: ; preds = %5
store i32 0, i32* %15
store i32 0, i32* %16
br label %33
33: ; preds = %255, %32
%34 = load i32, i32* %15
%35 = icmp ne i32 %34, 0
br i1 %35, label %36, label %52
36: ; preds = %33
%37 = load i8*, i8** %13
%38 = load i64, i64* %11
%39 = getelementptr inbounds i8, i8* %37, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = and i32 %41, 240
%43 = load i8*, i8** %13
%44 = load i64, i64* %11
%45 = getelementptr inbounds i8, i8* %43, i64 %44
%46 = getelementptr inbounds i8, i8* %45, i64 1
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = and i32 %48, 15
%50 = or i32 %42, %49
%51 = trunc i32 %50 to i8
store i8 %51, i8* %17
br label %57
52: ; preds = %33
%53 = load i8*, i8** %13
%54 = load i64, i64* %11
%55 = getelementptr inbounds i8, i8* %53, i64 %54
%56 = load i8, i8* %55
store i8 %56, i8* %17
br label %57
57: ; preds = %52, %36
%58 = load i64, i64* %11
%59 = add nsw i64 %58, 1
store i64 %59, i64* %11
%60 = load i8, i8* %17
%61 = zext i8 %60 to i32
%62 = and i32 %61, 128
%63 = icmp ne i32 %62, 0
br i1 %63, label %64, label %138
64: ; preds = %57
%65 = load i32, i32* %15
%66 = xor i32 %65, 1
store i32 %66, i32* %15
%67 = icmp ne i32 %66, 0
br i1 %67, label %68, label %76
68: ; preds = %64
%69 = load i8*, i8** %13
%70 = load i64, i64* %11
%71 = getelementptr inbounds i8, i8* %69, i64 %70
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = and i32 %73, 15
%75 = trunc i32 %74 to i8
store i8 %75, i8* %18
br label %85
76: ; preds = %64
%77 = load i8*, i8** %13
%78 = load i64, i64* %11
%79 = add nsw i64 %78, 1
store i64 %79, i64* %11
%80 = getelementptr inbounds i8, i8* %77, i64 %78
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = ashr i32 %82, 4
%84 = trunc i32 %83 to i8
store i8 %84, i8* %18
br label %85
85: ; preds = %76, %68
%86 = load i8, i8* %17
%87 = zext i8 %86 to i32
%88 = and i32 %87, 127
%89 = add nsw i32 %88, 1
%90 = trunc i32 %89 to i8
store i8 %90, i8* %17
%91 = load i32, i32* %16
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %107
93: ; preds = %85
%94 = load i8, i8* %18
%95 = zext i8 %94 to i32
%96 = shl i32 %95, 4
%97 = load i8*, i8** %14
%98 = load i64, i64* %12
%99 = add nsw i64 %98, 1
store i64 %99, i64* %12
%100 = getelementptr inbounds i8, i8* %97, i64 %98
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = or i32 %102, %96
%104 = trunc i32 %103 to i8
store i8 %104, i8* %100
%105 = load i8, i8* %17
%106 = add i8 %105, -1
store i8 %106, i8* %17
store i32 0, i32* %16
br label %107
107: ; preds = %93, %85
br label %108
108: ; preds = %124, %107
%109 = load i8, i8* %17
%110 = zext i8 %109 to i32
%111 = icmp sgt i32 %110, 1
br i1 %111, label %112, label %129
112: ; preds = %108
%113 = load i8, i8* %18
%114 = zext i8 %113 to i32
%115 = load i8, i8* %18
%116 = zext i8 %115 to i32
%117 = shl i32 %116, 4
%118 = or i32 %114, %117
%119 = trunc i32 %118 to i8
%120 = load i8*, i8** %14
%121 = load i64, i64* %12
%122 = add nsw i64 %121, 1
store i64 %122, i64* %12
%123 = getelementptr inbounds i8, i8* %120, i64 %121
store i8 %119, i8* %123
br label %124
124: ; preds = %112
%125 = load i8, i8* %17
%126 = zext i8 %125 to i32
%127 = sub nsw i32 %126, 2
%128 = trunc i32 %127 to i8
store i8 %128, i8* %17
br label %108
129: ; preds = %108
%130 = load i8, i8* %17
%131 = icmp ne i8 %130, 0
br i1 %131, label %132, label %137
132: ; preds = %129
store i32 1, i32* %16
%133 = load i8, i8* %18
%134 = load i8*, i8** %14
%135 = load i64, i64* %12
%136 = getelementptr inbounds i8, i8* %134, i64 %135
store i8 %133, i8* %136
br label %137
137: ; preds = %132, %129
br label %244
138: ; preds = %57
%139 = load i8, i8* %17
%140 = add i8 %139, 1
store i8 %140, i8* %17
%141 = load i32, i32* %15
%142 = load i32, i32* %16
%143 = icmp eq i32 %141, %142
br i1 %143, label %144, label %200
144: ; preds = %138
%145 = load i32, i32* %15
%146 = icmp ne i32 %145, 0
br i1 %146, label %147, label %165
147: ; preds = %144
%148 = load i8*, i8** %13
%149 = load i64, i64* %11
%150 = add nsw i64 %149, 1
store i64 %150, i64* %11
%151 = getelementptr inbounds i8, i8* %148, i64 %149
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = and i32 %153, 240
%155 = load i8*, i8** %14
%156 = load i64, i64* %12
%157 = add nsw i64 %156, 1
store i64 %157, i64* %12
%158 = getelementptr inbounds i8, i8* %155, i64 %156
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = or i32 %160, %154
%162 = trunc i32 %161 to i8
store i8 %162, i8* %158
%163 = load i8, i8* %17
%164 = add i8 %163, -1
store i8 %164, i8* %17
br label %165
165: ; preds = %147, %144
br label %166
166: ; preds = %180, %165
%167 = load i8, i8* %17
%168 = zext i8 %167 to i32
%169 = icmp sgt i32 %168, 1
br i1 %169, label %170, label %185
170: ; preds = %166
%171 = load i8*, i8** %13
%172 = load i64, i64* %11
%173 = add nsw i64 %172, 1
store i64 %173, i64* %11
%174 = getelementptr inbounds i8, i8* %171, i64 %172
%175 = load i8, i8* %174
%176 = load i8*, i8** %14
%177 = load i64, i64* %12
%178 = add nsw i64 %177, 1
store i64 %178, i64* %12
%179 = getelementptr inbounds i8, i8* %176, i64 %177
store i8 %175, i8* %179
br label %180
180: ; preds = %170
%181 = load i8, i8* %17
%182 = zext i8 %181 to i32
%183 = sub nsw i32 %182, 2
%184 = trunc i32 %183 to i8
store i8 %184, i8* %17
br label %166
185: ; preds = %166
%186 = load i8, i8* %17
%187 = icmp ne i8 %186, 0
br i1 %187, label %188, label %199
188: ; preds = %185
%189 = load i8*, i8** %13
%190 = load i64, i64* %11
%191 = getelementptr inbounds i8, i8* %189, i64 %190
%192 = load i8, i8* %191
%193 = zext i8 %192 to i32
%194 = and i32 %193, 15
%195 = trunc i32 %194 to i8
%196 = load i8*, i8** %14
%197 = load i64, i64* %12
%198 = getelementptr inbounds i8, i8* %196, i64 %197
store i8 %195, i8* %198
store i32 1, i32* %15
store i32 1, i32* %16
br label %199
199: ; preds = %188, %185
br label %243
200: ; preds = %138
br label %201
201: ; preds = %237, %200
%202 = load i8, i8* %17
%203 = zext i8 %202 to i32
%204 = icmp sgt i32 %203, 0
br i1 %204, label %205, label %240
205: ; preds = %201
%206 = load i32, i32* %16
%207 = xor i32 %206, 1
store i32 %207, i32* %16
%208 = icmp ne i32 %207, 0
br i1 %208, label %209, label %221
209: ; preds = %205
%210 = load i8*, i8** %13
%211 = load i64, i64* %11
%212 = add nsw i64 %211, 1
store i64 %212, i64* %11
%213 = getelementptr inbounds i8, i8* %210, i64 %211
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = ashr i32 %215, 4
%217 = trunc i32 %216 to i8
%218 = load i8*, i8** %14
%219 = load i64, i64* %12
%220 = getelementptr inbounds i8, i8* %218, i64 %219
store i8 %217, i8* %220
br label %236
221: ; preds = %205
%222 = load i8*, i8** %13
%223 = load i64, i64* %11
%224 = getelementptr inbounds i8, i8* %222, i64 %223
%225 = load i8, i8* %224
%226 = zext i8 %225 to i32
%227 = shl i32 %226, 4
%228 = load i8*, i8** %14
%229 = load i64, i64* %12
%230 = add nsw i64 %229, 1
store i64 %230, i64* %12
%231 = getelementptr inbounds i8, i8* %228, i64 %229
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = or i32 %233, %227
%235 = trunc i32 %234 to i8
store i8 %235, i8* %231
br label %236
236: ; preds = %221, %209
br label %237
237: ; preds = %236
%238 = load i8, i8* %17
%239 = add i8 %238, -1
store i8 %239, i8* %17
br label %201
240: ; preds = %201
%241 = load i32, i32* %16
%242 = xor i32 %241, 1
store i32 %242, i32* %15
br label %243
243: ; preds = %240, %199
br label %244
244: ; preds = %243, %137
br label %245
245: ; preds = %244
%246 = load i64, i64* %11
%247 = load i32, i32* %7
%248 = sext i32 %247 to i64
%249 = icmp slt i64 %246, %248
br i1 %249, label %250, label %255
250: ; preds = %245
%251 = load i64, i64* %12
%252 = load i32, i32* %9
%253 = sext i32 %252 to i64
%254 = icmp slt i64 %251, %253
br label %255
255: ; preds = %250, %245
%256 = phi i1 [ false, %245 ], [ %254, %250 ]
br i1 %256, label %33, label %257
257: ; preds = %255
br label %690
258: ; preds = %5
%259 = load i32, i32* %10
%260 = icmp eq i32 %259, 8
br i1 %260, label %261, label %333
261: ; preds = %258
br label %262
262: ; preds = %330, %261
%263 = load i8*, i8** %13
%264 = load i64, i64* %11
%265 = add nsw i64 %264, 1
store i64 %265, i64* %11
%266 = getelementptr inbounds i8, i8* %263, i64 %264
%267 = load i8, i8* %266
store i8 %267, i8* %19
%268 = load i8, i8* %19
%269 = zext i8 %268 to i32
%270 = and i32 %269, 128
%271 = icmp ne i32 %270, 0
br i1 %271, label %272, label %298
272: ; preds = %262
%273 = load i8, i8* %19
%274 = zext i8 %273 to i32
%275 = and i32 %274, 127
%276 = trunc i32 %275 to i8
store i8 %276, i8* %19
%277 = load i8*, i8** %13
%278 = load i64, i64* %11
%279 = add nsw i64 %278, 1
store i64 %279, i64* %11
%280 = getelementptr inbounds i8, i8* %277, i64 %278
%281 = load i8, i8* %280
store i8 %281, i8* %20
%282 = load i8, i8* %19
%283 = add i8 %282, 1
store i8 %283, i8* %19
br label %284
284: ; preds = %294, %272
%285 = load i8, i8* %19
%286 = zext i8 %285 to i32
%287 = icmp sgt i32 %286, 0
br i1 %287, label %288, label %297
288: ; preds = %284
%289 = load i8, i8* %20
%290 = load i8*, i8** %14
%291 = load i64, i64* %12
%292 = add nsw i64 %291, 1
store i64 %292, i64* %12
%293 = getelementptr inbounds i8, i8* %290, i64 %291
store i8 %289, i8* %293
br label %294
294: ; preds = %288
%295 = load i8, i8* %19
%296 = add i8 %295, -1
store i8 %296, i8* %19
br label %284
297: ; preds = %284
br label %319
298: ; preds = %262
%299 = load i8, i8* %19
%300 = add i8 %299, 1
store i8 %300, i8* %19
br label %301
301: ; preds = %315, %298
%302 = load i8, i8* %19
%303 = zext i8 %302 to i32
%304 = icmp sgt i32 %303, 0
br i1 %304, label %305, label %318
305: ; preds = %301
%306 = load i8*, i8** %13
%307 = load i64, i64* %11
%308 = add nsw i64 %307, 1
store i64 %308, i64* %11
%309 = getelementptr inbounds i8, i8* %306, i64 %307
%310 = load i8, i8* %309
%311 = load i8*, i8** %14
%312 = load i64, i64* %12
%313 = add nsw i64 %312, 1
store i64 %313, i64* %12
%314 = getelementptr inbounds i8, i8* %311, i64 %312
store i8 %310, i8* %314
br label %315
315: ; preds = %305
%316 = load i8, i8* %19
%317 = add i8 %316, -1
store i8 %317, i8* %19
br label %301
318: ; preds = %301
br label %319
319: ; preds = %318, %297
br label %320
320: ; preds = %319
%321 = load i64, i64* %11
%322 = load i32, i32* %7
%323 = sext i32 %322 to i64
%324 = icmp slt i64 %321, %323
br i1 %324, label %325, label %330
325: ; preds = %320
%326 = load i64, i64* %12
%327 = load i32, i32* %9
%328 = sext i32 %327 to i64
%329 = icmp slt i64 %326, %328
br label %330
330: ; preds = %325, %320
%331 = phi i1 [ false, %320 ], [ %329, %325 ]
br i1 %331, label %262, label %332
332: ; preds = %330
br label %689
333: ; preds = %258
%334 = load i32, i32* %10
%335 = icmp eq i32 %334, 16
br i1 %335, label %336, label %427
336: ; preds = %333
br label %337
337: ; preds = %424, %336
%338 = load i8*, i8** %13
%339 = load i64, i64* %11
%340 = add nsw i64 %339, 1
store i64 %340, i64* %11
%341 = getelementptr inbounds i8, i8* %338, i64 %339
%342 = load i8, i8* %341
store i8 %342, i8* %21
%343 = load i8, i8* %21
%344 = zext i8 %343 to i32
%345 = and i32 %344, 128
%346 = icmp ne i32 %345, 0
br i1 %346, label %347, label %383
347: ; preds = %337
%348 = load i8*, i8** %13
%349 = load i64, i64* %11
%350 = add nsw i64 %349, 1
store i64 %350, i64* %11
%351 = getelementptr inbounds i8, i8* %348, i64 %349
%352 = load i8, i8* %351
store i8 %352, i8* %22
%353 = load i8*, i8** %13
%354 = load i64, i64* %11
%355 = add nsw i64 %354, 1
store i64 %355, i64* %11
%356 = getelementptr inbounds i8, i8* %353, i64 %354
%357 = load i8, i8* %356
store i8 %357, i8* %23
%358 = load i8, i8* %21
%359 = zext i8 %358 to i32
%360 = and i32 %359, 127
%361 = trunc i32 %360 to i8
store i8 %361, i8* %21
%362 = load i8, i8* %21
%363 = add i8 %362, 1
store i8 %363, i8* %21
br label %364
364: ; preds = %379, %347
%365 = load i8, i8* %21
%366 = zext i8 %365 to i32
%367 = icmp sgt i32 %366, 0
br i1 %367, label %368, label %382
368: ; preds = %364
%369 = load i8, i8* %22
%370 = load i8*, i8** %14
%371 = load i64, i64* %12
%372 = add nsw i64 %371, 1
store i64 %372, i64* %12
%373 = getelementptr inbounds i8, i8* %370, i64 %371
store i8 %369, i8* %373
%374 = load i8, i8* %23
%375 = load i8*, i8** %14
%376 = load i64, i64* %12
%377 = add nsw i64 %376, 1
store i64 %377, i64* %12
%378 = getelementptr inbounds i8, i8* %375, i64 %376
store i8 %374, i8* %378
br label %379
379: ; preds = %368
%380 = load i8, i8* %21
%381 = add i8 %380, -1
store i8 %381, i8* %21
br label %364
382: ; preds = %364
br label %413
383: ; preds = %337
%384 = load i8, i8* %21
%385 = add i8 %384, 1
store i8 %385, i8* %21
br label %386
386: ; preds = %409, %383
%387 = load i8, i8* %21
%388 = zext i8 %387 to i32
%389 = icmp sgt i32 %388, 0
br i1 %389, label %390, label %412
390: ; preds = %386
%391 = load i8*, i8** %13
%392 = load i64, i64* %11
%393 = add nsw i64 %392, 1
store i64 %393, i64* %11
%394 = getelementptr inbounds i8, i8* %391, i64 %392
%395 = load i8, i8* %394
%396 = load i8*, i8** %14
%397 = load i64, i64* %12
%398 = add nsw i64 %397, 1
store i64 %398, i64* %12
%399 = getelementptr inbounds i8, i8* %396, i64 %397
store i8 %395, i8* %399
%400 = load i8*, i8** %13
%401 = load i64, i64* %11
%402 = add nsw i64 %401, 1
store i64 %402, i64* %11
%403 = getelementptr inbounds i8, i8* %400, i64 %401
%404 = load i8, i8* %403
%405 = load i8*, i8** %14
%406 = load i64, i64* %12
%407 = add nsw i64 %406, 1
store i64 %407, i64* %12
%408 = getelementptr inbounds i8, i8* %405, i64 %406
store i8 %404, i8* %408
br label %409
409: ; preds = %390
%410 = load i8, i8* %21
%411 = add i8 %410, -1
store i8 %411, i8* %21
br label %386
412: ; preds = %386
br label %413
413: ; preds = %412, %382
br label %414
414: ; preds = %413
%415 = load i64, i64* %11
%416 = load i32, i32* %7
%417 = sext i32 %416 to i64
%418 = icmp slt i64 %415, %417
br i1 %418, label %419, label %424
419: ; preds = %414
%420 = load i64, i64* %12
%421 = load i32, i32* %9
%422 = sext i32 %421 to i64
%423 = icmp slt i64 %420, %422
br label %424
424: ; preds = %419, %414
%425 = phi i1 [ false, %414 ], [ %423, %419 ]
br i1 %425, label %337, label %426
426: ; preds = %424
br label %688
427: ; preds = %333
%428 = load i32, i32* %10
%429 = icmp eq i32 %428, 24
br i1 %429, label %430, label %546
430: ; preds = %427
br label %431
431: ; preds = %543, %430
%432 = load i8*, i8** %13
%433 = load i64, i64* %11
%434 = add nsw i64 %433, 1
store i64 %434, i64* %11
%435 = getelementptr inbounds i8, i8* %432, i64 %433
%436 = load i8, i8* %435
store i8 %436, i8* %24
%437 = load i8, i8* %24
%438 = zext i8 %437 to i32
%439 = and i32 %438, 128
%440 = icmp ne i32 %439, 0
br i1 %440, label %441, label %493
441: ; preds = %431
%442 = load i8*, i8** %13
%443 = load i64, i64* %11
%444 = add nsw i64 %443, 1
store i64 %444, i64* %11
%445 = getelementptr inbounds i8, i8* %442, i64 %443
%446 = load i8, i8* %445
%447 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 0
store i8 %446, i8* %447
%448 = load i8*, i8** %13
%449 = load i64, i64* %11
%450 = add nsw i64 %449, 1
store i64 %450, i64* %11
%451 = getelementptr inbounds i8, i8* %448, i64 %449
%452 = load i8, i8* %451
%453 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 1
store i8 %452, i8* %453
%454 = load i8*, i8** %13
%455 = load i64, i64* %11
%456 = add nsw i64 %455, 1
store i64 %456, i64* %11
%457 = getelementptr inbounds i8, i8* %454, i64 %455
%458 = load i8, i8* %457
%459 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 2
store i8 %458, i8* %459
%460 = load i8, i8* %24
%461 = zext i8 %460 to i32
%462 = and i32 %461, 127
%463 = trunc i32 %462 to i8
store i8 %463, i8* %24
%464 = load i8, i8* %24
%465 = add i8 %464, 1
store i8 %465, i8* %24
br label %466
466: ; preds = %489, %441
%467 = load i8, i8* %24
%468 = zext i8 %467 to i32
%469 = icmp sgt i32 %468, 0
br i1 %469, label %470, label %492
470: ; preds = %466
%471 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 0
%472 = load i8, i8* %471
%473 = load i8*, i8** %14
%474 = load i64, i64* %12
%475 = add nsw i64 %474, 1
store i64 %475, i64* %12
%476 = getelementptr inbounds i8, i8* %473, i64 %474
store i8 %472, i8* %476
%477 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 1
%478 = load i8, i8* %477
%479 = load i8*, i8** %14
%480 = load i64, i64* %12
%481 = add nsw i64 %480, 1
store i64 %481, i64* %12
%482 = getelementptr inbounds i8, i8* %479, i64 %480
store i8 %478, i8* %482
%483 = getelementptr inbounds [3 x i8], [3 x i8]* %25, i64 0, i64 2
%484 = load i8, i8* %483
%485 = load i8*, i8** %14
%486 = load i64, i64* %12
%487 = add nsw i64 %486, 1
store i64 %487, i64* %12
%488 = getelementptr inbounds i8, i8* %485, i64 %486
store i8 %484, i8* %488
br label %489
489: ; preds = %470
%490 = load i8, i8* %24
%491 = add i8 %490, -1
store i8 %491, i8* %24
br label %466
492: ; preds = %466
br label %532
493: ; preds = %431
%494 = load i8, i8* %24
%495 = add i8 %494, 1
store i8 %495, i8* %24
br label %496
496: ; preds = %528, %493
%497 = load i8, i8* %24
%498 = zext i8 %497 to i32
%499 = icmp sgt i32 %498, 0
br i1 %499, label %500, label %531
500: ; preds = %496
%501 = load i8*, i8** %13
%502 = load i64, i64* %11
%503 = add nsw i64 %502, 1
store i64 %503, i64* %11
%504 = getelementptr inbounds i8, i8* %501, i64 %502
%505 = load i8, i8* %504
%506 = load i8*, i8** %14
%507 = load i64, i64* %12
%508 = add nsw i64 %507, 1
store i64 %508, i64* %12
%509 = getelementptr inbounds i8, i8* %506, i64 %507
store i8 %505, i8* %509
%510 = load i8*, i8** %13
%511 = load i64, i64* %11
%512 = add nsw i64 %511, 1
store i64 %512, i64* %11
%513 = getelementptr inbounds i8, i8* %510, i64 %511
%514 = load i8, i8* %513
%515 = load i8*, i8** %14
%516 = load i64, i64* %12
%517 = add nsw i64 %516, 1
store i64 %517, i64* %12
%518 = getelementptr inbounds i8, i8* %515, i64 %516
store i8 %514, i8* %518
%519 = load i8*, i8** %13
%520 = load i64, i64* %11
%521 = add nsw i64 %520, 1
store i64 %521, i64* %11
%522 = getelementptr inbounds i8, i8* %519, i64 %520
%523 = load i8, i8* %522
%524 = load i8*, i8** %14
%525 = load i64, i64* %12
%526 = add nsw i64 %525, 1
store i64 %526, i64* %12
%527 = getelementptr inbounds i8, i8* %524, i64 %525
store i8 %523, i8* %527
br label %528
528: ; preds = %500
%529 = load i8, i8* %24
%530 = add i8 %529, -1
store i8 %530, i8* %24
br label %496
531: ; preds = %496
br label %532
532: ; preds = %531, %492
br label %533
533: ; preds = %532
%534 = load i64, i64* %11
%535 = load i32, i32* %7
%536 = sext i32 %535 to i64
%537 = icmp slt i64 %534, %536
br i1 %537, label %538, label %543
538: ; preds = %533
%539 = load i64, i64* %12
%540 = load i32, i32* %9
%541 = sext i32 %540 to i64
%542 = icmp slt i64 %539, %541
br label %543
543: ; preds = %538, %533
%544 = phi i1 [ false, %533 ], [ %542, %538 ]
br i1 %544, label %431, label %545
545: ; preds = %543
br label %687
546: ; preds = %427
%547 = load i32, i32* %10
%548 = icmp eq i32 %547, 32
br i1 %548, label %549, label %686
549: ; preds = %546
br label %550
550: ; preds = %683, %549
%551 = load i8*, i8** %13
%552 = load i64, i64* %11
%553 = add nsw i64 %552, 1
store i64 %553, i64* %11
%554 = getelementptr inbounds i8, i8* %551, i64 %552
%555 = load i8, i8* %554
store i8 %555, i8* %26
%556 = load i8, i8* %26
%557 = zext i8 %556 to i32
%558 = and i32 %557, 128
%559 = icmp ne i32 %558, 0
br i1 %559, label %560, label %624
560: ; preds = %550
%561 = load i8*, i8** %13
%562 = load i64, i64* %11
%563 = add nsw i64 %562, 1
store i64 %563, i64* %11
%564 = getelementptr inbounds i8, i8* %561, i64 %562
%565 = load i8, i8* %564
%566 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 0
store i8 %565, i8* %566
%567 = load i8*, i8** %13
%568 = load i64, i64* %11
%569 = add nsw i64 %568, 1
store i64 %569, i64* %11
%570 = getelementptr inbounds i8, i8* %567, i64 %568
%571 = load i8, i8* %570
%572 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 1
store i8 %571, i8* %572
%573 = load i8*, i8** %13
%574 = load i64, i64* %11
%575 = add nsw i64 %574, 1
store i64 %575, i64* %11
%576 = getelementptr inbounds i8, i8* %573, i64 %574
%577 = load i8, i8* %576
%578 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 2
store i8 %577, i8* %578
%579 = load i8*, i8** %13
%580 = load i64, i64* %11
%581 = add nsw i64 %580, 1
store i64 %581, i64* %11
%582 = getelementptr inbounds i8, i8* %579, i64 %580
%583 = load i8, i8* %582
%584 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 3
store i8 %583, i8* %584
%585 = load i8, i8* %26
%586 = zext i8 %585 to i32
%587 = and i32 %586, 127
%588 = trunc i32 %587 to i8
store i8 %588, i8* %26
%589 = load i8, i8* %26
%590 = add i8 %589, 1
store i8 %590, i8* %26
br label %591
591: ; preds = %620, %560
%592 = load i8, i8* %26
%593 = zext i8 %592 to i32
%594 = icmp sgt i32 %593, 0
br i1 %594, label %595, label %623
595: ; preds = %591
%596 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 0
%597 = load i8, i8* %596
%598 = load i8*, i8** %14
%599 = load i64, i64* %12
%600 = add nsw i64 %599, 1
store i64 %600, i64* %12
%601 = getelementptr inbounds i8, i8* %598, i64 %599
store i8 %597, i8* %601
%602 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 1
%603 = load i8, i8* %602
%604 = load i8*, i8** %14
%605 = load i64, i64* %12
%606 = add nsw i64 %605, 1
store i64 %606, i64* %12
%607 = getelementptr inbounds i8, i8* %604, i64 %605
store i8 %603, i8* %607
%608 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 2
%609 = load i8, i8* %608
%610 = load i8*, i8** %14
%611 = load i64, i64* %12
%612 = add nsw i64 %611, 1
store i64 %612, i64* %12
%613 = getelementptr inbounds i8, i8* %610, i64 %611
store i8 %609, i8* %613
%614 = getelementptr inbounds [4 x i8], [4 x i8]* %27, i64 0, i64 3
%615 = load i8, i8* %614
%616 = load i8*, i8** %14
%617 = load i64, i64* %12
%618 = add nsw i64 %617, 1
store i64 %618, i64* %12
%619 = getelementptr inbounds i8, i8* %616, i64 %617
store i8 %615, i8* %619
br label %620
620: ; preds = %595
%621 = load i8, i8* %26
%622 = add i8 %621, -1
store i8 %622, i8* %26
br label %591
623: ; preds = %591
br label %672
624: ; preds = %550
%625 = load i8, i8* %26
%626 = add i8 %625, 1
store i8 %626, i8* %26
br label %627
627: ; preds = %668, %624
%628 = load i8, i8* %26
%629 = zext i8 %628 to i32
%630 = icmp sgt i32 %629, 0
br i1 %630, label %631, label %671
631: ; preds = %627
%632 = load i8*, i8** %13
%633 = load i64, i64* %11
%634 = add nsw i64 %633, 1
store i64 %634, i64* %11
%635 = getelementptr inbounds i8, i8* %632, i64 %633
%636 = load i8, i8* %635
%637 = load i8*, i8** %14
%638 = load i64, i64* %12
%639 = add nsw i64 %638, 1
store i64 %639, i64* %12
%640 = getelementptr inbounds i8, i8* %637, i64 %638
store i8 %636, i8* %640
%641 = load i8*, i8** %13
%642 = load i64, i64* %11
%643 = add nsw i64 %642, 1
store i64 %643, i64* %11
%644 = getelementptr inbounds i8, i8* %641, i64 %642
%645 = load i8, i8* %644
%646 = load i8*, i8** %14
%647 = load i64, i64* %12
%648 = add nsw i64 %647, 1
store i64 %648, i64* %12
%649 = getelementptr inbounds i8, i8* %646, i64 %647
store i8 %645, i8* %649
%650 = load i8*, i8** %13
%651 = load i64, i64* %11
%652 = add nsw i64 %651, 1
store i64 %652, i64* %11
%653 = getelementptr inbounds i8, i8* %650, i64 %651
%654 = load i8, i8* %653
%655 = load i8*, i8** %14
%656 = load i64, i64* %12
%657 = add nsw i64 %656, 1
store i64 %657, i64* %12
%658 = getelementptr inbounds i8, i8* %655, i64 %656
store i8 %654, i8* %658
%659 = load i8*, i8** %13
%660 = load i64, i64* %11
%661 = add nsw i64 %660, 1
store i64 %661, i64* %11
%662 = getelementptr inbounds i8, i8* %659, i64 %660
%663 = load i8, i8* %662
%664 = load i8*, i8** %14
%665 = load i64, i64* %12
%666 = add nsw i64 %665, 1
store i64 %666, i64* %12
%667 = getelementptr inbounds i8, i8* %664, i64 %665
store i8 %663, i8* %667
br label %668
668: ; preds = %631
%669 = load i8, i8* %26
%670 = add i8 %669, -1
store i8 %670, i8* %26
br label %627
671: ; preds = %627
br label %672
672: ; preds = %671, %623
br label %673
673: ; preds = %672
%674 = load i64, i64* %11
%675 = load i32, i32* %7
%676 = sext i32 %675 to i64
%677 = icmp slt i64 %674, %676
br i1 %677, label %678, label %683
678: ; preds = %673
%679 = load i64, i64* %12
%680 = load i32, i32* %9
%681 = sext i32 %680 to i64
%682 = icmp slt i64 %679, %681
br label %683
683: ; preds = %678, %673
%684 = phi i1 [ false, %673 ], [ %682, %678 ]
br i1 %684, label %550, label %685
685: ; preds = %683
br label %686
686: ; preds = %685, %546
br label %687
687: ; preds = %686, %545
br label %688
688: ; preds = %687, %426
br label %689
689: ; preds = %688, %332
br label %690
690: ; preds = %689, %257
ret void
}

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