int bitmap_decompress3(char *output, int width, int height, char *input,
                       int size) {
  char *prevline;
  char *line;
  char *end;
  char color1[3];
  char color2[3];
  char mix[3];
  int code;
  int mixmask;
  int mask;
  int opcode;
  int count;
  int offset;
  int isfillormix;
  int x;
  int lastopcode;
  int insertmix;
  int bicolor;
  int fom_mask;
  end = input + size;
  prevline = 0;
  line = 0;
  x = width;
  lastopcode = -1;
  insertmix = 0;
  bicolor = 0;
  color1[0] = 0;
  color1[1] = 0;
  color1[2] = 0;
  color2[0] = 0;
  color2[1] = 0;
  color2[2] = 0;
  mix[0] = 0xff;
  mix[1] = 0xff;
  mix[2] = 0xff;
  mask = 0;
  fom_mask = 0;
  while (input < end) {
    fom_mask = 0;
    code = ((unsigned char)(*(input++)));
    opcode = code >> 4;
    switch (opcode) {
    case 0xc:
    case 0xd:
    case 0xe:
      opcode -= 6;
      count = code & 0xf;
      offset = 16;
      break;
    case 0xf:
      opcode = code & 0xf;
      if (opcode < 9) {
        count = ((unsigned char)(*(input++)));
        count |= ((unsigned char)(*(input++))) << 8;
      } else {
        count = (opcode < 0xb) ? 8 : 1;
      }
      offset = 0;
      break;
    default:
      opcode >>= 1;
      count = code & 0x1f;
      offset = 32;
      break;
    }
    if (offset != 0) {
      isfillormix = ((opcode == 2) || (opcode == 7));
      if (count == 0) {
        if (isfillormix) {
          count = ((unsigned char)(*(input++))) + 1;
        } else {
          count = ((unsigned char)(*(input++))) + offset;
        }
      } else if (isfillormix) {
        count <<= 3;
      }
    }
    switch (opcode) {
    case 0:
      if ((lastopcode == opcode) && !((x == width) && (prevline == 0))) {
        insertmix = 1;
      }
      break;
    case 8:
      color1[0] = ((unsigned char)(*(input++)));
      color1[1] = ((unsigned char)(*(input++)));
      color1[2] = ((unsigned char)(*(input++)));
    case 3:
      color2[0] = ((unsigned char)(*(input++)));
      color2[1] = ((unsigned char)(*(input++)));
      color2[2] = ((unsigned char)(*(input++)));
      break;
    case 6:
    case 7:
      mix[0] = ((unsigned char)(*(input++)));
      mix[1] = ((unsigned char)(*(input++)));
      mix[2] = ((unsigned char)(*(input++)));
      opcode -= 5;
      break;
    case 9:
      mask = 0x03;
      opcode = 0x02;
      fom_mask = 3;
      break;
    case 0x0a:
      mask = 0x05;
      opcode = 0x02;
      fom_mask = 5;
      break;
    }
    lastopcode = opcode;
    mixmask = 0;
    while (count > 0) {
      if (x >= width) {
        if (height <= 0) {
          return 0;
        }
        x = 0;
        height--;
        prevline = line;
        line = output + height * (width * 3);
      }
      switch (opcode) {
      case 0:
        if (insertmix) {
          if (prevline == 0) {
            line[x * 3 + 0] = mix[0];
            line[x * 3 + 1] = mix[1];
            line[x * 3 + 2] = mix[2];
          } else {
            line[x * 3 + 0] = prevline[x * 3 + 0] ^ mix[0];
            line[x * 3 + 1] = prevline[x * 3 + 1] ^ mix[1];
            line[x * 3 + 2] = prevline[x * 3 + 2] ^ mix[2];
          }
          insertmix = 0;
          count--;
          x++;
        }
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 3 + 0] = 0;
              line[x * 3 + 1] = 0;
              line[x * 3 + 2] = 0;
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 3 + 0] = prevline[x * 3 + 0];
              line[x * 3 + 1] = prevline[x * 3 + 1];
              line[x * 3 + 2] = prevline[x * 3 + 2];
              ;
              count--;
              x++;
            }
          }
        }
        break;
      case 1:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 3 + 0] = mix[0];
              line[x * 3 + 1] = mix[1];
              line[x * 3 + 2] = mix[2];
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 3 + 0] = prevline[x * 3 + 0] ^ mix[0];
              line[x * 3 + 1] = prevline[x * 3 + 1] ^ mix[1];
              line[x * 3 + 2] = prevline[x * 3 + 2] ^ mix[2];
              ;
              count--;
              x++;
            }
          }
        }
        break;
      case 2:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              {
                mixmask <<= 1;
                if ((mixmask & 0xff) == 0) {
                  mask = fom_mask ? fom_mask : ((unsigned char)(*(input++)));
                  mixmask = 1;
                }
              };
              if (mask & mixmask) {
                line[x * 3 + 0] = mix[0];
                line[x * 3 + 1] = mix[1];
                line[x * 3 + 2] = mix[2];
              } else {
                line[x * 3 + 0] = 0;
                line[x * 3 + 1] = 0;
                line[x * 3 + 2] = 0;
              };
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              {
                mixmask <<= 1;
                if ((mixmask & 0xff) == 0) {
                  mask = fom_mask ? fom_mask : ((unsigned char)(*(input++)));
                  mixmask = 1;
                }
              };
              if (mask & mixmask) {
                line[x * 3 + 0] = prevline[x * 3 + 0] ^ mix[0];
                line[x * 3 + 1] = prevline[x * 3 + 1] ^ mix[1];
                line[x * 3 + 2] = prevline[x * 3 + 2] ^ mix[2];
              } else {
                line[x * 3 + 0] = prevline[x * 3 + 0];
                line[x * 3 + 1] = prevline[x * 3 + 1];
                line[x * 3 + 2] = prevline[x * 3 + 2];
              };
              count--;
              x++;
            }
          }
        }
        break;
      case 3: {
        while ((count > 0) && (x < width)) {
          line[x * 3 + 0] = color2[0];
          line[x * 3 + 1] = color2[1];
          line[x * 3 + 2] = color2[2];
          ;
          count--;
          x++;
        }
      } break;
      case 4: {
        while ((count > 0) && (x < width)) {
          line[x * 3 + 0] = ((unsigned char)(*(input++)));
          line[x * 3 + 1] = ((unsigned char)(*(input++)));
          line[x * 3 + 2] = ((unsigned char)(*(input++)));
          ;
          count--;
          x++;
        }
      } break;
      case 8: {
        while ((count > 0) && (x < width)) {
          if (bicolor) {
            line[x * 3 + 0] = color2[0];
            line[x * 3 + 1] = color2[1];
            line[x * 3 + 2] = color2[2];
            bicolor = 0;
          } else {
            line[x * 3 + 0] = color1[0];
            line[x * 3 + 1] = color1[1];
            line[x * 3 + 2] = color1[2];
            bicolor = 1;
            count++;
          };
          count--;
          x++;
        }
      } break;
      case 0xd: {
        while ((count > 0) && (x < width)) {
          line[x * 3 + 0] = 0xff;
          line[x * 3 + 1] = 0xff;
          line[x * 3 + 2] = 0xff;
          ;
          count--;
          x++;
        }
      } break;
      case 0xe: {
        while ((count > 0) && (x < width)) {
          line[x * 3 + 0] = 0;
          line[x * 3 + 1] = 0;
          line[x * 3 + 2] = 0;
          ;
          count--;
          x++;
        }
      } break;
      default:
        return 0;
        break;
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<bitmap_decompress3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0xffffffff,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movb   $0x0,-0x43(%rbp)
movb   $0x0,-0x42(%rbp)
movb   $0x0,-0x41(%rbp)
movb   $0x0,-0x46(%rbp)
movb   $0x0,-0x45(%rbp)
movb   $0x0,-0x44(%rbp)
movb   $0xff,-0x49(%rbp)
movb   $0xff,-0x48(%rbp)
movb   $0xff,-0x47(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1f1f <bitmap_decompress3+0xe1f>
movl   $0x0,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
sar    $0x4,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x80(%rbp)
add    $0xfffffff4,%eax
sub    $0x3,%eax
jb     11e1 <bitmap_decompress3+0xe1>
jmp    11d0 <bitmap_decompress3+0xd0>
mov    -0x80(%rbp),%eax
sub    $0xf,%eax
je     11ff <bitmap_decompress3+0xff>
jmp    1269 <bitmap_decompress3+0x169>
mov    -0x5c(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
and    $0xf,%eax
mov    %eax,-0x60(%rbp)
movl   $0x10,-0x64(%rbp)
jmp    1282 <bitmap_decompress3+0x182>
mov    -0x50(%rbp),%eax
and    $0xf,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x9,-0x5c(%rbp)
jge    1247 <bitmap_decompress3+0x147>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
shl    $0x8,%eax
or     -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    125d <bitmap_decompress3+0x15d>
mov    -0x5c(%rbp),%edx
mov    $0x1,%eax
mov    $0x8,%ecx
cmp    $0xb,%edx
cmovl  %ecx,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    1282 <bitmap_decompress3+0x182>
mov    -0x5c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
and    $0x1f,%eax
mov    %eax,-0x60(%rbp)
movl   $0x20,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
je     1324 <bitmap_decompress3+0x224>
mov    $0x1,%al
cmpl   $0x2,-0x5c(%rbp)
mov    %al,-0x81(%rbp)
je     12ab <bitmap_decompress3+0x1ab>
cmpl   $0x7,-0x5c(%rbp)
sete   %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1307 <bitmap_decompress3+0x207>
cmpl   $0x0,-0x68(%rbp)
je     12ea <bitmap_decompress3+0x1ea>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1302 <bitmap_decompress3+0x202>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    131f <bitmap_decompress3+0x21f>
cmpl   $0x0,-0x68(%rbp)
je     131a <bitmap_decompress3+0x21a>
mov    -0x60(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x60(%rbp)
jmp    131f <bitmap_decompress3+0x21f>
jmp    1324 <bitmap_decompress3+0x224>
mov    -0x5c(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0xa,%rax
ja     1474 <bitmap_decompress3+0x374>
mov    -0x90(%rbp),%rax
lea    0xcba(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jne    1379 <bitmap_decompress3+0x279>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1372 <bitmap_decompress3+0x272>
cmpq   $0x0,-0x30(%rbp)
je     1379 <bitmap_decompress3+0x279>
movl   $0x1,-0x74(%rbp)
jmp    1474 <bitmap_decompress3+0x374>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x43(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x42(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x41(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x46(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x45(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x44(%rbp)
jmp    1474 <bitmap_decompress3+0x374>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x49(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x47(%rbp)
mov    -0x5c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x5c(%rbp)
jmp    1474 <bitmap_decompress3+0x374>
movl   $0x3,-0x58(%rbp)
movl   $0x2,-0x5c(%rbp)
movl   $0x3,-0x7c(%rbp)
jmp    1474 <bitmap_decompress3+0x374>
movl   $0x5,-0x58(%rbp)
movl   $0x2,-0x5c(%rbp)
movl   $0x5,-0x7c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x0,-0x60(%rbp)
jle    1f1a <bitmap_decompress3+0xe1a>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     14dd <bitmap_decompress3+0x3dd>
cmpl   $0x0,-0x18(%rbp)
jg     14ad <bitmap_decompress3+0x3ad>
movl   $0x0,-0x4(%rbp)
jmp    1f26 <bitmap_decompress3+0xe26>
movl   $0x0,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   $0x3,-0x14(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
mov    %rax,-0x98(%rbp)
sub    $0xe,%rax
ja     1f09 <bitmap_decompress3+0xe09>
mov    -0x98(%rbp),%rax
lea    0xb2d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,-0x74(%rbp)
je     15f8 <bitmap_decompress3+0x4f8>
cmpq   $0x0,-0x30(%rbp)
jne    155e <bitmap_decompress3+0x45e>
mov    -0x49(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x47(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    15df <bitmap_decompress3+0x4df>
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x49(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x48(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x47(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x74(%rbp)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    168e <bitmap_decompress3+0x58e>
jmp    1608 <bitmap_decompress3+0x508>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x99(%rbp)
jle    1629 <bitmap_decompress3+0x529>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    163c <bitmap_decompress3+0x53c>
jmp    1689 <bitmap_decompress3+0x589>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1608 <bitmap_decompress3+0x508>
jmp    1749 <bitmap_decompress3+0x649>
jmp    1693 <bitmap_decompress3+0x593>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x9a(%rbp)
jle    16b4 <bitmap_decompress3+0x5b4>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
test   $0x1,%al
jne    16c7 <bitmap_decompress3+0x5c7>
jmp    1744 <bitmap_decompress3+0x644>
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1693 <bitmap_decompress3+0x593>
jmp    1749 <bitmap_decompress3+0x649>
jmp    1f15 <bitmap_decompress3+0xe15>
cmpq   $0x0,-0x30(%rbp)
jne    17ea <bitmap_decompress3+0x6ea>
jmp    175e <bitmap_decompress3+0x65e>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x9b(%rbp)
jle    177f <bitmap_decompress3+0x67f>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x9b(%rbp)
mov    -0x9b(%rbp),%al
test   $0x1,%al
jne    1792 <bitmap_decompress3+0x692>
jmp    17e5 <bitmap_decompress3+0x6e5>
mov    -0x49(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x47(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    175e <bitmap_decompress3+0x65e>
jmp    18c0 <bitmap_decompress3+0x7c0>
jmp    17ef <bitmap_decompress3+0x6ef>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x9c(%rbp)
jle    1810 <bitmap_decompress3+0x710>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x9c(%rbp)
mov    -0x9c(%rbp),%al
test   $0x1,%al
jne    1823 <bitmap_decompress3+0x723>
jmp    18bb <bitmap_decompress3+0x7bb>
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x49(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x48(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x47(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    17ef <bitmap_decompress3+0x6ef>
jmp    18c0 <bitmap_decompress3+0x7c0>
jmp    1f15 <bitmap_decompress3+0xe15>
cmpq   $0x0,-0x30(%rbp)
jne    1a05 <bitmap_decompress3+0x905>
jmp    18d5 <bitmap_decompress3+0x7d5>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x9d(%rbp)
jle    18f6 <bitmap_decompress3+0x7f6>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x9d(%rbp)
mov    -0x9d(%rbp),%al
test   $0x1,%al
jne    1909 <bitmap_decompress3+0x809>
jmp    1a00 <bitmap_decompress3+0x900>
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
cmp    $0x0,%eax
jne    1963 <bitmap_decompress3+0x863>
cmpl   $0x0,-0x7c(%rbp)
je     193b <bitmap_decompress3+0x83b>
mov    -0x7c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    1953 <bitmap_decompress3+0x853>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x58(%rbp),%eax
and    -0x54(%rbp),%eax
cmp    $0x0,%eax
je     19b3 <bitmap_decompress3+0x8b3>
mov    -0x49(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x47(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    19e9 <bitmap_decompress3+0x8e9>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    18d5 <bitmap_decompress3+0x7d5>
jmp    1baf <bitmap_decompress3+0xaaf>
jmp    1a0a <bitmap_decompress3+0x90a>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xa5(%rbp)
jle    1a2b <bitmap_decompress3+0x92b>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    1a3e <bitmap_decompress3+0x93e>
jmp    1baa <bitmap_decompress3+0xaaa>
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
cmp    $0x0,%eax
jne    1a98 <bitmap_decompress3+0x998>
cmpl   $0x0,-0x7c(%rbp)
je     1a70 <bitmap_decompress3+0x970>
mov    -0x7c(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1a88 <bitmap_decompress3+0x988>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x58(%rbp),%eax
and    -0x54(%rbp),%eax
cmp    $0x0,%eax
je     1b2d <bitmap_decompress3+0xa2d>
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x49(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x48(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x47(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1b93 <bitmap_decompress3+0xa93>
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1a0a <bitmap_decompress3+0x90a>
jmp    1baf <bitmap_decompress3+0xaaf>
jmp    1f15 <bitmap_decompress3+0xe15>
jmp    1bb9 <bitmap_decompress3+0xab9>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xad(%rbp)
jle    1bda <bitmap_decompress3+0xada>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xad(%rbp)
mov    -0xad(%rbp),%al
test   $0x1,%al
jne    1bed <bitmap_decompress3+0xaed>
jmp    1c40 <bitmap_decompress3+0xb40>
mov    -0x46(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x45(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1bb9 <bitmap_decompress3+0xab9>
jmp    1f15 <bitmap_decompress3+0xe15>
jmp    1c4a <bitmap_decompress3+0xb4a>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xae(%rbp)
jle    1c6b <bitmap_decompress3+0xb6b>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xae(%rbp)
mov    -0xae(%rbp),%al
test   $0x1,%al
jne    1c7e <bitmap_decompress3+0xb7e>
jmp    1cfb <bitmap_decompress3+0xbfb>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1c4a <bitmap_decompress3+0xb4a>
jmp    1f15 <bitmap_decompress3+0xe15>
jmp    1d05 <bitmap_decompress3+0xc05>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xaf(%rbp)
jle    1d26 <bitmap_decompress3+0xc26>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xaf(%rbp)
mov    -0xaf(%rbp),%al
test   $0x1,%al
jne    1d39 <bitmap_decompress3+0xc39>
jmp    1dee <bitmap_decompress3+0xcee>
cmpl   $0x0,-0x78(%rbp)
je     1d8b <bitmap_decompress3+0xc8b>
mov    -0x46(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x45(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x78(%rbp)
jmp    1dd7 <bitmap_decompress3+0xcd7>
mov    -0x43(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x42(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x41(%rbp),%dl
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x78(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1d05 <bitmap_decompress3+0xc05>
jmp    1f15 <bitmap_decompress3+0xe15>
jmp    1df8 <bitmap_decompress3+0xcf8>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xb0(%rbp)
jle    1e19 <bitmap_decompress3+0xd19>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xb0(%rbp)
mov    -0xb0(%rbp),%al
test   $0x1,%al
jne    1e2c <bitmap_decompress3+0xd2c>
jmp    1e79 <bitmap_decompress3+0xd79>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1df8 <bitmap_decompress3+0xcf8>
jmp    1f15 <bitmap_decompress3+0xe15>
jmp    1e83 <bitmap_decompress3+0xd83>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0xb1(%rbp)
jle    1ea4 <bitmap_decompress3+0xda4>
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    1eb7 <bitmap_decompress3+0xdb7>
jmp    1f04 <bitmap_decompress3+0xe04>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
imul   $0x3,-0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1e83 <bitmap_decompress3+0xd83>
jmp    1f15 <bitmap_decompress3+0xe15>
movl   $0x0,-0x4(%rbp)
jmp    1f26 <bitmap_decompress3+0xe26>
jmp    1481 <bitmap_decompress3+0x381>
jmp    1186 <bitmap_decompress3+0x86>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitmap_decompress3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %r8d,%r8d
jle    1a26 <bitmap_decompress3+0x926>
mov    %rcx,%rax
mov    %edx,%r11d
mov    %esi,%r13d
mov    %rdi,%r15
movslq %r8d,%rcx
add    %rax,%rcx
mov    %rcx,(%rsp)
lea    0x0(%r13,%r13,2),%r9d
movslq %esi,%rbx
movb   $0xff,-0x79(%rsp)
mov    $0xffffffff,%edi
xor    %ecx,%ecx
mov    %rcx,-0x38(%rsp)
movl   $0x0,-0x5c(%rsp)
mov    %esi,%r12d
movl   $0x0,-0x60(%rsp)
movb   $0xff,-0x7a(%rsp)
movb   $0xff,-0x7b(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x40(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x48(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x50(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x18(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x20(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x28(%rsp)
xor    %ebp,%ebp
xor    %ecx,%ecx
mov    %r9d,-0x64(%rsp)
mov    %rbx,-0x58(%rsp)
mov    %r15,-0x8(%rsp)
mov    %r13,-0x10(%rsp)
jmp    11bd <bitmap_decompress3+0xbd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rax
cmp    (%rsp),%r14
jae    1a26 <bitmap_decompress3+0x926>
mov    %rcx,%rsi
mov    %edi,%r8d
lea    0x1(%rax),%r14
movzbl (%rax),%edi
mov    %edi,%ecx
shr    $0x4,%ecx
lea    -0xc(%rcx),%edx
cmp    $0x3,%edx
jae    1210 <bitmap_decompress3+0x110>
add    $0xfffffffa,%ecx
mov    $0x10,%r9d
mov    $0xf,%r10d
and    %edi,%r10d
je     1246 <bitmap_decompress3+0x146>
mov    %rcx,%rdi
cmp    $0x7,%edi
je     11fc <bitmap_decompress3+0xfc>
cmp    $0x2,%edi
jne    1290 <bitmap_decompress3+0x190>
shl    $0x3,%r10d
jmp    1290 <bitmap_decompress3+0x190>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0xf,%ecx
jne    1230 <bitmap_decompress3+0x130>
and    $0xf,%edi
cmp    $0x8,%edi
ja     1265 <bitmap_decompress3+0x165>
movzwl 0x1(%rax),%r10d
add    $0x3,%rax
mov    %rax,%r14
jmp    1295 <bitmap_decompress3+0x195>
nopl   0x0(%rax,%rax,1)
mov    %edi,%ecx
shr    $0x5,%ecx
mov    $0x20,%r9d
mov    $0x1f,%r10d
and    %edi,%r10d
jne    11eb <bitmap_decompress3+0xeb>
mov    %rcx,%rdi
cmp    $0x7,%edi
je     1253 <bitmap_decompress3+0x153>
cmp    $0x2,%edi
jne    1279 <bitmap_decompress3+0x179>
movzbl 0x1(%rax),%r10d
add    $0x2,%rax
add    $0x1,%r10d
mov    %rax,%r14
jmp    1290 <bitmap_decompress3+0x190>
cmp    $0xb,%edi
mov    $0x1,%r10d
mov    $0x8,%eax
cmovb  %eax,%r10d
jmp    1295 <bitmap_decompress3+0x195>
movzbl 0x1(%rax),%ecx
add    $0x2,%rax
add    %ecx,%r9d
mov    %rax,%r14
mov    %r9d,%r10d
nopw   0x0(%rax,%rax,1)
mov    -0x64(%rsp),%r9d
movl   $0x0,-0x68(%rsp)
cmp    $0xa,%edi
ja     1a12 <bitmap_decompress3+0x912>
mov    %edi,%eax
lea    0xd51(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
movl   $0x0,-0x6c(%rsp)
mov    %rsi,%rcx
jmp    *%rax
mov    (%r14),%al
mov    %al,-0x79(%rsp)
mov    0x1(%r14),%al
mov    %al,-0x7a(%rsp)
mov    0x2(%r14),%al
mov    %al,-0x7b(%rsp)
add    $0x3,%r14
add    $0xfffffffb,%edi
jmp    1343 <bitmap_decompress3+0x243>
xor    %edi,%edi
test   %r8d,%r8d
jne    1343 <bitmap_decompress3+0x243>
test   %rcx,%rcx
mov    $0x1,%eax
mov    -0x5c(%rsp),%edx
cmovne %eax,%edx
cmp    %r13d,%r12d
cmovne %eax,%edx
mov    %edx,-0x5c(%rsp)
xor    %edi,%edi
jmp    1343 <bitmap_decompress3+0x243>
mov    (%r14),%al
mov    %rax,-0x18(%rsp)
mov    0x1(%r14),%al
mov    %rax,-0x20(%rsp)
mov    0x2(%r14),%al
mov    %rax,-0x28(%rsp)
add    $0x3,%r14
mov    (%r14),%al
mov    %rax,-0x40(%rsp)
mov    0x1(%r14),%al
mov    %rax,-0x48(%rsp)
mov    0x2(%r14),%al
mov    %rax,-0x50(%rsp)
add    $0x3,%r14
movl   $0x0,-0x68(%rsp)
movl   $0x0,-0x6c(%rsp)
test   %r10d,%r10d
jle    11b0 <bitmap_decompress3+0xb0>
xor    %r8d,%r8d
mov    %rdi,-0x78(%rsp)
jmp    1391 <bitmap_decompress3+0x291>
mov    %ebx,%r10d
mov    -0x64(%rsp),%r9d
mov    -0x58(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x78(%rsp),%rdi
mov    %rsi,%rcx
test   %r10d,%r10d
jle    11b0 <bitmap_decompress3+0xb0>
cmp    %r13d,%r12d
jl     13b6 <bitmap_decompress3+0x2b6>
test   %r11d,%r11d
jle    1a22 <bitmap_decompress3+0x922>
add    $0xffffffff,%r11d
mov    %r9d,%eax
imul   %r11d,%eax
mov    %rbp,%rcx
movslq %eax,%rbp
add    %r15,%rbp
xor    %r12d,%r12d
xor    %eax,%eax
cmp    $0xe,%edi
ja     1a2b <bitmap_decompress3+0x92b>
mov    %rcx,%rsi
mov    %edi,%edx
lea    0xc5f(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
cmpl   $0x0,-0x5c(%rsp)
je     1792 <bitmap_decompress3+0x692>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rax
test   %rsi,%rsi
je     18c2 <bitmap_decompress3+0x7c2>
mov    %rsi,%rcx
mov    (%rsi,%rax,1),%dl
xor    -0x79(%rsp),%dl
mov    %dl,0x0(%rbp,%rax,1)
mov    0x1(%rsi,%rax,1),%dl
xor    -0x7a(%rsp),%dl
mov    %dl,0x1(%rbp,%rax,1)
mov    0x2(%rsi,%rax,1),%bl
xor    -0x7b(%rsp),%bl
add    $0x2,%rax
jmp    18e0 <bitmap_decompress3+0x7e0>
mov    %rsi,%rcx
test   %rsi,%rsi
je     179a <bitmap_decompress3+0x69a>
cmp    %r13d,%r12d
jge    1388 <bitmap_decompress3+0x288>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdi
add    $0x2,%rdi
add    $0x1,%rax
mov    %r10d,%edx
movzbl -0x2(%rcx,%rdi,1),%ebx
xor    -0x79(%rsp),%bl
mov    %bl,-0x2(%rbp,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%ebx
xor    -0x7a(%rsp),%bl
mov    %bl,-0x1(%rbp,%rdi,1)
movzbl (%rcx,%rdi,1),%ebx
xor    -0x7b(%rsp),%bl
mov    %bl,0x0(%rbp,%rdi,1)
lea    -0x1(%rdx),%r10d
add    $0x1,%r12d
cmp    $0x1,%edx
je     18b3 <bitmap_decompress3+0x7b3>
add    $0x3,%rdi
lea    0x1(%rax),%rdx
mov    -0x58(%rsp),%rbx
cmp    %rbx,%rax
mov    %rdx,%rax
jl     1440 <bitmap_decompress3+0x340>
jmp    18b8 <bitmap_decompress3+0x7b8>
mov    %rsi,%rcx
test   %rsi,%rsi
je     1800 <bitmap_decompress3+0x700>
cmp    %r13d,%r12d
jge    1388 <bitmap_decompress3+0x288>
mov    %r11d,-0x2c(%rsp)
movslq %r12d,%rax
lea    (%rax,%rax,2),%r9
add    $0x2,%r9
lea    0x1(%rax),%rdi
mov    %r10d,%r11d
add    $0xffffffffffffffff,%r11
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
test   $0x7f,%r8b
lea    (%r8,%r8,1),%ecx
mov    %ecx,%r8d
mov    $0x1,%ecx
cmove  %ecx,%r8d
setne  %cl
mov    -0x60(%rsp),%ebx
cmove  -0x6c(%rsp),%ebx
or     -0x68(%rsp),%cl
jne    1504 <bitmap_decompress3+0x404>
movzbl (%r14),%ebx
add    $0x1,%r14
mov    $0x1,%r8d
mov    %rsi,%rcx
movzbl -0x2(%rsi,%r9,1),%edx
mov    %ebx,-0x60(%rsp)
test   %r8d,%ebx
je     1540 <bitmap_decompress3+0x440>
xor    -0x79(%rsp),%dl
mov    %dl,-0x2(%rbp,%r9,1)
movzbl -0x1(%rsi,%r9,1),%ecx
xor    -0x7a(%rsp),%cl
mov    %cl,-0x1(%rbp,%r9,1)
mov    %rsi,%rcx
movzbl (%rsi,%r9,1),%r15d
xor    -0x7b(%rsp),%r15b
mov    %r9,%rbx
jmp    1560 <bitmap_decompress3+0x460>
lea    (%rax,%rax,2),%rbx
mov    %dl,-0x2(%rbp,%r9,1)
movzbl -0x1(%rsi,%r9,1),%ecx
mov    %cl,-0x1(%rbp,%r9,1)
mov    %rsi,%rcx
add    $0x2,%rbx
movzbl (%rsi,%r9,1),%r15d
mov    %r15b,0x0(%rbp,%rbx,1)
lea    0x1(%r13),%rbx
cmp    %r13d,%r11d
je     1587 <bitmap_decompress3+0x487>
add    $0x1,%rax
add    %rdi,%r13
add    $0x3,%r9
cmp    -0x58(%rsp),%r13
mov    %rbx,%r13
jl     14d0 <bitmap_decompress3+0x3d0>
add    %ebx,%r12d
sub    %ebx,%r10d
mov    -0x2c(%rsp),%r11d
mov    -0x10(%rsp),%r13
mov    -0x8(%rsp),%r15
jmp    18ae <bitmap_decompress3+0x7ae>
cmp    %r13d,%r12d
jge    1385 <bitmap_decompress3+0x285>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
nopl   (%rax)
mov    %r10d,%ecx
mov    -0x40(%rsp),%rdx
mov    %dl,-0x2(%rdi)
mov    -0x48(%rsp),%rdx
mov    %dl,-0x1(%rdi)
mov    -0x50(%rsp),%rdx
mov    %dl,(%rdi)
lea    -0x1(%rcx),%r10d
add    $0x1,%r12d
cmp    $0x1,%ecx
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     15c0 <bitmap_decompress3+0x4c0>
jmp    1380 <bitmap_decompress3+0x280>
cmp    %r13d,%r12d
jge    1385 <bitmap_decompress3+0x285>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
nopl   0x0(%rax)
mov    %r10d,%ecx
movzbl (%r14),%edx
mov    %dl,-0x2(%rdi)
movzbl 0x1(%r14),%edx
mov    %dl,-0x1(%rdi)
movzbl 0x2(%r14),%edx
add    $0x3,%r14
mov    %dl,(%rdi)
lea    -0x1(%rcx),%r10d
add    $0x1,%r12d
cmp    $0x1,%ecx
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     1620 <bitmap_decompress3+0x520>
jmp    1380 <bitmap_decompress3+0x280>
cmp    %r13d,%r12d
jge    1385 <bitmap_decompress3+0x285>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
nop
cmpl   $0x0,-0x38(%rsp)
jne    16b0 <bitmap_decompress3+0x5b0>
mov    -0x18(%rsp),%rcx
mov    %cl,-0x2(%rdi)
mov    -0x20(%rsp),%rcx
mov    %cl,-0x1(%rdi)
mov    -0x28(%rsp),%rcx
mov    %cl,(%rdi)
add    $0x1,%r10d
mov    $0x1,%ecx
jmp    16c9 <bitmap_decompress3+0x5c9>
nopl   0x0(%rax)
mov    -0x40(%rsp),%rcx
mov    %cl,-0x2(%rdi)
mov    -0x48(%rsp),%rcx
mov    %cl,-0x1(%rdi)
mov    -0x50(%rsp),%rcx
mov    %cl,(%rdi)
xor    %ecx,%ecx
mov    %rcx,-0x38(%rsp)
add    $0x1,%r12d
add    $0xffffffff,%r10d
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     1680 <bitmap_decompress3+0x580>
jmp    1380 <bitmap_decompress3+0x280>
cmp    %r13d,%r12d
jge    1385 <bitmap_decompress3+0x285>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
nopl   (%rax)
mov    %r10d,%ecx
movw   $0xffff,-0x2(%rdi)
movb   $0xff,(%rdi)
lea    -0x1(%rcx),%r10d
add    $0x1,%r12d
cmp    $0x1,%ecx
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     1710 <bitmap_decompress3+0x610>
jmp    1380 <bitmap_decompress3+0x280>
cmp    %r13d,%r12d
jge    1385 <bitmap_decompress3+0x285>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
xchg   %ax,%ax
mov    %r10d,%ecx
movw   $0x0,-0x2(%rdi)
movb   $0x0,(%rdi)
lea    -0x1(%rcx),%r10d
add    $0x1,%r12d
cmp    $0x1,%ecx
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     1760 <bitmap_decompress3+0x660>
jmp    1380 <bitmap_decompress3+0x280>
mov    %rsi,%rcx
jmp    18f1 <bitmap_decompress3+0x7f1>
cmp    %r13d,%r12d
jge    1388 <bitmap_decompress3+0x288>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
mov    %r10d,%edx
movzbl -0x79(%rsp),%ecx
mov    %cl,-0x2(%rdi)
movzbl -0x7a(%rsp),%ecx
mov    %cl,-0x1(%rdi)
movzbl -0x7b(%rsp),%ecx
mov    %cl,(%rdi)
lea    -0x1(%rdx),%r10d
add    $0x1,%r12d
cmp    $0x1,%edx
je     1380 <bitmap_decompress3+0x280>
add    $0x3,%rdi
lea    0x1(%rax),%rdx
cmp    %rbx,%rax
mov    %rdx,%rax
jl     17c0 <bitmap_decompress3+0x6c0>
jmp    1380 <bitmap_decompress3+0x280>
cmp    %r13d,%r12d
jge    1388 <bitmap_decompress3+0x288>
movslq %r12d,%r9
lea    (%r9,%r9,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%r9
nopl   0x0(%rax)
test   $0x7f,%r8b
lea    (%r8,%r8,1),%edx
mov    %edx,%r8d
mov    $0x1,%eax
cmove  %eax,%r8d
setne  %dl
mov    -0x60(%rsp),%eax
cmove  -0x6c(%rsp),%eax
or     -0x68(%rsp),%dl
jne    1854 <bitmap_decompress3+0x754>
movzbl (%r14),%eax
add    $0x1,%r14
mov    $0x1,%r8d
mov    %eax,-0x60(%rsp)
mov    %eax,%edx
and    %r8d,%edx
movzbl -0x79(%rsp),%ebx
cmove  %edx,%ebx
movzbl -0x7a(%rsp),%ecx
cmove  %edx,%ecx
movzbl -0x7b(%rsp),%eax
cmove  %edx,%eax
mov    %bl,-0x2(%rdi)
mov    %cl,-0x1(%rdi)
mov    %al,(%rdi)
lea    -0x1(%r10),%ebx
add    $0x1,%r12d
cmp    $0x1,%r10d
je     1366 <bitmap_decompress3+0x266>
add    $0x3,%rdi
lea    0x1(%r9),%rax
mov    %ebx,%r10d
cmp    -0x58(%rsp),%r9
mov    %rax,%r9
jl     1820 <bitmap_decompress3+0x720>
mov    %rsi,%rcx
mov    %ebx,%r10d
mov    -0x64(%rsp),%r9d
mov    -0x58(%rsp),%rbx
mov    -0x78(%rsp),%rdi
jmp    1388 <bitmap_decompress3+0x288>
mov    -0x79(%rsp),%cl
mov    %cl,0x0(%rbp,%rax,1)
cltq
mov    -0x7a(%rsp),%cl
mov    %cl,0x1(%rax,%rbp,1)
mov    %rsi,%rcx
add    $0x2,%eax
cltq
mov    -0x7b(%rsp),%bl
mov    %bl,0x0(%rbp,%rax,1)
add    $0xffffffff,%r10d
add    $0x1,%r12d
mov    -0x58(%rsp),%rbx
test   %r10d,%r10d
setne  %dl
cmp    %r13d,%r12d
setl   %al
and    %dl,%al
test   %rcx,%rcx
je     1978 <bitmap_decompress3+0x878>
movl   $0x0,-0x5c(%rsp)
test   %al,%al
je     1388 <bitmap_decompress3+0x288>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdi
add    $0x2,%rdi
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10d,%edx
movzbl -0x2(%rcx,%rdi,1),%ebx
mov    %bl,-0x2(%rbp,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%ebx
mov    %bl,-0x1(%rbp,%rdi,1)
movzbl (%rcx,%rdi,1),%ebx
mov    %bl,0x0(%rbp,%rdi,1)
lea    -0x1(%rdx),%r10d
add    $0x1,%r12d
cmp    $0x1,%edx
je     18b3 <bitmap_decompress3+0x7b3>
add    $0x3,%rdi
lea    0x1(%rax),%rdx
mov    -0x58(%rsp),%rbx
cmp    %rbx,%rax
mov    %rdx,%rax
jl     1930 <bitmap_decompress3+0x830>
jmp    18b8 <bitmap_decompress3+0x7b8>
movl   $0x0,-0x5c(%rsp)
test   %al,%al
je     1388 <bitmap_decompress3+0x288>
movslq %r12d,%rax
lea    (%rax,%rax,2),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x2,%rdi
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
mov    %r10d,%edx
movw   $0x0,-0x2(%rdi)
movb   $0x0,(%rdi)
lea    -0x1(%rdx),%r10d
add    $0x1,%r12d
cmp    $0x1,%edx
je     18b8 <bitmap_decompress3+0x7b8>
add    $0x3,%rdi
lea    0x1(%rax),%rdx
cmp    %rbx,%rax
mov    %rdx,%rax
jl     19a0 <bitmap_decompress3+0x8a0>
jmp    18b8 <bitmap_decompress3+0x7b8>
mov    $0x1,%al
mov    %eax,-0x68(%rsp)
mov    $0x2,%edi
movl   $0x3,-0x60(%rsp)
movl   $0x3,-0x6c(%rsp)
jmp    1353 <bitmap_decompress3+0x253>
mov    $0x1,%al
mov    %eax,-0x68(%rsp)
mov    $0x2,%edi
movl   $0x5,-0x60(%rsp)
movl   $0x5,-0x6c(%rsp)
jmp    1353 <bitmap_decompress3+0x253>
movl   $0x0,-0x6c(%rsp)
mov    %rsi,%rcx
jmp    1353 <bitmap_decompress3+0x253>
xor    %eax,%eax
jmp    1a2b <bitmap_decompress3+0x92b>
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @bitmap_decompress3(i8* %0, i32 %1, i32 %2, i8* %3, i32 %4) {
%6 = sext i32 %4 to i64
%7 = getelementptr inbounds i8, i8* %3, i64 %6
%8 = icmp sgt i32 %4, 0
br i1 %8, label %9, label %532
9: ; preds = %5
%10 = mul nsw i32 %1, 3
%11 = sext i32 %1 to i64
br label %22
12: ; preds = %523, %123
%13 = phi i8* [ %40, %123 ], [ %160, %523 ]
%14 = phi i8* [ %39, %123 ], [ %161, %523 ]
%15 = phi i8* [ %124, %123 ], [ %524, %523 ]
%16 = phi i32 [ %28, %123 ], [ %162, %523 ]
%17 = phi i32 [ %134, %123 ], [ %526, %523 ]
%18 = phi i32 [ %26, %123 ], [ %528, %523 ]
%19 = phi i32 [ %136, %123 ], [ %529, %523 ]
%20 = phi i32 [ %23, %123 ], [ %530, %523 ]
%21 = icmp ult i8* %15, %7
br i1 %21, label %22, label %532
22: ; preds = %9, %12
%23 = phi i32 [ 0, %9 ], [ %20, %12 ]
%24 = phi i32 [ 0, %9 ], [ %19, %12 ]
%25 = phi i32 [ -1, %9 ], [ %135, %12 ]
%26 = phi i32 [ %1, %9 ], [ %18, %12 ]
%27 = phi i32 [ 0, %9 ], [ %17, %12 ]
%28 = phi i32 [ %2, %9 ], [ %16, %12 ]
%29 = phi i8 [ -1, %9 ], [ %133, %12 ]
%30 = phi i8 [ -1, %9 ], [ %132, %12 ]
%31 = phi i8 [ -1, %9 ], [ %131, %12 ]
%32 = phi i8 [ 0, %9 ], [ %130, %12 ]
%33 = phi i8 [ 0, %9 ], [ %129, %12 ]
%34 = phi i8 [ 0, %9 ], [ %128, %12 ]
%35 = phi i8 [ 0, %9 ], [ %127, %12 ]
%36 = phi i8 [ 0, %9 ], [ %126, %12 ]
%37 = phi i8 [ 0, %9 ], [ %125, %12 ]
%38 = phi i8* [ %3, %9 ], [ %15, %12 ]
%39 = phi i8* [ null, %9 ], [ %14, %12 ]
%40 = phi i8* [ null, %9 ], [ %13, %12 ]
%41 = getelementptr inbounds i8, i8* %38, i64 1
%42 = load i8, i8* %38
%43 = zext i8 %42 to i32
%44 = lshr i32 %43, 4
switch i32 %44, label %62 [
i32 12, label %45
i32 13, label %45
i32 14, label %45
i32 15, label %47
]
45: ; preds = %22, %22, %22
%46 = add nsw i32 %44, -6
br label %64
47: ; preds = %22
%48 = and i32 %43, 15
%49 = icmp ult i32 %48, 9
br i1 %49, label %50, label %59
50: ; preds = %47
%51 = getelementptr inbounds i8, i8* %38, i64 2
%52 = load i8, i8* %41
%53 = zext i8 %52 to i32
%54 = getelementptr inbounds i8, i8* %38, i64 3
%55 = load i8, i8* %51
%56 = zext i8 %55 to i32
%57 = shl nuw nsw i32 %56, 8
%58 = or i32 %57, %53
br label %84
59: ; preds = %47
%60 = icmp ult i32 %48, 11
%61 = select i1 %60, i32 8, i32 1
br label %84
62: ; preds = %22
%63 = lshr i32 %43, 5
br label %64
64: ; preds = %45, %62
%65 = phi i32 [ 15, %45 ], [ 31, %62 ]
%66 = phi i32 [ %46, %45 ], [ %63, %62 ]
%67 = phi i32 [ 16, %45 ], [ 32, %62 ]
%68 = and i32 %65, %43
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %81
70: ; preds = %64
switch i32 %66, label %76 [
i32 7, label %71
i32 2, label %71
]
71: ; preds = %70, %70
%72 = getelementptr inbounds i8, i8* %38, i64 2
%73 = load i8, i8* %41
%74 = zext i8 %73 to i32
%75 = add nuw nsw i32 %74, 1
br label %84
76: ; preds = %70
%77 = getelementptr inbounds i8, i8* %38, i64 2
%78 = load i8, i8* %41
%79 = zext i8 %78 to i32
%80 = add nuw nsw i32 %67, %79
br label %84
81: ; preds = %64
switch i32 %66, label %84 [
i32 7, label %82
i32 2, label %82
]
82: ; preds = %81, %81
%83 = shl nuw nsw i32 %68, 3
br label %84
84: ; preds = %50, %59, %81, %76, %71, %82
%85 = phi i32 [ %66, %71 ], [ %66, %76 ], [ %66, %82 ], [ %66, %81 ], [ %48, %59 ], [ %48, %50 ]
%86 = phi i8* [ %72, %71 ], [ %77, %76 ], [ %41, %82 ], [ %41, %81 ], [ %41, %59 ], [ %54, %50 ]
%87 = phi i32 [ %75, %71 ], [ %80, %76 ], [ %83, %82 ], [ %68, %81 ], [ %61, %59 ], [ %58, %50 ]
switch i32 %85, label %123 [
i32 0, label %88
i32 8, label %95
i32 3, label %102
i32 6, label %113
i32 7, label %113
i32 9, label %121
i32 10, label %122
]
88: ; preds = %84
%89 = icmp eq i32 %25, 0
br i1 %89, label %90, label %123
90: ; preds = %88
%91 = icmp eq i32 %26, %1
%92 = icmp eq i8* %40, null
%93 = select i1 %91, i1 %92, i1 false
%94 = select i1 %93, i32 %24, i32 1
br label %123
95: ; preds = %84
%96 = getelementptr inbounds i8, i8* %86, i64 1
%97 = load i8, i8* %86
%98 = getelementptr inbounds i8, i8* %86, i64 2
%99 = load i8, i8* %96
%100 = getelementptr inbounds i8, i8* %86, i64 3
%101 = load i8, i8* %98
br label %102
102: ; preds = %84, %95
%103 = phi i8* [ %86, %84 ], [ %100, %95 ]
%104 = phi i8 [ %37, %84 ], [ %101, %95 ]
%105 = phi i8 [ %36, %84 ], [ %99, %95 ]
%106 = phi i8 [ %35, %84 ], [ %97, %95 ]
%107 = getelementptr inbounds i8, i8* %103, i64 1
%108 = load i8, i8* %103
%109 = getelementptr inbounds i8, i8* %103, i64 2
%110 = load i8, i8* %107
%111 = getelementptr inbounds i8, i8* %103, i64 3
%112 = load i8, i8* %109
br label %123
113: ; preds = %84, %84
%114 = getelementptr inbounds i8, i8* %86, i64 1
%115 = load i8, i8* %86
%116 = getelementptr inbounds i8, i8* %86, i64 2
%117 = load i8, i8* %114
%118 = getelementptr inbounds i8, i8* %86, i64 3
%119 = load i8, i8* %116
%120 = add nsw i32 %85, -5
br label %123
121: ; preds = %84
br label %123
122: ; preds = %84
br label %123
123: ; preds = %90, %88, %84, %122, %121, %113, %102
%124 = phi i8* [ %86, %84 ], [ %86, %122 ], [ %86, %121 ], [ %118, %113 ], [ %111, %102 ], [ %86, %88 ], [ %86, %90 ]
%125 = phi i8 [ %37, %84 ], [ %37, %122 ], [ %37, %121 ], [ %37, %113 ], [ %104, %102 ], [ %37, %88 ], [ %37, %90 ]
%126 = phi i8 [ %36, %84 ], [ %36, %122 ], [ %36, %121 ], [ %36, %113 ], [ %105, %102 ], [ %36, %88 ], [ %36, %90 ]
%127 = phi i8 [ %35, %84 ], [ %35, %122 ], [ %35, %121 ], [ %35, %113 ], [ %106, %102 ], [ %35, %88 ], [ %35, %90 ]
%128 = phi i8 [ %34, %84 ], [ %34, %122 ], [ %34, %121 ], [ %34, %113 ], [ %112, %102 ], [ %34, %88 ], [ %34, %90 ]
%129 = phi i8 [ %33, %84 ], [ %33, %122 ], [ %33, %121 ], [ %33, %113 ], [ %110, %102 ], [ %33, %88 ], [ %33, %90 ]
%130 = phi i8 [ %32, %84 ], [ %32, %122 ], [ %32, %121 ], [ %32, %113 ], [ %108, %102 ], [ %32, %88 ], [ %32, %90 ]
%131 = phi i8 [ %31, %84 ], [ %31, %122 ], [ %31, %121 ], [ %119, %113 ], [ %31, %102 ], [ %31, %88 ], [ %31, %90 ]
%132 = phi i8 [ %30, %84 ], [ %30, %122 ], [ %30, %121 ], [ %117, %113 ], [ %30, %102 ], [ %30, %88 ], [ %30, %90 ]
%133 = phi i8 [ %29, %84 ], [ %29, %122 ], [ %29, %121 ], [ %115, %113 ], [ %29, %102 ], [ %29, %88 ], [ %29, %90 ]
%134 = phi i32 [ %27, %84 ], [ 5, %122 ], [ 3, %121 ], [ %27, %113 ], [ %27, %102 ], [ %27, %88 ], [ %27, %90 ]
%135 = phi i32 [ %85, %84 ], [ 2, %122 ], [ 2, %121 ], [ %120, %113 ], [ %85, %102 ], [ 0, %88 ], [ 0, %90 ]
%136 = phi i32 [ %24, %84 ], [ %24, %122 ], [ %24, %121 ], [ %24, %113 ], [ %24, %102 ], [ %24, %88 ], [ %94, %90 ]
%137 = phi i1 [ false, %84 ], [ true, %122 ], [ true, %121 ], [ false, %113 ], [ false, %102 ], [ false, %88 ], [ false, %90 ]
%138 = phi i32 [ 0, %84 ], [ 5, %122 ], [ 3, %121 ], [ 0, %113 ], [ 0, %102 ], [ 0, %88 ], [ 0, %90 ]
%139 = icmp sgt i32 %87, 0
br i1 %139, label %140, label %12
140: ; preds = %123, %523
%141 = phi i32 [ %530, %523 ], [ %23, %123 ]
%142 = phi i32 [ %529, %523 ], [ %136, %123 ]
%143 = phi i32 [ %528, %523 ], [ %26, %123 ]
%144 = phi i32 [ %527, %523 ], [ %87, %123 ]
%145 = phi i32 [ %526, %523 ], [ %134, %123 ]
%146 = phi i32 [ %525, %523 ], [ 0, %123 ]
%147 = phi i32 [ %162, %523 ], [ %28, %123 ]
%148 = phi i8* [ %524, %523 ], [ %124, %123 ]
%149 = phi i8* [ %161, %523 ], [ %39, %123 ]
%150 = phi i8* [ %160, %523 ], [ %40, %123 ]
%151 = icmp slt i32 %143, %1
br i1 %151, label %159, label %152
152: ; preds = %140
%153 = icmp slt i32 %147, 1
br i1 %153, label %532, label %154
154: ; preds = %152
%155 = add nsw i32 %147, -1
%156 = mul nsw i32 %10, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %0, i64 %157
br label %159
159: ; preds = %154, %140
%160 = phi i8* [ %149, %154 ], [ %150, %140 ]
%161 = phi i8* [ %158, %154 ], [ %149, %140 ]
%162 = phi i32 [ %155, %154 ], [ %147, %140 ]
%163 = phi i32 [ 0, %154 ], [ %143, %140 ]
switch i32 %135, label %532 [
i32 0, label %184
i32 1, label %266
i32 2, label %312
i32 3, label %180
i32 4, label %176
i32 8, label %172
i32 13, label %168
i32 14, label %164
]
164: ; preds = %159
%165 = icmp slt i32 %163, %1
br i1 %165, label %166, label %523
166: ; preds = %164
%167 = sext i32 %163 to i64
br label %487
168: ; preds = %159
%169 = icmp slt i32 %163, %1
br i1 %169, label %170, label %523
170: ; preds = %168
%171 = sext i32 %163 to i64
br label %473
172: ; preds = %159
%173 = icmp slt i32 %163, %1
br i1 %173, label %174, label %523
174: ; preds = %172
%175 = sext i32 %163 to i64
br label %447
176: ; preds = %159
%177 = icmp slt i32 %163, %1
br i1 %177, label %178, label %523
178: ; preds = %176
%179 = sext i32 %163 to i64
br label %426
180: ; preds = %159
%181 = icmp slt i32 %163, %1
br i1 %181, label %182, label %523
182: ; preds = %180
%183 = sext i32 %163 to i64
br label %412
184: ; preds = %159
%185 = icmp eq i32 %142, 0
br i1 %185, label %219, label %186
186: ; preds = %184
%187 = icmp eq i8* %160, null
%188 = mul nsw i32 %163, 3
%189 = sext i32 %188 to i64
br i1 %187, label %190, label %197
190: ; preds = %186
%191 = getelementptr inbounds i8, i8* %161, i64 %189
store i8 %133, i8* %191
%192 = add nsw i32 %188, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %161, i64 %193
store i8 %132, i8* %194
%195 = add nsw i32 %188, 2
%196 = sext i32 %195 to i64
br label %213
197: ; preds = %186
%198 = getelementptr inbounds i8, i8* %160, i64 %189
%199 = load i8, i8* %198
%200 = xor i8 %199, %133
%201 = getelementptr inbounds i8, i8* %161, i64 %189
store i8 %200, i8* %201
%202 = add nsw i32 %188, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i8, i8* %160, i64 %203
%205 = load i8, i8* %204
%206 = xor i8 %205, %132
%207 = getelementptr inbounds i8, i8* %161, i64 %203
store i8 %206, i8* %207
%208 = add nsw i32 %188, 2
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %160, i64 %209
%211 = load i8, i8* %210
%212 = xor i8 %211, %131
br label %213
213: ; preds = %197, %190
%214 = phi i64 [ %209, %197 ], [ %196, %190 ]
%215 = phi i8 [ %212, %197 ], [ %131, %190 ]
%216 = getelementptr inbounds i8, i8* %161, i64 %214
store i8 %215, i8* %216
%217 = add nsw i32 %144, -1
%218 = add nsw i32 %163, 1
br label %219
219: ; preds = %213, %184
%220 = phi i32 [ %217, %213 ], [ %144, %184 ]
%221 = phi i32 [ %218, %213 ], [ %163, %184 ]
%222 = icmp eq i8* %160, null
%223 = icmp ne i32 %220, 0
%224 = icmp slt i32 %221, %1
%225 = select i1 %223, i1 %224, i1 false
br i1 %222, label %229, label %226
226: ; preds = %219
br i1 %225, label %227, label %523
227: ; preds = %226
%228 = sext i32 %221 to i64
br label %246
229: ; preds = %219
br i1 %225, label %230, label %523
230: ; preds = %229
%231 = sext i32 %221 to i64
br label %232
232: ; preds = %230, %232
%233 = phi i64 [ %231, %230 ], [ %242, %232 ]
%234 = phi i32 [ %220, %230 ], [ %241, %232 ]
%235 = mul nsw i64 %233, 3
%236 = getelementptr inbounds i8, i8* %161, i64 %235
store i8 0, i8* %236
%237 = add nsw i64 %235, 1
%238 = getelementptr inbounds i8, i8* %161, i64 %237
store i8 0, i8* %238
%239 = add nsw i64 %235, 2
%240 = getelementptr inbounds i8, i8* %161, i64 %239
store i8 0, i8* %240
%241 = add nsw i32 %234, -1
%242 = add nsw i64 %233, 1
%243 = icmp ne i32 %241, 0
%244 = icmp slt i64 %242, %11
%245 = select i1 %243, i1 %244, i1 false
br i1 %245, label %232, label %501
246: ; preds = %227, %246
%247 = phi i64 [ %228, %227 ], [ %262, %246 ]
%248 = phi i32 [ %220, %227 ], [ %261, %246 ]
%249 = mul nsw i64 %247, 3
%250 = getelementptr inbounds i8, i8* %160, i64 %249
%251 = load i8, i8* %250
%252 = getelementptr inbounds i8, i8* %161, i64 %249
store i8 %251, i8* %252
%253 = add nsw i64 %249, 1
%254 = getelementptr inbounds i8, i8* %160, i64 %253
%255 = load i8, i8* %254
%256 = getelementptr inbounds i8, i8* %161, i64 %253
store i8 %255, i8* %256
%257 = add nsw i64 %249, 2
%258 = getelementptr inbounds i8, i8* %160, i64 %257
%259 = load i8, i8* %258
%260 = getelementptr inbounds i8, i8* %161, i64 %257
store i8 %259, i8* %260
%261 = add nsw i32 %248, -1
%262 = add nsw i64 %247, 1
%263 = icmp ne i32 %261, 0
%264 = icmp slt i64 %262, %11
%265 = select i1 %263, i1 %264, i1 false
br i1 %265, label %246, label %503
266: ; preds = %159
%267 = icmp eq i8* %160, null
%268 = icmp slt i32 %163, %1
br i1 %267, label %272, label %269
269: ; preds = %266
br i1 %268, label %270, label %523
270: ; preds = %269
%271 = sext i32 %163 to i64
br label %289
272: ; preds = %266
br i1 %268, label %273, label %523
273: ; preds = %272
%274 = sext i32 %163 to i64
br label %275
275: ; preds = %273, %275
%276 = phi i64 [ %274, %273 ], [ %285, %275 ]
%277 = phi i32 [ %144, %273 ], [ %284, %275 ]
%278 = mul nsw i64 %276, 3
%279 = getelementptr inbounds i8, i8* %161, i64 %278
store i8 %133, i8* %279
%280 = add nsw i64 %278, 1
%281 = getelementptr inbounds i8, i8* %161, i64 %280
store i8 %132, i8* %281
%282 = add nsw i64 %278, 2
%283 = getelementptr inbounds i8, i8* %161, i64 %282
store i8 %131, i8* %283
%284 = add nsw i32 %277, -1
%285 = add nsw i64 %276, 1
%286 = icmp ne i32 %284, 0
%287 = icmp slt i64 %285, %11
%288 = select i1 %286, i1 %287, i1 false
br i1 %288, label %275, label %505
289: ; preds = %270, %289
%290 = phi i64 [ %271, %270 ], [ %308, %289 ]
%291 = phi i32 [ %144, %270 ], [ %307, %289 ]
%292 = mul nsw i64 %290, 3
%293 = getelementptr inbounds i8, i8* %160, i64 %292
%294 = load i8, i8* %293
%295 = xor i8 %294, %133
%296 = getelementptr inbounds i8, i8* %161, i64 %292
store i8 %295, i8* %296
%297 = add nsw i64 %292, 1
%298 = getelementptr inbounds i8, i8* %160, i64 %297
%299 = load i8, i8* %298
%300 = xor i8 %299, %132
%301 = getelementptr inbounds i8, i8* %161, i64 %297
store i8 %300, i8* %301
%302 = add nsw i64 %292, 2
%303 = getelementptr inbounds i8, i8* %160, i64 %302
%304 = load i8, i8* %303
%305 = xor i8 %304, %131
%306 = getelementptr inbounds i8, i8* %161, i64 %302
store i8 %305, i8* %306
%307 = add nsw i32 %291, -1
%308 = add nsw i64 %290, 1
%309 = icmp ne i32 %307, 0
%310 = icmp slt i64 %308, %11
%311 = select i1 %309, i1 %310, i1 false
br i1 %311, label %289, label %507
312: ; preds = %159
%313 = icmp eq i8* %160, null
%314 = icmp slt i32 %163, %1
br i1 %313, label %318, label %315
315: ; preds = %312
br i1 %314, label %316, label %523
316: ; preds = %315
%317 = sext i32 %163 to i64
br label %357
318: ; preds = %312
br i1 %314, label %319, label %523
319: ; preds = %318
%320 = sext i32 %163 to i64
br label %321
321: ; preds = %319, %337
%322 = phi i64 [ %320, %319 ], [ %353, %337 ]
%323 = phi i32 [ %144, %319 ], [ %352, %337 ]
%324 = phi i32 [ %145, %319 ], [ %340, %337 ]
%325 = phi i32 [ %146, %319 ], [ %339, %337 ]
%326 = phi i8* [ %148, %319 ], [ %338, %337 ]
%327 = shl i32 %325, 1
%328 = and i32 %325, 127
%329 = icmp ne i32 %328, 0
%330 = or i1 %137, %329
%331 = select i1 %329, i32 %327, i32 1
%332 = select i1 %329, i32 %324, i32 %138
br i1 %330, label %337, label %333
333: ; preds = %321
%334 = getelementptr inbounds i8, i8* %326, i64 1
%335 = load i8, i8* %326
%336 = zext i8 %335 to i32
br label %337
337: ; preds = %321, %333
%338 = phi i8* [ %326, %321 ], [ %334, %333 ]
%339 = phi i32 [ %331, %321 ], [ 1, %333 ]
%340 = phi i32 [ %332, %321 ], [ %336, %333 ]
%341 = and i32 %340, %339
%342 = icmp eq i32 %341, 0
%343 = mul nsw i64 %322, 3
%344 = getelementptr inbounds i8, i8* %161, i64 %343
%345 = select i1 %342, i8 0, i8 %133
%346 = select i1 %342, i8 0, i8 %132
%347 = select i1 %342, i8 0, i8 %131
store i8 %345, i8* %344
%348 = add nsw i64 %343, 1
%349 = getelementptr inbounds i8, i8* %161, i64 %348
store i8 %346, i8* %349
%350 = add nsw i64 %343, 2
%351 = getelementptr inbounds i8, i8* %161, i64 %350
store i8 %347, i8* %351
%352 = add nsw i32 %323, -1
%353 = add nsw i64 %322, 1
%354 = icmp ne i32 %352, 0
%355 = icmp slt i64 %353, %11
%356 = select i1 %354, i1 %355, i1 false
br i1 %356, label %321, label %509
357: ; preds = %316, %403
%358 = phi i64 [ %317, %316 ], [ %408, %403 ]
%359 = phi i32 [ %144, %316 ], [ %407, %403 ]
%360 = phi i32 [ %145, %316 ], [ %376, %403 ]
%361 = phi i32 [ %146, %316 ], [ %375, %403 ]
%362 = phi i8* [ %148, %316 ], [ %374, %403 ]
%363 = shl i32 %361, 1
%364 = and i32 %361, 127
%365 = icmp ne i32 %364, 0
%366 = or i1 %137, %365
%367 = select i1 %365, i32 %363, i32 1
%368 = select i1 %365, i32 %360, i32 %138
br i1 %366, label %373, label %369
369: ; preds = %357
%370 = getelementptr inbounds i8, i8* %362, i64 1
%371 = load i8, i8* %362
%372 = zext i8 %371 to i32
br label %373
373: ; preds = %357, %369
%374 = phi i8* [ %362, %357 ], [ %370, %369 ]
%375 = phi i32 [ %367, %357 ], [ 1, %369 ]
%376 = phi i32 [ %368, %357 ], [ %372, %369 ]
%377 = and i32 %376, %375
%378 = icmp eq i32 %377, 0
%379 = mul nsw i64 %358, 3
%380 = getelementptr inbounds i8, i8* %160, i64 %379
%381 = load i8, i8* %380
br i1 %378, label %394, label %382
382: ; preds = %373
%383 = xor i8 %381, %133
%384 = getelementptr inbounds i8, i8* %161, i64 %379
store i8 %383, i8* %384
%385 = add nsw i64 %379, 1
%386 = getelementptr inbounds i8, i8* %160, i64 %385
%387 = load i8, i8* %386
%388 = xor i8 %387, %132
%389 = getelementptr inbounds i8, i8* %161, i64 %385
store i8 %388, i8* %389
%390 = add nsw i64 %379, 2
%391 = getelementptr inbounds i8, i8* %160, i64 %390
%392 = load i8, i8* %391
%393 = xor i8 %392, %131
br label %403
394: ; preds = %373
%395 = getelementptr inbounds i8, i8* %161, i64 %379
store i8 %381, i8* %395
%396 = add nsw i64 %379, 1
%397 = getelementptr inbounds i8, i8* %160, i64 %396
%398 = load i8, i8* %397
%399 = getelementptr inbounds i8, i8* %161, i64 %396
store i8 %398, i8* %399
%400 = add nsw i64 %379, 2
%401 = getelementptr inbounds i8, i8* %160, i64 %400
%402 = load i8, i8* %401
br label %403
403: ; preds = %394, %382
%404 = phi i64 [ %400, %394 ], [ %390, %382 ]
%405 = phi i8 [ %402, %394 ], [ %393, %382 ]
%406 = getelementptr inbounds i8, i8* %161, i64 %404
store i8 %405, i8* %406
%407 = add nsw i32 %359, -1
%408 = add nsw i64 %358, 1
%409 = icmp ne i32 %407, 0
%410 = icmp slt i64 %408, %11
%411 = select i1 %409, i1 %410, i1 false
br i1 %411, label %357, label %511
412: ; preds = %182, %412
%413 = phi i64 [ %183, %182 ], [ %422, %412 ]
%414 = phi i32 [ %144, %182 ], [ %421, %412 ]
%415 = mul nsw i64 %413, 3
%416 = getelementptr inbounds i8, i8* %161, i64 %415
store i8 %130, i8* %416
%417 = add nsw i64 %415, 1
%418 = getelementptr inbounds i8, i8* %161, i64 %417
store i8 %129, i8* %418
%419 = add nsw i64 %415, 2
%420 = getelementptr inbounds i8, i8* %161, i64 %419
store i8 %128, i8* %420
%421 = add nsw i32 %414, -1
%422 = add nsw i64 %413, 1
%423 = icmp ne i32 %421, 0
%424 = icmp slt i64 %422, %11
%425 = select i1 %423, i1 %424, i1 false
br i1 %425, label %412, label %513
426: ; preds = %178, %426
%427 = phi i64 [ %179, %178 ], [ %443, %426 ]
%428 = phi i32 [ %144, %178 ], [ %442, %426 ]
%429 = phi i8* [ %148, %178 ], [ %438, %426 ]
%430 = getelementptr inbounds i8, i8* %429, i64 1
%431 = load i8, i8* %429
%432 = mul nsw i64 %427, 3
%433 = getelementptr inbounds i8, i8* %161, i64 %432
store i8 %431, i8* %433
%434 = getelementptr inbounds i8, i8* %429, i64 2
%435 = load i8, i8* %430
%436 = add nsw i64 %432, 1
%437 = getelementptr inbounds i8, i8* %161, i64 %436
store i8 %435, i8* %437
%438 = getelementptr inbounds i8, i8* %429, i64 3
%439 = load i8, i8* %434
%440 = add nsw i64 %432, 2
%441 = getelementptr inbounds i8, i8* %161, i64 %440
store i8 %439, i8* %441
%442 = add nsw i32 %428, -1
%443 = add nsw i64 %427, 1
%444 = icmp ne i32 %442, 0
%445 = icmp slt i64 %443, %11
%446 = select i1 %444, i1 %445, i1 false
br i1 %446, label %426, label %515
447: ; preds = %174, %465
%448 = phi i64 [ %175, %174 ], [ %469, %465 ]
%449 = phi i32 [ %141, %174 ], [ %467, %465 ]
%450 = phi i32 [ %144, %174 ], [ %468, %465 ]
%451 = icmp eq i32 %449, 0
%452 = mul nsw i64 %448, 3
%453 = getelementptr inbounds i8, i8* %161, i64 %452
br i1 %451, label %459, label %454
454: ; preds = %447
store i8 %130, i8* %453
%455 = add nsw i64 %452, 1
%456 = getelementptr inbounds i8, i8* %161, i64 %455
store i8 %129, i8* %456
%457 = add nsw i64 %452, 2
%458 = getelementptr inbounds i8, i8* %161, i64 %457
store i8 %128, i8* %458
br label %465
459: ; preds = %447
store i8 %127, i8* %453
%460 = add nsw i64 %452, 1
%461 = getelementptr inbounds i8, i8* %161, i64 %460
store i8 %126, i8* %461
%462 = add nsw i64 %452, 2
%463 = getelementptr inbounds i8, i8* %161, i64 %462
store i8 %125, i8* %463
%464 = add nuw nsw i32 %450, 1
br label %465
465: ; preds = %459, %454
%466 = phi i32 [ %450, %454 ], [ %464, %459 ]
%467 = phi i32 [ 0, %454 ], [ 1, %459 ]
%468 = add nsw i32 %466, -1
%469 = add nsw i64 %448, 1
%470 = icmp ne i32 %468, 0
%471 = icmp slt i64 %469, %11
%472 = select i1 %470, i1 %471, i1 false
br i1 %472, label %447, label %517
473: ; preds = %170, %473
%474 = phi i64 [ %171, %170 ], [ %483, %473 ]
%475 = phi i32 [ %144, %170 ], [ %482, %473 ]
%476 = mul nsw i64 %474, 3
%477 = getelementptr inbounds i8, i8* %161, i64 %476
store i8 -1, i8* %477
%478 = add nsw i64 %476, 1
%479 = getelementptr inbounds i8, i8* %161, i64 %478
store i8 -1, i8* %479
%480 = add nsw i64 %476, 2
%481 = getelementptr inbounds i8, i8* %161, i64 %480
store i8 -1, i8* %481
%482 = add nsw i32 %475, -1
%483 = add nsw i64 %474, 1
%484 = icmp ne i32 %482, 0
%485 = icmp slt i64 %483, %11
%486 = select i1 %484, i1 %485, i1 false
br i1 %486, label %473, label %519
487: ; preds = %166, %487
%488 = phi i64 [ %167, %166 ], [ %497, %487 ]
%489 = phi i32 [ %144, %166 ], [ %496, %487 ]
%490 = mul nsw i64 %488, 3
%491 = getelementptr inbounds i8, i8* %161, i64 %490
store i8 0, i8* %491
%492 = add nsw i64 %490, 1
%493 = getelementptr inbounds i8, i8* %161, i64 %492
store i8 0, i8* %493
%494 = add nsw i64 %490, 2
%495 = getelementptr inbounds i8, i8* %161, i64 %494
store i8 0, i8* %495
%496 = add nsw i32 %489, -1
%497 = add nsw i64 %488, 1
%498 = icmp ne i32 %496, 0
%499 = icmp slt i64 %497, %11
%500 = select i1 %498, i1 %499, i1 false
br i1 %500, label %487, label %521
501: ; preds = %232
%502 = trunc i64 %242 to i32
br label %523
503: ; preds = %246
%504 = trunc i64 %262 to i32
br label %523
505: ; preds = %275
%506 = trunc i64 %285 to i32
br label %523
507: ; preds = %289
%508 = trunc i64 %308 to i32
br label %523
509: ; preds = %337
%510 = trunc i64 %353 to i32
br label %523
511: ; preds = %403
%512 = trunc i64 %408 to i32
br label %523
513: ; preds = %412
%514 = trunc i64 %422 to i32
br label %523
515: ; preds = %426
%516 = trunc i64 %443 to i32
br label %523
517: ; preds = %465
%518 = trunc i64 %469 to i32
br label %523
519: ; preds = %473
%520 = trunc i64 %483 to i32
br label %523
521: ; preds = %487
%522 = trunc i64 %497 to i32
br label %523
523: ; preds = %521, %519, %517, %515, %513, %511, %509, %507, %505, %503, %501, %164, %168, %172, %176, %180, %315, %318, %269, %272, %226, %229
%524 = phi i8* [ %148, %229 ], [ %148, %226 ], [ %148, %272 ], [ %148, %269 ], [ %148, %318 ], [ %148, %315 ], [ %148, %180 ], [ %148, %176 ], [ %148, %172 ], [ %148, %168 ], [ %148, %164 ], [ %148, %501 ], [ %148, %503 ], [ %148, %505 ], [ %148, %507 ], [ %338, %509 ], [ %374, %511 ], [ %148, %513 ], [ %438, %515 ], [ %148, %517 ], [ %148, %519 ], [ %148, %521 ]
%525 = phi i32 [ %146, %229 ], [ %146, %226 ], [ %146, %272 ], [ %146, %269 ], [ %146, %318 ], [ %146, %315 ], [ %146, %180 ], [ %146, %176 ], [ %146, %172 ], [ %146, %168 ], [ %146, %164 ], [ %146, %501 ], [ %146, %503 ], [ %146, %505 ], [ %146, %507 ], [ %339, %509 ], [ %375, %511 ], [ %146, %513 ], [ %146, %515 ], [ %146, %517 ], [ %146, %519 ], [ %146, %521 ]
%526 = phi i32 [ %145, %229 ], [ %145, %226 ], [ %145, %272 ], [ %145, %269 ], [ %145, %318 ], [ %145, %315 ], [ %145, %180 ], [ %145, %176 ], [ %145, %172 ], [ %145, %168 ], [ %145, %164 ], [ %145, %501 ], [ %145, %503 ], [ %145, %505 ], [ %145, %507 ], [ %340, %509 ], [ %376, %511 ], [ %145, %513 ], [ %145, %515 ], [ %145, %517 ], [ %145, %519 ], [ %145, %521 ]
%527 = phi i32 [ %220, %229 ], [ %220, %226 ], [ %144, %272 ], [ %144, %269 ], [ %144, %318 ], [ %144, %315 ], [ %144, %180 ], [ %144, %176 ], [ %144, %172 ], [ %144, %168 ], [ %144, %164 ], [ %241, %501 ], [ %261, %503 ], [ %284, %505 ], [ %307, %507 ], [ %352, %509 ], [ %407, %511 ], [ %421, %513 ], [ %442, %515 ], [ %468, %517 ], [ %482, %519 ], [ %496, %521 ]
%528 = phi i32 [ %221, %229 ], [ %221, %226 ], [ %163, %272 ], [ %163, %269 ], [ %163, %318 ], [ %163, %315 ], [ %163, %180 ], [ %163, %176 ], [ %163, %172 ], [ %163, %168 ], [ %163, %164 ], [ %502, %501 ], [ %504, %503 ], [ %506, %505 ], [ %508, %507 ], [ %510, %509 ], [ %512, %511 ], [ %514, %513 ], [ %516, %515 ], [ %518, %517 ], [ %520, %519 ], [ %522, %521 ]
%529 = phi i32 [ 0, %229 ], [ 0, %226 ], [ %142, %272 ], [ %142, %269 ], [ %142, %318 ], [ %142, %315 ], [ %142, %180 ], [ %142, %176 ], [ %142, %172 ], [ %142, %168 ], [ %142, %164 ], [ 0, %501 ], [ 0, %503 ], [ %142, %505 ], [ %142, %507 ], [ %142, %509 ], [ %142, %511 ], [ %142, %513 ], [ %142, %515 ], [ %142, %517 ], [ %142, %519 ], [ %142, %521 ]
%530 = phi i32 [ %141, %229 ], [ %141, %226 ], [ %141, %272 ], [ %141, %269 ], [ %141, %318 ], [ %141, %315 ], [ %141, %180 ], [ %141, %176 ], [ %141, %172 ], [ %141, %168 ], [ %141, %164 ], [ %141, %501 ], [ %141, %503 ], [ %141, %505 ], [ %141, %507 ], [ %141, %509 ], [ %141, %511 ], [ %141, %513 ], [ %141, %515 ], [ %467, %517 ], [ %141, %519 ], [ %141, %521 ]
%531 = icmp sgt i32 %527, 0
br i1 %531, label %140, label %12
532: ; preds = %12, %159, %152, %5
%533 = phi i32 [ 1, %5 ], [ 0, %152 ], [ 0, %159 ], [ 1, %12 ]
ret i32 %533
}