long encodeRLE(void *src, int srcLen, int linesz, void *dst, int dstLen,
               int bits) {
  if (linesz == 0)
    linesz = (srcLen << 3) / (bits);
  int i;
  long count = 0;
  long count2 = 0;
  unsigned char *s = (unsigned char *)src;
  unsigned char *d = (unsigned char *)dst;
  if (bits == 4) {
    unsigned char sswap = 0, dswap = 0;
    do {
      unsigned char maxrun = (linesz - ((count * 2) % linesz));
      if (maxrun > (srcLen - count) * 2)
        maxrun = (srcLen - count) * 2;
      if (maxrun > 128)
        maxrun = 128;
      unsigned char run;
      unsigned char c;
      if (sswap) {
        c = (*(s + count) >> 4) | (*(s + count + 1) << 4);
        count++;
      } else
        c = *(s + count);
      sswap ^= 1;
      if (count2 >= dstLen)
        break;
      if (maxrun >= 2 && (c >> 4) == (c & 0xF)) {
        for (run = 1;
             run < maxrun && ((sswap) ? (c & 0xF) == (*(s + count++) >> 4)
                                      : (c & 0xF) == (*(s + count) & 0xF));
             run++, sswap ^= 1)
          ;
        if (dswap ^= 1) {
          *(d + count2++) = 0x80 | (run - 1);
          *(d + count2) = c & 0xF;
        } else {
          *(d + count2++) |= (0x80 | (run - 1)) & 0xF0;
          *(d + count2++) = (c << 4) | ((0x80 | (run - 1)) & 0xF);
        }
      } else {
        unsigned char tswap = sswap ^ 1;
        unsigned char tcount = count;
        for (run = 1;
             run < maxrun &&
             ((sswap) ? (*(s + count++) >> 4) != (*(s + count + 1) & 0xF)
                      : (*(s + count) >> 4) != (*(s + count) & 0xF));
             run++, sswap ^= 1)
          ;
        if (count2 + run / 2 + 1 >= dstLen)
          break;
        if (!dswap)
          *(d + count2++) = (0x00 | (run - 1));
        else {
          *(d + count2++) |= (run - 1) & 0xF0;
          *(d + count2) = (run - 1) & 0xF;
        }
        if (dswap == tswap) {
          if (dswap) {
            *(d + count2++) |= (*(s + tcount) & 0xF0);
            run--;
            dswap = 0;
          }
          for (i = 0; i < run / 2; i++)
            *(d + count2++) = *(s + tcount + i);
          if (run & 1) {
            *(d + count2) = *(s + count) & 0xF;
            dswap = 1;
          }
        } else {
          for (i = 0; i < run; i++)
            if (dswap ^= 1)
              *(d + count2) = (*(s + tcount++) >> 4);
            else
              *(d + count2++) |= (*(s + tcount) << 4);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 8) {
    do {
      unsigned char maxrun = (linesz - (count % linesz));
      if (maxrun > srcLen - count)
        maxrun = srcLen - count;
      if (maxrun > 128)
        maxrun = 128;
      unsigned char run;
      unsigned char c = *(s + count++);
      if (count2 >= dstLen - 1)
        break;
      if (maxrun >= 2 && c == *(s + count)) {
        for (run = 1; run < maxrun && c == *(s + count); run++, count++)
          ;
        *(d + count2++) = (0x80 | (run - 1));
        *(d + count2++) = c;
      } else {
        for (run = 1; run < maxrun && *(s + count) != *(s + count + 1);
             run++, count++)
          ;
        *(d + count2++) = (0x00 | (run - 1));
        if (count2 + run >= dstLen)
          break;
        for (i = 0; i < run; i++)
          *(d + count2++) = *(s + count - run + i);
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 16) {
    do {
      unsigned char maxrun = linesz - ((count / 2) % linesz);
      if (maxrun > (srcLen - count) / 2)
        maxrun = (srcLen - count) / 2;
      if (maxrun > 128)
        maxrun = 128;
      unsigned char run;
      unsigned char c1 = *(s + count++);
      unsigned char c2 = *(s + count++);
      if (count2 >= dstLen - 2)
        break;
      if (maxrun >= 2 && c1 == *(s + count) && c2 == *(s + count + 1)) {
        for (run = 1;
             run < maxrun && c1 == *(s + count) && c2 == *(s + count + 1);
             run++, count += 2)
          ;
        *(d + count2++) = (0x80 | (run - 1));
        *(d + count2++) = c1;
        *(d + count2++) = c2;
      } else {
        for (run = 1; run < maxrun && (*(s + count) != *(s + count + 2) ||
                                       *(s + count + 1) != *(s + count + 3));
             run++, count += 2)
          ;
        *(d + count2++) = (0x00 | (run - 1));
        if (count2 + run * 2 >= dstLen)
          break;
        for (i = 0; i < run; i++) {
          *(d + count2++) = *(s + count - run * 2 + i * 2);
          *(d + count2++) = *(s + count - run * 2 + i * 2 + 1);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 24) {
    do {
      unsigned char maxrun = linesz - ((count / 3) % linesz);
      if (maxrun > (srcLen - count) / 3)
        maxrun = (srcLen - count) / 3;
      if (maxrun > 128)
        maxrun = 128;
      unsigned char run;
      unsigned char c1 = *(s + count++);
      unsigned char c2 = *(s + count++);
      unsigned char c3 = *(s + count++);
      if (count2 >= dstLen - 3)
        break;
      if (maxrun >= 2 && c1 == *(s + count) && c2 == *(s + count + 1) &&
          c3 == *(s + count + 2)) {
        for (run = 1; run < maxrun && c1 == *(s + count) &&
                      c2 == *(s + count + 1) && c3 == *(s + count + 2);
             run++, count += 3)
          ;
        *(d + count2++) = (0x80 | (run - 1));
        *(d + count2++) = c1;
        *(d + count2++) = c2;
        *(d + count2++) = c3;
      } else {
        for (run = 1; run < maxrun && (*(s + count) != *(s + count + 3) ||
                                       *(s + count + 1) != *(s + count + 4) ||
                                       *(s + count + 2) != *(s + count + 5));
             run++, count += 3)
          ;
        *(d + count2++) = (0x00 | (run - 1));
        if (count2 + run * 3 >= dstLen)
          break;
        for (i = 0; i < run; i++) {
          *(d + count2++) = *(s + count - run * 3 + i * 3);
          *(d + count2++) = *(s + count - run * 3 + i * 3 + 1);
          *(d + count2++) = *(s + count - run * 3 + i * 3 + 2);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  } else if (bits == 32) {
    do {
      unsigned char maxrun = linesz - ((count / 4) % linesz);
      if (maxrun > (srcLen - count) / 4)
        maxrun = (srcLen - count) / 4;
      if (maxrun > 128)
        maxrun = 128;
      unsigned char run;
      unsigned char c1 = *(s + count++);
      unsigned char c2 = *(s + count++);
      unsigned char c3 = *(s + count++);
      unsigned char c4 = *(s + count++);
      if (count2 >= dstLen - 4)
        break;
      if (maxrun >= 2 && c1 == *(s + count) && c2 == *(s + count + 1) &&
          c3 == *(s + count + 2) && c4 == *(s + count + 3)) {
        for (run = 1;
             run < maxrun && c1 == *(s + count) && c2 == *(s + count + 1) &&
             c3 == *(s + count + 2) && c4 == *(s + count + 3);
             run++, count += 4)
          ;
        *(d + count2++) = (0x80 | (run - 1));
        *(d + count2++) = c1;
        *(d + count2++) = c2;
        *(d + count2++) = c3;
        *(d + count2++) = c4;
      } else {
        for (run = 1; run < maxrun && (*(s + count) != *(s + count + 4) ||
                                       *(s + count + 1) != *(s + count + 5) ||
                                       *(s + count + 2) != *(s + count + 6) ||
                                       *(s + count + 3) != *(s + count + 7));
             run++, count += 4)
          ;
        *(d + count2++) = (0x00 | (run - 1));
        if (count2 + run * 4 >= dstLen)
          break;
        for (i = 0; i < run; i++) {
          *(d + count2++) = *(s + count - run * 4 + i * 4);
          *(d + count2++) = *(s + count - run * 4 + i * 4 + 1);
          *(d + count2++) = *(s + count - run * 4 + i * 4 + 2);
          *(d + count2++) = *(s + count - run * 4 + i * 4 + 3);
        }
      }
    } while ((count < srcLen) && (count2 < dstLen));
  }
  return count2;
}


x86 assembly (clang, -O0):
<encodeRLE>:
push   %rbp
mov    %rsp,%rbp
sub    $0x68,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
cmpl   $0x0,-0x10(%rbp)
jne    1135 <encodeRLE+0x35>
mov    -0xc(%rbp),%eax
shl    $0x3,%eax
cltd
idivl  -0x20(%rbp)
mov    %eax,-0x10(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x4,-0x20(%rbp)
jne    1717 <encodeRLE+0x617>
movb   $0x0,-0x49(%rbp)
movb   $0x0,-0x4a(%rbp)
movslq -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    -0x70(%rbp),%rax
sub    %rdx,%rax
mov    %al,-0x4b(%rbp)
movzbl -0x4b(%rbp),%eax
movslq -0xc(%rbp),%rcx
sub    -0x30(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jle    11b2 <encodeRLE+0xb2>
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
shl    $0x1,%rax
mov    %al,-0x4b(%rbp)
movzbl -0x4b(%rbp),%eax
cmp    $0x80,%eax
jle    11c5 <encodeRLE+0xc5>
movb   $0x80,-0x4b(%rbp)
cmpb   $0x0,-0x49(%rbp)
je     1204 <encodeRLE+0x104>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
shl    $0x4,%ecx
or     %ecx,%eax
mov    %al,-0x4d(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1212 <encodeRLE+0x112>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x4d(%rbp)
movzbl -0x49(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x49(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     1232 <encodeRLE+0x132>
jmp    1712 <encodeRLE+0x612>
movzbl -0x4b(%rbp),%eax
cmp    $0x2,%eax
jl     13bd <encodeRLE+0x2bd>
movzbl -0x4d(%rbp),%eax
sar    $0x4,%eax
movzbl -0x4d(%rbp),%ecx
and    $0xf,%ecx
cmp    %ecx,%eax
jne    13bd <encodeRLE+0x2bd>
movb   $0x1,-0x4c(%rbp)
movzbl -0x4c(%rbp),%ecx
movzbl -0x4b(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x71(%rbp)
jge    12dd <encodeRLE+0x1dd>
movzbl -0x49(%rbp),%eax
cmp    $0x0,%eax
je     12ae <encodeRLE+0x1ae>
movzbl -0x4d(%rbp),%eax
and    $0xf,%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
mov    %rdx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
movzbl (%rcx,%rdx,1),%ecx
sar    $0x4,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x78(%rbp)
jmp    12d1 <encodeRLE+0x1d1>
movzbl -0x4d(%rbp),%eax
and    $0xf,%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xf,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    12ed <encodeRLE+0x1ed>
jmp    1309 <encodeRLE+0x209>
jmp    12f2 <encodeRLE+0x1f2>
mov    -0x4c(%rbp),%al
add    $0x1,%al
mov    %al,-0x4c(%rbp)
movzbl -0x49(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x49(%rbp)
jmp    1259 <encodeRLE+0x159>
movzbl -0x4a(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x4a(%rbp)
cmp    $0x0,%al
je     1358 <encodeRLE+0x258>
movzbl -0x4c(%rbp),%eax
sub    $0x1,%eax
or     $0x80,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
movzbl -0x4d(%rbp),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    13b8 <encodeRLE+0x2b8>
movzbl -0x4c(%rbp),%esi
sub    $0x1,%esi
or     $0x80,%esi
and    $0xf0,%esi
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x4d(%rbp),%eax
shl    $0x4,%eax
movzbl -0x4c(%rbp),%ecx
sub    $0x1,%ecx
or     $0x80,%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    16d2 <encodeRLE+0x5d2>
movzbl -0x49(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x4e(%rbp)
mov    -0x30(%rbp),%rax
mov    %al,-0x4f(%rbp)
movb   $0x1,-0x4c(%rbp)
movzbl -0x4c(%rbp),%ecx
movzbl -0x4b(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x79(%rbp)
jge    1467 <encodeRLE+0x367>
movzbl -0x49(%rbp),%eax
cmp    $0x0,%eax
je     1430 <encodeRLE+0x330>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
and    $0xf,%ecx
cmp    %ecx,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
jmp    145b <encodeRLE+0x35b>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xf,%ecx
cmp    %ecx,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1477 <encodeRLE+0x377>
jmp    1493 <encodeRLE+0x393>
jmp    147c <encodeRLE+0x37c>
mov    -0x4c(%rbp),%al
add    $0x1,%al
mov    %al,-0x4c(%rbp)
movzbl -0x49(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x49(%rbp)
jmp    13d2 <encodeRLE+0x2d2>
mov    -0x38(%rbp),%rax
mov    %rax,-0x88(%rbp)
movzbl -0x4c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     14cf <encodeRLE+0x3cf>
jmp    1712 <encodeRLE+0x612>
cmpb   $0x0,-0x4a(%rbp)
jne    1500 <encodeRLE+0x400>
movzbl -0x4c(%rbp),%eax
sub    $0x1,%eax
or     $0x0,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    1540 <encodeRLE+0x440>
movzbl -0x4c(%rbp),%esi
sub    $0x1,%esi
and    $0xf0,%esi
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x4c(%rbp),%eax
sub    $0x1,%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movzbl -0x4a(%rbp),%eax
movzbl -0x4e(%rbp),%ecx
cmp    %ecx,%eax
jne    1631 <encodeRLE+0x531>
cmpb   $0x0,-0x4a(%rbp)
je     1597 <encodeRLE+0x497>
mov    -0x40(%rbp),%rax
movzbl -0x4f(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
and    $0xf0,%esi
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%al
add    $0xff,%al
mov    %al,-0x4c(%rbp)
movb   $0x0,-0x4a(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movzbl -0x4c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
cmp    %ecx,%eax
jge    15fc <encodeRLE+0x4fc>
mov    -0x40(%rbp),%rax
movzbl -0x4f(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    159e <encodeRLE+0x49e>
movzbl -0x4c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     162c <encodeRLE+0x52c>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movb   $0x1,-0x4a(%rbp)
jmp    16cd <encodeRLE+0x5cd>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movzbl -0x4c(%rbp),%ecx
cmp    %ecx,%eax
jge    16c8 <encodeRLE+0x5c8>
movzbl -0x4a(%rbp),%eax
xor    $0x1,%eax
mov    %al,-0x4a(%rbp)
cmp    $0x0,%al
je     1687 <encodeRLE+0x587>
mov    -0x40(%rbp),%rax
mov    -0x4f(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x4f(%rbp)
movzbl %cl,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    16b5 <encodeRLE+0x5b5>
mov    -0x40(%rbp),%rax
movzbl -0x4f(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
shl    $0x4,%esi
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    16ba <encodeRLE+0x5ba>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1638 <encodeRLE+0x538>
jmp    16cd <encodeRLE+0x5cd>
jmp    16d2 <encodeRLE+0x5d2>
jmp    16d7 <encodeRLE+0x5d7>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x8d(%rbp)
jge    1704 <encodeRLE+0x604>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x8d(%rbp)
mov    -0x8d(%rbp),%al
test   $0x1,%al
jne    1167 <encodeRLE+0x67>
jmp    27e2 <encodeRLE+0x16e2>
cmpl   $0x8,-0x20(%rbp)
jne    19d3 <encodeRLE+0x8d3>
jmp    1726 <encodeRLE+0x626>
movslq -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    -0x98(%rbp),%rax
sub    %rdx,%rax
mov    %al,-0x50(%rbp)
movzbl -0x50(%rbp),%eax
movslq -0xc(%rbp),%rcx
sub    -0x30(%rbp),%rcx
cmp    %rcx,%rax
jle    176b <encodeRLE+0x66b>
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %al,-0x50(%rbp)
movzbl -0x50(%rbp),%eax
cmp    $0x80,%eax
jle    177e <encodeRLE+0x67e>
movb   $0x80,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x52(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     17b2 <encodeRLE+0x6b2>
jmp    19ce <encodeRLE+0x8ce>
movzbl -0x50(%rbp),%eax
cmp    $0x2,%eax
jl     1881 <encodeRLE+0x781>
movzbl -0x52(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1881 <encodeRLE+0x781>
movb   $0x1,-0x51(%rbp)
movzbl -0x51(%rbp),%ecx
movzbl -0x50(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x99(%rbp)
jge    180e <encodeRLE+0x70e>
movzbl -0x52(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    1821 <encodeRLE+0x721>
jmp    183f <encodeRLE+0x73f>
jmp    1826 <encodeRLE+0x726>
mov    -0x51(%rbp),%al
add    $0x1,%al
mov    %al,-0x51(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    17db <encodeRLE+0x6db>
movzbl -0x51(%rbp),%eax
sub    $0x1,%eax
or     $0x80,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x52(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    198e <encodeRLE+0x88e>
movb   $0x1,-0x51(%rbp)
movzbl -0x51(%rbp),%ecx
movzbl -0x50(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x9a(%rbp)
jge    18c1 <encodeRLE+0x7c1>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
test   $0x1,%al
jne    18d4 <encodeRLE+0x7d4>
jmp    18f2 <encodeRLE+0x7f2>
jmp    18d9 <encodeRLE+0x7d9>
mov    -0x51(%rbp),%al
add    $0x1,%al
mov    %al,-0x51(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1885 <encodeRLE+0x785>
movzbl -0x51(%rbp),%eax
sub    $0x1,%eax
or     $0x0,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movzbl -0x51(%rbp),%ecx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     1931 <encodeRLE+0x831>
jmp    19ce <encodeRLE+0x8ce>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movzbl -0x51(%rbp),%ecx
cmp    %ecx,%eax
jge    1989 <encodeRLE+0x889>
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x51(%rbp),%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1938 <encodeRLE+0x838>
jmp    198e <encodeRLE+0x88e>
jmp    1993 <encodeRLE+0x893>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x9b(%rbp)
jge    19c0 <encodeRLE+0x8c0>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x9b(%rbp)
mov    -0x9b(%rbp),%al
test   $0x1,%al
jne    1726 <encodeRLE+0x626>
jmp    27dd <encodeRLE+0x16dd>
cmpl   $0x10,-0x20(%rbp)
jne    1dab <encodeRLE+0xcab>
jmp    19e2 <encodeRLE+0x8e2>
movslq -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x30(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    -0xb0(%rbp),%rax
sub    %rdx,%rax
mov    %al,-0x53(%rbp)
movzbl -0x53(%rbp),%eax
mov    %rax,-0xa8(%rbp)
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0xa8(%rbp),%rax
cmp    %rcx,%rax
jle    1a56 <encodeRLE+0x956>
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %al,-0x53(%rbp)
movzbl -0x53(%rbp),%eax
cmp    $0x80,%eax
jle    1a69 <encodeRLE+0x969>
movb   $0x80,-0x53(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x55(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x56(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     1ab6 <encodeRLE+0x9b6>
jmp    1da6 <encodeRLE+0xca6>
movzbl -0x53(%rbp),%eax
cmp    $0x2,%eax
jl     1bd8 <encodeRLE+0xad8>
movzbl -0x55(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1bd8 <encodeRLE+0xad8>
movzbl -0x56(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1bd8 <encodeRLE+0xad8>
movb   $0x1,-0x54(%rbp)
movzbl -0x54(%rbp),%ecx
movzbl -0x53(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xb1(%rbp)
jge    1b4c <encodeRLE+0xa4c>
movzbl -0x55(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xb1(%rbp)
jne    1b4c <encodeRLE+0xa4c>
movzbl -0x56(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    1b5f <encodeRLE+0xa5f>
jmp    1b7d <encodeRLE+0xa7d>
jmp    1b64 <encodeRLE+0xa64>
mov    -0x54(%rbp),%al
add    $0x1,%al
mov    %al,-0x54(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    1af8 <encodeRLE+0x9f8>
movzbl -0x54(%rbp),%eax
sub    $0x1,%eax
or     $0x80,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x55(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x56(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    1d66 <encodeRLE+0xc66>
movb   $0x1,-0x54(%rbp)
movzbl -0x54(%rbp),%ecx
movzbl -0x53(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xb2(%rbp)
jge    1c4e <encodeRLE+0xb4e>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x2(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xb3(%rbp)
jne    1c42 <encodeRLE+0xb42>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x3(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xb3(%rbp)
mov    -0xb3(%rbp),%al
mov    %al,-0xb2(%rbp)
mov    -0xb2(%rbp),%al
test   $0x1,%al
jne    1c61 <encodeRLE+0xb61>
jmp    1c7f <encodeRLE+0xb7f>
jmp    1c66 <encodeRLE+0xb66>
mov    -0x54(%rbp),%al
add    $0x1,%al
mov    %al,-0x54(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    1bdc <encodeRLE+0xadc>
movzbl -0x54(%rbp),%eax
sub    $0x1,%eax
or     $0x0,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movzbl -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     1cc4 <encodeRLE+0xbc4>
jmp    1da6 <encodeRLE+0xca6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movzbl -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    1d61 <encodeRLE+0xc61>
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ccb <encodeRLE+0xbcb>
jmp    1d66 <encodeRLE+0xc66>
jmp    1d6b <encodeRLE+0xc6b>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0xb4(%rbp)
jge    1d98 <encodeRLE+0xc98>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0xb4(%rbp)
mov    -0xb4(%rbp),%al
test   $0x1,%al
jne    19e2 <encodeRLE+0x8e2>
jmp    27d8 <encodeRLE+0x16d8>
cmpl   $0x18,-0x20(%rbp)
jne    2250 <encodeRLE+0x1150>
jmp    1dba <encodeRLE+0xcba>
movslq -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x30(%rbp),%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    -0xc8(%rbp),%rax
sub    %rdx,%rax
mov    %al,-0x57(%rbp)
movzbl -0x57(%rbp),%eax
mov    %rax,-0xc0(%rbp)
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0xc0(%rbp),%rax
cmp    %rcx,%rax
jle    1e2e <encodeRLE+0xd2e>
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x3,%ecx
cqto
idiv   %rcx
mov    %al,-0x57(%rbp)
movzbl -0x57(%rbp),%eax
cmp    $0x80,%eax
jle    1e41 <encodeRLE+0xd41>
movb   $0x80,-0x57(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x59(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x5a(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x5b(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     1ea7 <encodeRLE+0xda7>
jmp    224b <encodeRLE+0x114b>
movzbl -0x57(%rbp),%eax
cmp    $0x2,%eax
jl     201c <encodeRLE+0xf1c>
movzbl -0x59(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    201c <encodeRLE+0xf1c>
movzbl -0x5a(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    201c <encodeRLE+0xf1c>
movzbl -0x5b(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    201c <encodeRLE+0xf1c>
movb   $0x1,-0x58(%rbp)
movzbl -0x58(%rbp),%ecx
movzbl -0x57(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xc9(%rbp)
jge    1f77 <encodeRLE+0xe77>
movzbl -0x59(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xc9(%rbp)
jne    1f77 <encodeRLE+0xe77>
movzbl -0x5a(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xc9(%rbp)
jne    1f77 <encodeRLE+0xe77>
movzbl -0x5b(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xc9(%rbp)
mov    -0xc9(%rbp),%al
test   $0x1,%al
jne    1f8a <encodeRLE+0xe8a>
jmp    1fa8 <encodeRLE+0xea8>
jmp    1f8f <encodeRLE+0xe8f>
mov    -0x58(%rbp),%al
add    $0x1,%al
mov    %al,-0x58(%rbp)
mov    -0x30(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x30(%rbp)
jmp    1f02 <encodeRLE+0xe02>
movzbl -0x58(%rbp),%eax
sub    $0x1,%eax
or     $0x80,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x59(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x5a(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x5b(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    220b <encodeRLE+0x110b>
movb   $0x1,-0x58(%rbp)
movzbl -0x58(%rbp),%ecx
movzbl -0x57(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xca(%rbp)
jge    20bc <encodeRLE+0xfbc>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x3(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xcb(%rbp)
jne    20b0 <encodeRLE+0xfb0>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x4(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xcb(%rbp)
jne    20b0 <encodeRLE+0xfb0>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x2(%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x5(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xcb(%rbp)
mov    -0xcb(%rbp),%al
mov    %al,-0xca(%rbp)
mov    -0xca(%rbp),%al
test   $0x1,%al
jne    20cf <encodeRLE+0xfcf>
jmp    20ed <encodeRLE+0xfed>
jmp    20d4 <encodeRLE+0xfd4>
mov    -0x58(%rbp),%al
add    $0x1,%al
mov    %al,-0x58(%rbp)
mov    -0x30(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x30(%rbp)
jmp    2020 <encodeRLE+0xf20>
movzbl -0x58(%rbp),%eax
sub    $0x1,%eax
or     $0x0,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movzbl -0x58(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     2132 <encodeRLE+0x1032>
jmp    224b <encodeRLE+0x114b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movzbl -0x58(%rbp),%ecx
cmp    %ecx,%eax
jge    2206 <encodeRLE+0x1106>
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x58(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x58(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x58(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    0x2(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2139 <encodeRLE+0x1039>
jmp    220b <encodeRLE+0x110b>
jmp    2210 <encodeRLE+0x1110>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0xcc(%rbp)
jge    223d <encodeRLE+0x113d>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0xcc(%rbp)
mov    -0xcc(%rbp),%al
test   $0x1,%al
jne    1dba <encodeRLE+0xcba>
jmp    27d3 <encodeRLE+0x16d3>
cmpl   $0x20,-0x20(%rbp)
jne    27ce <encodeRLE+0x16ce>
jmp    225f <encodeRLE+0x115f>
movslq -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x30(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    -0xe0(%rbp),%rax
sub    %rdx,%rax
mov    %al,-0x5c(%rbp)
movzbl -0x5c(%rbp),%eax
mov    %rax,-0xd8(%rbp)
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0xd8(%rbp),%rax
cmp    %rcx,%rax
jle    22d3 <encodeRLE+0x11d3>
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %al,-0x5c(%rbp)
movzbl -0x5c(%rbp),%eax
cmp    $0x80,%eax
jle    22e6 <encodeRLE+0x11e6>
movb   $0x80,-0x5c(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x5e(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x5f(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,1),%al
mov    %al,-0x61(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jl     2365 <encodeRLE+0x1265>
jmp    27c9 <encodeRLE+0x16c9>
movzbl -0x5c(%rbp),%eax
cmp    $0x2,%eax
jl     252d <encodeRLE+0x142d>
movzbl -0x5e(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    252d <encodeRLE+0x142d>
movzbl -0x5f(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    252d <encodeRLE+0x142d>
movzbl -0x60(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    252d <encodeRLE+0x142d>
movzbl -0x61(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x3(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    252d <encodeRLE+0x142d>
movb   $0x1,-0x5d(%rbp)
movzbl -0x5d(%rbp),%ecx
movzbl -0x5c(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xe1(%rbp)
jge    246f <encodeRLE+0x136f>
movzbl -0x5e(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xe1(%rbp)
jne    246f <encodeRLE+0x136f>
movzbl -0x5f(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x1(%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xe1(%rbp)
jne    246f <encodeRLE+0x136f>
movzbl -0x60(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x2(%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xe1(%rbp)
jne    246f <encodeRLE+0x136f>
movzbl -0x61(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x3(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xe1(%rbp)
mov    -0xe1(%rbp),%al
test   $0x1,%al
jne    2482 <encodeRLE+0x1382>
jmp    24a0 <encodeRLE+0x13a0>
jmp    2487 <encodeRLE+0x1387>
mov    -0x5d(%rbp),%al
add    $0x1,%al
mov    %al,-0x5d(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    23d9 <encodeRLE+0x12d9>
movzbl -0x5d(%rbp),%eax
sub    $0x1,%eax
or     $0x80,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x5e(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x5f(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x61(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
jmp    2789 <encodeRLE+0x1689>
movb   $0x1,-0x5d(%rbp)
movzbl -0x5d(%rbp),%ecx
movzbl -0x5c(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0xe2(%rbp)
jge    25f7 <encodeRLE+0x14f7>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x4(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xe3(%rbp)
jne    25eb <encodeRLE+0x14eb>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x5(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xe3(%rbp)
jne    25eb <encodeRLE+0x14eb>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x2(%rax,%rcx,1),%ecx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rdx
movzbl 0x6(%rax,%rdx,1),%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0xe3(%rbp)
jne    25eb <encodeRLE+0x14eb>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl 0x3(%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl 0x7(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0xe3(%rbp)
mov    -0xe3(%rbp),%al
mov    %al,-0xe2(%rbp)
mov    -0xe2(%rbp),%al
test   $0x1,%al
jne    260a <encodeRLE+0x150a>
jmp    2628 <encodeRLE+0x1528>
jmp    260f <encodeRLE+0x150f>
mov    -0x5d(%rbp),%al
add    $0x1,%al
mov    %al,-0x5d(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    2531 <encodeRLE+0x1431>
movzbl -0x5d(%rbp),%eax
sub    $0x1,%eax
or     $0x0,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movzbl -0x5d(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jl     266d <encodeRLE+0x156d>
jmp    27c9 <encodeRLE+0x16c9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movzbl -0x5d(%rbp),%ecx
cmp    %ecx,%eax
jge    2784 <encodeRLE+0x1684>
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x5d(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x5d(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x5d(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    0x2(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    -0x30(%rbp),%rax
movzbl -0x5d(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    0x3(%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2674 <encodeRLE+0x1574>
jmp    2789 <encodeRLE+0x1689>
jmp    278e <encodeRLE+0x168e>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0xe4(%rbp)
jge    27bb <encodeRLE+0x16bb>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0xe4(%rbp)
mov    -0xe4(%rbp),%al
test   $0x1,%al
jne    225f <encodeRLE+0x115f>
jmp    27ce <encodeRLE+0x16ce>
jmp    27d3 <encodeRLE+0x16d3>
jmp    27d8 <encodeRLE+0x16d8>
jmp    27dd <encodeRLE+0x16dd>
jmp    27e2 <encodeRLE+0x16e2>
mov    -0x38(%rbp),%rax
add    $0x68,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encodeRLE>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,-0x3c(%rsp)
test   %edx,%edx
jne    1121 <encodeRLE+0x21>
lea    0x0(,%rsi,8),%eax
cltd
idiv   %r9d
mov    %eax,-0x3c(%rsp)
add    $0xfffffffc,%r9d
rol    $0x1e,%r9d
xor    %r11d,%r11d
cmp    $0x7,%r9d
ja     21da <encodeRLE+0x10da>
lea    0x1ec3(%rip),%rax
movslq (%rax,%r9,4),%rdx
add    %rax,%rdx
jmp    *%rdx
movslq -0x3c(%rsp),%rbp
movslq %esi,%rsi
movslq %r8d,%r10
lea    0x30(%rcx),%rax
mov    %rax,-0x20(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,-0x8(%rsp)
lea    0x3(%rdi),%rax
mov    %rax,-0x18(%rsp)
xor    %r8d,%r8d
xor    %r13d,%r13d
xor    %r11d,%r11d
xor    %r14d,%r14d
mov    %rbp,-0x30(%rsp)
mov    %rsi,-0x38(%rsp)
mov    %r10,-0x28(%rsp)
nopw   0x0(%rax,%rax,1)
lea    (%r14,%r14,1),%rax
mov    %rax,%rdx
or     %rbp,%rdx
shr    $0x20,%rdx
je     11b0 <encodeRLE+0xb0>
cqto
idiv   %rbp
jmp    11b6 <encodeRLE+0xb6>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
divl   -0x3c(%rsp)
mov    %rbp,%rax
sub    %rdx,%rax
movzbl %al,%edx
sub    %r14,%rsi
add    %rsi,%rsi
cmp    %rsi,%rdx
cmovle %rax,%rsi
mov    (%rdi,%r14,1),%bl
test   %r13b,%r13b
je     11e6 <encodeRLE+0xe6>
mov    0x1(%rdi,%r14,1),%al
shl    $0x4,%al
shr    $0x4,%bl
or     %al,%bl
add    $0x1,%r14
mov    %r14,%rdx
cmp    %r10,%r11
jge    21da <encodeRLE+0x10da>
movzbl %sil,%ebp
mov    %r13d,%r15d
xor    $0x1,%r15b
cmp    $0x81,%ebp
movzbl %sil,%esi
mov    $0x80,%eax
cmovae %eax,%esi
cmp    $0x2,%esi
jb     12a0 <encodeRLE+0x1a0>
movzbl %bl,%r12d
mov    %r12d,%r9d
shr    $0x4,%r9d
mov    %r12d,%ebp
and    $0xf,%ebp
cmp    %ebp,%r9d
jne    12b0 <encodeRLE+0x1b0>
mov    $0x1,%ebp
nopw   0x0(%rax,%rax,1)
test   %r15b,%r15b
je     1260 <encodeRLE+0x160>
movzbl (%rdi,%rdx,1),%ebx
add    $0x1,%rdx
shr    $0x4,%bl
jmp    1267 <encodeRLE+0x167>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi,%rdx,1),%ebx
and    $0xf,%bl
movzbl %bl,%ebx
cmp    %ebx,%r9d
jne    127c <encodeRLE+0x17c>
add    $0x1,%ebp
xor    $0x1,%r15b
cmp    %ebp,%esi
jne    1240 <encodeRLE+0x140>
mov    %esi,%ebp
xor    $0x1,%r8b
je     1308 <encodeRLE+0x208>
add    $0xff,%bpl
or     $0x80,%bpl
mov    %bpl,(%rcx,%r11,1)
add    $0x1,%r11
mov    %r11,%r10
jmp    15c2 <encodeRLE+0x4c2>
xchg   %ax,%ax
mov    $0x1,%esi
mov    $0x1,%r12b
mov    %rdx,%r14
jmp    1343 <encodeRLE+0x243>
mov    $0x1,%r12d
mov    %rdx,%r14
jmp    12de <encodeRLE+0x1de>
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%r14,1),%eax
mov    %eax,%ebp
shr    $0x4,%ebp
and    $0xf,%eax
cmp    %eax,%ebp
je     1338 <encodeRLE+0x238>
add    $0x1,%r12d
xor    $0x1,%r15b
cmp    %r12d,%esi
je     1303 <encodeRLE+0x203>
test   %r15b,%r15b
je     12c0 <encodeRLE+0x1c0>
lea    0x1(%r14),%rbp
movzbl (%rdi,%r14,1),%ebx
movzbl 0x2(%rdi,%r14,1),%eax
shr    $0x4,%bl
and    $0xf,%al
mov    %rbp,%r14
cmp    %al,%bl
jne    12d1 <encodeRLE+0x1d1>
mov    %rbp,%r14
jmp    1340 <encodeRLE+0x240>
mov    %esi,%r12d
jmp    1340 <encodeRLE+0x240>
add    $0xffffffff,%ebp
mov    %ebp,%ebx
and    $0x70,%bl
or     (%rcx,%r11,1),%bl
lea    0x1(%r11),%r10
or     $0x80,%bl
mov    %bl,(%rcx,%r11,1)
shl    $0x4,%r12d
and    $0xf,%ebp
or     %r12d,%ebp
add    $0x2,%r11
xor    %r8d,%r8d
mov    %ebp,%r9d
jmp    15c2 <encodeRLE+0x4c2>
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %r12d,%esi
mov    %esi,%eax
shr    %eax
add    %r11,%rax
add    $0x1,%rax
cmp    %r10,%rax
jge    21da <encodeRLE+0x10da>
lea    0x1(%r11),%r10
lea    -0x1(%r12),%r9d
test   %r8b,%r8b
je     13a0 <encodeRLE+0x2a0>
mov    %r9d,%eax
and    $0xf0,%al
or     %al,(%rcx,%r11,1)
mov    %r9d,%ebx
and    $0xf,%bl
mov    %bl,0x1(%rcx,%r11,1)
cmp    %r13b,%r8b
jne    14a8 <encodeRLE+0x3a8>
movzbl %dl,%eax
mov    (%rdi,%rax,1),%al
and    $0xf0,%al
or     %al,%bl
mov    %bl,0x1(%rcx,%r11,1)
add    $0x2,%r11
mov    %r9d,%r12d
mov    %r11,%r10
jmp    13ad <encodeRLE+0x2ad>
nopl   (%rax)
mov    %r9b,(%rcx,%r11,1)
test   %r13b,%r13b
jne    14a8 <encodeRLE+0x3a8>
cmp    $0x2,%r12b
jb     15a0 <encodeRLE+0x4a0>
movzbl %r12b,%r8d
shr    %r8d
movzbl %dl,%r11d
lea    (%rdi,%r11,1),%rbp
cmp    $0x2,%r8d
mov    $0x1,%eax
cmovb  %eax,%r8d
cmp    $0x10,%r8d
jb     13fd <encodeRLE+0x2fd>
lea    (%rcx,%r10,1),%rdx
lea    (%r11,%r8,1),%rsi
add    %rdi,%rsi
cmp    %rsi,%rdx
jae    14c9 <encodeRLE+0x3c9>
lea    (%r10,%r8,1),%rdx
add    %rcx,%rdx
cmp    %rdx,%rbp
jae    14c9 <encodeRLE+0x3c9>
xor    %ebx,%ebx
mov    %rbx,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rdx
and    $0x3,%rdx
je     1437 <encodeRLE+0x337>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rbx,1),%eax
mov    %al,(%rcx,%r10,1)
add    $0x1,%r10
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1420 <encodeRLE+0x320>
cmp    $0x3,%rsi
jb     15a0 <encodeRLE+0x4a0>
add    -0x18(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
movzbl -0x3(%r11,%rbx,1),%eax
mov    %al,(%rcx,%r10,1)
movzbl -0x2(%r11,%rbx,1),%eax
mov    %al,0x1(%rcx,%r10,1)
movzbl -0x1(%r11,%rbx,1),%eax
mov    %al,0x2(%rcx,%r10,1)
movzbl (%r11,%rbx,1),%eax
mov    %al,0x3(%rcx,%r10,1)
add    $0x4,%r10
add    $0x4,%rbx
cmp    %rbx,%r8
jne    1450 <encodeRLE+0x350>
jmp    15a0 <encodeRLE+0x4a0>
nopl   0x0(%rax)
movzbl (%rdi,%rax,1),%eax
shl    $0x4,%al
or     %al,(%rcx,%r10,1)
add    $0x1,%r10
add    $0xffffffff,%esi
je     15a9 <encodeRLE+0x4a9>
movzbl %dl,%eax
xor    $0x1,%r8b
je     1490 <encodeRLE+0x390>
add    $0x1,%dl
movzbl (%rdi,%rax,1),%eax
shr    $0x4,%al
mov    %al,(%rcx,%r10,1)
add    $0xffffffff,%esi
jne    14a8 <encodeRLE+0x3a8>
jmp    15a9 <encodeRLE+0x4a9>
mov    %rbp,-0x10(%rsp)
mov    %r8d,%ebx
and    $0xfffffff0,%ebx
lea    -0x10(%rbx),%rsi
mov    %rsi,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x30,%rsi
jae    14f2 <encodeRLE+0x3f2>
xor    %esi,%esi
jmp    1549 <encodeRLE+0x449>
and    $0xfffffffffffffffc,%rdx
mov    %rax,%rsi
mov    -0x20(%rsp),%rax
lea    (%rax,%r10,1),%r9
mov    -0x8(%rsp),%rax
lea    (%rax,%r11,1),%r13
mov    %rsi,%rax
xor    %esi,%esi
movups -0x30(%r13,%rsi,1),%xmm0
movups %xmm0,-0x30(%r9,%rsi,1)
movups -0x20(%r13,%rsi,1),%xmm0
movups %xmm0,-0x20(%r9,%rsi,1)
movups -0x10(%r13,%rsi,1),%xmm0
movups %xmm0,-0x10(%r9,%rsi,1)
movups 0x0(%r13,%rsi,1),%xmm0
movups %xmm0,(%r9,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1510 <encodeRLE+0x410>
test   %rax,%rax
je     1581 <encodeRLE+0x481>
lea    (%rsi,%r11,1),%rdx
add    %rdi,%rdx
add    %r10,%rsi
add    %rcx,%rsi
shl    $0x4,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rbp,1),%xmm0
movups %xmm0,(%rsi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%rax
jne    1570 <encodeRLE+0x470>
add    %rbx,%r10
cmp    %r8,%rbx
mov    -0x10(%rsp),%rbp
jne    13ff <encodeRLE+0x2ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   $0x1,%r12b
jne    15b1 <encodeRLE+0x4b1>
xor    %r8d,%r8d
mov    %r15d,%r13d
mov    %r10,%r11
jmp    15cc <encodeRLE+0x4cc>
mov    (%rdi,%r14,1),%r9b
and    $0xf,%r9b
mov    $0x1,%r8b
mov    %r10,%r11
mov    %r14,%rdx
mov    %r9b,(%rcx,%r10,1)
mov    %r15d,%r13d
mov    %rdx,%r14
mov    -0x30(%rsp),%rbp
mov    -0x38(%rsp),%rsi
mov    -0x28(%rsp),%r10
cmp    %rsi,%r14
jge    21da <encodeRLE+0x10da>
cmp    %r10,%r11
jl     1190 <encodeRLE+0x90>
jmp    21da <encodeRLE+0x10da>
movslq -0x3c(%rsp),%r13
movslq %esi,%r15
lea    -0x1(%r8),%eax
movslq %eax,%r9
movslq %r8d,%r8
lea    0x1(%rcx),%rax
mov    %rax,-0x30(%rsp)
lea    0x3(%rdi),%rax
mov    %rax,-0x38(%rsp)
xor    %r11d,%r11d
xor    %esi,%esi
jmp    1638 <encodeRLE+0x538>
nopl   (%rax)
mov    %rdx,%r11
mov    %r10,%rsi
cmp    %r15,%rsi
jge    21da <encodeRLE+0x10da>
cmp    %r8,%r11
jge    21da <encodeRLE+0x10da>
mov    %rsi,%rax
or     %r13,%rax
shr    $0x20,%rax
je     1650 <encodeRLE+0x550>
mov    %rsi,%rax
cqto
idiv   %r13
jmp    1658 <encodeRLE+0x558>
xchg   %ax,%ax
mov    %esi,%eax
xor    %edx,%edx
divl   -0x3c(%rsp)
mov    %r13,%rbp
sub    %rdx,%rbp
movzbl %bpl,%edx
mov    %r15,%rax
sub    %rsi,%rax
cmp    %rax,%rdx
cmovle %rbp,%rax
cmp    %r9,%r11
jge    21da <encodeRLE+0x10da>
lea    0x1(%rsi),%r10
movzbl %al,%ebp
cmp    $0x81,%ebp
mov    $0x80,%eax
cmovae %eax,%ebp
cmp    $0x2,%ebp
jb     16f0 <encodeRLE+0x5f0>
mov    (%rdi,%rsi,1),%bl
lea    -0x2(%rbp),%eax
lea    (%rsi,%rax,1),%r14
add    $0x2,%r14
cmp    0x1(%rdi,%rsi,1),%bl
jne    1700 <encodeRLE+0x600>
mov    $0x2,%eax
sub    %ebp,%eax
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rax,%rdx,1),%esi
cmp    $0x1,%esi
je     18fb <encodeRLE+0x7fb>
lea    0x1(%r10),%rsi
add    $0x1,%edx
cmp    0x1(%rdi,%r10,1),%bl
mov    %rsi,%r10
je     16c0 <encodeRLE+0x5c0>
jmp    1900 <encodeRLE+0x800>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ebx
mov    $0x1,%sil
jmp    172e <encodeRLE+0x62e>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%r10,1),%eax
cmp    0x1(%rdi,%r10,1),%al
je     172c <encodeRLE+0x62c>
add    $0x1,%esi
add    $0x1,%r10
cmp    %esi,%ebp
jne    1710 <encodeRLE+0x610>
mov    %r14,%r10
mov    %ebp,%esi
mov    %esi,%ebx
lea    -0x1(%rsi),%eax
lea    0x1(%r11),%rdx
mov    %al,(%rcx,%r11,1)
movzbl %sil,%r12d
lea    (%r11,%r12,1),%rax
add    $0x1,%rax
cmp    %r8,%rax
jge    21d7 <encodeRLE+0x10d7>
lea    (%rdi,%r10,1),%rax
sub    %r12,%rax
mov    %ebx,%r14d
cmp    $0x20,%ebx
jb     1789 <encodeRLE+0x689>
mov    -0x30(%rsp),%rbp
lea    (%r11,%rbp,1),%rsi
lea    (%r10,%r14,1),%rbx
sub    %r12,%rbx
add    %rdi,%rbx
cmp    %rbx,%rsi
jae    1804 <encodeRLE+0x704>
lea    (%r11,%r14,1),%rsi
add    %rbp,%rsi
cmp    %rsi,%rax
jae    1804 <encodeRLE+0x704>
xor    %esi,%esi
mov    %rsi,%r11
not    %r11
add    %r14,%r11
mov    %r14,%rbp
and    $0x3,%rbp
je     17b5 <encodeRLE+0x6b5>
nopl   (%rax)
movzbl (%rax,%rsi,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0x1,%rdx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    17a0 <encodeRLE+0x6a0>
cmp    $0x3,%r11
jb     1620 <encodeRLE+0x520>
mov    %r10,%rax
sub    %r12,%rax
add    -0x38(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movzbl -0x3(%rax,%rsi,1),%ebx
mov    %bl,(%rcx,%rdx,1)
movzbl -0x2(%rax,%rsi,1),%ebx
mov    %bl,0x1(%rcx,%rdx,1)
movzbl -0x1(%rax,%rsi,1),%ebx
mov    %bl,0x2(%rcx,%rdx,1)
movzbl (%rax,%rsi,1),%ebx
mov    %bl,0x3(%rcx,%rdx,1)
add    $0x4,%rdx
add    $0x4,%rsi
cmp    %rsi,%r14
jne    17d0 <encodeRLE+0x6d0>
jmp    1620 <encodeRLE+0x520>
mov    %r14d,%esi
and    $0xffffffe0,%esi
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups %xmm0,(%rcx,%rdx,1)
movups %xmm1,0x10(%rcx,%rdx,1)
cmp    $0x20,%rsi
je     18ea <encodeRLE+0x7ea>
movups 0x20(%rax),%xmm0
movups 0x30(%rax),%xmm1
movups %xmm0,0x21(%r11,%rcx,1)
movups %xmm1,0x31(%r11,%rcx,1)
cmp    $0x40,%esi
je     18ea <encodeRLE+0x7ea>
movups 0x40(%rax),%xmm0
movups 0x50(%rax),%xmm1
movups %xmm0,0x41(%r11,%rcx,1)
movups %xmm1,0x51(%r11,%rcx,1)
cmp    $0x60,%esi
je     18ea <encodeRLE+0x7ea>
movups 0x60(%rax),%xmm0
movups 0x70(%rax),%xmm1
movups %xmm0,0x61(%r11,%rcx,1)
movups %xmm1,0x71(%r11,%rcx,1)
cmp    $0x80,%esi
je     18ea <encodeRLE+0x7ea>
movups 0x80(%rax),%xmm0
movups 0x90(%rax),%xmm1
movups %xmm0,0x81(%r11,%rcx,1)
movups %xmm1,0x91(%r11,%rcx,1)
cmp    $0xa0,%esi
je     18ea <encodeRLE+0x7ea>
movups 0xa0(%rax),%xmm0
movups 0xb0(%rax),%xmm1
movups %xmm0,0xa1(%r11,%rcx,1)
movups %xmm1,0xb1(%r11,%rcx,1)
cmp    $0xc0,%esi
je     18ea <encodeRLE+0x7ea>
movups 0xc0(%rax),%xmm0
movups 0xd0(%rax),%xmm1
movups %xmm0,0xc1(%r11,%rcx,1)
movups %xmm1,0xd1(%r11,%rcx,1)
add    %rsi,%rdx
cmp    %r14,%rsi
je     1620 <encodeRLE+0x520>
jmp    178b <encodeRLE+0x68b>
mov    %ebp,%edx
mov    %r14,%rsi
add    $0xff,%dl
or     $0x80,%dl
mov    %dl,(%rcx,%r11,1)
mov    %bl,0x1(%rcx,%r11,1)
add    $0x2,%r11
cmp    %r15,%rsi
jl     162f <encodeRLE+0x52f>
jmp    21da <encodeRLE+0x10da>
movslq -0x3c(%rsp),%r9
movslq %esi,%r13
lea    -0x2(%r8),%eax
cltq
mov    %rax,-0x28(%rsp)
movslq %r8d,%rax
mov    %rax,-0x30(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,-0x38(%rsp)
lea    0x31(%rcx),%rax
mov    %rax,-0x8(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,-0x10(%rsp)
lea    0x3(%rdi),%rax
mov    %rax,-0x18(%rsp)
xor    %r11d,%r11d
xor    %ebx,%ebx
mov    %r13,-0x20(%rsp)
jmp    198a <encodeRLE+0x88a>
nopl   0x0(%rax)
mov    %r15,%r11
mov    %r8,%rbx
cmp    %r13,%rbx
jge    21da <encodeRLE+0x10da>
cmp    -0x30(%rsp),%r11
jge    21da <encodeRLE+0x10da>
mov    %rbx,%rax
shr    $0x3f,%rax
add    %rbx,%rax
sar    %rax
mov    %rax,%rdx
or     %r9,%rdx
shr    $0x20,%rdx
je     19b0 <encodeRLE+0x8b0>
cqto
idiv   %r9
jmp    19b6 <encodeRLE+0x8b6>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
divl   -0x3c(%rsp)
mov    %r9,%rsi
sub    %rdx,%rsi
movzbl %sil,%edx
mov    %r13,%rbp
sub    %rbx,%rbp
mov    %rbp,%rax
shr    $0x3f,%rax
add    %rbp,%rax
sar    %rax
cmp    %rax,%rdx
cmovle %rsi,%rax
cmp    -0x28(%rsp),%r11
jge    21da <encodeRLE+0x10da>
lea    0x2(%rbx),%r8
movzbl %al,%esi
cmp    $0x81,%esi
mov    $0x80,%eax
cmovae %eax,%esi
cmp    $0x2,%esi
jb     1a60 <encodeRLE+0x960>
mov    (%rdi,%rbx,1),%r10b
cmp    (%rdi,%r8,1),%r10b
jne    1a70 <encodeRLE+0x970>
mov    0x1(%rdi,%rbx,1),%r14b
cmp    0x1(%rdi,%r8,1),%r14b
jne    1a70 <encodeRLE+0x970>
add    $0x4,%rbx
mov    $0x2,%eax
sub    %esi,%eax
mov    $0x1,%edx
mov    %rbx,%rbp
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rbx
cmp    -0x1(%rdi,%rbp,1),%r14b
jne    1c78 <encodeRLE+0xb78>
lea    (%rax,%rdx,1),%ebp
add    $0x2,%r8
cmp    $0x1,%ebp
je     1c7e <encodeRLE+0xb7e>
lea    0x2(%rbx),%rbp
add    $0x1,%edx
cmp    (%rdi,%rbx,1),%r10b
je     1a30 <encodeRLE+0x930>
jmp    1c83 <encodeRLE+0xb83>
mov    $0x1,%eax
mov    $0x1,%dl
mov    -0x38(%rsp),%rbp
jmp    1ab4 <encodeRLE+0x9b4>
xchg   %ax,%ax
mov    $0x1,%edx
mov    -0x38(%rsp),%rbp
jmp    1a8b <encodeRLE+0x98b>
nopl   0x0(%rax)
add    $0x1,%edx
add    $0x2,%r8
cmp    %edx,%esi
je     1ab0 <encodeRLE+0x9b0>
movzbl (%rdi,%r8,1),%eax
cmp    0x2(%rdi,%r8,1),%al
jne    1a80 <encodeRLE+0x980>
movzbl 0x1(%rdi,%r8,1),%eax
cmp    0x3(%rdi,%r8,1),%al
jne    1a80 <encodeRLE+0x980>
jmp    1ab2 <encodeRLE+0x9b2>
cs nopw 0x0(%rax,%rax,1)
mov    %esi,%edx
mov    %edx,%eax
add    $0xff,%dl
lea    0x1(%r11),%r15
mov    %dl,(%rcx,%r11,1)
lea    (%rax,%rax,1),%r12d
lea    (%r11,%r12,1),%rdx
add    $0x1,%rdx
cmp    -0x30(%rsp),%rdx
jge    21d2 <encodeRLE+0x10d2>
lea    (%rdi,%r8,1),%rdx
mov    %rdx,%r14
sub    %r12,%r14
mov    %eax,%ebx
cmp    $0x8,%eax
jb     1b04 <encodeRLE+0xa04>
lea    (%r11,%rbp,1),%rax
cmp    %rdx,%rax
jae    1ba0 <encodeRLE+0xaa0>
lea    (%r11,%r12,1),%rax
add    %rbp,%rax
cmp    %rax,%r14
jae    1ba0 <encodeRLE+0xaa0>
xor    %r10d,%r10d
test   $0x1,%bl
jne    1b20 <encodeRLE+0xa20>
mov    %r10,%rdx
jmp    1b40 <encodeRLE+0xa40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%r10,2),%al
mov    %al,(%rcx,%r15,1)
mov    0x1(%r14,%r10,2),%al
mov    %al,0x1(%rcx,%r15,1)
add    $0x2,%r15
mov    %r10,%rdx
or     $0x1,%rdx
mov    %r15,%r11
not    %r10
add    %rbx,%r10
je     1973 <encodeRLE+0x873>
mov    -0x18(%rsp),%rax
add    %r8,%rax
sub    %rbx,%rdx
nopw   0x0(%rax,%rax,1)
movzbl -0x3(%rax,%rdx,2),%ebx
mov    %bl,(%rcx,%r15,1)
movzbl -0x2(%rax,%rdx,2),%ebx
mov    %bl,0x1(%rcx,%r15,1)
movzbl -0x1(%rax,%rdx,2),%ebx
mov    %bl,0x2(%rcx,%r15,1)
movzbl (%rax,%rdx,2),%ebx
mov    %bl,0x3(%rcx,%r15,1)
add    $0x4,%r15
add    $0x2,%rdx
jne    1b60 <encodeRLE+0xa60>
jmp    1970 <encodeRLE+0x870>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%r10d
and    $0xfffffff8,%r10d
lea    -0x8(%r10),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r13d
and    $0x3,%r13d
cmp    $0x18,%rax
jae    1bc7 <encodeRLE+0xac7>
xor    %esi,%esi
jmp    1c21 <encodeRLE+0xb21>
and    $0xfffffffffffffffc,%rdx
mov    -0x8(%rsp),%rax
lea    (%rax,%r11,1),%rbp
mov    %r8,%rax
sub    %r12,%rax
add    -0x10(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%rsi,2),%xmm0
movups %xmm0,-0x30(%rbp,%rsi,2)
movups -0x20(%rax,%rsi,2),%xmm0
movups %xmm0,-0x20(%rbp,%rsi,2)
movups -0x10(%rax,%rsi,2),%xmm0
movups %xmm0,-0x10(%rbp,%rsi,2)
movups (%rax,%rsi,2),%xmm0
movups %xmm0,0x0(%rbp,%rsi,2)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1bf0 <encodeRLE+0xaf0>
test   %r13,%r13
mov    -0x38(%rsp),%rbp
je     1c61 <encodeRLE+0xb61>
lea    (%r8,%rsi,2),%rax
sub    %r12,%rax
add    %rdi,%rax
lea    (%r11,%rsi,2),%rdx
add    %rbp,%rdx
shl    $0x4,%r13
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rax,%rsi,1),%xmm0
movups %xmm0,(%rdx,%rsi,1)
add    $0x10,%rsi
cmp    %rsi,%r13
jne    1c50 <encodeRLE+0xb50>
lea    (%r15,%r10,2),%r15
cmp    %rbx,%r10
mov    -0x20(%rsp),%r13
je     1970 <encodeRLE+0x870>
jmp    1b07 <encodeRLE+0xa07>
add    $0xfffffffffffffffe,%rbx
jmp    1c83 <encodeRLE+0xb83>
mov    %esi,%edx
mov    %r8,%rbx
add    $0xff,%dl
or     $0x80,%dl
mov    %dl,(%rcx,%r11,1)
mov    %r10b,0x1(%rcx,%r11,1)
mov    %r14b,0x2(%rcx,%r11,1)
add    $0x3,%r11
cmp    %r13,%rbx
jl     197f <encodeRLE+0x87f>
jmp    21da <encodeRLE+0x10da>
movslq -0x3c(%rsp),%r15
movslq %esi,%rdx
lea    -0x3(%r8),%eax
movslq %eax,%r12
movslq %r8d,%r13
mov    %rdx,%r8
lea    0x2(%rdi),%rax
mov    %rax,-0x30(%rsp)
xor    %r11d,%r11d
movabs $0x5555555555555556,%rbp
55 55 55
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
mov    %r10,%rax
imul   %rbp
mov    %rdx,%rax
shr    $0x3f,%rax
add    %rdx,%rax
mov    %rax,%rdx
or     %r15,%rdx
shr    $0x20,%rdx
je     1d10 <encodeRLE+0xc10>
cqto
idiv   %r15
jmp    1d16 <encodeRLE+0xc16>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edx,%edx
divl   -0x3c(%rsp)
mov    %r15,%rsi
sub    %rdx,%rsi
movzbl %sil,%ebx
mov    %r8,%rax
sub    %r10,%rax
imul   %rbp
mov    %rdx,%rax
shr    $0x3f,%rax
add    %rdx,%rax
cmp    %rax,%rbx
cmovle %rsi,%rax
cmp    %r12,%r11
jge    21da <encodeRLE+0x10da>
lea    0x3(%r10),%r9
movzbl %al,%r14d
cmp    $0x81,%r14d
mov    $0x80,%eax
cmovae %eax,%r14d
cmp    $0x2,%r14d
jb     1df0 <encodeRLE+0xcf0>
mov    %r13,%rsi
mov    %r12,%rbp
mov    (%rdi,%r10,1),%bl
cmp    (%rdi,%r9,1),%bl
jne    1e00 <encodeRLE+0xd00>
mov    0x1(%rdi,%r10,1),%r13b
cmp    0x1(%rdi,%r9,1),%r13b
jne    1e00 <encodeRLE+0xd00>
mov    0x2(%rdi,%r10,1),%r12b
cmp    0x2(%rdi,%r9,1),%r12b
jne    1e00 <encodeRLE+0xd00>
mov    %r8,-0x38(%rsp)
add    $0x6,%r10
mov    $0x2,%edx
sub    %r14d,%edx
mov    $0x1,%r8d
mov    %r10,%rax
nop
mov    %rax,%r10
cmp    -0x2(%rdi,%rax,1),%r13b
jne    1edb <encodeRLE+0xddb>
cmp    -0x1(%rdi,%r10,1),%r12b
jne    1ee4 <encodeRLE+0xde4>
lea    (%rdx,%r8,1),%eax
add    $0x3,%r9
cmp    $0x1,%eax
je     1ee1 <encodeRLE+0xde1>
lea    0x3(%r10),%rax
add    $0x1,%r8d
cmp    (%rdi,%r10,1),%bl
je     1db0 <encodeRLE+0xcb0>
jmp    1ee7 <encodeRLE+0xde7>
nopl   (%rax)
mov    $0x1,%eax
mov    $0x1,%dl
jmp    1e58 <encodeRLE+0xd58>
nopl   0x0(%rax)
mov    $0x1,%edx
mov    %rsi,%r13
jmp    1e1c <encodeRLE+0xd1c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edx
add    $0x3,%r9
cmp    %edx,%r14d
je     1e50 <encodeRLE+0xd50>
movzbl (%rdi,%r9,1),%eax
cmp    0x3(%rdi,%r9,1),%al
jne    1e10 <encodeRLE+0xd10>
movzbl 0x1(%rdi,%r9,1),%eax
cmp    0x4(%rdi,%r9,1),%al
jne    1e10 <encodeRLE+0xd10>
movzbl 0x2(%rdi,%r9,1),%eax
cmp    0x5(%rdi,%r9,1),%al
jne    1e10 <encodeRLE+0xd10>
jmp    1e53 <encodeRLE+0xd53>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14d,%edx
mov    %rbp,%r12
mov    %edx,%eax
add    $0xff,%dl
lea    0x1(%r11),%rbx
mov    %dl,(%rcx,%r11,1)
lea    (%rax,%rax,2),%esi
lea    (%r11,%rsi,1),%rdx
add    $0x1,%rdx
cmp    %r13,%rdx
jge    21cd <encodeRLE+0x10cd>
mov    %eax,%ebp
mov    %r9,%rax
sub    %rsi,%rax
add    -0x30(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x2(%rax),%edx
mov    %dl,(%rcx,%rbx,1)
movzbl -0x1(%rax),%edx
mov    %dl,0x1(%rcx,%rbx,1)
movzbl (%rax),%edx
mov    %dl,0x2(%rcx,%rbx,1)
add    $0x3,%rbx
add    $0x3,%rax
add    $0xffffffffffffffff,%rbp
jne    1e90 <encodeRLE+0xd90>
mov    %rbx,%r11
mov    %r9,%r10
movabs $0x5555555555555556,%rbp
55 55 55
cmp    %r8,%r10
jge    21da <encodeRLE+0x10da>
cmp    %r13,%r11
jl     1ce0 <encodeRLE+0xbe0>
jmp    21da <encodeRLE+0x10da>
add    $0xfffffffffffffffd,%r10
jmp    1ee7 <encodeRLE+0xde7>
mov    %r14d,%r8d
mov    %r9,%r10
add    $0xff,%r8b
or     $0x80,%r8b
mov    %r8b,(%rcx,%r11,1)
mov    %bl,0x1(%rcx,%r11,1)
mov    %r13b,0x2(%rcx,%r11,1)
mov    %r12b,0x3(%rcx,%r11,1)
add    $0x4,%r11
mov    -0x38(%rsp),%r8
mov    %rbp,%r12
mov    %rsi,%r13
jmp    1eba <encodeRLE+0xdba>
movslq -0x3c(%rsp),%r14
movslq %esi,%r15
lea    -0x4(%r8),%eax
movslq %eax,%r10
movslq %r8d,%r12
lea    0x3(%rdi),%r13
lea    0x4(%rcx),%rax
mov    %rax,-0x30(%rsp)
xor    %r11d,%r11d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    0x3(%rbx),%rax
test   %rbx,%rbx
cmovns %rbx,%rax
sar    $0x2,%rax
mov    %rax,%rdx
or     %r14,%rdx
shr    $0x20,%rdx
je     1f70 <encodeRLE+0xe70>
cqto
idiv   %r14
jmp    1f76 <encodeRLE+0xe76>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
divl   -0x3c(%rsp)
mov    %r14,%rsi
sub    %rdx,%rsi
movzbl %sil,%edx
mov    %r15,%rbp
sub    %rbx,%rbp
lea    0x3(%rbp),%rax
test   %rbp,%rbp
cmovns %rbp,%rax
sar    $0x2,%rax
cmp    %rax,%rdx
cmovle %rsi,%rax
cmp    %r10,%r11
jge    21da <encodeRLE+0x10da>
lea    0x4(%rbx),%r9
movzbl %al,%r8d
cmp    $0x81,%r8d
mov    $0x80,%eax
cmovae %eax,%r8d
cmp    $0x2,%r8d
jb     2090 <encodeRLE+0xf90>
mov    (%rdi,%rbx,1),%dl
cmp    (%rdi,%r9,1),%dl
jne    20a0 <encodeRLE+0xfa0>
mov    0x1(%rdi,%rbx,1),%bpl
cmp    0x1(%rdi,%r9,1),%bpl
jne    20a0 <encodeRLE+0xfa0>
mov    0x2(%rdi,%rbx,1),%al
mov    %al,-0x38(%rsp)
cmp    0x2(%rdi,%r9,1),%al
jne    20a0 <encodeRLE+0xfa0>
mov    0x3(%rdi,%rbx,1),%al
cmp    0x3(%rdi,%r9,1),%al
jne    20a0 <encodeRLE+0xfa0>
mov    %al,-0x28(%rsp)
mov    %r10,-0x20(%rsp)
add    $0x8,%rbx
mov    $0x2,%eax
sub    %r8d,%eax
mov    %rax,-0x18(%rsp)
mov    $0x1,%r10d
mov    %rbx,%rsi
nopl   0x0(%rax)
mov    %rsi,%rbx
cmp    -0x3(%rdi,%rsi,1),%bpl
jne    2189 <encodeRLE+0x1089>
movzbl -0x38(%rsp),%eax
cmp    -0x2(%rdi,%rbx,1),%al
jne    2192 <encodeRLE+0x1092>
movzbl -0x28(%rsp),%eax
cmp    -0x1(%rdi,%rbx,1),%al
jne    2192 <encodeRLE+0x1092>
mov    -0x18(%rsp),%rax
lea    (%rax,%r10,1),%esi
add    $0x4,%r9
cmp    $0x1,%esi
je     218f <encodeRLE+0x108f>
lea    0x4(%rbx),%rsi
add    $0x1,%r10d
cmp    (%rdi,%rbx,1),%dl
je     2030 <encodeRLE+0xf30>
jmp    2195 <encodeRLE+0x1095>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1,%eax
mov    $0x1,%dl
jmp    2105 <encodeRLE+0x1005>
nopl   0x0(%rax)
mov    $0x1,%edx
jmp    20bc <encodeRLE+0xfbc>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edx
add    $0x4,%r9
cmp    %edx,%r8d
je     2100 <encodeRLE+0x1000>
movzbl (%rdi,%r9,1),%eax
cmp    0x4(%rdi,%r9,1),%al
jne    20b0 <encodeRLE+0xfb0>
movzbl 0x1(%rdi,%r9,1),%eax
cmp    0x5(%rdi,%r9,1),%al
jne    20b0 <encodeRLE+0xfb0>
movzbl 0x2(%rdi,%r9,1),%eax
cmp    0x6(%rdi,%r9,1),%al
jne    20b0 <encodeRLE+0xfb0>
movzbl 0x3(%rdi,%r9,1),%eax
cmp    0x7(%rdi,%r9,1),%al
jne    20b0 <encodeRLE+0xfb0>
jmp    2103 <encodeRLE+0x1003>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8d,%edx
mov    %edx,%eax
add    $0xff,%dl
lea    0x1(%r11),%rbx
mov    %dl,(%rcx,%r11,1)
lea    0x0(,%rax,4),%esi
lea    (%r11,%rsi,1),%rdx
add    $0x1,%rdx
cmp    %r12,%rdx
jge    21cd <encodeRLE+0x10cd>
mov    %eax,%ebp
mov    %r9,%rax
sub    %rsi,%rax
add    %r13,%rax
add    -0x30(%rsp),%r11
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl -0x3(%rax,%rsi,4),%edx
mov    %dl,-0x3(%r11,%rsi,4)
movzbl -0x2(%rax,%rsi,4),%edx
mov    %dl,-0x2(%r11,%rsi,4)
movzbl -0x1(%rax,%rsi,4),%edx
mov    %dl,-0x1(%r11,%rsi,4)
movzbl (%rax,%rsi,4),%edx
add    $0x4,%rbx
mov    %dl,(%r11,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    2140 <encodeRLE+0x1040>
mov    %rbx,%r11
mov    %r9,%rbx
cmp    %r15,%rbx
jge    21da <encodeRLE+0x10da>
cmp    %r12,%r11
jl     1f40 <encodeRLE+0xe40>
jmp    21da <encodeRLE+0x10da>
add    $0xfffffffffffffffc,%rbx
jmp    2195 <encodeRLE+0x1095>
mov    %r8d,%r10d
mov    %r9,%rbx
add    $0xff,%r10b
or     $0x80,%r10b
mov    %r10b,(%rcx,%r11,1)
mov    %dl,0x1(%rcx,%r11,1)
mov    %bpl,0x2(%rcx,%r11,1)
mov    -0x38(%rsp),%al
mov    %al,0x3(%rcx,%r11,1)
mov    -0x28(%rsp),%al
mov    %al,0x4(%rcx,%r11,1)
add    $0x5,%r11
mov    -0x20(%rsp),%r10
cmp    %r15,%rbx
jl     217e <encodeRLE+0x107e>
jmp    21da <encodeRLE+0x10da>
mov    %rbx,%r11
jmp    21da <encodeRLE+0x10da>
mov    %r15,%r11
jmp    21da <encodeRLE+0x10da>
mov    %rdx,%r11
mov    %r11,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i64 @encodeRLE(i8* %0, i32 %1, i32 %2, i8* %3, i32 %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i64
%15 = alloca i64
%16 = alloca i8*
%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 i8
%26 = alloca i8
%27 = alloca i8
%28 = alloca i8
%29 = alloca i8
%30 = alloca i8
%31 = alloca i8
%32 = alloca i8
%33 = alloca i8
%34 = alloca i8
%35 = alloca i8
%36 = alloca i8
%37 = alloca i8
%38 = alloca i8
%39 = alloca i8
%40 = alloca i8
%41 = alloca i8
%42 = alloca i8
store i8* %0, i8** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i8* %3, i8** %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%43 = load i32, i32* %9
%44 = icmp eq i32 %43, 0
br i1 %44, label %45, label %50
45: ; preds = %6
%46 = load i32, i32* %8
%47 = shl i32 %46, 3
%48 = load i32, i32* %12
%49 = sdiv i32 %47, %48
store i32 %49, i32* %9
br label %50
50: ; preds = %45, %6
store i64 0, i64* %14
store i64 0, i64* %15
%51 = load i8*, i8** %7
store i8* %51, i8** %16
%52 = load i8*, i8** %10
store i8* %52, i8** %17
%53 = load i32, i32* %12
%54 = icmp eq i32 %53, 4
br i1 %54, label %55, label %475
55: ; preds = %50
store i8 0, i8* %18
store i8 0, i8* %19
br label %56
56: ; preds = %472, %55
%57 = load i32, i32* %9
%58 = sext i32 %57 to i64
%59 = load i64, i64* %14
%60 = mul nsw i64 %59, 2
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = srem i64 %60, %62
%64 = sub nsw i64 %58, %63
%65 = trunc i64 %64 to i8
store i8 %65, i8* %20
%66 = load i8, i8* %20
%67 = zext i8 %66 to i64
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = load i64, i64* %14
%71 = sub nsw i64 %69, %70
%72 = mul nsw i64 %71, 2
%73 = icmp sgt i64 %67, %72
br i1 %73, label %74, label %81
74: ; preds = %56
%75 = load i32, i32* %8
%76 = sext i32 %75 to i64
%77 = load i64, i64* %14
%78 = sub nsw i64 %76, %77
%79 = mul nsw i64 %78, 2
%80 = trunc i64 %79 to i8
store i8 %80, i8* %20
br label %81
81: ; preds = %74, %56
%82 = load i8, i8* %20
%83 = zext i8 %82 to i32
%84 = icmp sgt i32 %83, 128
br i1 %84, label %85, label %86
85: ; preds = %81
store i8 -128, i8* %20
br label %86
86: ; preds = %85, %81
%87 = load i8, i8* %18
%88 = icmp ne i8 %87, 0
br i1 %88, label %89, label %107
89: ; preds = %86
%90 = load i8*, i8** %16
%91 = load i64, i64* %14
%92 = getelementptr inbounds i8, i8* %90, i64 %91
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = ashr i32 %94, 4
%96 = load i8*, i8** %16
%97 = load i64, i64* %14
%98 = getelementptr inbounds i8, i8* %96, i64 %97
%99 = getelementptr inbounds i8, i8* %98, i64 1
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = shl i32 %101, 4
%103 = or i32 %95, %102
%104 = trunc i32 %103 to i8
store i8 %104, i8* %22
%105 = load i64, i64* %14
%106 = add nsw i64 %105, 1
store i64 %106, i64* %14
br label %112
107: ; preds = %86
%108 = load i8*, i8** %16
%109 = load i64, i64* %14
%110 = getelementptr inbounds i8, i8* %108, i64 %109
%111 = load i8, i8* %110
store i8 %111, i8* %22
br label %112
112: ; preds = %107, %89
%113 = load i8, i8* %18
%114 = zext i8 %113 to i32
%115 = xor i32 %114, 1
%116 = trunc i32 %115 to i8
store i8 %116, i8* %18
%117 = load i64, i64* %15
%118 = load i32, i32* %11
%119 = sext i32 %118 to i64
%120 = icmp sge i64 %117, %119
br i1 %120, label %121, label %122
121: ; preds = %112
br label %474
122: ; preds = %112
%123 = load i8, i8* %20
%124 = zext i8 %123 to i32
%125 = icmp sge i32 %124, 2
br i1 %125, label %126, label %235
126: ; preds = %122
%127 = load i8, i8* %22
%128 = zext i8 %127 to i32
%129 = ashr i32 %128, 4
%130 = load i8, i8* %22
%131 = zext i8 %130 to i32
%132 = and i32 %131, 15
%133 = icmp eq i32 %129, %132
br i1 %133, label %134, label %235
134: ; preds = %126
store i8 1, i8* %21
br label %135
135: ; preds = %176, %134
%136 = load i8, i8* %21
%137 = zext i8 %136 to i32
%138 = load i8, i8* %20
%139 = zext i8 %138 to i32
%140 = icmp slt i32 %137, %139
br i1 %140, label %141, label %173
141: ; preds = %135
%142 = load i8, i8* %18
%143 = zext i8 %142 to i32
%144 = icmp ne i32 %143, 0
br i1 %144, label %145, label %158
145: ; preds = %141
%146 = load i8, i8* %22
%147 = zext i8 %146 to i32
%148 = and i32 %147, 15
%149 = load i8*, i8** %16
%150 = load i64, i64* %14
%151 = add nsw i64 %150, 1
store i64 %151, i64* %14
%152 = getelementptr inbounds i8, i8* %149, i64 %150
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = ashr i32 %154, 4
%156 = icmp eq i32 %148, %155
%157 = zext i1 %156 to i32
br label %170
158: ; preds = %141
%159 = load i8, i8* %22
%160 = zext i8 %159 to i32
%161 = and i32 %160, 15
%162 = load i8*, i8** %16
%163 = load i64, i64* %14
%164 = getelementptr inbounds i8, i8* %162, i64 %163
%165 = load i8, i8* %164
%166 = zext i8 %165 to i32
%167 = and i32 %166, 15
%168 = icmp eq i32 %161, %167
%169 = zext i1 %168 to i32
br label %170
170: ; preds = %158, %145
%171 = phi i32 [ %157, %145 ], [ %169, %158 ]
%172 = icmp ne i32 %171, 0
br label %173
173: ; preds = %170, %135
%174 = phi i1 [ false, %135 ], [ %172, %170 ]
br i1 %174, label %175, label %183
175: ; preds = %173
br label %176
176: ; preds = %175
%177 = load i8, i8* %21
%178 = add i8 %177, 1
store i8 %178, i8* %21
%179 = load i8, i8* %18
%180 = zext i8 %179 to i32
%181 = xor i32 %180, 1
%182 = trunc i32 %181 to i8
store i8 %182, i8* %18
br label %135
183: ; preds = %173
%184 = load i8, i8* %19
%185 = zext i8 %184 to i32
%186 = xor i32 %185, 1
%187 = trunc i32 %186 to i8
store i8 %187, i8* %19
%188 = icmp ne i8 %187, 0
br i1 %188, label %189, label %206
189: ; preds = %183
%190 = load i8, i8* %21
%191 = zext i8 %190 to i32
%192 = sub nsw i32 %191, 1
%193 = or i32 128, %192
%194 = trunc i32 %193 to i8
%195 = load i8*, i8** %17
%196 = load i64, i64* %15
%197 = add nsw i64 %196, 1
store i64 %197, i64* %15
%198 = getelementptr inbounds i8, i8* %195, i64 %196
store i8 %194, i8* %198
%199 = load i8, i8* %22
%200 = zext i8 %199 to i32
%201 = and i32 %200, 15
%202 = trunc i32 %201 to i8
%203 = load i8*, i8** %17
%204 = load i64, i64* %15
%205 = getelementptr inbounds i8, i8* %203, i64 %204
store i8 %202, i8* %205
br label %234
206: ; preds = %183
%207 = load i8, i8* %21
%208 = zext i8 %207 to i32
%209 = sub nsw i32 %208, 1
%210 = or i32 128, %209
%211 = and i32 %210, 240
%212 = load i8*, i8** %17
%213 = load i64, i64* %15
%214 = add nsw i64 %213, 1
store i64 %214, i64* %15
%215 = getelementptr inbounds i8, i8* %212, i64 %213
%216 = load i8, i8* %215
%217 = zext i8 %216 to i32
%218 = or i32 %217, %211
%219 = trunc i32 %218 to i8
store i8 %219, i8* %215
%220 = load i8, i8* %22
%221 = zext i8 %220 to i32
%222 = shl i32 %221, 4
%223 = load i8, i8* %21
%224 = zext i8 %223 to i32
%225 = sub nsw i32 %224, 1
%226 = or i32 128, %225
%227 = and i32 %226, 15
%228 = or i32 %222, %227
%229 = trunc i32 %228 to i8
%230 = load i8*, i8** %17
%231 = load i64, i64* %15
%232 = add nsw i64 %231, 1
store i64 %232, i64* %15
%233 = getelementptr inbounds i8, i8* %230, i64 %231
store i8 %229, i8* %233
br label %234
234: ; preds = %206, %189
br label %461
235: ; preds = %126, %122
%236 = load i8, i8* %18
%237 = zext i8 %236 to i32
%238 = xor i32 %237, 1
%239 = trunc i32 %238 to i8
store i8 %239, i8* %23
%240 = load i64, i64* %14
%241 = trunc i64 %240 to i8
store i8 %241, i8* %24
store i8 1, i8* %21
br label %242
242: ; preds = %290, %235
%243 = load i8, i8* %21
%244 = zext i8 %243 to i32
%245 = load i8, i8* %20
%246 = zext i8 %245 to i32
%247 = icmp slt i32 %244, %246
br i1 %247, label %248, label %287
248: ; preds = %242
%249 = load i8, i8* %18
%250 = zext i8 %249 to i32
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %269
252: ; preds = %248
%253 = load i8*, i8** %16
%254 = load i64, i64* %14
%255 = add nsw i64 %254, 1
store i64 %255, i64* %14
%256 = getelementptr inbounds i8, i8* %253, i64 %254
%257 = load i8, i8* %256
%258 = zext i8 %257 to i32
%259 = ashr i32 %258, 4
%260 = load i8*, i8** %16
%261 = load i64, i64* %14
%262 = getelementptr inbounds i8, i8* %260, i64 %261
%263 = getelementptr inbounds i8, i8* %262, i64 1
%264 = load i8, i8* %263
%265 = zext i8 %264 to i32
%266 = and i32 %265, 15
%267 = icmp ne i32 %259, %266
%268 = zext i1 %267 to i32
br label %284
269: ; preds = %248
%270 = load i8*, i8** %16
%271 = load i64, i64* %14
%272 = getelementptr inbounds i8, i8* %270, i64 %271
%273 = load i8, i8* %272
%274 = zext i8 %273 to i32
%275 = ashr i32 %274, 4
%276 = load i8*, i8** %16
%277 = load i64, i64* %14
%278 = getelementptr inbounds i8, i8* %276, i64 %277
%279 = load i8, i8* %278
%280 = zext i8 %279 to i32
%281 = and i32 %280, 15
%282 = icmp ne i32 %275, %281
%283 = zext i1 %282 to i32
br label %284
284: ; preds = %269, %252
%285 = phi i32 [ %268, %252 ], [ %283, %269 ]
%286 = icmp ne i32 %285, 0
br label %287
287: ; preds = %284, %242
%288 = phi i1 [ false, %242 ], [ %286, %284 ]
br i1 %288, label %289, label %297
289: ; preds = %287
br label %290
290: ; preds = %289
%291 = load i8, i8* %21
%292 = add i8 %291, 1
store i8 %292, i8* %21
%293 = load i8, i8* %18
%294 = zext i8 %293 to i32
%295 = xor i32 %294, 1
%296 = trunc i32 %295 to i8
store i8 %296, i8* %18
br label %242
297: ; preds = %287
%298 = load i64, i64* %15
%299 = load i8, i8* %21
%300 = zext i8 %299 to i32
%301 = sdiv i32 %300, 2
%302 = sext i32 %301 to i64
%303 = add nsw i64 %298, %302
%304 = add nsw i64 %303, 1
%305 = load i32, i32* %11
%306 = sext i32 %305 to i64
%307 = icmp sge i64 %304, %306
br i1 %307, label %308, label %309
308: ; preds = %297
br label %474
309: ; preds = %297
%310 = load i8, i8* %19
%311 = icmp ne i8 %310, 0
br i1 %311, label %322, label %312
312: ; preds = %309
%313 = load i8, i8* %21
%314 = zext i8 %313 to i32
%315 = sub nsw i32 %314, 1
%316 = or i32 0, %315
%317 = trunc i32 %316 to i8
%318 = load i8*, i8** %17
%319 = load i64, i64* %15
%320 = add nsw i64 %319, 1
store i64 %320, i64* %15
%321 = getelementptr inbounds i8, i8* %318, i64 %319
store i8 %317, i8* %321
br label %343
322: ; preds = %309
%323 = load i8, i8* %21
%324 = zext i8 %323 to i32
%325 = sub nsw i32 %324, 1
%326 = and i32 %325, 240
%327 = load i8*, i8** %17
%328 = load i64, i64* %15
%329 = add nsw i64 %328, 1
store i64 %329, i64* %15
%330 = getelementptr inbounds i8, i8* %327, i64 %328
%331 = load i8, i8* %330
%332 = zext i8 %331 to i32
%333 = or i32 %332, %326
%334 = trunc i32 %333 to i8
store i8 %334, i8* %330
%335 = load i8, i8* %21
%336 = zext i8 %335 to i32
%337 = sub nsw i32 %336, 1
%338 = and i32 %337, 15
%339 = trunc i32 %338 to i8
%340 = load i8*, i8** %17
%341 = load i64, i64* %15
%342 = getelementptr inbounds i8, i8* %340, i64 %341
store i8 %339, i8* %342
br label %343
343: ; preds = %322, %312
%344 = load i8, i8* %19
%345 = zext i8 %344 to i32
%346 = load i8, i8* %23
%347 = zext i8 %346 to i32
%348 = icmp eq i32 %345, %347
br i1 %348, label %349, label %412
349: ; preds = %343
%350 = load i8, i8* %19
%351 = icmp ne i8 %350, 0
br i1 %351, label %352, label %371
352: ; preds = %349
%353 = load i8*, i8** %16
%354 = load i8, i8* %24
%355 = zext i8 %354 to i32
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i8, i8* %353, i64 %356
%358 = load i8, i8* %357
%359 = zext i8 %358 to i32
%360 = and i32 %359, 240
%361 = load i8*, i8** %17
%362 = load i64, i64* %15
%363 = add nsw i64 %362, 1
store i64 %363, i64* %15
%364 = getelementptr inbounds i8, i8* %361, i64 %362
%365 = load i8, i8* %364
%366 = zext i8 %365 to i32
%367 = or i32 %366, %360
%368 = trunc i32 %367 to i8
store i8 %368, i8* %364
%369 = load i8, i8* %21
%370 = add i8 %369, -1
store i8 %370, i8* %21
store i8 0, i8* %19
br label %371
371: ; preds = %352, %349
store i32 0, i32* %13
br label %372
372: ; preds = %392, %371
%373 = load i32, i32* %13
%374 = load i8, i8* %21
%375 = zext i8 %374 to i32
%376 = sdiv i32 %375, 2
%377 = icmp slt i32 %373, %376
br i1 %377, label %378, label %395
378: ; preds = %372
%379 = load i8*, i8** %16
%380 = load i8, i8* %24
%381 = zext i8 %380 to i32
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i8, i8* %379, i64 %382
%384 = load i32, i32* %13
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i8, i8* %383, i64 %385
%387 = load i8, i8* %386
%388 = load i8*, i8** %17
%389 = load i64, i64* %15
%390 = add nsw i64 %389, 1
store i64 %390, i64* %15
%391 = getelementptr inbounds i8, i8* %388, i64 %389
store i8 %387, i8* %391
br label %392
392: ; preds = %378
%393 = load i32, i32* %13
%394 = add nsw i32 %393, 1
store i32 %394, i32* %13
br label %372
395: ; preds = %372
%396 = load i8, i8* %21
%397 = zext i8 %396 to i32
%398 = and i32 %397, 1
%399 = icmp ne i32 %398, 0
br i1 %399, label %400, label %411
400: ; preds = %395
%401 = load i8*, i8** %16
%402 = load i64, i64* %14
%403 = getelementptr inbounds i8, i8* %401, i64 %402
%404 = load i8, i8* %403
%405 = zext i8 %404 to i32
%406 = and i32 %405, 15
%407 = trunc i32 %406 to i8
%408 = load i8*, i8** %17
%409 = load i64, i64* %15
%410 = getelementptr inbounds i8, i8* %408, i64 %409
store i8 %407, i8* %410
store i8 1, i8* %19
br label %411
411: ; preds = %400, %395
br label %460
412: ; preds = %343
store i32 0, i32* %13
br label %413
413: ; preds = %456, %412
%414 = load i32, i32* %13
%415 = load i8, i8* %21
%416 = zext i8 %415 to i32
%417 = icmp slt i32 %414, %416
br i1 %417, label %418, label %459
418: ; preds = %413
%419 = load i8, i8* %19
%420 = zext i8 %419 to i32
%421 = xor i32 %420, 1
%422 = trunc i32 %421 to i8
store i8 %422, i8* %19
%423 = icmp ne i8 %422, 0
br i1 %423, label %424, label %438
424: ; preds = %418
%425 = load i8*, i8** %16
%426 = load i8, i8* %24
%427 = add i8 %426, 1
store i8 %427, i8* %24
%428 = zext i8 %426 to i32
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8, i8* %425, i64 %429
%431 = load i8, i8* %430
%432 = zext i8 %431 to i32
%433 = ashr i32 %432, 4
%434 = trunc i32 %433 to i8
%435 = load i8*, i8** %17
%436 = load i64, i64* %15
%437 = getelementptr inbounds i8, i8* %435, i64 %436
store i8 %434, i8* %437
br label %455
438: ; preds = %418
%439 = load i8*, i8** %16
%440 = load i8, i8* %24
%441 = zext i8 %440 to i32
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds i8, i8* %439, i64 %442
%444 = load i8, i8* %443
%445 = zext i8 %444 to i32
%446 = shl i32 %445, 4
%447 = load i8*, i8** %17
%448 = load i64, i64* %15
%449 = add nsw i64 %448, 1
store i64 %449, i64* %15
%450 = getelementptr inbounds i8, i8* %447, i64 %448
%451 = load i8, i8* %450
%452 = zext i8 %451 to i32
%453 = or i32 %452, %446
%454 = trunc i32 %453 to i8
store i8 %454, i8* %450
br label %455
455: ; preds = %438, %424
br label %456
456: ; preds = %455
%457 = load i32, i32* %13
%458 = add nsw i32 %457, 1
store i32 %458, i32* %13
br label %413
459: ; preds = %413
br label %460
460: ; preds = %459, %411
br label %461
461: ; preds = %460, %234
br label %462
462: ; preds = %461
%463 = load i64, i64* %14
%464 = load i32, i32* %8
%465 = sext i32 %464 to i64
%466 = icmp slt i64 %463, %465
br i1 %466, label %467, label %472
467: ; preds = %462
%468 = load i64, i64* %15
%469 = load i32, i32* %11
%470 = sext i32 %469 to i64
%471 = icmp slt i64 %468, %470
br label %472
472: ; preds = %467, %462
%473 = phi i1 [ false, %462 ], [ %471, %467 ]
br i1 %473, label %56, label %474
474: ; preds = %472, %308, %121
br label %1612
475: ; preds = %50
%476 = load i32, i32* %12
%477 = icmp eq i32 %476, 8
br i1 %477, label %478, label %657
478: ; preds = %475
br label %479
479: ; preds = %654, %478
%480 = load i32, i32* %9
%481 = sext i32 %480 to i64
%482 = load i64, i64* %14
%483 = load i32, i32* %9
%484 = sext i32 %483 to i64
%485 = srem i64 %482, %484
%486 = sub nsw i64 %481, %485
%487 = trunc i64 %486 to i8
store i8 %487, i8* %25
%488 = load i8, i8* %25
%489 = zext i8 %488 to i64
%490 = load i32, i32* %8
%491 = sext i32 %490 to i64
%492 = load i64, i64* %14
%493 = sub nsw i64 %491, %492
%494 = icmp sgt i64 %489, %493
br i1 %494, label %495, label %501
495: ; preds = %479
%496 = load i32, i32* %8
%497 = sext i32 %496 to i64
%498 = load i64, i64* %14
%499 = sub nsw i64 %497, %498
%500 = trunc i64 %499 to i8
store i8 %500, i8* %25
br label %501
501: ; preds = %495, %479
%502 = load i8, i8* %25
%503 = zext i8 %502 to i32
%504 = icmp sgt i32 %503, 128
br i1 %504, label %505, label %506
505: ; preds = %501
store i8 -128, i8* %25
br label %506
506: ; preds = %505, %501
%507 = load i8*, i8** %16
%508 = load i64, i64* %14
%509 = add nsw i64 %508, 1
store i64 %509, i64* %14
%510 = getelementptr inbounds i8, i8* %507, i64 %508
%511 = load i8, i8* %510
store i8 %511, i8* %27
%512 = load i64, i64* %15
%513 = load i32, i32* %11
%514 = sub nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = icmp sge i64 %512, %515
br i1 %516, label %517, label %518
517: ; preds = %506
br label %656
518: ; preds = %506
%519 = load i8, i8* %25
%520 = zext i8 %519 to i32
%521 = icmp sge i32 %520, 2
br i1 %521, label %522, label %570
522: ; preds = %518
%523 = load i8, i8* %27
%524 = zext i8 %523 to i32
%525 = load i8*, i8** %16
%526 = load i64, i64* %14
%527 = getelementptr inbounds i8, i8* %525, i64 %526
%528 = load i8, i8* %527
%529 = zext i8 %528 to i32
%530 = icmp eq i32 %524, %529
br i1 %530, label %531, label %570
531: ; preds = %522
store i8 1, i8* %26
br label %532
532: ; preds = %550, %531
%533 = load i8, i8* %26
%534 = zext i8 %533 to i32
%535 = load i8, i8* %25
%536 = zext i8 %535 to i32
%537 = icmp slt i32 %534, %536
br i1 %537, label %538, label %547
538: ; preds = %532
%539 = load i8, i8* %27
%540 = zext i8 %539 to i32
%541 = load i8*, i8** %16
%542 = load i64, i64* %14
%543 = getelementptr inbounds i8, i8* %541, i64 %542
%544 = load i8, i8* %543
%545 = zext i8 %544 to i32
%546 = icmp eq i32 %540, %545
br label %547
547: ; preds = %538, %532
%548 = phi i1 [ false, %532 ], [ %546, %538 ]
br i1 %548, label %549, label %555
549: ; preds = %547
br label %550
550: ; preds = %549
%551 = load i8, i8* %26
%552 = add i8 %551, 1
store i8 %552, i8* %26
%553 = load i64, i64* %14
%554 = add nsw i64 %553, 1
store i64 %554, i64* %14
br label %532
555: ; preds = %547
%556 = load i8, i8* %26
%557 = zext i8 %556 to i32
%558 = sub nsw i32 %557, 1
%559 = or i32 128, %558
%560 = trunc i32 %559 to i8
%561 = load i8*, i8** %17
%562 = load i64, i64* %15
%563 = add nsw i64 %562, 1
store i64 %563, i64* %15
%564 = getelementptr inbounds i8, i8* %561, i64 %562
store i8 %560, i8* %564
%565 = load i8, i8* %27
%566 = load i8*, i8** %17
%567 = load i64, i64* %15
%568 = add nsw i64 %567, 1
store i64 %568, i64* %15
%569 = getelementptr inbounds i8, i8* %566, i64 %567
store i8 %565, i8* %569
br label %643
570: ; preds = %522, %518
store i8 1, i8* %26
br label %571
571: ; preds = %593, %570
%572 = load i8, i8* %26
%573 = zext i8 %572 to i32
%574 = load i8, i8* %25
%575 = zext i8 %574 to i32
%576 = icmp slt i32 %573, %575
br i1 %576, label %577, label %590
577: ; preds = %571
%578 = load i8*, i8** %16
%579 = load i64, i64* %14
%580 = getelementptr inbounds i8, i8* %578, i64 %579
%581 = load i8, i8* %580
%582 = zext i8 %581 to i32
%583 = load i8*, i8** %16
%584 = load i64, i64* %14
%585 = getelementptr inbounds i8, i8* %583, i64 %584
%586 = getelementptr inbounds i8, i8* %585, i64 1
%587 = load i8, i8* %586
%588 = zext i8 %587 to i32
%589 = icmp ne i32 %582, %588
br label %590
590: ; preds = %577, %571
%591 = phi i1 [ false, %571 ], [ %589, %577 ]
br i1 %591, label %592, label %598
592: ; preds = %590
br label %593
593: ; preds = %592
%594 = load i8, i8* %26
%595 = add i8 %594, 1
store i8 %595, i8* %26
%596 = load i64, i64* %14
%597 = add nsw i64 %596, 1
store i64 %597, i64* %14
br label %571
598: ; preds = %590
%599 = load i8, i8* %26
%600 = zext i8 %599 to i32
%601 = sub nsw i32 %600, 1
%602 = or i32 0, %601
%603 = trunc i32 %602 to i8
%604 = load i8*, i8** %17
%605 = load i64, i64* %15
%606 = add nsw i64 %605, 1
store i64 %606, i64* %15
%607 = getelementptr inbounds i8, i8* %604, i64 %605
store i8 %603, i8* %607
%608 = load i64, i64* %15
%609 = load i8, i8* %26
%610 = zext i8 %609 to i64
%611 = add nsw i64 %608, %610
%612 = load i32, i32* %11
%613 = sext i32 %612 to i64
%614 = icmp sge i64 %611, %613
br i1 %614, label %615, label %616
615: ; preds = %598
br label %656
616: ; preds = %598
store i32 0, i32* %13
br label %617
617: ; preds = %639, %616
%618 = load i32, i32* %13
%619 = load i8, i8* %26
%620 = zext i8 %619 to i32
%621 = icmp slt i32 %618, %620
br i1 %621, label %622, label %642
622: ; preds = %617
%623 = load i8*, i8** %16
%624 = load i64, i64* %14
%625 = getelementptr inbounds i8, i8* %623, i64 %624
%626 = load i8, i8* %26
%627 = zext i8 %626 to i32
%628 = sext i32 %627 to i64
%629 = sub i64 0, %628
%630 = getelementptr inbounds i8, i8* %625, i64 %629
%631 = load i32, i32* %13
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i8, i8* %630, i64 %632
%634 = load i8, i8* %633
%635 = load i8*, i8** %17
%636 = load i64, i64* %15
%637 = add nsw i64 %636, 1
store i64 %637, i64* %15
%638 = getelementptr inbounds i8, i8* %635, i64 %636
store i8 %634, i8* %638
br label %639
639: ; preds = %622
%640 = load i32, i32* %13
%641 = add nsw i32 %640, 1
store i32 %641, i32* %13
br label %617
642: ; preds = %617
br label %643
643: ; preds = %642, %555
br label %644
644: ; preds = %643
%645 = load i64, i64* %14
%646 = load i32, i32* %8
%647 = sext i32 %646 to i64
%648 = icmp slt i64 %645, %647
br i1 %648, label %649, label %654
649: ; preds = %644
%650 = load i64, i64* %15
%651 = load i32, i32* %11
%652 = sext i32 %651 to i64
%653 = icmp slt i64 %650, %652
br label %654
654: ; preds = %649, %644
%655 = phi i1 [ false, %644 ], [ %653, %649 ]
br i1 %655, label %479, label %656
656: ; preds = %654, %615, %517
br label %1611
657: ; preds = %475
%658 = load i32, i32* %12
%659 = icmp eq i32 %658, 16
br i1 %659, label %660, label %911
660: ; preds = %657
br label %661
661: ; preds = %908, %660
%662 = load i32, i32* %9
%663 = sext i32 %662 to i64
%664 = load i64, i64* %14
%665 = sdiv i64 %664, 2
%666 = load i32, i32* %9
%667 = sext i32 %666 to i64
%668 = srem i64 %665, %667
%669 = sub nsw i64 %663, %668
%670 = trunc i64 %669 to i8
store i8 %670, i8* %28
%671 = load i8, i8* %28
%672 = zext i8 %671 to i64
%673 = load i32, i32* %8
%674 = sext i32 %673 to i64
%675 = load i64, i64* %14
%676 = sub nsw i64 %674, %675
%677 = sdiv i64 %676, 2
%678 = icmp sgt i64 %672, %677
br i1 %678, label %679, label %686
679: ; preds = %661
%680 = load i32, i32* %8
%681 = sext i32 %680 to i64
%682 = load i64, i64* %14
%683 = sub nsw i64 %681, %682
%684 = sdiv i64 %683, 2
%685 = trunc i64 %684 to i8
store i8 %685, i8* %28
br label %686
686: ; preds = %679, %661
%687 = load i8, i8* %28
%688 = zext i8 %687 to i32
%689 = icmp sgt i32 %688, 128
br i1 %689, label %690, label %691
690: ; preds = %686
store i8 -128, i8* %28
br label %691
691: ; preds = %690, %686
%692 = load i8*, i8** %16
%693 = load i64, i64* %14
%694 = add nsw i64 %693, 1
store i64 %694, i64* %14
%695 = getelementptr inbounds i8, i8* %692, i64 %693
%696 = load i8, i8* %695
store i8 %696, i8* %30
%697 = load i8*, i8** %16
%698 = load i64, i64* %14
%699 = add nsw i64 %698, 1
store i64 %699, i64* %14
%700 = getelementptr inbounds i8, i8* %697, i64 %698
%701 = load i8, i8* %700
store i8 %701, i8* %31
%702 = load i64, i64* %15
%703 = load i32, i32* %11
%704 = sub nsw i32 %703, 2
%705 = sext i32 %704 to i64
%706 = icmp sge i64 %702, %705
br i1 %706, label %707, label %708
707: ; preds = %691
br label %910
708: ; preds = %691
%709 = load i8, i8* %28
%710 = zext i8 %709 to i32
%711 = icmp sge i32 %710, 2
br i1 %711, label %712, label %785
712: ; preds = %708
%713 = load i8, i8* %30
%714 = zext i8 %713 to i32
%715 = load i8*, i8** %16
%716 = load i64, i64* %14
%717 = getelementptr inbounds i8, i8* %715, i64 %716
%718 = load i8, i8* %717
%719 = zext i8 %718 to i32
%720 = icmp eq i32 %714, %719
br i1 %720, label %721, label %785
721: ; preds = %712
%722 = load i8, i8* %31
%723 = zext i8 %722 to i32
%724 = load i8*, i8** %16
%725 = load i64, i64* %14
%726 = getelementptr inbounds i8, i8* %724, i64 %725
%727 = getelementptr inbounds i8, i8* %726, i64 1
%728 = load i8, i8* %727
%729 = zext i8 %728 to i32
%730 = icmp eq i32 %723, %729
br i1 %730, label %731, label %785
731: ; preds = %721
store i8 1, i8* %29
br label %732
732: ; preds = %760, %731
%733 = load i8, i8* %29
%734 = zext i8 %733 to i32
%735 = load i8, i8* %28
%736 = zext i8 %735 to i32
%737 = icmp slt i32 %734, %736
br i1 %737, label %738, label %757
738: ; preds = %732
%739 = load i8, i8* %30
%740 = zext i8 %739 to i32
%741 = load i8*, i8** %16
%742 = load i64, i64* %14
%743 = getelementptr inbounds i8, i8* %741, i64 %742
%744 = load i8, i8* %743
%745 = zext i8 %744 to i32
%746 = icmp eq i32 %740, %745
br i1 %746, label %747, label %757
747: ; preds = %738
%748 = load i8, i8* %31
%749 = zext i8 %748 to i32
%750 = load i8*, i8** %16
%751 = load i64, i64* %14
%752 = getelementptr inbounds i8, i8* %750, i64 %751
%753 = getelementptr inbounds i8, i8* %752, i64 1
%754 = load i8, i8* %753
%755 = zext i8 %754 to i32
%756 = icmp eq i32 %749, %755
br label %757
757: ; preds = %747, %738, %732
%758 = phi i1 [ false, %738 ], [ false, %732 ], [ %756, %747 ]
br i1 %758, label %759, label %765
759: ; preds = %757
br label %760
760: ; preds = %759
%761 = load i8, i8* %29
%762 = add i8 %761, 1
store i8 %762, i8* %29
%763 = load i64, i64* %14
%764 = add nsw i64 %763, 2
store i64 %764, i64* %14
br label %732
765: ; preds = %757
%766 = load i8, i8* %29
%767 = zext i8 %766 to i32
%768 = sub nsw i32 %767, 1
%769 = or i32 128, %768
%770 = trunc i32 %769 to i8
%771 = load i8*, i8** %17
%772 = load i64, i64* %15
%773 = add nsw i64 %772, 1
store i64 %773, i64* %15
%774 = getelementptr inbounds i8, i8* %771, i64 %772
store i8 %770, i8* %774
%775 = load i8, i8* %30
%776 = load i8*, i8** %17
%777 = load i64, i64* %15
%778 = add nsw i64 %777, 1
store i64 %778, i64* %15
%779 = getelementptr inbounds i8, i8* %776, i64 %777
store i8 %775, i8* %779
%780 = load i8, i8* %31
%781 = load i8*, i8** %17
%782 = load i64, i64* %15
%783 = add nsw i64 %782, 1
store i64 %783, i64* %15
%784 = getelementptr inbounds i8, i8* %781, i64 %782
store i8 %780, i8* %784
br label %897
785: ; preds = %721, %712, %708
store i8 1, i8* %29
br label %786
786: ; preds = %824, %785
%787 = load i8, i8* %29
%788 = zext i8 %787 to i32
%789 = load i8, i8* %28
%790 = zext i8 %789 to i32
%791 = icmp slt i32 %788, %790
br i1 %791, label %792, label %821
792: ; preds = %786
%793 = load i8*, i8** %16
%794 = load i64, i64* %14
%795 = getelementptr inbounds i8, i8* %793, i64 %794
%796 = load i8, i8* %795
%797 = zext i8 %796 to i32
%798 = load i8*, i8** %16
%799 = load i64, i64* %14
%800 = getelementptr inbounds i8, i8* %798, i64 %799
%801 = getelementptr inbounds i8, i8* %800, i64 2
%802 = load i8, i8* %801
%803 = zext i8 %802 to i32
%804 = icmp ne i32 %797, %803
br i1 %804, label %819, label %805
805: ; preds = %792
%806 = load i8*, i8** %16
%807 = load i64, i64* %14
%808 = getelementptr inbounds i8, i8* %806, i64 %807
%809 = getelementptr inbounds i8, i8* %808, i64 1
%810 = load i8, i8* %809
%811 = zext i8 %810 to i32
%812 = load i8*, i8** %16
%813 = load i64, i64* %14
%814 = getelementptr inbounds i8, i8* %812, i64 %813
%815 = getelementptr inbounds i8, i8* %814, i64 3
%816 = load i8, i8* %815
%817 = zext i8 %816 to i32
%818 = icmp ne i32 %811, %817
br label %819
819: ; preds = %805, %792
%820 = phi i1 [ true, %792 ], [ %818, %805 ]
br label %821
821: ; preds = %819, %786
%822 = phi i1 [ false, %786 ], [ %820, %819 ]
br i1 %822, label %823, label %829
823: ; preds = %821
br label %824
824: ; preds = %823
%825 = load i8, i8* %29
%826 = add i8 %825, 1
store i8 %826, i8* %29
%827 = load i64, i64* %14
%828 = add nsw i64 %827, 2
store i64 %828, i64* %14
br label %786
829: ; preds = %821
%830 = load i8, i8* %29
%831 = zext i8 %830 to i32
%832 = sub nsw i32 %831, 1
%833 = or i32 0, %832
%834 = trunc i32 %833 to i8
%835 = load i8*, i8** %17
%836 = load i64, i64* %15
%837 = add nsw i64 %836, 1
store i64 %837, i64* %15
%838 = getelementptr inbounds i8, i8* %835, i64 %836
store i8 %834, i8* %838
%839 = load i64, i64* %15
%840 = load i8, i8* %29
%841 = zext i8 %840 to i32
%842 = mul nsw i32 %841, 2
%843 = sext i32 %842 to i64
%844 = add nsw i64 %839, %843
%845 = load i32, i32* %11
%846 = sext i32 %845 to i64
%847 = icmp sge i64 %844, %846
br i1 %847, label %848, label %849
848: ; preds = %829
br label %910
849: ; preds = %829
store i32 0, i32* %13
br label %850
850: ; preds = %893, %849
%851 = load i32, i32* %13
%852 = load i8, i8* %29
%853 = zext i8 %852 to i32
%854 = icmp slt i32 %851, %853
br i1 %854, label %855, label %896
855: ; preds = %850
%856 = load i8*, i8** %16
%857 = load i64, i64* %14
%858 = getelementptr inbounds i8, i8* %856, i64 %857
%859 = load i8, i8* %29
%860 = zext i8 %859 to i32
%861 = mul nsw i32 %860, 2
%862 = sext i32 %861 to i64
%863 = sub i64 0, %862
%864 = getelementptr inbounds i8, i8* %858, i64 %863
%865 = load i32, i32* %13
%866 = mul nsw i32 %865, 2
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds i8, i8* %864, i64 %867
%869 = load i8, i8* %868
%870 = load i8*, i8** %17
%871 = load i64, i64* %15
%872 = add nsw i64 %871, 1
store i64 %872, i64* %15
%873 = getelementptr inbounds i8, i8* %870, i64 %871
store i8 %869, i8* %873
%874 = load i8*, i8** %16
%875 = load i64, i64* %14
%876 = getelementptr inbounds i8, i8* %874, i64 %875
%877 = load i8, i8* %29
%878 = zext i8 %877 to i32
%879 = mul nsw i32 %878, 2
%880 = sext i32 %879 to i64
%881 = sub i64 0, %880
%882 = getelementptr inbounds i8, i8* %876, i64 %881
%883 = load i32, i32* %13
%884 = mul nsw i32 %883, 2
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds i8, i8* %882, i64 %885
%887 = getelementptr inbounds i8, i8* %886, i64 1
%888 = load i8, i8* %887
%889 = load i8*, i8** %17
%890 = load i64, i64* %15
%891 = add nsw i64 %890, 1
store i64 %891, i64* %15
%892 = getelementptr inbounds i8, i8* %889, i64 %890
store i8 %888, i8* %892
br label %893
893: ; preds = %855
%894 = load i32, i32* %13
%895 = add nsw i32 %894, 1
store i32 %895, i32* %13
br label %850
896: ; preds = %850
br label %897
897: ; preds = %896, %765
br label %898
898: ; preds = %897
%899 = load i64, i64* %14
%900 = load i32, i32* %8
%901 = sext i32 %900 to i64
%902 = icmp slt i64 %899, %901
br i1 %902, label %903, label %908
903: ; preds = %898
%904 = load i64, i64* %15
%905 = load i32, i32* %11
%906 = sext i32 %905 to i64
%907 = icmp slt i64 %904, %906
br label %908
908: ; preds = %903, %898
%909 = phi i1 [ false, %898 ], [ %907, %903 ]
br i1 %909, label %661, label %910
910: ; preds = %908, %848, %707
br label %1610
911: ; preds = %657
%912 = load i32, i32* %12
%913 = icmp eq i32 %912, 24
br i1 %913, label %914, label %1228
914: ; preds = %911
br label %915
915: ; preds = %1225, %914
%916 = load i32, i32* %9
%917 = sext i32 %916 to i64
%918 = load i64, i64* %14
%919 = sdiv i64 %918, 3
%920 = load i32, i32* %9
%921 = sext i32 %920 to i64
%922 = srem i64 %919, %921
%923 = sub nsw i64 %917, %922
%924 = trunc i64 %923 to i8
store i8 %924, i8* %32
%925 = load i8, i8* %32
%926 = zext i8 %925 to i64
%927 = load i32, i32* %8
%928 = sext i32 %927 to i64
%929 = load i64, i64* %14
%930 = sub nsw i64 %928, %929
%931 = sdiv i64 %930, 3
%932 = icmp sgt i64 %926, %931
br i1 %932, label %933, label %940
933: ; preds = %915
%934 = load i32, i32* %8
%935 = sext i32 %934 to i64
%936 = load i64, i64* %14
%937 = sub nsw i64 %935, %936
%938 = sdiv i64 %937, 3
%939 = trunc i64 %938 to i8
store i8 %939, i8* %32
br label %940
940: ; preds = %933, %915
%941 = load i8, i8* %32
%942 = zext i8 %941 to i32
%943 = icmp sgt i32 %942, 128
br i1 %943, label %944, label %945
944: ; preds = %940
store i8 -128, i8* %32
br label %945
945: ; preds = %944, %940
%946 = load i8*, i8** %16
%947 = load i64, i64* %14
%948 = add nsw i64 %947, 1
store i64 %948, i64* %14
%949 = getelementptr inbounds i8, i8* %946, i64 %947
%950 = load i8, i8* %949
store i8 %950, i8* %34
%951 = load i8*, i8** %16
%952 = load i64, i64* %14
%953 = add nsw i64 %952, 1
store i64 %953, i64* %14
%954 = getelementptr inbounds i8, i8* %951, i64 %952
%955 = load i8, i8* %954
store i8 %955, i8* %35
%956 = load i8*, i8** %16
%957 = load i64, i64* %14
%958 = add nsw i64 %957, 1
store i64 %958, i64* %14
%959 = getelementptr inbounds i8, i8* %956, i64 %957
%960 = load i8, i8* %959
store i8 %960, i8* %36
%961 = load i64, i64* %15
%962 = load i32, i32* %11
%963 = sub nsw i32 %962, 3
%964 = sext i32 %963 to i64
%965 = icmp sge i64 %961, %964
br i1 %965, label %966, label %967
966: ; preds = %945
br label %1227
967: ; preds = %945
%968 = load i8, i8* %32
%969 = zext i8 %968 to i32
%970 = icmp sge i32 %969, 2
br i1 %970, label %971, label %1069
971: ; preds = %967
%972 = load i8, i8* %34
%973 = zext i8 %972 to i32
%974 = load i8*, i8** %16
%975 = load i64, i64* %14
%976 = getelementptr inbounds i8, i8* %974, i64 %975
%977 = load i8, i8* %976
%978 = zext i8 %977 to i32
%979 = icmp eq i32 %973, %978
br i1 %979, label %980, label %1069
980: ; preds = %971
%981 = load i8, i8* %35
%982 = zext i8 %981 to i32
%983 = load i8*, i8** %16
%984 = load i64, i64* %14
%985 = getelementptr inbounds i8, i8* %983, i64 %984
%986 = getelementptr inbounds i8, i8* %985, i64 1
%987 = load i8, i8* %986
%988 = zext i8 %987 to i32
%989 = icmp eq i32 %982, %988
br i1 %989, label %990, label %1069
990: ; preds = %980
%991 = load i8, i8* %36
%992 = zext i8 %991 to i32
%993 = load i8*, i8** %16
%994 = load i64, i64* %14
%995 = getelementptr inbounds i8, i8* %993, i64 %994
%996 = getelementptr inbounds i8, i8* %995, i64 2
%997 = load i8, i8* %996
%998 = zext i8 %997 to i32
%999 = icmp eq i32 %992, %998
br i1 %999, label %1000, label %1069
1000: ; preds = %990
store i8 1, i8* %33
br label %1001
1001: ; preds = %1039, %1000
%1002 = load i8, i8* %33
%1003 = zext i8 %1002 to i32
%1004 = load i8, i8* %32
%1005 = zext i8 %1004 to i32
%1006 = icmp slt i32 %1003, %1005
br i1 %1006, label %1007, label %1036
1007: ; preds = %1001
%1008 = load i8, i8* %34
%1009 = zext i8 %1008 to i32
%1010 = load i8*, i8** %16
%1011 = load i64, i64* %14
%1012 = getelementptr inbounds i8, i8* %1010, i64 %1011
%1013 = load i8, i8* %1012
%1014 = zext i8 %1013 to i32
%1015 = icmp eq i32 %1009, %1014
br i1 %1015, label %1016, label %1036
1016: ; preds = %1007
%1017 = load i8, i8* %35
%1018 = zext i8 %1017 to i32
%1019 = load i8*, i8** %16
%1020 = load i64, i64* %14
%1021 = getelementptr inbounds i8, i8* %1019, i64 %1020
%1022 = getelementptr inbounds i8, i8* %1021, i64 1
%1023 = load i8, i8* %1022
%1024 = zext i8 %1023 to i32
%1025 = icmp eq i32 %1018, %1024
br i1 %1025, label %1026, label %1036
1026: ; preds = %1016
%1027 = load i8, i8* %36
%1028 = zext i8 %1027 to i32
%1029 = load i8*, i8** %16
%1030 = load i64, i64* %14
%1031 = getelementptr inbounds i8, i8* %1029, i64 %1030
%1032 = getelementptr inbounds i8, i8* %1031, i64 2
%1033 = load i8, i8* %1032
%1034 = zext i8 %1033 to i32
%1035 = icmp eq i32 %1028, %1034
br label %1036
1036: ; preds = %1026, %1016, %1007, %1001
%1037 = phi i1 [ false, %1016 ], [ false, %1007 ], [ false, %1001 ], [ %1035, %1026 ]
br i1 %1037, label %1038, label %1044
1038: ; preds = %1036
br label %1039
1039: ; preds = %1038
%1040 = load i8, i8* %33
%1041 = add i8 %1040, 1
store i8 %1041, i8* %33
%1042 = load i64, i64* %14
%1043 = add nsw i64 %1042, 3
store i64 %1043, i64* %14
br label %1001
1044: ; preds = %1036
%1045 = load i8, i8* %33
%1046 = zext i8 %1045 to i32
%1047 = sub nsw i32 %1046, 1
%1048 = or i32 128, %1047
%1049 = trunc i32 %1048 to i8
%1050 = load i8*, i8** %17
%1051 = load i64, i64* %15
%1052 = add nsw i64 %1051, 1
store i64 %1052, i64* %15
%1053 = getelementptr inbounds i8, i8* %1050, i64 %1051
store i8 %1049, i8* %1053
%1054 = load i8, i8* %34
%1055 = load i8*, i8** %17
%1056 = load i64, i64* %15
%1057 = add nsw i64 %1056, 1
store i64 %1057, i64* %15
%1058 = getelementptr inbounds i8, i8* %1055, i64 %1056
store i8 %1054, i8* %1058
%1059 = load i8, i8* %35
%1060 = load i8*, i8** %17
%1061 = load i64, i64* %15
%1062 = add nsw i64 %1061, 1
store i64 %1062, i64* %15
%1063 = getelementptr inbounds i8, i8* %1060, i64 %1061
store i8 %1059, i8* %1063
%1064 = load i8, i8* %36
%1065 = load i8*, i8** %17
%1066 = load i64, i64* %15
%1067 = add nsw i64 %1066, 1
store i64 %1067, i64* %15
%1068 = getelementptr inbounds i8, i8* %1065, i64 %1066
store i8 %1064, i8* %1068
br label %1214
1069: ; preds = %990, %980, %971, %967
store i8 1, i8* %33
br label %1070
1070: ; preds = %1122, %1069
%1071 = load i8, i8* %33
%1072 = zext i8 %1071 to i32
%1073 = load i8, i8* %32
%1074 = zext i8 %1073 to i32
%1075 = icmp slt i32 %1072, %1074
br i1 %1075, label %1076, label %1119
1076: ; preds = %1070
%1077 = load i8*, i8** %16
%1078 = load i64, i64* %14
%1079 = getelementptr inbounds i8, i8* %1077, i64 %1078
%1080 = load i8, i8* %1079
%1081 = zext i8 %1080 to i32
%1082 = load i8*, i8** %16
%1083 = load i64, i64* %14
%1084 = getelementptr inbounds i8, i8* %1082, i64 %1083
%1085 = getelementptr inbounds i8, i8* %1084, i64 3
%1086 = load i8, i8* %1085
%1087 = zext i8 %1086 to i32
%1088 = icmp ne i32 %1081, %1087
br i1 %1088, label %1117, label %1089
1089: ; preds = %1076
%1090 = load i8*, i8** %16
%1091 = load i64, i64* %14
%1092 = getelementptr inbounds i8, i8* %1090, i64 %1091
%1093 = getelementptr inbounds i8, i8* %1092, i64 1
%1094 = load i8, i8* %1093
%1095 = zext i8 %1094 to i32
%1096 = load i8*, i8** %16
%1097 = load i64, i64* %14
%1098 = getelementptr inbounds i8, i8* %1096, i64 %1097
%1099 = getelementptr inbounds i8, i8* %1098, i64 4
%1100 = load i8, i8* %1099
%1101 = zext i8 %1100 to i32
%1102 = icmp ne i32 %1095, %1101
br i1 %1102, label %1117, label %1103
1103: ; preds = %1089
%1104 = load i8*, i8** %16
%1105 = load i64, i64* %14
%1106 = getelementptr inbounds i8, i8* %1104, i64 %1105
%1107 = getelementptr inbounds i8, i8* %1106, i64 2
%1108 = load i8, i8* %1107
%1109 = zext i8 %1108 to i32
%1110 = load i8*, i8** %16
%1111 = load i64, i64* %14
%1112 = getelementptr inbounds i8, i8* %1110, i64 %1111
%1113 = getelementptr inbounds i8, i8* %1112, i64 5
%1114 = load i8, i8* %1113
%1115 = zext i8 %1114 to i32
%1116 = icmp ne i32 %1109, %1115
br label %1117
1117: ; preds = %1103, %1089, %1076
%1118 = phi i1 [ true, %1089 ], [ true, %1076 ], [ %1116, %1103 ]
br label %1119
1119: ; preds = %1117, %1070
%1120 = phi i1 [ false, %1070 ], [ %1118, %1117 ]
br i1 %1120, label %1121, label %1127
1121: ; preds = %1119
br label %1122
1122: ; preds = %1121
%1123 = load i8, i8* %33
%1124 = add i8 %1123, 1
store i8 %1124, i8* %33
%1125 = load i64, i64* %14
%1126 = add nsw i64 %1125, 3
store i64 %1126, i64* %14
br label %1070
1127: ; preds = %1119
%1128 = load i8, i8* %33
%1129 = zext i8 %1128 to i32
%1130 = sub nsw i32 %1129, 1
%1131 = or i32 0, %1130
%1132 = trunc i32 %1131 to i8
%1133 = load i8*, i8** %17
%1134 = load i64, i64* %15
%1135 = add nsw i64 %1134, 1
store i64 %1135, i64* %15
%1136 = getelementptr inbounds i8, i8* %1133, i64 %1134
store i8 %1132, i8* %1136
%1137 = load i64, i64* %15
%1138 = load i8, i8* %33
%1139 = zext i8 %1138 to i32
%1140 = mul nsw i32 %1139, 3
%1141 = sext i32 %1140 to i64
%1142 = add nsw i64 %1137, %1141
%1143 = load i32, i32* %11
%1144 = sext i32 %1143 to i64
%1145 = icmp sge i64 %1142, %1144
br i1 %1145, label %1146, label %1147
1146: ; preds = %1127
br label %1227
1147: ; preds = %1127
store i32 0, i32* %13
br label %1148
1148: ; preds = %1210, %1147
%1149 = load i32, i32* %13
%1150 = load i8, i8* %33
%1151 = zext i8 %1150 to i32
%1152 = icmp slt i32 %1149, %1151
br i1 %1152, label %1153, label %1213
1153: ; preds = %1148
%1154 = load i8*, i8** %16
%1155 = load i64, i64* %14
%1156 = getelementptr inbounds i8, i8* %1154, i64 %1155
%1157 = load i8, i8* %33
%1158 = zext i8 %1157 to i32
%1159 = mul nsw i32 %1158, 3
%1160 = sext i32 %1159 to i64
%1161 = sub i64 0, %1160
%1162 = getelementptr inbounds i8, i8* %1156, i64 %1161
%1163 = load i32, i32* %13
%1164 = mul nsw i32 %1163, 3
%1165 = sext i32 %1164 to i64
%1166 = getelementptr inbounds i8, i8* %1162, i64 %1165
%1167 = load i8, i8* %1166
%1168 = load i8*, i8** %17
%1169 = load i64, i64* %15
%1170 = add nsw i64 %1169, 1
store i64 %1170, i64* %15
%1171 = getelementptr inbounds i8, i8* %1168, i64 %1169
store i8 %1167, i8* %1171
%1172 = load i8*, i8** %16
%1173 = load i64, i64* %14
%1174 = getelementptr inbounds i8, i8* %1172, i64 %1173
%1175 = load i8, i8* %33
%1176 = zext i8 %1175 to i32
%1177 = mul nsw i32 %1176, 3
%1178 = sext i32 %1177 to i64
%1179 = sub i64 0, %1178
%1180 = getelementptr inbounds i8, i8* %1174, i64 %1179
%1181 = load i32, i32* %13
%1182 = mul nsw i32 %1181, 3
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds i8, i8* %1180, i64 %1183
%1185 = getelementptr inbounds i8, i8* %1184, i64 1
%1186 = load i8, i8* %1185
%1187 = load i8*, i8** %17
%1188 = load i64, i64* %15
%1189 = add nsw i64 %1188, 1
store i64 %1189, i64* %15
%1190 = getelementptr inbounds i8, i8* %1187, i64 %1188
store i8 %1186, i8* %1190
%1191 = load i8*, i8** %16
%1192 = load i64, i64* %14
%1193 = getelementptr inbounds i8, i8* %1191, i64 %1192
%1194 = load i8, i8* %33
%1195 = zext i8 %1194 to i32
%1196 = mul nsw i32 %1195, 3
%1197 = sext i32 %1196 to i64
%1198 = sub i64 0, %1197
%1199 = getelementptr inbounds i8, i8* %1193, i64 %1198
%1200 = load i32, i32* %13
%1201 = mul nsw i32 %1200, 3
%1202 = sext i32 %1201 to i64
%1203 = getelementptr inbounds i8, i8* %1199, i64 %1202
%1204 = getelementptr inbounds i8, i8* %1203, i64 2
%1205 = load i8, i8* %1204
%1206 = load i8*, i8** %17
%1207 = load i64, i64* %15
%1208 = add nsw i64 %1207, 1
store i64 %1208, i64* %15
%1209 = getelementptr inbounds i8, i8* %1206, i64 %1207
store i8 %1205, i8* %1209
br label %1210
1210: ; preds = %1153
%1211 = load i32, i32* %13
%1212 = add nsw i32 %1211, 1
store i32 %1212, i32* %13
br label %1148
1213: ; preds = %1148
br label %1214
1214: ; preds = %1213, %1044
br label %1215
1215: ; preds = %1214
%1216 = load i64, i64* %14
%1217 = load i32, i32* %8
%1218 = sext i32 %1217 to i64
%1219 = icmp slt i64 %1216, %1218
br i1 %1219, label %1220, label %1225
1220: ; preds = %1215
%1221 = load i64, i64* %15
%1222 = load i32, i32* %11
%1223 = sext i32 %1222 to i64
%1224 = icmp slt i64 %1221, %1223
br label %1225
1225: ; preds = %1220, %1215
%1226 = phi i1 [ false, %1215 ], [ %1224, %1220 ]
br i1 %1226, label %915, label %1227
1227: ; preds = %1225, %1146, %966
br label %1609
1228: ; preds = %911
%1229 = load i32, i32* %12
%1230 = icmp eq i32 %1229, 32
br i1 %1230, label %1231, label %1608
1231: ; preds = %1228
br label %1232
1232: ; preds = %1605, %1231
%1233 = load i32, i32* %9
%1234 = sext i32 %1233 to i64
%1235 = load i64, i64* %14
%1236 = sdiv i64 %1235, 4
%1237 = load i32, i32* %9
%1238 = sext i32 %1237 to i64
%1239 = srem i64 %1236, %1238
%1240 = sub nsw i64 %1234, %1239
%1241 = trunc i64 %1240 to i8
store i8 %1241, i8* %37
%1242 = load i8, i8* %37
%1243 = zext i8 %1242 to i64
%1244 = load i32, i32* %8
%1245 = sext i32 %1244 to i64
%1246 = load i64, i64* %14
%1247 = sub nsw i64 %1245, %1246
%1248 = sdiv i64 %1247, 4
%1249 = icmp sgt i64 %1243, %1248
br i1 %1249, label %1250, label %1257
1250: ; preds = %1232
%1251 = load i32, i32* %8
%1252 = sext i32 %1251 to i64
%1253 = load i64, i64* %14
%1254 = sub nsw i64 %1252, %1253
%1255 = sdiv i64 %1254, 4
%1256 = trunc i64 %1255 to i8
store i8 %1256, i8* %37
br label %1257
1257: ; preds = %1250, %1232
%1258 = load i8, i8* %37
%1259 = zext i8 %1258 to i32
%1260 = icmp sgt i32 %1259, 128
br i1 %1260, label %1261, label %1262
1261: ; preds = %1257
store i8 -128, i8* %37
br label %1262
1262: ; preds = %1261, %1257
%1263 = load i8*, i8** %16
%1264 = load i64, i64* %14
%1265 = add nsw i64 %1264, 1
store i64 %1265, i64* %14
%1266 = getelementptr inbounds i8, i8* %1263, i64 %1264
%1267 = load i8, i8* %1266
store i8 %1267, i8* %39
%1268 = load i8*, i8** %16
%1269 = load i64, i64* %14
%1270 = add nsw i64 %1269, 1
store i64 %1270, i64* %14
%1271 = getelementptr inbounds i8, i8* %1268, i64 %1269
%1272 = load i8, i8* %1271
store i8 %1272, i8* %40
%1273 = load i8*, i8** %16
%1274 = load i64, i64* %14
%1275 = add nsw i64 %1274, 1
store i64 %1275, i64* %14
%1276 = getelementptr inbounds i8, i8* %1273, i64 %1274
%1277 = load i8, i8* %1276
store i8 %1277, i8* %41
%1278 = load i8*, i8** %16
%1279 = load i64, i64* %14
%1280 = add nsw i64 %1279, 1
store i64 %1280, i64* %14
%1281 = getelementptr inbounds i8, i8* %1278, i64 %1279
%1282 = load i8, i8* %1281
store i8 %1282, i8* %42
%1283 = load i64, i64* %15
%1284 = load i32, i32* %11
%1285 = sub nsw i32 %1284, 4
%1286 = sext i32 %1285 to i64
%1287 = icmp sge i64 %1283, %1286
br i1 %1287, label %1288, label %1289
1288: ; preds = %1262
br label %1607
1289: ; preds = %1262
%1290 = load i8, i8* %37
%1291 = zext i8 %1290 to i32
%1292 = icmp sge i32 %1291, 2
br i1 %1292, label %1293, label %1416
1293: ; preds = %1289
%1294 = load i8, i8* %39
%1295 = zext i8 %1294 to i32
%1296 = load i8*, i8** %16
%1297 = load i64, i64* %14
%1298 = getelementptr inbounds i8, i8* %1296, i64 %1297
%1299 = load i8, i8* %1298
%1300 = zext i8 %1299 to i32
%1301 = icmp eq i32 %1295, %1300
br i1 %1301, label %1302, label %1416
1302: ; preds = %1293
%1303 = load i8, i8* %40
%1304 = zext i8 %1303 to i32
%1305 = load i8*, i8** %16
%1306 = load i64, i64* %14
%1307 = getelementptr inbounds i8, i8* %1305, i64 %1306
%1308 = getelementptr inbounds i8, i8* %1307, i64 1
%1309 = load i8, i8* %1308
%1310 = zext i8 %1309 to i32
%1311 = icmp eq i32 %1304, %1310
br i1 %1311, label %1312, label %1416
1312: ; preds = %1302
%1313 = load i8, i8* %41
%1314 = zext i8 %1313 to i32
%1315 = load i8*, i8** %16
%1316 = load i64, i64* %14
%1317 = getelementptr inbounds i8, i8* %1315, i64 %1316
%1318 = getelementptr inbounds i8, i8* %1317, i64 2
%1319 = load i8, i8* %1318
%1320 = zext i8 %1319 to i32
%1321 = icmp eq i32 %1314, %1320
br i1 %1321, label %1322, label %1416
1322: ; preds = %1312
%1323 = load i8, i8* %42
%1324 = zext i8 %1323 to i32
%1325 = load i8*, i8** %16
%1326 = load i64, i64* %14
%1327 = getelementptr inbounds i8, i8* %1325, i64 %1326
%1328 = getelementptr inbounds i8, i8* %1327, i64 3
%1329 = load i8, i8* %1328
%1330 = zext i8 %1329 to i32
%1331 = icmp eq i32 %1324, %1330
br i1 %1331, label %1332, label %1416
1332: ; preds = %1322
store i8 1, i8* %38
br label %1333
1333: ; preds = %1381, %1332
%1334 = load i8, i8* %38
%1335 = zext i8 %1334 to i32
%1336 = load i8, i8* %37
%1337 = zext i8 %1336 to i32
%1338 = icmp slt i32 %1335, %1337
br i1 %1338, label %1339, label %1378
1339: ; preds = %1333
%1340 = load i8, i8* %39
%1341 = zext i8 %1340 to i32
%1342 = load i8*, i8** %16
%1343 = load i64, i64* %14
%1344 = getelementptr inbounds i8, i8* %1342, i64 %1343
%1345 = load i8, i8* %1344
%1346 = zext i8 %1345 to i32
%1347 = icmp eq i32 %1341, %1346
br i1 %1347, label %1348, label %1378
1348: ; preds = %1339
%1349 = load i8, i8* %40
%1350 = zext i8 %1349 to i32
%1351 = load i8*, i8** %16
%1352 = load i64, i64* %14
%1353 = getelementptr inbounds i8, i8* %1351, i64 %1352
%1354 = getelementptr inbounds i8, i8* %1353, i64 1
%1355 = load i8, i8* %1354
%1356 = zext i8 %1355 to i32
%1357 = icmp eq i32 %1350, %1356
br i1 %1357, label %1358, label %1378
1358: ; preds = %1348
%1359 = load i8, i8* %41
%1360 = zext i8 %1359 to i32
%1361 = load i8*, i8** %16
%1362 = load i64, i64* %14
%1363 = getelementptr inbounds i8, i8* %1361, i64 %1362
%1364 = getelementptr inbounds i8, i8* %1363, i64 2
%1365 = load i8, i8* %1364
%1366 = zext i8 %1365 to i32
%1367 = icmp eq i32 %1360, %1366
br i1 %1367, label %1368, label %1378
1368: ; preds = %1358
%1369 = load i8, i8* %42
%1370 = zext i8 %1369 to i32
%1371 = load i8*, i8** %16
%1372 = load i64, i64* %14
%1373 = getelementptr inbounds i8, i8* %1371, i64 %1372
%1374 = getelementptr inbounds i8, i8* %1373, i64 3
%1375 = load i8, i8* %1374
%1376 = zext i8 %1375 to i32
%1377 = icmp eq i32 %1370, %1376
br label %1378
1378: ; preds = %1368, %1358, %1348, %1339, %1333
%1379 = phi i1 [ false, %1358 ], [ false, %1348 ], [ false, %1339 ], [ false, %1333 ], [ %1377, %1368 ]
br i1 %1379, label %1380, label %1386
1380: ; preds = %1378
br label %1381
1381: ; preds = %1380
%1382 = load i8, i8* %38
%1383 = add i8 %1382, 1
store i8 %1383, i8* %38
%1384 = load i64, i64* %14
%1385 = add nsw i64 %1384, 4
store i64 %1385, i64* %14
br label %1333
1386: ; preds = %1378
%1387 = load i8, i8* %38
%1388 = zext i8 %1387 to i32
%1389 = sub nsw i32 %1388, 1
%1390 = or i32 128, %1389
%1391 = trunc i32 %1390 to i8
%1392 = load i8*, i8** %17
%1393 = load i64, i64* %15
%1394 = add nsw i64 %1393, 1
store i64 %1394, i64* %15
%1395 = getelementptr inbounds i8, i8* %1392, i64 %1393
store i8 %1391, i8* %1395
%1396 = load i8, i8* %39
%1397 = load i8*, i8** %17
%1398 = load i64, i64* %15
%1399 = add nsw i64 %1398, 1
store i64 %1399, i64* %15
%1400 = getelementptr inbounds i8, i8* %1397, i64 %1398
store i8 %1396, i8* %1400
%1401 = load i8, i8* %40
%1402 = load i8*, i8** %17
%1403 = load i64, i64* %15
%1404 = add nsw i64 %1403, 1
store i64 %1404, i64* %15
%1405 = getelementptr inbounds i8, i8* %1402, i64 %1403
store i8 %1401, i8* %1405
%1406 = load i8, i8* %41
%1407 = load i8*, i8** %17
%1408 = load i64, i64* %15
%1409 = add nsw i64 %1408, 1
store i64 %1409, i64* %15
%1410 = getelementptr inbounds i8, i8* %1407, i64 %1408
store i8 %1406, i8* %1410
%1411 = load i8, i8* %42
%1412 = load i8*, i8** %17
%1413 = load i64, i64* %15
%1414 = add nsw i64 %1413, 1
store i64 %1414, i64* %15
%1415 = getelementptr inbounds i8, i8* %1412, i64 %1413
store i8 %1411, i8* %1415
br label %1594
1416: ; preds = %1322, %1312, %1302, %1293, %1289
store i8 1, i8* %38
br label %1417
1417: ; preds = %1483, %1416
%1418 = load i8, i8* %38
%1419 = zext i8 %1418 to i32
%1420 = load i8, i8* %37
%1421 = zext i8 %1420 to i32
%1422 = icmp slt i32 %1419, %1421
br i1 %1422, label %1423, label %1480
1423: ; preds = %1417
%1424 = load i8*, i8** %16
%1425 = load i64, i64* %14
%1426 = getelementptr inbounds i8, i8* %1424, i64 %1425
%1427 = load i8, i8* %1426
%1428 = zext i8 %1427 to i32
%1429 = load i8*, i8** %16
%1430 = load i64, i64* %14
%1431 = getelementptr inbounds i8, i8* %1429, i64 %1430
%1432 = getelementptr inbounds i8, i8* %1431, i64 4
%1433 = load i8, i8* %1432
%1434 = zext i8 %1433 to i32
%1435 = icmp ne i32 %1428, %1434
br i1 %1435, label %1478, label %1436
1436: ; preds = %1423
%1437 = load i8*, i8** %16
%1438 = load i64, i64* %14
%1439 = getelementptr inbounds i8, i8* %1437, i64 %1438
%1440 = getelementptr inbounds i8, i8* %1439, i64 1
%1441 = load i8, i8* %1440
%1442 = zext i8 %1441 to i32
%1443 = load i8*, i8** %16
%1444 = load i64, i64* %14
%1445 = getelementptr inbounds i8, i8* %1443, i64 %1444
%1446 = getelementptr inbounds i8, i8* %1445, i64 5
%1447 = load i8, i8* %1446
%1448 = zext i8 %1447 to i32
%1449 = icmp ne i32 %1442, %1448
br i1 %1449, label %1478, label %1450
1450: ; preds = %1436
%1451 = load i8*, i8** %16
%1452 = load i64, i64* %14
%1453 = getelementptr inbounds i8, i8* %1451, i64 %1452
%1454 = getelementptr inbounds i8, i8* %1453, i64 2
%1455 = load i8, i8* %1454
%1456 = zext i8 %1455 to i32
%1457 = load i8*, i8** %16
%1458 = load i64, i64* %14
%1459 = getelementptr inbounds i8, i8* %1457, i64 %1458
%1460 = getelementptr inbounds i8, i8* %1459, i64 6
%1461 = load i8, i8* %1460
%1462 = zext i8 %1461 to i32
%1463 = icmp ne i32 %1456, %1462
br i1 %1463, label %1478, label %1464
1464: ; preds = %1450
%1465 = load i8*, i8** %16
%1466 = load i64, i64* %14
%1467 = getelementptr inbounds i8, i8* %1465, i64 %1466
%1468 = getelementptr inbounds i8, i8* %1467, i64 3
%1469 = load i8, i8* %1468
%1470 = zext i8 %1469 to i32
%1471 = load i8*, i8** %16
%1472 = load i64, i64* %14
%1473 = getelementptr inbounds i8, i8* %1471, i64 %1472
%1474 = getelementptr inbounds i8, i8* %1473, i64 7
%1475 = load i8, i8* %1474
%1476 = zext i8 %1475 to i32
%1477 = icmp ne i32 %1470, %1476
br label %1478
1478: ; preds = %1464, %1450, %1436, %1423
%1479 = phi i1 [ true, %1450 ], [ true, %1436 ], [ true, %1423 ], [ %1477, %1464 ]
br label %1480
1480: ; preds = %1478, %1417
%1481 = phi i1 [ false, %1417 ], [ %1479, %1478 ]
br i1 %1481, label %1482, label %1488
1482: ; preds = %1480
br label %1483
1483: ; preds = %1482
%1484 = load i8, i8* %38
%1485 = add i8 %1484, 1
store i8 %1485, i8* %38
%1486 = load i64, i64* %14
%1487 = add nsw i64 %1486, 4
store i64 %1487, i64* %14
br label %1417
1488: ; preds = %1480
%1489 = load i8, i8* %38
%1490 = zext i8 %1489 to i32
%1491 = sub nsw i32 %1490, 1
%1492 = or i32 0, %1491
%1493 = trunc i32 %1492 to i8
%1494 = load i8*, i8** %17
%1495 = load i64, i64* %15
%1496 = add nsw i64 %1495, 1
store i64 %1496, i64* %15
%1497 = getelementptr inbounds i8, i8* %1494, i64 %1495
store i8 %1493, i8* %1497
%1498 = load i64, i64* %15
%1499 = load i8, i8* %38
%1500 = zext i8 %1499 to i32
%1501 = mul nsw i32 %1500, 4
%1502 = sext i32 %1501 to i64
%1503 = add nsw i64 %1498, %1502
%1504 = load i32, i32* %11
%1505 = sext i32 %1504 to i64
%1506 = icmp sge i64 %1503, %1505
br i1 %1506, label %1507, label %1508
1507: ; preds = %1488
br label %1607
1508: ; preds = %1488
store i32 0, i32* %13
br label %1509
1509: ; preds = %1590, %1508
%1510 = load i32, i32* %13
%1511 = load i8, i8* %38
%1512 = zext i8 %1511 to i32
%1513 = icmp slt i32 %1510, %1512
br i1 %1513, label %1514, label %1593
1514: ; preds = %1509
%1515 = load i8*, i8** %16
%1516 = load i64, i64* %14
%1517 = getelementptr inbounds i8, i8* %1515, i64 %1516
%1518 = load i8, i8* %38
%1519 = zext i8 %1518 to i32
%1520 = mul nsw i32 %1519, 4
%1521 = sext i32 %1520 to i64
%1522 = sub i64 0, %1521
%1523 = getelementptr inbounds i8, i8* %1517, i64 %1522
%1524 = load i32, i32* %13
%1525 = mul nsw i32 %1524, 4
%1526 = sext i32 %1525 to i64
%1527 = getelementptr inbounds i8, i8* %1523, i64 %1526
%1528 = load i8, i8* %1527
%1529 = load i8*, i8** %17
%1530 = load i64, i64* %15
%1531 = add nsw i64 %1530, 1
store i64 %1531, i64* %15
%1532 = getelementptr inbounds i8, i8* %1529, i64 %1530
store i8 %1528, i8* %1532
%1533 = load i8*, i8** %16
%1534 = load i64, i64* %14
%1535 = getelementptr inbounds i8, i8* %1533, i64 %1534
%1536 = load i8, i8* %38
%1537 = zext i8 %1536 to i32
%1538 = mul nsw i32 %1537, 4
%1539 = sext i32 %1538 to i64
%1540 = sub i64 0, %1539
%1541 = getelementptr inbounds i8, i8* %1535, i64 %1540
%1542 = load i32, i32* %13
%1543 = mul nsw i32 %1542, 4
%1544 = sext i32 %1543 to i64
%1545 = getelementptr inbounds i8, i8* %1541, i64 %1544
%1546 = getelementptr inbounds i8, i8* %1545, i64 1
%1547 = load i8, i8* %1546
%1548 = load i8*, i8** %17
%1549 = load i64, i64* %15
%1550 = add nsw i64 %1549, 1
store i64 %1550, i64* %15
%1551 = getelementptr inbounds i8, i8* %1548, i64 %1549
store i8 %1547, i8* %1551
%1552 = load i8*, i8** %16
%1553 = load i64, i64* %14
%1554 = getelementptr inbounds i8, i8* %1552, i64 %1553
%1555 = load i8, i8* %38
%1556 = zext i8 %1555 to i32
%1557 = mul nsw i32 %1556, 4
%1558 = sext i32 %1557 to i64
%1559 = sub i64 0, %1558
%1560 = getelementptr inbounds i8, i8* %1554, i64 %1559
%1561 = load i32, i32* %13
%1562 = mul nsw i32 %1561, 4
%1563 = sext i32 %1562 to i64
%1564 = getelementptr inbounds i8, i8* %1560, i64 %1563
%1565 = getelementptr inbounds i8, i8* %1564, i64 2
%1566 = load i8, i8* %1565
%1567 = load i8*, i8** %17
%1568 = load i64, i64* %15
%1569 = add nsw i64 %1568, 1
store i64 %1569, i64* %15
%1570 = getelementptr inbounds i8, i8* %1567, i64 %1568
store i8 %1566, i8* %1570
%1571 = load i8*, i8** %16
%1572 = load i64, i64* %14
%1573 = getelementptr inbounds i8, i8* %1571, i64 %1572
%1574 = load i8, i8* %38
%1575 = zext i8 %1574 to i32
%1576 = mul nsw i32 %1575, 4
%1577 = sext i32 %1576 to i64
%1578 = sub i64 0, %1577
%1579 = getelementptr inbounds i8, i8* %1573, i64 %1578
%1580 = load i32, i32* %13
%1581 = mul nsw i32 %1580, 4
%1582 = sext i32 %1581 to i64
%1583 = getelementptr inbounds i8, i8* %1579, i64 %1582
%1584 = getelementptr inbounds i8, i8* %1583, i64 3
%1585 = load i8, i8* %1584
%1586 = load i8*, i8** %17
%1587 = load i64, i64* %15
%1588 = add nsw i64 %1587, 1
store i64 %1588, i64* %15
%1589 = getelementptr inbounds i8, i8* %1586, i64 %1587
store i8 %1585, i8* %1589
br label %1590
1590: ; preds = %1514
%1591 = load i32, i32* %13
%1592 = add nsw i32 %1591, 1
store i32 %1592, i32* %13
br label %1509
1593: ; preds = %1509
br label %1594
1594: ; preds = %1593, %1386
br label %1595
1595: ; preds = %1594
%1596 = load i64, i64* %14
%1597 = load i32, i32* %8
%1598 = sext i32 %1597 to i64
%1599 = icmp slt i64 %1596, %1598
br i1 %1599, label %1600, label %1605
1600: ; preds = %1595
%1601 = load i64, i64* %15
%1602 = load i32, i32* %11
%1603 = sext i32 %1602 to i64
%1604 = icmp slt i64 %1601, %1603
br label %1605
1605: ; preds = %1600, %1595
%1606 = phi i1 [ false, %1595 ], [ %1604, %1600 ]
br i1 %1606, label %1232, label %1607
1607: ; preds = %1605, %1507, %1288
br label %1608
1608: ; preds = %1607, %1228
br label %1609
1609: ; preds = %1608, %1227
br label %1610
1610: ; preds = %1609, %910
br label %1611
1611: ; preds = %1610, %656
br label %1612
1612: ; preds = %1611, %474
%1613 = load i64, i64* %15
ret i64 %1613
}

LLVM IR (-O2):
define i64 @encodeRLE(i8* %0, i32 %1, i32 %2, i8* %3, i32 %4, i32 %5) {
%7 = icmp eq i32 %2, 0
br i1 %7, label %8, label %11
8: ; preds = %6
%9 = shl i32 %1, 3
%10 = sdiv i32 %9, %5
br label %11
11: ; preds = %8, %6
%12 = phi i32 [ %10, %8 ], [ %2, %6 ]
%13 = add i32 %5, -4
%14 = tail call i32 @llvm.fshl.i32(i32 %13, i32 %13, i32 30)
switch i32 %14, label %1150 [
i32 0, label %44
i32 1, label %36
i32 3, label %27
i32 5, label %21
i32 7, label %15
]
15: ; preds = %11
%16 = sext i32 %12 to i64
%17 = sext i32 %1 to i64
%18 = add nsw i32 %4, -4
%19 = sext i32 %18 to i64
%20 = sext i32 %4 to i64
br label %985
21: ; preds = %11
%22 = sext i32 %12 to i64
%23 = sext i32 %1 to i64
%24 = add nsw i32 %4, -3
%25 = sext i32 %24 to i64
%26 = sext i32 %4 to i64
br label %843
27: ; preds = %11
%28 = sext i32 %12 to i64
%29 = sext i32 %1 to i64
%30 = add nsw i32 %4, -2
%31 = sext i32 %30 to i64
%32 = sext i32 %4 to i64
%33 = getelementptr inbounds i8, i8* %0, i64 1
%34 = getelementptr i8, i8* %3, i64 1
%35 = getelementptr i8, i8* %3, i64 1
br label %613
36: ; preds = %11
%37 = sext i32 %12 to i64
%38 = sext i32 %1 to i64
%39 = add nsw i32 %4, -1
%40 = sext i32 %39 to i64
%41 = sext i32 %4 to i64
%42 = getelementptr i8, i8* %3, i64 1
%43 = getelementptr i8, i8* %3, i64 1
br label %378
44: ; preds = %11
%45 = sext i32 %12 to i64
%46 = sext i32 %1 to i64
%47 = sext i32 %4 to i64
%48 = getelementptr inbounds i8, i8* %0, i64 1
br label %49
49: ; preds = %44, %370
%50 = phi i8 [ %371, %370 ], [ 0, %44 ]
%51 = phi i8 [ %372, %370 ], [ 0, %44 ]
%52 = phi i64 [ %373, %370 ], [ 0, %44 ]
%53 = phi i64 [ %374, %370 ], [ 0, %44 ]
%54 = shl nsw i64 %53, 1
%55 = srem i64 %54, %45
%56 = sub nsw i64 %45, %55
%57 = and i64 %56, 255
%58 = sub nsw i64 %46, %53
%59 = shl nsw i64 %58, 1
%60 = icmp sgt i64 %57, %59
%61 = select i1 %60, i64 %59, i64 %56
%62 = trunc i64 %61 to i32
%63 = and i64 %61, 255
%64 = icmp ugt i64 %63, 128
%65 = icmp eq i8 %51, 0
%66 = getelementptr inbounds i8, i8* %0, i64 %53
%67 = load i8, i8* %66
br i1 %65, label %73, label %68
68: ; preds = %49
%69 = getelementptr inbounds i8, i8* %66, i64 1
%70 = load i8, i8* %69
%71 = tail call i8 @llvm.fshl.i8(i8 %70, i8 %67, i8 4)
%72 = add nsw i64 %53, 1
br label %73
73: ; preds = %49, %68
%74 = phi i8 [ %71, %68 ], [ %67, %49 ]
%75 = phi i64 [ %72, %68 ], [ %53, %49 ]
%76 = xor i8 %51, 1
%77 = icmp slt i64 %52, %47
br i1 %77, label %78, label %1150
78: ; preds = %73
%79 = and i32 %62, 255
%80 = select i1 %64, i32 128, i32 %79
%81 = icmp ugt i32 %80, 1
br i1 %81, label %82, label %167
82: ; preds = %78
%83 = zext i8 %74 to i32
%84 = lshr i32 %83, 4
%85 = and i32 %83, 15
%86 = icmp eq i32 %84, %85
br i1 %86, label %87, label %136
87: ; preds = %82, %106
%88 = phi i32 [ %107, %106 ], [ 1, %82 ]
%89 = phi i64 [ %102, %106 ], [ %75, %82 ]
%90 = phi i8 [ %108, %106 ], [ %76, %82 ]
%91 = icmp eq i8 %90, 0
br i1 %91, label %97, label %92
92: ; preds = %87
%93 = add nsw i64 %89, 1
%94 = getelementptr inbounds i8, i8* %0, i64 %89
%95 = load i8, i8* %94
%96 = lshr i8 %95, 4
br label %101
97: ; preds = %87
%98 = getelementptr inbounds i8, i8* %0, i64 %89
%99 = load i8, i8* %98
%100 = and i8 %99, 15
br label %101
101: ; preds = %97, %92
%102 = phi i64 [ %93, %92 ], [ %89, %97 ]
%103 = phi i8 [ %96, %92 ], [ %100, %97 ]
%104 = zext i8 %103 to i32
%105 = icmp eq i32 %84, %104
br i1 %105, label %106, label %110
106: ; preds = %101
%107 = add nuw nsw i32 %88, 1
%108 = xor i8 %90, 1
%109 = icmp eq i32 %107, %80
br i1 %109, label %110, label %87
110: ; preds = %101, %106
%111 = phi i8 [ %90, %101 ], [ %108, %106 ]
%112 = phi i32 [ %88, %101 ], [ %80, %106 ]
%113 = xor i8 %50, 1
%114 = icmp eq i8 %113, 0
br i1 %114, label %122, label %115
115: ; preds = %110
%116 = trunc i32 %112 to i8
%117 = add i8 %116, 127
%118 = or i8 %117, -128
%119 = add nsw i64 %52, 1
%120 = getelementptr inbounds i8, i8* %3, i64 %52
store i8 %118, i8* %120
%121 = trunc i32 %84 to i8
br label %362
122: ; preds = %110
%123 = add nsw i32 %112, -1
%124 = add nsw i64 %52, 1
%125 = getelementptr inbounds i8, i8* %3, i64 %52
%126 = load i8, i8* %125
%127 = trunc i32 %123 to i8
%128 = and i8 %127, 112
%129 = or i8 %128, %126
%130 = or i8 %129, -128
store i8 %130, i8* %125
%131 = shl nuw nsw i32 %83, 4
%132 = and i32 %123, 15
%133 = or i32 %132, %131
%134 = trunc i32 %133 to i8
%135 = add nsw i64 %52, 2
br label %362
136: ; preds = %82, %157
%137 = phi i32 [ %159, %157 ], [ 1, %82 ]
%138 = phi i64 [ %158, %157 ], [ %75, %82 ]
%139 = phi i8 [ %160, %157 ], [ %76, %82 ]
%140 = icmp eq i8 %139, 0
br i1 %140, label %150, label %141
141: ; preds = %136
%142 = add nsw i64 %138, 1
%143 = getelementptr inbounds i8, i8* %0, i64 %138
%144 = load i8, i8* %143
%145 = lshr i8 %144, 4
%146 = getelementptr inbounds i8, i8* %48, i64 %142
%147 = load i8, i8* %146
%148 = and i8 %147, 15
%149 = icmp eq i8 %145, %148
br i1 %149, label %162, label %157
150: ; preds = %136
%151 = getelementptr inbounds i8, i8* %0, i64 %138
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = lshr i32 %153, 4
%155 = and i32 %153, 15
%156 = icmp eq i32 %154, %155
br i1 %156, label %162, label %157
157: ; preds = %141, %150
%158 = phi i64 [ %142, %141 ], [ %138, %150 ]
%159 = add nuw nsw i32 %137, 1
%160 = xor i8 %139, 1
%161 = icmp eq i32 %159, %80
br i1 %161, label %162, label %136
162: ; preds = %141, %157, %150
%163 = phi i8 [ 0, %150 ], [ %160, %157 ], [ %139, %141 ]
%164 = phi i32 [ %137, %150 ], [ %80, %157 ], [ %137, %141 ]
%165 = phi i64 [ %138, %150 ], [ %158, %157 ], [ %142, %141 ]
%166 = trunc i32 %164 to i8
br label %167
167: ; preds = %78, %162
%168 = phi i8 [ %166, %162 ], [ 1, %78 ]
%169 = phi i8 [ %163, %162 ], [ %76, %78 ]
%170 = phi i32 [ %164, %162 ], [ 1, %78 ]
%171 = phi i64 [ %165, %162 ], [ %75, %78 ]
%172 = trunc i64 %75 to i8
%173 = lshr i32 %170, 1
%174 = zext i32 %173 to i64
%175 = add i64 %52, 1
%176 = add i64 %175, %174
%177 = icmp slt i64 %176, %47
br i1 %177, label %178, label %1150
178: ; preds = %167
%179 = icmp eq i8 %50, 0
%180 = add i8 %168, -1
%181 = getelementptr inbounds i8, i8* %3, i64 %52
br i1 %179, label %182, label %184
182: ; preds = %178
store i8 %180, i8* %181
br i1 %65, label %198, label %183
183: ; preds = %184, %182
br label %334
184: ; preds = %178
%185 = load i8, i8* %181
%186 = and i8 %180, -16
%187 = or i8 %185, %186
store i8 %187, i8* %181
%188 = and i8 %180, 15
%189 = getelementptr inbounds i8, i8* %3, i64 %175
store i8 %188, i8* %189
%190 = icmp eq i8 %50, %51
br i1 %190, label %191, label %183
191: ; preds = %184
%192 = and i64 %75, 255
%193 = getelementptr inbounds i8, i8* %0, i64 %192
%194 = load i8, i8* %193
%195 = and i8 %194, -16
%196 = add nsw i64 %52, 2
%197 = or i8 %188, %195
store i8 %197, i8* %189
br label %198
198: ; preds = %182, %191
%199 = phi i8 [ %180, %191 ], [ %168, %182 ]
%200 = phi i64 [ %196, %191 ], [ %175, %182 ]
%201 = zext i8 %199 to i32
%202 = icmp ult i8 %199, 2
br i1 %202, label %326, label %203
203: ; preds = %198
%204 = lshr i32 %201, 1
%205 = and i64 %75, 255
%206 = getelementptr inbounds i8, i8* %0, i64 %205
%207 = call i32 @llvm.umax.i32(i32 %204, i32 1)
%208 = zext i32 %207 to i64
%209 = icmp ult i32 %207, 16
br i1 %209, label %279, label %210
210: ; preds = %203
%211 = getelementptr i8, i8* %3, i64 %200
%212 = add i64 %200, %208
%213 = getelementptr i8, i8* %3, i64 %212
%214 = add nuw nsw i64 %205, %208
%215 = getelementptr i8, i8* %0, i64 %214
%216 = icmp ult i8* %211, %215
%217 = icmp ult i8* %206, %213
%218 = and i1 %216, %217
br i1 %218, label %279, label %219
219: ; preds = %210
%220 = and i64 %208, 112
%221 = add i64 %200, %220
%222 = add nsw i64 %220, -16
%223 = lshr exact i64 %222, 4
%224 = add nuw nsw i64 %223, 1
%225 = and i64 %224, 3
%226 = icmp ult i64 %222, 48
br i1 %226, label %262, label %227
227: ; preds = %219
%228 = and i64 %224, 2305843009213693948
br label %229
229: ; preds = %229, %227
%230 = phi i64 [ 0, %227 ], [ %259, %229 ]
%231 = phi i64 [ 0, %227 ], [ %260, %229 ]
%232 = add i64 %200, %230
%233 = getelementptr inbounds i8, i8* %206, i64 %230
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = getelementptr inbounds i8, i8* %3, i64 %232
%237 = bitcast i8* %236 to <16 x i8>*
store <16 x i8> %235, <16 x i8>* %237
%238 = or i64 %230, 16
%239 = add i64 %200, %238
%240 = getelementptr inbounds i8, i8* %206, i64 %238
%241 = bitcast i8* %240 to <16 x i8>*
%242 = load <16 x i8>, <16 x i8>* %241
%243 = getelementptr inbounds i8, i8* %3, i64 %239
%244 = bitcast i8* %243 to <16 x i8>*
store <16 x i8> %242, <16 x i8>* %244
%245 = or i64 %230, 32
%246 = add i64 %200, %245
%247 = getelementptr inbounds i8, i8* %206, i64 %245
%248 = bitcast i8* %247 to <16 x i8>*
%249 = load <16 x i8>, <16 x i8>* %248
%250 = getelementptr inbounds i8, i8* %3, i64 %246
%251 = bitcast i8* %250 to <16 x i8>*
store <16 x i8> %249, <16 x i8>* %251
%252 = or i64 %230, 48
%253 = add i64 %200, %252
%254 = getelementptr inbounds i8, i8* %206, i64 %252
%255 = bitcast i8* %254 to <16 x i8>*
%256 = load <16 x i8>, <16 x i8>* %255
%257 = getelementptr inbounds i8, i8* %3, i64 %253
%258 = bitcast i8* %257 to <16 x i8>*
store <16 x i8> %256, <16 x i8>* %258
%259 = add nuw i64 %230, 64
%260 = add i64 %231, 4
%261 = icmp eq i64 %260, %228
br i1 %261, label %262, label %229
262: ; preds = %229, %219
%263 = phi i64 [ 0, %219 ], [ %259, %229 ]
%264 = icmp eq i64 %225, 0
br i1 %264, label %277, label %265
265: ; preds = %262, %265
%266 = phi i64 [ %274, %265 ], [ %263, %262 ]
%267 = phi i64 [ %275, %265 ], [ 0, %262 ]
%268 = add i64 %200, %266
%269 = getelementptr inbounds i8, i8* %206, i64 %266
%270 = bitcast i8* %269 to <16 x i8>*
%271 = load <16 x i8>, <16 x i8>* %270
%272 = getelementptr inbounds i8, i8* %3, i64 %268
%273 = bitcast i8* %272 to <16 x i8>*
store <16 x i8> %271, <16 x i8>* %273
%274 = add nuw i64 %266, 16
%275 = add i64 %267, 1
%276 = icmp eq i64 %275, %225
br i1 %276, label %277, label %265
277: ; preds = %265, %262
%278 = icmp eq i64 %220, %208
br i1 %278, label %326, label %279
279: ; preds = %210, %203, %277
%280 = phi i64 [ 0, %210 ], [ 0, %203 ], [ %220, %277 ]
%281 = phi i64 [ %200, %210 ], [ %200, %203 ], [ %221, %277 ]
%282 = xor i64 %280, -1
%283 = add nsw i64 %282, %208
%284 = and i64 %208, 3
%285 = icmp eq i64 %284, 0
br i1 %285, label %297, label %286
286: ; preds = %279, %286
%287 = phi i64 [ %294, %286 ], [ %280, %279 ]
%288 = phi i64 [ %292, %286 ], [ %281, %279 ]
%289 = phi i64 [ %295, %286 ], [ 0, %279 ]
%290 = getelementptr inbounds i8, i8* %206, i64 %287
%291 = load i8, i8* %290
%292 = add nsw i64 %288, 1
%293 = getelementptr inbounds i8, i8* %3, i64 %288
store i8 %291, i8* %293
%294 = add nuw nsw i64 %287, 1
%295 = add i64 %289, 1
%296 = icmp eq i64 %295, %284
br i1 %296, label %297, label %286
297: ; preds = %286, %279
%298 = phi i64 [ undef, %279 ], [ %292, %286 ]
%299 = phi i64 [ %280, %279 ], [ %294, %286 ]
%300 = phi i64 [ %281, %279 ], [ %292, %286 ]
%301 = icmp ult i64 %283, 3
br i1 %301, label %326, label %302
302: ; preds = %297, %302
%303 = phi i64 [ %324, %302 ], [ %299, %297 ]
%304 = phi i64 [ %322, %302 ], [ %300, %297 ]
%305 = getelementptr inbounds i8, i8* %206, i64 %303
%306 = load i8, i8* %305
%307 = add nsw i64 %304, 1
%308 = getelementptr inbounds i8, i8* %3, i64 %304
store i8 %306, i8* %308
%309 = add nuw nsw i64 %303, 1
%310 = getelementptr inbounds i8, i8* %206, i64 %309
%311 = load i8, i8* %310
%312 = add nsw i64 %304, 2
%313 = getelementptr inbounds i8, i8* %3, i64 %307
store i8 %311, i8* %313
%314 = add nuw nsw i64 %303, 2
%315 = getelementptr inbounds i8, i8* %206, i64 %314
%316 = load i8, i8* %315
%317 = add nsw i64 %304, 3
%318 = getelementptr inbounds i8, i8* %3, i64 %312
store i8 %316, i8* %318
%319 = add nuw nsw i64 %303, 3
%320 = getelementptr inbounds i8, i8* %206, i64 %319
%321 = load i8, i8* %320
%322 = add nsw i64 %304, 4
%323 = getelementptr inbounds i8, i8* %3, i64 %317
store i8 %321, i8* %323
%324 = add nuw nsw i64 %303, 4
%325 = icmp eq i64 %324, %208
br i1 %325, label %326, label %302
326: ; preds = %297, %302, %277, %198
%327 = phi i64 [ %200, %198 ], [ %221, %277 ], [ %298, %297 ], [ %322, %302 ]
%328 = and i32 %201, 1
%329 = icmp eq i32 %328, 0
br i1 %329, label %370, label %330
330: ; preds = %326
%331 = getelementptr inbounds i8, i8* %0, i64 %171
%332 = load i8, i8* %331
%333 = and i8 %332, 15
br label %362
334: ; preds = %183, %357
%335 = phi i32 [ %360, %357 ], [ 0, %183 ]
%336 = phi i64 [ %359, %357 ], [ %175, %183 ]
%337 = phi i8 [ %339, %357 ], [ %50, %183 ]
%338 = phi i8 [ %358, %357 ], [ %172, %183 ]
%339 = xor i8 %337, 1
%340 = icmp eq i8 %339, 0
br i1 %340, label %348, label %341
341: ; preds = %334
%342 = add i8 %338, 1
%343 = zext i8 %338 to i64
%344 = getelementptr inbounds i8, i8* %0, i64 %343
%345 = load i8, i8* %344
%346 = lshr i8 %345, 4
%347 = getelementptr inbounds i8, i8* %3, i64 %336
store i8 %346, i8* %347
br label %357
348: ; preds = %334
%349 = zext i8 %338 to i64
%350 = getelementptr inbounds i8, i8* %0, i64 %349
%351 = load i8, i8* %350
%352 = shl i8 %351, 4
%353 = add nsw i64 %336, 1
%354 = getelementptr inbounds i8, i8* %3, i64 %336
%355 = load i8, i8* %354
%356 = or i8 %352, %355
store i8 %356, i8* %354
br label %357
357: ; preds = %341, %348
%358 = phi i8 [ %342, %341 ], [ %338, %348 ]
%359 = phi i64 [ %336, %341 ], [ %353, %348 ]
%360 = add nuw nsw i32 %335, 1
%361 = icmp eq i32 %360, %170
br i1 %361, label %370, label %334
362: ; preds = %115, %122, %330
%363 = phi i64 [ %327, %330 ], [ %124, %122 ], [ %119, %115 ]
%364 = phi i8 [ %333, %330 ], [ %134, %122 ], [ %121, %115 ]
%365 = phi i8 [ 1, %330 ], [ 0, %122 ], [ %113, %115 ]
%366 = phi i8 [ %169, %330 ], [ %111, %122 ], [ %111, %115 ]
%367 = phi i64 [ %327, %330 ], [ %135, %122 ], [ %119, %115 ]
%368 = phi i64 [ %171, %330 ], [ %102, %122 ], [ %102, %115 ]
%369 = getelementptr inbounds i8, i8* %3, i64 %363
store i8 %364, i8* %369
br label %370
370: ; preds = %357, %362, %326
%371 = phi i8 [ 0, %326 ], [ %365, %362 ], [ %339, %357 ]
%372 = phi i8 [ %169, %326 ], [ %366, %362 ], [ %169, %357 ]
%373 = phi i64 [ %327, %326 ], [ %367, %362 ], [ %359, %357 ]
%374 = phi i64 [ %171, %326 ], [ %368, %362 ], [ %171, %357 ]
%375 = icmp slt i64 %374, %46
%376 = icmp slt i64 %373, %47
%377 = select i1 %375, i1 %376, i1 false
br i1 %377, label %49, label %1150
378: ; preds = %36, %607
%379 = phi i64 [ %608, %607 ], [ 0, %36 ]
%380 = phi i64 [ %609, %607 ], [ 0, %36 ]
%381 = srem i64 %380, %37
%382 = sub nsw i64 %37, %381
%383 = and i64 %382, 255
%384 = sub nsw i64 %38, %380
%385 = icmp sgt i64 %383, %384
%386 = select i1 %385, i64 %384, i64 %382
%387 = add nsw i64 %380, 1
%388 = getelementptr inbounds i8, i8* %0, i64 %380
%389 = load i8, i8* %388
%390 = icmp slt i64 %379, %40
br i1 %390, label %391, label %1150
391: ; preds = %378
%392 = and i64 %386, 255
%393 = icmp ugt i64 %392, 128
%394 = trunc i64 %386 to i32
%395 = and i32 %394, 255
%396 = select i1 %393, i32 128, i32 %395
%397 = icmp ugt i32 %396, 1
br i1 %397, label %398, label %442
398: ; preds = %391
%399 = getelementptr inbounds i8, i8* %0, i64 %387
%400 = load i8, i8* %399
%401 = icmp eq i8 %389, %400
%402 = add i64 %380, 2
%403 = add nsw i32 %396, -2
%404 = zext i32 %403 to i64
%405 = add i64 %402, %404
br i1 %401, label %406, label %426
406: ; preds = %398, %412
%407 = phi i64 [ %410, %412 ], [ %387, %398 ]
%408 = phi i32 [ %409, %412 ], [ 1, %398 ]
%409 = add nuw nsw i32 %408, 1
%410 = add nsw i64 %407, 1
%411 = icmp eq i32 %409, %396
br i1 %411, label %416, label %412
412: ; preds = %406
%413 = getelementptr inbounds i8, i8* %0, i64 %410
%414 = load i8, i8* %413
%415 = icmp eq i8 %389, %414
br i1 %415, label %406, label %416
416: ; preds = %412, %406
%417 = phi i32 [ %409, %412 ], [ %396, %406 ]
%418 = phi i64 [ %410, %412 ], [ %405, %406 ]
%419 = trunc i32 %417 to i8
%420 = add i8 %419, 127
%421 = or i8 %420, -128
%422 = add nsw i64 %379, 1
%423 = getelementptr inbounds i8, i8* %3, i64 %379
store i8 %421, i8* %423
%424 = add nsw i64 %379, 2
%425 = getelementptr inbounds i8, i8* %3, i64 %422
store i8 %389, i8* %425
br label %607
426: ; preds = %398, %434
%427 = phi i32 [ %435, %434 ], [ 1, %398 ]
%428 = phi i64 [ %436, %434 ], [ %387, %398 ]
%429 = getelementptr inbounds i8, i8* %0, i64 %428
%430 = load i8, i8* %429
%431 = getelementptr inbounds i8, i8* %429, i64 1
%432 = load i8, i8* %431
%433 = icmp eq i8 %430, %432
br i1 %433, label %438, label %434
434: ; preds = %426
%435 = add nuw nsw i32 %427, 1
%436 = add nsw i64 %428, 1
%437 = icmp eq i32 %435, %396
br i1 %437, label %438, label %426
438: ; preds = %434, %426
%439 = phi i64 [ %428, %426 ], [ %405, %434 ]
%440 = phi i32 [ %427, %426 ], [ %396, %434 ]
%441 = trunc i32 %440 to i8
br label %442
442: ; preds = %391, %438
%443 = phi i8 [ %441, %438 ], [ 1, %391 ]
%444 = phi i64 [ %439, %438 ], [ %387, %391 ]
%445 = phi i32 [ %440, %438 ], [ 1, %391 ]
%446 = add i8 %443, -1
%447 = add nsw i64 %379, 1
%448 = getelementptr inbounds i8, i8* %3, i64 %379
store i8 %446, i8* %448
%449 = zext i8 %443 to i64
%450 = add nsw i64 %447, %449
%451 = icmp slt i64 %450, %41
br i1 %451, label %452, label %1150
452: ; preds = %442
%453 = getelementptr inbounds i8, i8* %0, i64 %444
%454 = sub nsw i64 0, %449
%455 = getelementptr inbounds i8, i8* %453, i64 %454
%456 = zext i32 %445 to i64
%457 = icmp ult i32 %445, 32
br i1 %457, label %560, label %458
458: ; preds = %452
%459 = getelementptr i8, i8* %42, i64 %379
%460 = add i64 %379, %456
%461 = getelementptr i8, i8* %43, i64 %460
%462 = add i64 %444, %456
%463 = sub i64 %462, %449
%464 = getelementptr i8, i8* %0, i64 %463
%465 = icmp ult i8* %459, %464
%466 = icmp ult i8* %455, %461
%467 = and i1 %465, %466
br i1 %467, label %560, label %468
468: ; preds = %458
%469 = and i64 %456, 4294967264
%470 = add i64 %447, %469
%471 = bitcast i8* %455 to <16 x i8>*
%472 = load <16 x i8>, <16 x i8>* %471
%473 = getelementptr inbounds i8, i8* %455, i64 16
%474 = bitcast i8* %473 to <16 x i8>*
%475 = load <16 x i8>, <16 x i8>* %474
%476 = getelementptr inbounds i8, i8* %3, i64 %447
%477 = bitcast i8* %476 to <16 x i8>*
store <16 x i8> %472, <16 x i8>* %477
%478 = getelementptr inbounds i8, i8* %476, i64 16
%479 = bitcast i8* %478 to <16 x i8>*
store <16 x i8> %475, <16 x i8>* %479
%480 = icmp eq i64 %469, 32
br i1 %480, label %558, label %481
481: ; preds = %468
%482 = add i64 %379, 33
%483 = getelementptr inbounds i8, i8* %455, i64 32
%484 = bitcast i8* %483 to <16 x i8>*
%485 = load <16 x i8>, <16 x i8>* %484
%486 = getelementptr inbounds i8, i8* %483, i64 16
%487 = bitcast i8* %486 to <16 x i8>*
%488 = load <16 x i8>, <16 x i8>* %487
%489 = getelementptr inbounds i8, i8* %3, i64 %482
%490 = bitcast i8* %489 to <16 x i8>*
store <16 x i8> %485, <16 x i8>* %490
%491 = getelementptr inbounds i8, i8* %489, i64 16
%492 = bitcast i8* %491 to <16 x i8>*
store <16 x i8> %488, <16 x i8>* %492
%493 = icmp eq i64 %469, 64
br i1 %493, label %558, label %494
494: ; preds = %481
%495 = add i64 %379, 65
%496 = getelementptr inbounds i8, i8* %455, i64 64
%497 = bitcast i8* %496 to <16 x i8>*
%498 = load <16 x i8>, <16 x i8>* %497
%499 = getelementptr inbounds i8, i8* %496, i64 16
%500 = bitcast i8* %499 to <16 x i8>*
%501 = load <16 x i8>, <16 x i8>* %500
%502 = getelementptr inbounds i8, i8* %3, i64 %495
%503 = bitcast i8* %502 to <16 x i8>*
store <16 x i8> %498, <16 x i8>* %503
%504 = getelementptr inbounds i8, i8* %502, i64 16
%505 = bitcast i8* %504 to <16 x i8>*
store <16 x i8> %501, <16 x i8>* %505
%506 = icmp eq i64 %469, 96
br i1 %506, label %558, label %507
507: ; preds = %494
%508 = add i64 %379, 97
%509 = getelementptr inbounds i8, i8* %455, i64 96
%510 = bitcast i8* %509 to <16 x i8>*
%511 = load <16 x i8>, <16 x i8>* %510
%512 = getelementptr inbounds i8, i8* %509, i64 16
%513 = bitcast i8* %512 to <16 x i8>*
%514 = load <16 x i8>, <16 x i8>* %513
%515 = getelementptr inbounds i8, i8* %3, i64 %508
%516 = bitcast i8* %515 to <16 x i8>*
store <16 x i8> %511, <16 x i8>* %516
%517 = getelementptr inbounds i8, i8* %515, i64 16
%518 = bitcast i8* %517 to <16 x i8>*
store <16 x i8> %514, <16 x i8>* %518
%519 = icmp eq i64 %469, 128
br i1 %519, label %558, label %520
520: ; preds = %507
%521 = add i64 %379, 129
%522 = getelementptr inbounds i8, i8* %455, i64 128
%523 = bitcast i8* %522 to <16 x i8>*
%524 = load <16 x i8>, <16 x i8>* %523
%525 = getelementptr inbounds i8, i8* %522, i64 16
%526 = bitcast i8* %525 to <16 x i8>*
%527 = load <16 x i8>, <16 x i8>* %526
%528 = getelementptr inbounds i8, i8* %3, i64 %521
%529 = bitcast i8* %528 to <16 x i8>*
store <16 x i8> %524, <16 x i8>* %529
%530 = getelementptr inbounds i8, i8* %528, i64 16
%531 = bitcast i8* %530 to <16 x i8>*
store <16 x i8> %527, <16 x i8>* %531
%532 = icmp eq i64 %469, 160
br i1 %532, label %558, label %533
533: ; preds = %520
%534 = add i64 %379, 161
%535 = getelementptr inbounds i8, i8* %455, i64 160
%536 = bitcast i8* %535 to <16 x i8>*
%537 = load <16 x i8>, <16 x i8>* %536
%538 = getelementptr inbounds i8, i8* %535, i64 16
%539 = bitcast i8* %538 to <16 x i8>*
%540 = load <16 x i8>, <16 x i8>* %539
%541 = getelementptr inbounds i8, i8* %3, i64 %534
%542 = bitcast i8* %541 to <16 x i8>*
store <16 x i8> %537, <16 x i8>* %542
%543 = getelementptr inbounds i8, i8* %541, i64 16
%544 = bitcast i8* %543 to <16 x i8>*
store <16 x i8> %540, <16 x i8>* %544
%545 = icmp eq i64 %469, 192
br i1 %545, label %558, label %546
546: ; preds = %533
%547 = add i64 %379, 193
%548 = getelementptr inbounds i8, i8* %455, i64 192
%549 = bitcast i8* %548 to <16 x i8>*
%550 = load <16 x i8>, <16 x i8>* %549
%551 = getelementptr inbounds i8, i8* %548, i64 16
%552 = bitcast i8* %551 to <16 x i8>*
%553 = load <16 x i8>, <16 x i8>* %552
%554 = getelementptr inbounds i8, i8* %3, i64 %547
%555 = bitcast i8* %554 to <16 x i8>*
store <16 x i8> %550, <16 x i8>* %555
%556 = getelementptr inbounds i8, i8* %554, i64 16
%557 = bitcast i8* %556 to <16 x i8>*
store <16 x i8> %553, <16 x i8>* %557
br label %558
558: ; preds = %546, %533, %520, %507, %494, %481, %468
%559 = icmp eq i64 %469, %456
br i1 %559, label %607, label %560
560: ; preds = %458, %452, %558
%561 = phi i64 [ 0, %458 ], [ 0, %452 ], [ %469, %558 ]
%562 = phi i64 [ %447, %458 ], [ %447, %452 ], [ %470, %558 ]
%563 = xor i64 %561, -1
%564 = add nsw i64 %563, %456
%565 = and i64 %456, 3
%566 = icmp eq i64 %565, 0
br i1 %566, label %578, label %567
567: ; preds = %560, %567
%568 = phi i64 [ %575, %567 ], [ %561, %560 ]
%569 = phi i64 [ %573, %567 ], [ %562, %560 ]
%570 = phi i64 [ %576, %567 ], [ 0, %560 ]
%571 = getelementptr inbounds i8, i8* %455, i64 %568
%572 = load i8, i8* %571
%573 = add nsw i64 %569, 1
%574 = getelementptr inbounds i8, i8* %3, i64 %569
store i8 %572, i8* %574
%575 = add nuw nsw i64 %568, 1
%576 = add i64 %570, 1
%577 = icmp eq i64 %576, %565
br i1 %577, label %578, label %567
578: ; preds = %567, %560
%579 = phi i64 [ undef, %560 ], [ %573, %567 ]
%580 = phi i64 [ %561, %560 ], [ %575, %567 ]
%581 = phi i64 [ %562, %560 ], [ %573, %567 ]
%582 = icmp ult i64 %564, 3
br i1 %582, label %607, label %583
583: ; preds = %578, %583
%584 = phi i64 [ %605, %583 ], [ %580, %578 ]
%585 = phi i64 [ %603, %583 ], [ %581, %578 ]
%586 = getelementptr inbounds i8, i8* %455, i64 %584
%587 = load i8, i8* %586
%588 = add nsw i64 %585, 1
%589 = getelementptr inbounds i8, i8* %3, i64 %585
store i8 %587, i8* %589
%590 = add nuw nsw i64 %584, 1
%591 = getelementptr inbounds i8, i8* %455, i64 %590
%592 = load i8, i8* %591
%593 = add nsw i64 %585, 2
%594 = getelementptr inbounds i8, i8* %3, i64 %588
store i8 %592, i8* %594
%595 = add nuw nsw i64 %584, 2
%596 = getelementptr inbounds i8, i8* %455, i64 %595
%597 = load i8, i8* %596
%598 = add nsw i64 %585, 3
%599 = getelementptr inbounds i8, i8* %3, i64 %593
store i8 %597, i8* %599
%600 = add nuw nsw i64 %584, 3
%601 = getelementptr inbounds i8, i8* %455, i64 %600
%602 = load i8, i8* %601
%603 = add nsw i64 %585, 4
%604 = getelementptr inbounds i8, i8* %3, i64 %598
store i8 %602, i8* %604
%605 = add nuw nsw i64 %584, 4
%606 = icmp eq i64 %605, %456
br i1 %606, label %607, label %583
607: ; preds = %578, %583, %558, %416
%608 = phi i64 [ %424, %416 ], [ %470, %558 ], [ %579, %578 ], [ %603, %583 ]
%609 = phi i64 [ %418, %416 ], [ %444, %558 ], [ %444, %583 ], [ %444, %578 ]
%610 = icmp slt i64 %609, %38
%611 = icmp slt i64 %608, %41
%612 = select i1 %610, i1 %611, i1 false
br i1 %612, label %378, label %1150
613: ; preds = %27, %837
%614 = phi i64 [ %838, %837 ], [ 0, %27 ]
%615 = phi i64 [ %839, %837 ], [ 0, %27 ]
%616 = sdiv i64 %615, 2
%617 = srem i64 %616, %28
%618 = sub nsw i64 %28, %617
%619 = and i64 %618, 255
%620 = sub nsw i64 %29, %615
%621 = sdiv i64 %620, 2
%622 = icmp sgt i64 %619, %621
%623 = select i1 %622, i64 %621, i64 %618
%624 = add nsw i64 %615, 1
%625 = getelementptr inbounds i8, i8* %0, i64 %615
%626 = load i8, i8* %625
%627 = add nsw i64 %615, 2
%628 = getelementptr inbounds i8, i8* %0, i64 %624
%629 = load i8, i8* %628
%630 = icmp slt i64 %614, %31
br i1 %630, label %631, label %1150
631: ; preds = %613
%632 = and i64 %623, 255
%633 = icmp ugt i64 %632, 128
%634 = trunc i64 %623 to i32
%635 = and i32 %634, 255
%636 = select i1 %633, i32 128, i32 %635
%637 = icmp ugt i32 %636, 1
br i1 %637, label %638, label %695
638: ; preds = %631
%639 = getelementptr inbounds i8, i8* %0, i64 %627
%640 = load i8, i8* %639
%641 = icmp eq i8 %626, %640
br i1 %641, label %643, label %642
642: ; preds = %643, %638
br label %673
643: ; preds = %638
%644 = getelementptr inbounds i8, i8* %639, i64 1
%645 = load i8, i8* %644
%646 = icmp eq i8 %629, %645
br i1 %646, label %647, label %642
647: ; preds = %643, %657
%648 = phi i64 [ %655, %657 ], [ %627, %643 ]
%649 = phi i32 [ %654, %657 ], [ 1, %643 ]
%650 = getelementptr inbounds i8, i8* %33, i64 %648
%651 = load i8, i8* %650
%652 = icmp eq i8 %629, %651
br i1 %652, label %653, label %661
653: ; preds = %647
%654 = add nuw nsw i32 %649, 1
%655 = add nsw i64 %648, 2
%656 = icmp eq i32 %654, %636
br i1 %656, label %661, label %657
657: ; preds = %653
%658 = getelementptr inbounds i8, i8* %0, i64 %655
%659 = load i8, i8* %658
%660 = icmp eq i8 %626, %659
br i1 %660, label %647, label %661
661: ; preds = %647, %657, %653
%662 = phi i32 [ %649, %647 ], [ %654, %657 ], [ %636, %653 ]
%663 = phi i64 [ %648, %647 ], [ %655, %657 ], [ %655, %653 ]
%664 = trunc i32 %662 to i8
%665 = add i8 %664, 127
%666 = or i8 %665, -128
%667 = add nsw i64 %614, 1
%668 = getelementptr inbounds i8, i8* %3, i64 %614
store i8 %666, i8* %668
%669 = add nsw i64 %614, 2
%670 = getelementptr inbounds i8, i8* %3, i64 %667
store i8 %626, i8* %670
%671 = add nsw i64 %614, 3
%672 = getelementptr inbounds i8, i8* %3, i64 %669
store i8 %629, i8* %672
br label %837
673: ; preds = %642, %687
%674 = phi i32 [ %688, %687 ], [ 1, %642 ]
%675 = phi i64 [ %689, %687 ], [ %627, %642 ]
%676 = getelementptr inbounds i8, i8* %0, i64 %675
%677 = load i8, i8* %676
%678 = getelementptr inbounds i8, i8* %676, i64 2
%679 = load i8, i8* %678
%680 = icmp eq i8 %677, %679
br i1 %680, label %681, label %687
681: ; preds = %673
%682 = getelementptr inbounds i8, i8* %676, i64 1
%683 = load i8, i8* %682
%684 = getelementptr inbounds i8, i8* %676, i64 3
%685 = load i8, i8* %684
%686 = icmp eq i8 %683, %685
br i1 %686, label %691, label %687
687: ; preds = %673, %681
%688 = add nuw nsw i32 %674, 1
%689 = add nsw i64 %675, 2
%690 = icmp eq i32 %688, %636
br i1 %690, label %691, label %673
691: ; preds = %687, %681
%692 = phi i64 [ %675, %681 ], [ %689, %687 ]
%693 = phi i32 [ %674, %681 ], [ %636, %687 ]
%694 = trunc i32 %693 to i8
br label %695
695: ; preds = %631, %691
%696 = phi i8 [ %694, %691 ], [ 1, %631 ]
%697 = phi i64 [ %692, %691 ], [ %627, %631 ]
%698 = phi i32 [ %693, %691 ], [ 1, %631 ]
%699 = add i8 %696, -1
%700 = add nsw i64 %614, 1
%701 = getelementptr inbounds i8, i8* %3, i64 %614
store i8 %699, i8* %701
%702 = shl nuw nsw i32 %698, 1
%703 = zext i32 %702 to i64
%704 = add nsw i64 %700, %703
%705 = icmp slt i64 %704, %32
br i1 %705, label %706, label %1150
706: ; preds = %695
%707 = getelementptr inbounds i8, i8* %0, i64 %697
%708 = sub nsw i64 0, %703
%709 = getelementptr inbounds i8, i8* %707, i64 %708
%710 = zext i32 %698 to i64
%711 = icmp ult i32 %698, 8
br i1 %711, label %790, label %712
712: ; preds = %706
%713 = getelementptr i8, i8* %34, i64 %614
%714 = add i64 %614, %703
%715 = getelementptr i8, i8* %35, i64 %714
%716 = icmp ult i8* %713, %707
%717 = icmp ult i8* %709, %715
%718 = and i1 %716, %717
br i1 %718, label %790, label %719
719: ; preds = %712
%720 = and i64 %710, 4294967288
%721 = shl nuw nsw i64 %720, 1
%722 = add i64 %700, %721
%723 = add nsw i64 %720, -8
%724 = lshr exact i64 %723, 3
%725 = add nuw nsw i64 %724, 1
%726 = and i64 %725, 3
%727 = icmp ult i64 %723, 24
br i1 %727, label %771, label %728
728: ; preds = %719
%729 = and i64 %725, 4611686018427387900
br label %730
730: ; preds = %730, %728
%731 = phi i64 [ 0, %728 ], [ %768, %730 ]
%732 = phi i64 [ 0, %728 ], [ %769, %730 ]
%733 = shl i64 %731, 1
%734 = add i64 %700, %733
%735 = shl nuw nsw i64 %731, 1
%736 = getelementptr inbounds i8, i8* %709, i64 %735
%737 = bitcast i8* %736 to <16 x i8>*
%738 = load <16 x i8>, <16 x i8>* %737
%739 = getelementptr inbounds i8, i8* %3, i64 %734
%740 = bitcast i8* %739 to <16 x i8>*
store <16 x i8> %738, <16 x i8>* %740
%741 = or i64 %731, 8
%742 = shl i64 %741, 1
%743 = add i64 %700, %742
%744 = shl nuw nsw i64 %741, 1
%745 = getelementptr inbounds i8, i8* %709, i64 %744
%746 = bitcast i8* %745 to <16 x i8>*
%747 = load <16 x i8>, <16 x i8>* %746
%748 = getelementptr inbounds i8, i8* %3, i64 %743
%749 = bitcast i8* %748 to <16 x i8>*
store <16 x i8> %747, <16 x i8>* %749
%750 = or i64 %731, 16
%751 = shl i64 %750, 1
%752 = add i64 %700, %751
%753 = shl nuw nsw i64 %750, 1
%754 = getelementptr inbounds i8, i8* %709, i64 %753
%755 = bitcast i8* %754 to <16 x i8>*
%756 = load <16 x i8>, <16 x i8>* %755
%757 = getelementptr inbounds i8, i8* %3, i64 %752
%758 = bitcast i8* %757 to <16 x i8>*
store <16 x i8> %756, <16 x i8>* %758
%759 = or i64 %731, 24
%760 = shl i64 %759, 1
%761 = add i64 %700, %760
%762 = shl nuw nsw i64 %759, 1
%763 = getelementptr inbounds i8, i8* %709, i64 %762
%764 = bitcast i8* %763 to <16 x i8>*
%765 = load <16 x i8>, <16 x i8>* %764
%766 = getelementptr inbounds i8, i8* %3, i64 %761
%767 = bitcast i8* %766 to <16 x i8>*
store <16 x i8> %765, <16 x i8>* %767
%768 = add nuw i64 %731, 32
%769 = add i64 %732, 4
%770 = icmp eq i64 %769, %729
br i1 %770, label %771, label %730
771: ; preds = %730, %719
%772 = phi i64 [ 0, %719 ], [ %768, %730 ]
%773 = icmp eq i64 %726, 0
br i1 %773, label %788, label %774
774: ; preds = %771, %774
%775 = phi i64 [ %785, %774 ], [ %772, %771 ]
%776 = phi i64 [ %786, %774 ], [ 0, %771 ]
%777 = shl i64 %775, 1
%778 = add i64 %700, %777
%779 = shl nuw nsw i64 %775, 1
%780 = getelementptr inbounds i8, i8* %709, i64 %779
%781 = bitcast i8* %780 to <16 x i8>*
%782 = load <16 x i8>, <16 x i8>* %781
%783 = getelementptr inbounds i8, i8* %3, i64 %778
%784 = bitcast i8* %783 to <16 x i8>*
store <16 x i8> %782, <16 x i8>* %784
%785 = add nuw i64 %775, 8
%786 = add i64 %776, 1
%787 = icmp eq i64 %786, %726
br i1 %787, label %788, label %774
788: ; preds = %774, %771
%789 = icmp eq i64 %720, %710
br i1 %789, label %837, label %790
790: ; preds = %712, %706, %788
%791 = phi i64 [ 0, %712 ], [ 0, %706 ], [ %720, %788 ]
%792 = phi i64 [ %700, %712 ], [ %700, %706 ], [ %722, %788 ]
%793 = xor i64 %791, -1
%794 = and i64 %710, 1
%795 = icmp eq i64 %794, 0
br i1 %795, label %807, label %796
796: ; preds = %790
%797 = shl nuw nsw i64 %791, 1
%798 = getelementptr inbounds i8, i8* %709, i64 %797
%799 = load i8, i8* %798
%800 = add nsw i64 %792, 1
%801 = getelementptr inbounds i8, i8* %3, i64 %792
store i8 %799, i8* %801
%802 = getelementptr inbounds i8, i8* %798, i64 1
%803 = load i8, i8* %802
%804 = add nsw i64 %792, 2
%805 = getelementptr inbounds i8, i8* %3, i64 %800
store i8 %803, i8* %805
%806 = or i64 %791, 1
br label %807
807: ; preds = %796, %790
%808 = phi i64 [ undef, %790 ], [ %804, %796 ]
%809 = phi i64 [ %791, %790 ], [ %806, %796 ]
%810 = phi i64 [ %792, %790 ], [ %804, %796 ]
%811 = sub nsw i64 0, %710
%812 = icmp eq i64 %793, %811
br i1 %812, label %837, label %813
813: ; preds = %807, %813
%814 = phi i64 [ %835, %813 ], [ %809, %807 ]
%815 = phi i64 [ %833, %813 ], [ %810, %807 ]
%816 = shl nuw nsw i64 %814, 1
%817 = getelementptr inbounds i8, i8* %709, i64 %816
%818 = load i8, i8* %817
%819 = add nsw i64 %815, 1
%820 = getelementptr inbounds i8, i8* %3, i64 %815
store i8 %818, i8* %820
%821 = getelementptr inbounds i8, i8* %817, i64 1
%822 = load i8, i8* %821
%823 = add nsw i64 %815, 2
%824 = getelementptr inbounds i8, i8* %3, i64 %819
store i8 %822, i8* %824
%825 = shl i64 %814, 1
%826 = add i64 %825, 2
%827 = getelementptr inbounds i8, i8* %709, i64 %826
%828 = load i8, i8* %827
%829 = add nsw i64 %815, 3
%830 = getelementptr inbounds i8, i8* %3, i64 %823
store i8 %828, i8* %830
%831 = getelementptr inbounds i8, i8* %827, i64 1
%832 = load i8, i8* %831
%833 = add nsw i64 %815, 4
%834 = getelementptr inbounds i8, i8* %3, i64 %829
store i8 %832, i8* %834
%835 = add nuw nsw i64 %814, 2
%836 = icmp eq i64 %835, %710
br i1 %836, label %837, label %813
837: ; preds = %807, %813, %788, %661
%838 = phi i64 [ %671, %661 ], [ %722, %788 ], [ %808, %807 ], [ %833, %813 ]
%839 = phi i64 [ %663, %661 ], [ %697, %788 ], [ %697, %813 ], [ %697, %807 ]
%840 = icmp slt i64 %839, %29
%841 = icmp slt i64 %838, %32
%842 = select i1 %840, i1 %841, i1 false
br i1 %842, label %613, label %1150
843: ; preds = %21, %979
%844 = phi i64 [ %980, %979 ], [ 0, %21 ]
%845 = phi i64 [ %981, %979 ], [ 0, %21 ]
%846 = sdiv i64 %845, 3
%847 = srem i64 %846, %22
%848 = sub nsw i64 %22, %847
%849 = and i64 %848, 255
%850 = sub nsw i64 %23, %845
%851 = sdiv i64 %850, 3
%852 = icmp sgt i64 %849, %851
%853 = select i1 %852, i64 %851, i64 %848
%854 = add nsw i64 %845, 1
%855 = getelementptr inbounds i8, i8* %0, i64 %845
%856 = load i8, i8* %855
%857 = add nsw i64 %845, 2
%858 = getelementptr inbounds i8, i8* %0, i64 %854
%859 = load i8, i8* %858
%860 = add nsw i64 %845, 3
%861 = getelementptr inbounds i8, i8* %0, i64 %857
%862 = load i8, i8* %861
%863 = icmp slt i64 %844, %25
br i1 %863, label %864, label %1150
864: ; preds = %843
%865 = and i64 %853, 255
%866 = icmp ugt i64 %865, 128
%867 = trunc i64 %853 to i32
%868 = and i32 %867, 255
%869 = select i1 %866, i32 128, i32 %868
%870 = icmp ugt i32 %869, 1
br i1 %870, label %871, label %945
871: ; preds = %864
%872 = getelementptr inbounds i8, i8* %0, i64 %860
%873 = load i8, i8* %872
%874 = icmp eq i8 %856, %873
br i1 %874, label %876, label %875
875: ; preds = %880, %876, %871
br label %917
876: ; preds = %871
%877 = getelementptr inbounds i8, i8* %872, i64 1
%878 = load i8, i8* %877
%879 = icmp eq i8 %859, %878
br i1 %879, label %880, label %875
880: ; preds = %876
%881 = getelementptr inbounds i8, i8* %872, i64 2
%882 = load i8, i8* %881
%883 = icmp eq i8 %862, %882
br i1 %883, label %884, label %875
884: ; preds = %880, %899
%885 = phi i64 [ %897, %899 ], [ %860, %880 ]
%886 = phi i32 [ %896, %899 ], [ 1, %880 ]
%887 = getelementptr inbounds i8, i8* %0, i64 %885
%888 = getelementptr inbounds i8, i8* %887, i64 1
%889 = load i8, i8* %888
%890 = icmp eq i8 %859, %889
br i1 %890, label %891, label %903
891: ; preds = %884
%892 = getelementptr inbounds i8, i8* %887, i64 2
%893 = load i8, i8* %892
%894 = icmp eq i8 %862, %893
br i1 %894, label %895, label %903
895: ; preds = %891
%896 = add nuw nsw i32 %886, 1
%897 = add nsw i64 %885, 3
%898 = icmp eq i32 %896, %869
br i1 %898, label %903, label %899
899: ; preds = %895
%900 = getelementptr inbounds i8, i8* %0, i64 %897
%901 = load i8, i8* %900
%902 = icmp eq i8 %856, %901
br i1 %902, label %884, label %903
903: ; preds = %891, %884, %899, %895
%904 = phi i32 [ %886, %891 ], [ %886, %884 ], [ %896, %899 ], [ %869, %895 ]
%905 = phi i64 [ %885, %891 ], [ %885, %884 ], [ %897, %899 ], [ %897, %895 ]
%906 = trunc i32 %904 to i8
%907 = add i8 %906, 127
%908 = or i8 %907, -128
%909 = add nsw i64 %844, 1
%910 = getelementptr inbounds i8, i8* %3, i64 %844
store i8 %908, i8* %910
%911 = add nsw i64 %844, 2
%912 = getelementptr inbounds i8, i8* %3, i64 %909
store i8 %856, i8* %912
%913 = add nsw i64 %844, 3
%914 = getelementptr inbounds i8, i8* %3, i64 %911
store i8 %859, i8* %914
%915 = add nsw i64 %844, 4
%916 = getelementptr inbounds i8, i8* %3, i64 %913
store i8 %862, i8* %916
br label %979
917: ; preds = %875, %937
%918 = phi i32 [ %938, %937 ], [ 1, %875 ]
%919 = phi i64 [ %939, %937 ], [ %860, %875 ]
%920 = getelementptr inbounds i8, i8* %0, i64 %919
%921 = load i8, i8* %920
%922 = getelementptr inbounds i8, i8* %920, i64 3
%923 = load i8, i8* %922
%924 = icmp eq i8 %921, %923
br i1 %924, label %925, label %937
925: ; preds = %917
%926 = getelementptr inbounds i8, i8* %920, i64 1
%927 = load i8, i8* %926
%928 = getelementptr inbounds i8, i8* %920, i64 4
%929 = load i8, i8* %928
%930 = icmp eq i8 %927, %929
br i1 %930, label %931, label %937
931: ; preds = %925
%932 = getelementptr inbounds i8, i8* %920, i64 2
%933 = load i8, i8* %932
%934 = getelementptr inbounds i8, i8* %920, i64 5
%935 = load i8, i8* %934
%936 = icmp eq i8 %933, %935
br i1 %936, label %941, label %937
937: ; preds = %917, %925, %931
%938 = add nuw nsw i32 %918, 1
%939 = add nsw i64 %919, 3
%940 = icmp eq i32 %938, %869
br i1 %940, label %941, label %917
941: ; preds = %937, %931
%942 = phi i64 [ %919, %931 ], [ %939, %937 ]
%943 = phi i32 [ %918, %931 ], [ %869, %937 ]
%944 = trunc i32 %943 to i8
br label %945
945: ; preds = %864, %941
%946 = phi i8 [ %944, %941 ], [ 1, %864 ]
%947 = phi i64 [ %942, %941 ], [ %860, %864 ]
%948 = phi i32 [ %943, %941 ], [ 1, %864 ]
%949 = add i8 %946, -1
%950 = add nsw i64 %844, 1
%951 = getelementptr inbounds i8, i8* %3, i64 %844
store i8 %949, i8* %951
%952 = mul nuw nsw i32 %948, 3
%953 = zext i32 %952 to i64
%954 = add nsw i64 %950, %953
%955 = icmp slt i64 %954, %26
br i1 %955, label %956, label %1150
956: ; preds = %945
%957 = getelementptr inbounds i8, i8* %0, i64 %947
%958 = sub nsw i64 0, %953
%959 = getelementptr inbounds i8, i8* %957, i64 %958
%960 = zext i32 %948 to i64
br label %961
961: ; preds = %956, %961
%962 = phi i64 [ 0, %956 ], [ %977, %961 ]
%963 = phi i64 [ %950, %956 ], [ %975, %961 ]
%964 = mul nuw nsw i64 %962, 3
%965 = getelementptr inbounds i8, i8* %959, i64 %964
%966 = load i8, i8* %965
%967 = add nsw i64 %963, 1
%968 = getelementptr inbounds i8, i8* %3, i64 %963
store i8 %966, i8* %968
%969 = getelementptr inbounds i8, i8* %965, i64 1
%970 = load i8, i8* %969
%971 = add nsw i64 %963, 2
%972 = getelementptr inbounds i8, i8* %3, i64 %967
store i8 %970, i8* %972
%973 = getelementptr inbounds i8, i8* %965, i64 2
%974 = load i8, i8* %973
%975 = add nsw i64 %963, 3
%976 = getelementptr inbounds i8, i8* %3, i64 %971
store i8 %974, i8* %976
%977 = add nuw nsw i64 %962, 1
%978 = icmp eq i64 %977, %960
br i1 %978, label %979, label %961
979: ; preds = %961, %903
%980 = phi i64 [ %915, %903 ], [ %975, %961 ]
%981 = phi i64 [ %905, %903 ], [ %947, %961 ]
%982 = icmp slt i64 %981, %23
%983 = icmp slt i64 %980, %26
%984 = select i1 %982, i1 %983, i1 false
br i1 %984, label %843, label %1150
985: ; preds = %15, %1144
%986 = phi i64 [ %1145, %1144 ], [ 0, %15 ]
%987 = phi i64 [ %1146, %1144 ], [ 0, %15 ]
%988 = sdiv i64 %987, 4
%989 = srem i64 %988, %16
%990 = sub nsw i64 %16, %989
%991 = and i64 %990, 255
%992 = sub nsw i64 %17, %987
%993 = sdiv i64 %992, 4
%994 = icmp sgt i64 %991, %993
%995 = select i1 %994, i64 %993, i64 %990
%996 = add nsw i64 %987, 1
%997 = getelementptr inbounds i8, i8* %0, i64 %987
%998 = load i8, i8* %997
%999 = add nsw i64 %987, 2
%1000 = getelementptr inbounds i8, i8* %0, i64 %996
%1001 = load i8, i8* %1000
%1002 = add nsw i64 %987, 3
%1003 = getelementptr inbounds i8, i8* %0, i64 %999
%1004 = load i8, i8* %1003
%1005 = add nsw i64 %987, 4
%1006 = getelementptr inbounds i8, i8* %0, i64 %1002
%1007 = load i8, i8* %1006
%1008 = icmp slt i64 %986, %19
br i1 %1008, label %1009, label %1150
1009: ; preds = %985
%1010 = and i64 %995, 255
%1011 = icmp ugt i64 %1010, 128
%1012 = trunc i64 %995 to i32
%1013 = and i32 %1012, 255
%1014 = select i1 %1011, i32 128, i32 %1013
%1015 = icmp ugt i32 %1014, 1
br i1 %1015, label %1016, label %1106
1016: ; preds = %1009
%1017 = getelementptr inbounds i8, i8* %0, i64 %1005
%1018 = load i8, i8* %1017
%1019 = icmp eq i8 %998, %1018
br i1 %1019, label %1021, label %1020
1020: ; preds = %1029, %1025, %1021, %1016
br label %1072
1021: ; preds = %1016
%1022 = getelementptr inbounds i8, i8* %1017, i64 1
%1023 = load i8, i8* %1022
%1024 = icmp eq i8 %1001, %1023
br i1 %1024, label %1025, label %1020
1025: ; preds = %1021
%1026 = getelementptr inbounds i8, i8* %1017, i64 2
%1027 = load i8, i8* %1026
%1028 = icmp eq i8 %1004, %1027
br i1 %1028, label %1029, label %1020
1029: ; preds = %1025
%1030 = getelementptr inbounds i8, i8* %1017, i64 3
%1031 = load i8, i8* %1030
%1032 = icmp eq i8 %1007, %1031
br i1 %1032, label %1033, label %1020
1033: ; preds = %1029, %1052
%1034 = phi i64 [ %1050, %1052 ], [ %1005, %1029 ]
%1035 = phi i32 [ %1049, %1052 ], [ 1, %1029 ]
%1036 = getelementptr inbounds i8, i8* %0, i64 %1034
%1037 = getelementptr inbounds i8, i8* %1036, i64 1
%1038 = load i8, i8* %1037
%1039 = icmp eq i8 %1001, %1038
br i1 %1039, label %1040, label %1056
1040: ; preds = %1033
%1041 = getelementptr inbounds i8, i8* %1036, i64 2
%1042 = load i8, i8* %1041
%1043 = icmp eq i8 %1004, %1042
br i1 %1043, label %1044, label %1056
1044: ; preds = %1040
%1045 = getelementptr inbounds i8, i8* %1036, i64 3
%1046 = load i8, i8* %1045
%1047 = icmp eq i8 %1007, %1046
br i1 %1047, label %1048, label %1056
1048: ; preds = %1044
%1049 = add nuw nsw i32 %1035, 1
%1050 = add nsw i64 %1034, 4
%1051 = icmp eq i32 %1049, %1014
br i1 %1051, label %1056, label %1052
1052: ; preds = %1048
%1053 = getelementptr inbounds i8, i8* %0, i64 %1050
%1054 = load i8, i8* %1053
%1055 = icmp eq i8 %998, %1054
br i1 %1055, label %1033, label %1056
1056: ; preds = %1044, %1040, %1033, %1052, %1048
%1057 = phi i32 [ %1035, %1044 ], [ %1035, %1040 ], [ %1035, %1033 ], [ %1049, %1052 ], [ %1014, %1048 ]
%1058 = phi i64 [ %1034, %1044 ], [ %1034, %1040 ], [ %1034, %1033 ], [ %1050, %1052 ], [ %1050, %1048 ]
%1059 = trunc i32 %1057 to i8
%1060 = add i8 %1059, 127
%1061 = or i8 %1060, -128
%1062 = add nsw i64 %986, 1
%1063 = getelementptr inbounds i8, i8* %3, i64 %986
store i8 %1061, i8* %1063
%1064 = add nsw i64 %986, 2
%1065 = getelementptr inbounds i8, i8* %3, i64 %1062
store i8 %998, i8* %1065
%1066 = add nsw i64 %986, 3
%1067 = getelementptr inbounds i8, i8* %3, i64 %1064
store i8 %1001, i8* %1067
%1068 = add nsw i64 %986, 4
%1069 = getelementptr inbounds i8, i8* %3, i64 %1066
store i8 %1004, i8* %1069
%1070 = add nsw i64 %986, 5
%1071 = getelementptr inbounds i8, i8* %3, i64 %1068
store i8 %1007, i8* %1071
br label %1144
1072: ; preds = %1020, %1098
%1073 = phi i32 [ %1099, %1098 ], [ 1, %1020 ]
%1074 = phi i64 [ %1100, %1098 ], [ %1005, %1020 ]
%1075 = getelementptr inbounds i8, i8* %0, i64 %1074
%1076 = load i8, i8* %1075
%1077 = getelementptr inbounds i8, i8* %1075, i64 4
%1078 = load i8, i8* %1077
%1079 = icmp eq i8 %1076, %1078
br i1 %1079, label %1080, label %1098
1080: ; preds = %1072
%1081 = getelementptr inbounds i8, i8* %1075, i64 1
%1082 = load i8, i8* %1081
%1083 = getelementptr inbounds i8, i8* %1075, i64 5
%1084 = load i8, i8* %1083
%1085 = icmp eq i8 %1082, %1084
br i1 %1085, label %1086, label %1098
1086: ; preds = %1080
%1087 = getelementptr inbounds i8, i8* %1075, i64 2
%1088 = load i8, i8* %1087
%1089 = getelementptr inbounds i8, i8* %1075, i64 6
%1090 = load i8, i8* %1089
%1091 = icmp eq i8 %1088, %1090
br i1 %1091, label %1092, label %1098
1092: ; preds = %1086
%1093 = getelementptr inbounds i8, i8* %1075, i64 3
%1094 = load i8, i8* %1093
%1095 = getelementptr inbounds i8, i8* %1075, i64 7
%1096 = load i8, i8* %1095
%1097 = icmp eq i8 %1094, %1096
br i1 %1097, label %1102, label %1098
1098: ; preds = %1072, %1080, %1086, %1092
%1099 = add nuw nsw i32 %1073, 1
%1100 = add nsw i64 %1074, 4
%1101 = icmp eq i32 %1099, %1014
br i1 %1101, label %1102, label %1072
1102: ; preds = %1098, %1092
%1103 = phi i64 [ %1074, %1092 ], [ %1100, %1098 ]
%1104 = phi i32 [ %1073, %1092 ], [ %1014, %1098 ]
%1105 = trunc i32 %1104 to i8
br label %1106
1106: ; preds = %1009, %1102
%1107 = phi i8 [ %1105, %1102 ], [ 1, %1009 ]
%1108 = phi i64 [ %1103, %1102 ], [ %1005, %1009 ]
%1109 = phi i32 [ %1104, %1102 ], [ 1, %1009 ]
%1110 = add i8 %1107, -1
%1111 = add nsw i64 %986, 1
%1112 = getelementptr inbounds i8, i8* %3, i64 %986
store i8 %1110, i8* %1112
%1113 = shl nuw nsw i32 %1109, 2
%1114 = zext i32 %1113 to i64
%1115 = add nsw i64 %1111, %1114
%1116 = icmp slt i64 %1115, %20
br i1 %1116, label %1117, label %1150
1117: ; preds = %1106
%1118 = getelementptr inbounds i8, i8* %0, i64 %1108
%1119 = sub nsw i64 0, %1114
%1120 = getelementptr inbounds i8, i8* %1118, i64 %1119
%1121 = zext i32 %1109 to i64
br label %1122
1122: ; preds = %1117, %1122
%1123 = phi i64 [ 0, %1117 ], [ %1142, %1122 ]
%1124 = phi i64 [ %1111, %1117 ], [ %1140, %1122 ]
%1125 = shl nsw i64 %1123, 2
%1126 = getelementptr inbounds i8, i8* %1120, i64 %1125
%1127 = load i8, i8* %1126
%1128 = add nsw i64 %1124, 1
%1129 = getelementptr inbounds i8, i8* %3, i64 %1124
store i8 %1127, i8* %1129
%1130 = getelementptr inbounds i8, i8* %1126, i64 1
%1131 = load i8, i8* %1130
%1132 = add nsw i64 %1124, 2
%1133 = getelementptr inbounds i8, i8* %3, i64 %1128
store i8 %1131, i8* %1133
%1134 = getelementptr inbounds i8, i8* %1126, i64 2
%1135 = load i8, i8* %1134
%1136 = add nsw i64 %1124, 3
%1137 = getelementptr inbounds i8, i8* %3, i64 %1132
store i8 %1135, i8* %1137
%1138 = getelementptr inbounds i8, i8* %1126, i64 3
%1139 = load i8, i8* %1138
%1140 = add nsw i64 %1124, 4
%1141 = getelementptr inbounds i8, i8* %3, i64 %1136
store i8 %1139, i8* %1141
%1142 = add nuw nsw i64 %1123, 1
%1143 = icmp eq i64 %1142, %1121
br i1 %1143, label %1144, label %1122
1144: ; preds = %1122, %1056
%1145 = phi i64 [ %1070, %1056 ], [ %1140, %1122 ]
%1146 = phi i64 [ %1058, %1056 ], [ %1108, %1122 ]
%1147 = icmp slt i64 %1146, %17
%1148 = icmp slt i64 %1145, %20
%1149 = select i1 %1147, i1 %1148, i1 false
br i1 %1149, label %985, label %1150
1150: ; preds = %985, %1106, %1144, %843, %945, %979, %613, %695, %837, %378, %442, %607, %167, %73, %370, %11
%1151 = phi i64 [ 0, %11 ], [ %52, %167 ], [ %52, %73 ], [ %373, %370 ], [ %447, %442 ], [ %379, %378 ], [ %608, %607 ], [ %700, %695 ], [ %614, %613 ], [ %838, %837 ], [ %950, %945 ], [ %844, %843 ], [ %980, %979 ], [ %1111, %1106 ], [ %986, %985 ], [ %1145, %1144 ]
ret i64 %1151
}