int bitmap_decompress2(char *output, int width, int height, char *input,
                       int size) {
  char *prevline;
  char *line;
  char *end;
  char color1[2];
  char color2[2];
  char mix[2];
  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;
  color2[0] = 0;
  color2[1] = 0;
  mix[0] = 0xff;
  mix[1] = 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++)));
    case 3:
      color2[0] = ((unsigned char)(*(input++)));
      color2[1] = ((unsigned char)(*(input++)));
      break;
    case 6:
    case 7:
      mix[0] = ((unsigned char)(*(input++)));
      mix[1] = ((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 * 2);
      }
      switch (opcode) {
      case 0:
        if (insertmix) {
          if (prevline == 0) {
            line[x * 2 + 0] = mix[0];
            line[x * 2 + 1] = mix[1];
          } else {
            line[x * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
            line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
          }
          insertmix = 0;
          count--;
          x++;
        }
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = 0;
              line[x * 2 + 1] = 0;
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = prevline[x * 2 + 0];
              line[x * 2 + 1] = prevline[x * 2 + 1];
              ;
              count--;
              x++;
            }
          }
        }
        break;
      case 1:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = mix[0];
              line[x * 2 + 1] = mix[1];
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
              line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
              ;
              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 * 2 + 0] = mix[0];
                line[x * 2 + 1] = mix[1];
              } else {
                line[x * 2 + 0] = 0;
                line[x * 2 + 1] = 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 * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
                line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
              } else {
                line[x * 2 + 0] = prevline[x * 2 + 0];
                line[x * 2 + 1] = prevline[x * 2 + 1];
              };
              count--;
              x++;
            }
          }
        }
        break;
      case 3: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = color2[0];
          line[x * 2 + 1] = color2[1];
          ;
          count--;
          x++;
        }
      } break;
      case 4: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = ((unsigned char)(*(input++)));
          line[x * 2 + 1] = ((unsigned char)(*(input++)));
          ;
          count--;
          x++;
        }
      } break;
      case 8: {
        while ((count > 0) && (x < width)) {
          if (bicolor) {
            line[x * 2 + 0] = color2[0];
            line[x * 2 + 1] = color2[1];
            bicolor = 0;
          } else {
            line[x * 2 + 0] = color1[0];
            line[x * 2 + 1] = color1[1];
            bicolor = 1;
            count++;
          };
          count--;
          x++;
        }
      } break;
      case 0xd: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = 0xff;
          line[x * 2 + 1] = 0xff;
          ;
          count--;
          x++;
        }
      } break;
      case 0xe: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = 0;
          line[x * 2 + 1] = 0;
          ;
          count--;
          x++;
        }
      } break;
      default:
        return 0;
        break;
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<bitmap_decompress2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%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,-0x68(%rbp)
movl   $0xffffffff,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movb   $0x0,-0x42(%rbp)
movb   $0x0,-0x41(%rbp)
movb   $0x0,-0x44(%rbp)
movb   $0x0,-0x43(%rbp)
movb   $0xff,-0x46(%rbp)
movb   $0xff,-0x45(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1d7d <bitmap_decompress2+0xc7d>
movl   $0x0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sar    $0x4,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x7c(%rbp)
add    $0xfffffff4,%eax
sub    $0x3,%eax
jb     11d5 <bitmap_decompress2+0xd5>
jmp    11c4 <bitmap_decompress2+0xc4>
mov    -0x7c(%rbp),%eax
sub    $0xf,%eax
je     11f3 <bitmap_decompress2+0xf3>
jmp    125d <bitmap_decompress2+0x15d>
mov    -0x58(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
and    $0xf,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x10,-0x60(%rbp)
jmp    1276 <bitmap_decompress2+0x176>
mov    -0x4c(%rbp),%eax
and    $0xf,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x9,-0x58(%rbp)
jge    123b <bitmap_decompress2+0x13b>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
shl    $0x8,%eax
or     -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1251 <bitmap_decompress2+0x151>
mov    -0x58(%rbp),%edx
mov    $0x1,%eax
mov    $0x8,%ecx
cmp    $0xb,%edx
cmovl  %ecx,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
jmp    1276 <bitmap_decompress2+0x176>
mov    -0x58(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
and    $0x1f,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x20,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
je     130f <bitmap_decompress2+0x20f>
mov    $0x1,%al
cmpl   $0x2,-0x58(%rbp)
mov    %al,-0x7d(%rbp)
je     1299 <bitmap_decompress2+0x199>
cmpl   $0x7,-0x58(%rbp)
sete   %al
mov    %al,-0x7d(%rbp)
mov    -0x7d(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jne    12f2 <bitmap_decompress2+0x1f2>
cmpl   $0x0,-0x64(%rbp)
je     12d5 <bitmap_decompress2+0x1d5>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12ed <bitmap_decompress2+0x1ed>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    130a <bitmap_decompress2+0x20a>
cmpl   $0x0,-0x64(%rbp)
je     1305 <bitmap_decompress2+0x205>
mov    -0x5c(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x5c(%rbp)
jmp    130a <bitmap_decompress2+0x20a>
jmp    130f <bitmap_decompress2+0x20f>
mov    -0x58(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0xa,%rax
ja     1423 <bitmap_decompress2+0x323>
mov    -0x88(%rbp),%rax
lea    0xccf(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x6c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    1364 <bitmap_decompress2+0x264>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    135d <bitmap_decompress2+0x25d>
cmpq   $0x0,-0x30(%rbp)
je     1364 <bitmap_decompress2+0x264>
movl   $0x1,-0x70(%rbp)
jmp    1423 <bitmap_decompress2+0x323>
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,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x43(%rbp)
jmp    1423 <bitmap_decompress2+0x323>
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    -0x58(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x58(%rbp)
jmp    1423 <bitmap_decompress2+0x323>
movl   $0x3,-0x54(%rbp)
movl   $0x2,-0x58(%rbp)
movl   $0x3,-0x78(%rbp)
jmp    1423 <bitmap_decompress2+0x323>
movl   $0x5,-0x54(%rbp)
movl   $0x2,-0x58(%rbp)
movl   $0x5,-0x78(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jle    1d78 <bitmap_decompress2+0xc78>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     148e <bitmap_decompress2+0x38e>
cmpl   $0x0,-0x18(%rbp)
jg     145c <bitmap_decompress2+0x35c>
movl   $0x0,-0x4(%rbp)
jmp    1d84 <bitmap_decompress2+0xc84>
movl   $0x0,-0x68(%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
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0xe,%rax
ja     1d67 <bitmap_decompress2+0xc67>
mov    -0x90(%rbp),%rax
lea    0xb7c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,-0x70(%rbp)
je     1576 <bitmap_decompress2+0x476>
cmpq   $0x0,-0x30(%rbp)
jne    14ff <bitmap_decompress2+0x3ff>
mov    -0x46(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x45(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    155d <bitmap_decompress2+0x45d>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x46(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x45(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    15fe <bitmap_decompress2+0x4fe>
jmp    1586 <bitmap_decompress2+0x486>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x91(%rbp)
jle    15a7 <bitmap_decompress2+0x4a7>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    15ba <bitmap_decompress2+0x4ba>
jmp    15f9 <bitmap_decompress2+0x4f9>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1586 <bitmap_decompress2+0x486>
jmp    169f <bitmap_decompress2+0x59f>
jmp    1603 <bitmap_decompress2+0x503>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x92(%rbp)
jle    1624 <bitmap_decompress2+0x524>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x92(%rbp)
mov    -0x92(%rbp),%al
test   $0x1,%al
jne    1637 <bitmap_decompress2+0x537>
jmp    169a <bitmap_decompress2+0x59a>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1603 <bitmap_decompress2+0x503>
jmp    169f <bitmap_decompress2+0x59f>
jmp    1d73 <bitmap_decompress2+0xc73>
cmpq   $0x0,-0x30(%rbp)
jne    1730 <bitmap_decompress2+0x630>
jmp    16b4 <bitmap_decompress2+0x5b4>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x93(%rbp)
jle    16d5 <bitmap_decompress2+0x5d5>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x93(%rbp)
mov    -0x93(%rbp),%al
test   $0x1,%al
jne    16e8 <bitmap_decompress2+0x5e8>
jmp    172b <bitmap_decompress2+0x62b>
mov    -0x46(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x45(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16b4 <bitmap_decompress2+0x5b4>
jmp    17e3 <bitmap_decompress2+0x6e3>
jmp    1735 <bitmap_decompress2+0x635>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x94(%rbp)
jle    1756 <bitmap_decompress2+0x656>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x94(%rbp)
mov    -0x94(%rbp),%al
test   $0x1,%al
jne    1769 <bitmap_decompress2+0x669>
jmp    17de <bitmap_decompress2+0x6de>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x46(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x45(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1735 <bitmap_decompress2+0x635>
jmp    17e3 <bitmap_decompress2+0x6e3>
jmp    1d73 <bitmap_decompress2+0xc73>
cmpq   $0x0,-0x30(%rbp)
jne    190a <bitmap_decompress2+0x80a>
jmp    17f8 <bitmap_decompress2+0x6f8>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x95(%rbp)
jle    1819 <bitmap_decompress2+0x719>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x95(%rbp)
mov    -0x95(%rbp),%al
test   $0x1,%al
jne    182c <bitmap_decompress2+0x72c>
jmp    1905 <bitmap_decompress2+0x805>
mov    -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
and    $0xff,%eax
cmp    $0x0,%eax
jne    1886 <bitmap_decompress2+0x786>
cmpl   $0x0,-0x78(%rbp)
je     185e <bitmap_decompress2+0x75e>
mov    -0x78(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1876 <bitmap_decompress2+0x776>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x54(%rbp),%eax
and    -0x50(%rbp),%eax
cmp    $0x0,%eax
je     18c6 <bitmap_decompress2+0x7c6>
mov    -0x46(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x45(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    18ee <bitmap_decompress2+0x7ee>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    17f8 <bitmap_decompress2+0x6f8>
jmp    1a77 <bitmap_decompress2+0x977>
jmp    190f <bitmap_decompress2+0x80f>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x9d(%rbp)
jle    1930 <bitmap_decompress2+0x830>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x9d(%rbp)
mov    -0x9d(%rbp),%al
test   $0x1,%al
jne    1943 <bitmap_decompress2+0x843>
jmp    1a72 <bitmap_decompress2+0x972>
mov    -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
and    $0xff,%eax
cmp    $0x0,%eax
jne    199d <bitmap_decompress2+0x89d>
cmpl   $0x0,-0x78(%rbp)
je     1975 <bitmap_decompress2+0x875>
mov    -0x78(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    198d <bitmap_decompress2+0x88d>
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,-0x54(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x54(%rbp),%eax
and    -0x50(%rbp),%eax
cmp    $0x0,%eax
je     1a0f <bitmap_decompress2+0x90f>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x46(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x45(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1a5b <bitmap_decompress2+0x95b>
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    190f <bitmap_decompress2+0x80f>
jmp    1a77 <bitmap_decompress2+0x977>
jmp    1d73 <bitmap_decompress2+0xc73>
jmp    1a81 <bitmap_decompress2+0x981>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0xa5(%rbp)
jle    1aa2 <bitmap_decompress2+0x9a2>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    1ab5 <bitmap_decompress2+0x9b5>
jmp    1af8 <bitmap_decompress2+0x9f8>
mov    -0x44(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x43(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a81 <bitmap_decompress2+0x981>
jmp    1d73 <bitmap_decompress2+0xc73>
jmp    1b02 <bitmap_decompress2+0xa02>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0xa6(%rbp)
jle    1b23 <bitmap_decompress2+0xa23>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa6(%rbp)
mov    -0xa6(%rbp),%al
test   $0x1,%al
jne    1b36 <bitmap_decompress2+0xa36>
jmp    1b95 <bitmap_decompress2+0xa95>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%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
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b02 <bitmap_decompress2+0xa02>
jmp    1d73 <bitmap_decompress2+0xc73>
jmp    1b9f <bitmap_decompress2+0xa9f>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0xa7(%rbp)
jle    1bc0 <bitmap_decompress2+0xac0>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa7(%rbp)
mov    -0xa7(%rbp),%al
test   $0x1,%al
jne    1bd3 <bitmap_decompress2+0xad3>
jmp    1c68 <bitmap_decompress2+0xb68>
cmpl   $0x0,-0x74(%rbp)
je     1c15 <bitmap_decompress2+0xb15>
mov    -0x44(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x43(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x74(%rbp)
jmp    1c51 <bitmap_decompress2+0xb51>
mov    -0x42(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x41(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x74(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b9f <bitmap_decompress2+0xa9f>
jmp    1d73 <bitmap_decompress2+0xc73>
jmp    1c72 <bitmap_decompress2+0xb72>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0xa8(%rbp)
jle    1c93 <bitmap_decompress2+0xb93>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa8(%rbp)
mov    -0xa8(%rbp),%al
test   $0x1,%al
jne    1ca6 <bitmap_decompress2+0xba6>
jmp    1ce5 <bitmap_decompress2+0xbe5>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1c72 <bitmap_decompress2+0xb72>
jmp    1d73 <bitmap_decompress2+0xc73>
jmp    1cef <bitmap_decompress2+0xbef>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0xa9(%rbp)
jle    1d10 <bitmap_decompress2+0xc10>
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    1d23 <bitmap_decompress2+0xc23>
jmp    1d62 <bitmap_decompress2+0xc62>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1cef <bitmap_decompress2+0xbef>
jmp    1d73 <bitmap_decompress2+0xc73>
movl   $0x0,-0x4(%rbp)
jmp    1d84 <bitmap_decompress2+0xc84>
jmp    1430 <bitmap_decompress2+0x330>
jmp    117a <bitmap_decompress2+0x7a>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitmap_decompress2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdi,0xb8(%rsp)
test   %r8d,%r8d
jle    25ed <bitmap_decompress2+0x14dd>
mov    %edx,0x64(%rsp)
movslq %r8d,%rax
add    %rcx,%rax
mov    %rax,0xb0(%rsp)
lea    (%rsi,%rsi,1),%eax
mov    %eax,0x7c(%rsp)
lea    -0x1(%rsi),%eax
mov    %eax,0x60(%rsp)
movslq %esi,%r15
pxor   %xmm0,%xmm0
movdqa %xmm0,0xc0(%rsp)
pcmpeqd %xmm0,%xmm0
movdqa %xmm0,0xd0(%rsp)
mov    $0xffffffff,%edx
xor    %edi,%edi
movl   $0x0,0x4c(%rsp)
mov    %esi,%ebp
xor    %r9d,%r9d
xor    %eax,%eax
mov    %rax,0x88(%rsp)
xor    %eax,%eax
mov    %rax,0x80(%rsp)
mov    %rsi,%rbx
xor    %r14d,%r14d
xor    %r11d,%r11d
mov    %rsi,0x40(%rsp)
jmp    11c6 <bitmap_decompress2+0xb6>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rdx
mov    %r10,%rcx
cmp    0xb0(%rsp),%r10
jae    25ed <bitmap_decompress2+0x14dd>
mov    %edx,%r13d
lea    0x1(%rcx),%r10
movzbl (%rcx),%edx
mov    %edx,%eax
shr    $0x4,%eax
lea    -0xc(%rax),%esi
cmp    $0x3,%esi
jae    1210 <bitmap_decompress2+0x100>
add    $0xfffffffa,%eax
mov    $0x10,%esi
mov    $0xf,%r12d
and    %edx,%r12d
je     1245 <bitmap_decompress2+0x135>
mov    %rax,%rdx
cmp    $0x7,%edx
je     1201 <bitmap_decompress2+0xf1>
cmp    $0x2,%edx
jne    1290 <bitmap_decompress2+0x180>
shl    $0x3,%r12d
jmp    1290 <bitmap_decompress2+0x180>
nopw   0x0(%rax,%rax,1)
cmp    $0xf,%eax
jne    1230 <bitmap_decompress2+0x120>
and    $0xf,%edx
cmp    $0x8,%edx
ja     1264 <bitmap_decompress2+0x154>
movzwl 0x1(%rcx),%r12d
add    $0x3,%rcx
mov    %rcx,%r10
jmp    1290 <bitmap_decompress2+0x180>
nopl   0x0(%rax,%rax,1)
mov    %edx,%eax
shr    $0x5,%eax
mov    $0x20,%esi
mov    $0x1f,%r12d
and    %edx,%r12d
jne    11f0 <bitmap_decompress2+0xe0>
mov    %rax,%rdx
cmp    $0x7,%edx
je     1252 <bitmap_decompress2+0x142>
cmp    $0x2,%edx
jne    1278 <bitmap_decompress2+0x168>
movzbl 0x1(%rcx),%r12d
add    $0x2,%rcx
add    $0x1,%r12d
mov    %rcx,%r10
jmp    1290 <bitmap_decompress2+0x180>
cmp    $0xb,%edx
mov    $0x1,%r12d
mov    $0x8,%ecx
cmovb  %ecx,%r12d
jmp    1290 <bitmap_decompress2+0x180>
movzbl 0x1(%rcx),%edx
add    $0x2,%rcx
add    %edx,%esi
mov    %rax,%rdx
mov    %rcx,%r10
mov    %esi,%r12d
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x3c(%rsp)
cmp    $0xa,%edx
mov    %rdx,0x30(%rsp)
ja     133d <bitmap_decompress2+0x22d>
mov    %edx,%ecx
lea    0x1d51(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
movl   $0x0,0x38(%rsp)
jmp    *%rcx
movzwl (%r10),%eax
add    $0x2,%r10
movd   %eax,%xmm0
movdqa %xmm0,0xd0(%rsp)
mov    0x30(%rsp),%rax
add    $0xfffffffb,%eax
jmp    12fe <bitmap_decompress2+0x1ee>
test   %r13d,%r13d
jne    12fc <bitmap_decompress2+0x1ec>
test   %r11,%r11
mov    0x4c(%rsp),%eax
mov    $0x1,%ecx
cmovne %ecx,%eax
cmp    %ebx,%ebp
cmovne %ecx,%eax
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
jmp    1335 <bitmap_decompress2+0x225>
mov    (%r10),%al
mov    %rax,0x88(%rsp)
mov    0x1(%r10),%al
mov    %rax,0x80(%rsp)
add    $0x2,%r10
movzwl (%r10),%eax
add    $0x2,%r10
movd   %eax,%xmm0
movdqa %xmm0,0xc0(%rsp)
movl   $0x0,0x3c(%rsp)
movl   $0x0,0x38(%rsp)
test   %r12d,%r12d
jle    11b0 <bitmap_decompress2+0xa0>
movdqa 0xc0(%rsp),%xmm0
movdqa %xmm0,0xe0(%rsp)
mov    0xe0(%rsp),%r8b
mov    0xe1(%rsp),%al
mov    %al,0xb(%rsp)
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm1
pshuflw $0x55,%xmm0,%xmm0
punpcklbw %xmm0,%xmm1
movdqa 0xd0(%rsp),%xmm0
movdqa %xmm0,0xf0(%rsp)
mov    0xf0(%rsp),%al
mov    %al,0xa(%rsp)
mov    0xf1(%rsp),%al
mov    %al,0x9(%rsp)
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm2
pshuflw $0x55,%xmm0,%xmm0
punpcklbw %xmm0,%xmm2
xor    %r13d,%r13d
mov    0x30(%rsp),%rdx
mov    %r8b,0x8(%rsp)
movdqa %xmm1,0xa0(%rsp)
movdqa %xmm2,0x90(%rsp)
jmp    1409 <bitmap_decompress2+0x2f9>
mov    0x40(%rsp),%rbx
mov    0x20(%rsp),%r11
mov    0x30(%rsp),%rdx
mov    0x8(%rsp),%r8b
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r12d,%r12d
jle    11b5 <bitmap_decompress2+0xa5>
cmp    %ebx,%ebp
jl     1437 <bitmap_decompress2+0x327>
mov    0x64(%rsp),%ecx
test   %ecx,%ecx
jle    25e9 <bitmap_decompress2+0x14d9>
add    $0xffffffff,%ecx
mov    0x7c(%rsp),%eax
mov    %ecx,0x64(%rsp)
imul   %ecx,%eax
mov    %r14,%r11
movslq %eax,%r14
add    0xb8(%rsp),%r14
xor    %ebp,%ebp
xor    %eax,%eax
cmp    $0xe,%edx
ja     25f2 <bitmap_decompress2+0x14e2>
mov    %edx,%ecx
lea    0x1be1(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
mov    %rdi,0x18(%rsp)
mov    %r11,0x20(%rsp)
jmp    *%rcx
cmpl   $0x0,0x4c(%rsp)
je     1b31 <bitmap_decompress2+0xa21>
movslq %ebp,%rax
add    %rax,%rax
test   %r11,%r11
je     1b15 <bitmap_decompress2+0xa05>
mov    (%r11,%rax,1),%cl
xor    0xa(%rsp),%cl
mov    %cl,(%r14,%rax,1)
cltq
or     $0x1,%rax
mov    (%r11,%rax,1),%cl
xor    0x9(%rsp),%cl
jmp    1b26 <bitmap_decompress2+0xa16>
test   %r11,%r11
je     1804 <bitmap_decompress2+0x6f4>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
mov    %r9d,0xc(%rsp)
movslq %ebp,%rax
lea    -0x1(%r12),%edi
mov    %rax,%rsi
not    %rsi
add    %r15,%rsi
cmp    %rdi,%rsi
mov    %rdi,%r9
cmovb  %rsi,%r9
add    $0x1,%r9
test   %edi,%edi
mov    $0x1,%ecx
cmove  %rcx,%r9
cmp    $0x8,%r9
jae    1c3a <bitmap_decompress2+0xb2a>
mov    0x18(%rsp),%rdi
jmp    24a5 <bitmap_decompress2+0x1395>
test   %r11,%r11
je     184f <bitmap_decompress2+0x73f>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
movslq %ebp,%rax
lea    0x0(%rbp,%rbp,1),%ecx
add    $0x1,%rax
nopw   0x0(%rax,%rax,1)
test   $0x7f,%r13b
lea    0x0(%r13,%r13,1),%edx
mov    %edx,%r13d
mov    $0x1,%edx
cmove  %edx,%r13d
setne  %dl
cmove  0x38(%rsp),%r9d
or     0x3c(%rsp),%dl
je     1540 <bitmap_decompress2+0x430>
mov    %r10,%r8
jmp    1551 <bitmap_decompress2+0x441>
nopl   0x0(%rax)
movzbl (%r10),%r9d
add    $0x1,%r10
mov    %r10,%r8
mov    $0x1,%r13d
movslq %ecx,%rdx
movzbl (%r11,%rdx,1),%ebx
mov    %r9d,%r10d
test   %r13d,%r9d
je     1580 <bitmap_decompress2+0x470>
xor    0xa(%rsp),%bl
mov    %bl,(%r14,%rdx,1)
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%r11,%rdx,1),%ebx
xor    0x9(%rsp),%bl
jmp    158f <bitmap_decompress2+0x47f>
nopw   0x0(%rax,%rax,1)
mov    %bl,(%r14,%rdx,1)
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%r11,%rdx,1),%ebx
mov    %bl,(%r14,%rdx,1)
lea    -0x1(%r12),%edx
add    $0x1,%ebp
cmp    $0x1,%r12d
je     1ebd <bitmap_decompress2+0xdad>
add    $0x2,%ecx
lea    0x1(%rax),%rsi
mov    %edx,%r12d
cmp    %r15,%rax
mov    %rsi,%rax
mov    %r10d,%r9d
mov    0x20(%rsp),%r11
mov    %r8,%r10
jl     1510 <bitmap_decompress2+0x400>
mov    %edx,%r12d
mov    0x30(%rsp),%rdx
jmp    1ed0 <bitmap_decompress2+0xdc0>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
mov    %r10,0x10(%rsp)
movslq %ebp,%rax
lea    -0x1(%r12),%esi
mov    %rax,%rdx
not    %rdx
add    %r15,%rdx
cmp    %rsi,%rdx
mov    %rsi,%r10
cmovb  %rdx,%r10
add    $0x1,%r10
test   %esi,%esi
mov    $0x1,%ecx
cmove  %rcx,%r10
cmp    $0x10,%r10
jae    1903 <bitmap_decompress2+0x7f3>
mov    0x10(%rsp),%r10
jmp    2159 <bitmap_decompress2+0x1049>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
mov    %r9d,0xc(%rsp)
movslq %ebp,%rax
lea    -0x1(%r12),%edi
mov    %rax,%rsi
not    %rsi
add    %r15,%rsi
cmp    %rdi,%rsi
mov    %rdi,%r11
cmovb  %rsi,%r11
add    $0x1,%r11
test   %edi,%edi
mov    $0x1,%ecx
cmove  %rcx,%r11
cmp    $0x8,%r11
jae    1a4c <bitmap_decompress2+0x93c>
mov    0x20(%rsp),%r11
jmp    23a1 <bitmap_decompress2+0x1291>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
movslq %ebp,%rax
lea    0x0(%rbp,%rbp,1),%ecx
add    $0x1,%rax
nopl   0x0(%rax)
movslq %ecx,%rdx
test   %edi,%edi
jne    16b0 <bitmap_decompress2+0x5a0>
mov    0x88(%rsp),%rsi
mov    %sil,(%r14,%rdx,1)
lea    0x1(%rcx),%edx
movslq %edx,%rdx
mov    0x80(%rsp),%rsi
mov    %sil,(%r14,%rdx,1)
add    $0x1,%r12d
mov    $0x1,%edi
jmp    16c5 <bitmap_decompress2+0x5b5>
mov    %r8b,(%r14,%rdx,1)
add    $0x1,%edx
movslq %edx,%rdx
movzbl 0xb(%rsp),%ebx
mov    %bl,(%r14,%rdx,1)
xor    %edi,%edi
add    $0x1,%ebp
add    $0xffffffff,%r12d
je     255a <bitmap_decompress2+0x144a>
add    $0x2,%ecx
lea    0x1(%rax),%rdx
cmp    %r15,%rax
mov    %rdx,%rax
jl     1680 <bitmap_decompress2+0x570>
jmp    255a <bitmap_decompress2+0x144a>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
lea    0x0(%rbp,%rbp,1),%eax
movslq %eax,%rdi
add    %r14,%rdi
lea    -0x1(%r12),%eax
mov    0x60(%rsp),%ecx
sub    %ebp,%ecx
cmp    %eax,%ecx
cmovae %eax,%ecx
test   %eax,%eax
cmove  %eax,%ecx
lea    0x2(%rcx,%rcx,1),%rdx
mov    $0xff,%esi
mov    %r9d,0xc(%rsp)
mov    %r10,0x10(%rsp)
call   1030 <memset@plt>
movdqa 0x90(%rsp),%xmm2
movdqa 0xa0(%rsp),%xmm1
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
movslq %ebp,%rax
add    $0x1,%rax
xchg   %ax,%ax
mov    %r12d,%ecx
lea    -0x1(%rcx),%r12d
add    $0x1,%ebp
cmp    $0x1,%ecx
je     13e0 <bitmap_decompress2+0x2d0>
lea    0x1(%rax),%rcx
cmp    %r15,%rax
mov    %rcx,%rax
jl     1750 <bitmap_decompress2+0x640>
jmp    13e0 <bitmap_decompress2+0x2d0>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
lea    0x0(%rbp,%rbp,1),%eax
movslq %eax,%rdi
add    %r14,%rdi
lea    -0x1(%r12),%eax
mov    0x60(%rsp),%ecx
sub    %ebp,%ecx
cmp    %eax,%ecx
cmovae %eax,%ecx
test   %eax,%eax
cmove  %eax,%ecx
lea    (%rcx,%rcx,1),%rdx
add    $0x2,%rdx
xor    %esi,%esi
mov    %r9d,0xc(%rsp)
mov    %r10,0x10(%rsp)
call   1030 <memset@plt>
movdqa 0x90(%rsp),%xmm2
movdqa 0xa0(%rsp),%xmm1
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
movslq %ebp,%rax
add    $0x1,%rax
nopl   0x0(%rax)
mov    %r12d,%ecx
lea    -0x1(%rcx),%r12d
add    $0x1,%ebp
cmp    $0x1,%ecx
je     13e0 <bitmap_decompress2+0x2d0>
lea    0x1(%rax),%rcx
cmp    %r15,%rax
mov    %rcx,%rax
jl     17e0 <bitmap_decompress2+0x6d0>
jmp    13e0 <bitmap_decompress2+0x2d0>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
mov    %r10,0x10(%rsp)
movslq %ebp,%rax
lea    -0x1(%r12),%esi
mov    %rax,%rdx
not    %rdx
add    %r15,%rdx
cmp    %rsi,%rdx
mov    %rsi,%r10
cmovb  %rdx,%r10
add    $0x1,%r10
test   %esi,%esi
mov    $0x1,%ecx
cmove  %rcx,%r10
cmp    $0x10,%r10
jae    2192 <bitmap_decompress2+0x1082>
mov    0x10(%rsp),%r10
jmp    2439 <bitmap_decompress2+0x1329>
cmp    %ebx,%ebp
jge    1400 <bitmap_decompress2+0x2f0>
movslq %ebp,%rax
lea    0x0(%rbp,%rbp,1),%ecx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   $0x7f,%r13b
lea    0x0(%r13,%r13,1),%edx
mov    %edx,%r13d
mov    $0x1,%edx
cmove  %edx,%r13d
setne  %dl
cmove  0x38(%rsp),%r9d
or     0x3c(%rsp),%dl
jne    18a2 <bitmap_decompress2+0x792>
movzbl (%r10),%r9d
add    $0x1,%r10
mov    $0x1,%r13d
mov    %r9d,%edx
and    %r13d,%edx
movzbl 0xa(%rsp),%esi
cmove  %edx,%esi
movzbl 0x9(%rsp),%edi
cmove  %edx,%edi
movslq %ecx,%rdx
mov    %sil,(%r14,%rdx,1)
add    $0x1,%edx
movslq %edx,%rdx
mov    %dil,(%r14,%rdx,1)
lea    -0x1(%r12),%edx
add    $0x1,%ebp
cmp    $0x1,%r12d
je     22e1 <bitmap_decompress2+0x11d1>
add    $0x2,%ecx
lea    0x1(%rax),%rsi
mov    %edx,%r12d
cmp    %r15,%rax
mov    %rsi,%rax
mov    0x18(%rsp),%rdi
jl     1870 <bitmap_decompress2+0x760>
mov    %edx,%r12d
mov    0x30(%rsp),%rdx
jmp    1400 <bitmap_decompress2+0x2f0>
mov    %r9d,0xc(%rsp)
cmp    %rsi,%rdx
cmovae %rsi,%rdx
test   %esi,%esi
mov    $0x0,%edi
cmovne %rdx,%rdi
lea    0x0(%rbp,%rbp,1),%edx
mov    %edi,%esi
add    %esi,%esi
setb   %r8b
lea    (%rsi,%rbp,2),%ebx
cmp    %edx,%ebx
jl     2145 <bitmap_decompress2+0x1035>
test   %r8b,%r8b
jne    2145 <bitmap_decompress2+0x1035>
lea    0x1(%rbp,%rbp,1),%ebx
lea    (%rsi,%rbp,2),%esi
add    $0x1,%esi
cmp    %ebx,%esi
jl     2145 <bitmap_decompress2+0x1035>
test   %r8b,%r8b
jne    2145 <bitmap_decompress2+0x1035>
movslq %edx,%r8
lea    (%r14,%r8,1),%rsi
lea    (%rsi,%rdi,2),%rbx
cmp    %rsi,%rbx
jb     2145 <bitmap_decompress2+0x1035>
lea    (%r14,%r8,1),%rbx
add    $0x1,%rbx
lea    (%rsi,%rdi,2),%rsi
add    $0x1,%rsi
cmp    %rbx,%rsi
jb     2145 <bitmap_decompress2+0x1035>
movabs $0x1fffffff8,%rcx
lea    -0x8(%rcx),%r8
and    %r10,%r8
lea    -0x10(%r8),%rsi
mov    %rsi,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2414 <bitmap_decompress2+0x1304>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
add    $0x31,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    -0x30(%rdx),%ebx
lea    -0x20(%rdx),%ecx
movslq %ebx,%rbx
movslq %ecx,%rcx
movdqu %xmm1,-0x1(%r14,%rbx,1)
movdqu %xmm1,-0x1(%r14,%rcx,1)
lea    -0x10(%rdx),%ecx
movslq %ecx,%rcx
movslq %edx,%rdx
movdqu %xmm1,-0x1(%r14,%rcx,1)
movdqu %xmm1,-0x1(%r14,%rdx,1)
add    $0x20,%rsi
add    $0x40,%edx
add    $0xfffffffffffffffe,%rdi
jne    19c0 <bitmap_decompress2+0x8b0>
test   $0x1,%r9b
je     1a20 <bitmap_decompress2+0x910>
add    %esi,%ebp
mov    %ebp,%ecx
add    %ebp,%ecx
lea    0x10(%rbp,%rbp,1),%edx
movslq %ecx,%rcx
movslq %edx,%rdx
movdqu %xmm1,(%r14,%rcx,1)
movdqu %xmm1,(%r14,%rdx,1)
add    %r8,%rax
sub    %r8d,%r12d
cmp    %r8,%r10
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
mov    0xb(%rsp),%bl
jne    215d <bitmap_decompress2+0x104d>
jmp    2479 <bitmap_decompress2+0x1369>
cmp    %rdi,%rsi
mov    %rdi,%rcx
cmovb  %rsi,%rcx
test   %edi,%edi
mov    $0x0,%r8d
cmovne %rcx,%r8
lea    0x0(%rbp,%rbp,1),%edx
mov    %r8d,%ecx
add    %ecx,%ecx
setb   %r9b
lea    (%rcx,%rbp,2),%ebx
cmp    %edx,%ebx
jl     1b06 <bitmap_decompress2+0x9f6>
test   %r9b,%r9b
jne    1b06 <bitmap_decompress2+0x9f6>
lea    0x1(%rbp,%rbp,1),%ebx
lea    (%rcx,%rbp,2),%ecx
add    $0x1,%ecx
cmp    %ebx,%ecx
jl     1b06 <bitmap_decompress2+0x9f6>
test   %r9b,%r9b
jne    1b06 <bitmap_decompress2+0x9f6>
mov    %r10,0x10(%rsp)
movslq %edx,%r10
lea    (%r14,%r10,1),%r9
lea    (%r9,%r8,2),%rcx
cmp    %r9,%rcx
jb     22f3 <bitmap_decompress2+0x11e3>
lea    (%r14,%r10,1),%rcx
add    $0x1,%rcx
lea    (%r9,%r8,2),%rbx
add    $0x1,%rbx
cmp    %rcx,%rbx
jb     22f3 <bitmap_decompress2+0x11e3>
cmp    %rdi,%rsi
cmovae %rdi,%rsi
add    %rsi,%rsi
test   %edi,%edi
mov    $0x0,%ecx
cmovne %rsi,%rcx
add    %rcx,%r10
lea    (%r14,%r10,1),%rsi
add    $0x2,%rsi
mov    0x10(%rsp),%r10
cmp    %rsi,%r10
jae    2307 <bitmap_decompress2+0x11f7>
add    %r10,%rcx
add    $0x2,%rcx
cmp    %rcx,%r9
jae    2307 <bitmap_decompress2+0x11f7>
mov    0x20(%rsp),%r11
mov    0x8(%rsp),%r8b
jmp    23a1 <bitmap_decompress2+0x1291>
mov    0xa(%rsp),%cl
mov    %cl,(%r14,%rax,1)
or     $0x1,%eax
cltq
mov    0x9(%rsp),%cl
mov    %cl,(%r14,%rax,1)
add    $0xffffffff,%r12d
add    $0x1,%ebp
test   %r12d,%r12d
setne  %cl
cmp    %ebx,%ebp
setl   %al
and    %cl,%al
test   %r11,%r11
je     1b96 <bitmap_decompress2+0xa86>
movl   $0x0,0x4c(%rsp)
test   %al,%al
je     1400 <bitmap_decompress2+0x2f0>
mov    %r9d,0xc(%rsp)
movslq %ebp,%rax
lea    -0x1(%r12),%edi
mov    %rax,%rsi
not    %rsi
add    %r15,%rsi
cmp    %rdi,%rsi
mov    %rdi,%r9
cmovb  %rsi,%r9
add    $0x1,%r9
test   %edi,%edi
mov    $0x1,%ecx
cmove  %rcx,%r9
cmp    $0x8,%r9
jae    1eda <bitmap_decompress2+0xdca>
mov    0x18(%rsp),%rdi
jmp    2516 <bitmap_decompress2+0x1406>
movl   $0x0,0x4c(%rsp)
test   %al,%al
je     1400 <bitmap_decompress2+0x2f0>
lea    0x0(%rbp,%rbp,1),%eax
movslq %eax,%rdi
add    %r14,%rdi
lea    -0x1(%r12),%eax
mov    0x60(%rsp),%ecx
sub    %ebp,%ecx
cmp    %eax,%ecx
cmovae %eax,%ecx
test   %eax,%eax
cmove  %eax,%ecx
lea    (%rcx,%rcx,1),%rdx
add    $0x2,%rdx
xor    %esi,%esi
mov    %r9d,0xc(%rsp)
mov    %r10,0x10(%rsp)
call   1030 <memset@plt>
movdqa 0x90(%rsp),%xmm2
movdqa 0xa0(%rsp),%xmm1
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%rdx
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8b
mov    0xc(%rsp),%r9d
movslq %ebp,%rax
add    $0x1,%rax
mov    %r12d,%ecx
lea    -0x1(%rcx),%r12d
add    $0x1,%ebp
cmp    $0x1,%ecx
je     1c2b <bitmap_decompress2+0xb1b>
lea    0x1(%rax),%rcx
cmp    %r15,%rax
mov    %rcx,%rax
jl     1c10 <bitmap_decompress2+0xb00>
mov    0x40(%rsp),%rbx
mov    0x20(%rsp),%r11
jmp    1400 <bitmap_decompress2+0x2f0>
mov    %r10,0x10(%rsp)
cmp    %rdi,%rsi
mov    %rdi,%rcx
cmovb  %rsi,%rcx
test   %edi,%edi
mov    $0x0,%r10d
cmovne %rcx,%r10
lea    0x0(%rbp,%rbp,1),%edx
mov    %r10d,%ecx
add    %ecx,%ecx
setb   %r8b
lea    (%rcx,%rbp,2),%ebx
cmp    %edx,%ebx
jl     2400 <bitmap_decompress2+0x12f0>
test   %r8b,%r8b
jne    2400 <bitmap_decompress2+0x12f0>
lea    0x1(%rbp,%rbp,1),%ebx
lea    (%rcx,%rbp,2),%ecx
add    $0x1,%ecx
cmp    %ebx,%ecx
jl     2400 <bitmap_decompress2+0x12f0>
test   %r8b,%r8b
jne    2400 <bitmap_decompress2+0x12f0>
movslq %edx,%rcx
lea    (%r11,%rcx,1),%r8
add    %rcx,%r11
add    $0x1,%r11
lea    (%r8,%r10,2),%rbx
add    $0x1,%rbx
cmp    %r11,%rbx
jb     2491 <bitmap_decompress2+0x1381>
lea    (%r14,%rcx,1),%rbx
lea    (%r14,%rcx,1),%r11
add    $0x1,%r11
lea    (%rbx,%r10,2),%rcx
add    $0x1,%rcx
cmp    %r11,%rcx
jb     2491 <bitmap_decompress2+0x1381>
lea    (%rbx,%r10,2),%rcx
cmp    %rbx,%rcx
mov    0x20(%rsp),%r11
jb     2400 <bitmap_decompress2+0x12f0>
lea    (%r8,%r10,2),%rcx
cmp    %r8,%rcx
jb     2400 <bitmap_decompress2+0x12f0>
lea    0x0(%rbp,%rbp,1),%ecx
movslq %ecx,%rcx
lea    (%r14,%rcx,1),%rbx
mov    %rbx,0x50(%rsp)
cmp    %rdi,%rsi
cmovae %rdi,%rsi
add    %rsi,%rsi
test   %edi,%edi
mov    $0x0,%edi
cmovne %rsi,%rdi
add    %rcx,%rdi
lea    (%r14,%rdi,1),%rsi
add    $0x1,%rsi
lea    0x1(%r14,%rcx,1),%rbx
lea    0x2(%r14,%rdi,1),%r10
lea    (%r11,%rcx,1),%r8
mov    %r8,0x58(%rsp)
lea    0x1(%r11,%rdi,1),%r8
lea    0x1(%r11,%rcx,1),%rcx
mov    %rcx,0x70(%rsp)
add    %rdi,%r11
add    $0x2,%r11
mov    %r11,0x68(%rsp)
mov    0x50(%rsp),%rcx
cmp    %r10,%rcx
setb   0x2f(%rsp)
cmp    %rsi,%rbx
setb   0x2e(%rsp)
mov    %r8,%rdi
cmp    %r8,%rcx
mov    %rcx,%r8
setb   0x2d(%rsp)
mov    0x58(%rsp),%rcx
cmp    %rsi,%rcx
setb   0x2c(%rsp)
cmp    %r11,%r8
setb   %r8b
mov    0x70(%rsp),%r11
cmp    %rsi,%r11
setb   0x50(%rsp)
cmp    %rdi,%rbx
setb   %sil
cmp    %r10,%rcx
setb   0x58(%rsp)
cmp    0x68(%rsp),%rbx
setb   %bl
cmp    %r10,%r11
setb   %r11b
mov    0x2e(%rsp),%cl
test   %cl,0x2f(%rsp)
jne    2491 <bitmap_decompress2+0x1381>
mov    0x2c(%rsp),%cl
and    %cl,0x2d(%rsp)
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r10
jne    24fb <bitmap_decompress2+0x13eb>
and    0x50(%rsp),%r8b
jne    24fb <bitmap_decompress2+0x13eb>
and    0x58(%rsp),%sil
jne    24fb <bitmap_decompress2+0x13eb>
and    %r11b,%bl
mov    0x20(%rsp),%r11
jne    24a0 <bitmap_decompress2+0x1390>
mov    %r9,%r8
movabs $0x1fffffff8,%rcx
and    %rcx,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     2581 <bitmap_decompress2+0x1471>
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
movdqu (%r11,%rdx,1),%xmm0
lea    0x1(%rdx),%ebx
movslq %ebx,%rbx
pxor   %xmm2,%xmm0
movdqu %xmm0,-0x1(%r14,%rbx,1)
lea    0x10(%rdx),%ebx
movslq %ebx,%rbx
movdqu (%r11,%rbx,1),%xmm0
lea    0x11(%rdx),%ebx
movslq %ebx,%rbx
pxor   %xmm2,%xmm0
movdqu %xmm0,-0x1(%r14,%rbx,1)
add    $0x10,%rsi
add    $0x20,%edx
add    $0xfffffffffffffffe,%rcx
jne    1e30 <bitmap_decompress2+0xd20>
test   $0x1,%dil
je     1e95 <bitmap_decompress2+0xd85>
add    %esi,%ebp
movslq %ebp,%rcx
movdqu (%r11,%rcx,2),%xmm0
add    %rcx,%rcx
movslq %ecx,%rcx
pxor   %xmm2,%xmm0
movdqu %xmm0,(%r14,%rcx,1)
add    %r8,%rax
sub    %r8d,%r12d
cmp    %r8,%r9
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8b
mov    0xa(%rsp),%r9b
mov    0x9(%rsp),%bpl
je     2553 <bitmap_decompress2+0x1443>
jmp    24af <bitmap_decompress2+0x139f>
mov    %edx,%r12d
mov    %r10d,%r9d
mov    0x20(%rsp),%r11
mov    0x30(%rsp),%rdx
mov    %r8,%r10
mov    0x8(%rsp),%r8b
jmp    255f <bitmap_decompress2+0x144f>
mov    %r10,0x10(%rsp)
cmp    %rdi,%rsi
mov    %rdi,%rcx
cmovb  %rsi,%rcx
test   %edi,%edi
mov    $0x0,%r10d
cmovne %rcx,%r10
lea    0x0(%rbp,%rbp,1),%edx
mov    %r10d,%ecx
add    %ecx,%ecx
setb   %r8b
lea    (%rcx,%rbp,2),%ebx
cmp    %edx,%ebx
jl     240a <bitmap_decompress2+0x12fa>
test   %r8b,%r8b
jne    240a <bitmap_decompress2+0x12fa>
lea    0x1(%rbp,%rbp,1),%ebx
lea    (%rcx,%rbp,2),%ecx
add    $0x1,%ecx
cmp    %ebx,%ecx
jl     240a <bitmap_decompress2+0x12fa>
test   %r8b,%r8b
jne    240a <bitmap_decompress2+0x12fa>
movslq %edx,%rcx
lea    (%r11,%rcx,1),%r8
add    %rcx,%r11
add    $0x1,%r11
lea    (%r8,%r10,2),%rbx
add    $0x1,%rbx
cmp    %r11,%rbx
jb     2502 <bitmap_decompress2+0x13f2>
lea    (%r14,%rcx,1),%rbx
lea    (%r14,%rcx,1),%r11
add    $0x1,%r11
lea    (%rbx,%r10,2),%rcx
add    $0x1,%rcx
cmp    %r11,%rcx
jb     2502 <bitmap_decompress2+0x13f2>
lea    (%rbx,%r10,2),%rcx
cmp    %rbx,%rcx
mov    0x20(%rsp),%r11
jb     240a <bitmap_decompress2+0x12fa>
lea    (%r8,%r10,2),%rcx
cmp    %r8,%rcx
jb     240a <bitmap_decompress2+0x12fa>
lea    0x0(%rbp,%rbp,1),%ecx
movslq %ecx,%rcx
lea    (%r14,%rcx,1),%rbx
mov    %rbx,0x50(%rsp)
cmp    %rdi,%rsi
cmovae %rdi,%rsi
add    %rsi,%rsi
test   %edi,%edi
mov    $0x0,%edi
cmovne %rsi,%rdi
add    %rcx,%rdi
lea    (%r14,%rdi,1),%rsi
add    $0x1,%rsi
lea    0x1(%r14,%rcx,1),%rbx
lea    0x2(%r14,%rdi,1),%r10
lea    (%r11,%rcx,1),%r8
mov    %r8,0x58(%rsp)
lea    0x1(%r11,%rdi,1),%r8
lea    0x1(%r11,%rcx,1),%rcx
mov    %rcx,0x70(%rsp)
add    %rdi,%r11
add    $0x2,%r11
mov    %r11,0x68(%rsp)
mov    0x50(%rsp),%rcx
cmp    %r10,%rcx
setb   0x2f(%rsp)
cmp    %rsi,%rbx
setb   0x2e(%rsp)
mov    %r8,%rdi
cmp    %r8,%rcx
mov    %rcx,%r8
setb   0x2d(%rsp)
mov    0x58(%rsp),%rcx
cmp    %rsi,%rcx
setb   0x2c(%rsp)
cmp    %r11,%r8
setb   %r8b
mov    0x70(%rsp),%r11
cmp    %rsi,%r11
setb   0x50(%rsp)
cmp    %rdi,%rbx
setb   %sil
cmp    %r10,%rcx
setb   0x58(%rsp)
cmp    0x68(%rsp),%rbx
setb   %bl
cmp    %r10,%r11
setb   %r11b
mov    0x2e(%rsp),%cl
test   %cl,0x2f(%rsp)
jne    2502 <bitmap_decompress2+0x13f2>
mov    0x2c(%rsp),%cl
and    %cl,0x2d(%rsp)
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r10
jne    2569 <bitmap_decompress2+0x1459>
and    0x50(%rsp),%r8b
jne    2569 <bitmap_decompress2+0x1459>
and    0x58(%rsp),%sil
jne    2569 <bitmap_decompress2+0x1459>
and    %r11b,%bl
mov    0x20(%rsp),%r11
jne    2511 <bitmap_decompress2+0x1401>
mov    %r9,%r8
movabs $0x1fffffff8,%rcx
and    %rcx,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     2592 <bitmap_decompress2+0x1482>
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
movups (%r11,%rdx,1),%xmm0
lea    0x1(%rdx),%ebx
movslq %ebx,%rbx
movups %xmm0,-0x1(%r14,%rbx,1)
lea    0x10(%rdx),%ebx
movslq %ebx,%rbx
movdqu (%r11,%rbx,1),%xmm0
lea    0x11(%rdx),%ebx
movslq %ebx,%rbx
movdqu %xmm0,-0x1(%r14,%rbx,1)
add    $0x10,%rsi
add    $0x20,%edx
add    $0xfffffffffffffffe,%rcx
jne    20d0 <bitmap_decompress2+0xfc0>
test   $0x1,%dil
je     2127 <bitmap_decompress2+0x1017>
add    %esi,%ebp
movslq %ebp,%rcx
movdqu (%r11,%rcx,2),%xmm0
add    %rcx,%rcx
movslq %ecx,%rcx
movdqu %xmm0,(%r14,%rcx,1)
add    %r8,%rax
sub    %r8d,%r12d
cmp    %r8,%r9
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8b
je     2553 <bitmap_decompress2+0x1443>
jmp    2516 <bitmap_decompress2+0x1406>
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
mov    0xb(%rsp),%bl
lea    (%rax,%rax,1),%ecx
mov    %r12d,%edx
movslq %ecx,%rsi
mov    %r8b,(%r14,%rsi,1)
add    $0x1,%esi
movslq %esi,%rsi
mov    %bl,(%r14,%rsi,1)
lea    -0x1(%rdx),%r12d
add    $0x1,%rax
cmp    $0x1,%edx
je     2479 <bitmap_decompress2+0x1369>
add    $0x2,%ecx
cmp    %r15,%rax
jl     2160 <bitmap_decompress2+0x1050>
jmp    2479 <bitmap_decompress2+0x1369>
mov    %r9d,0xc(%rsp)
cmp    %rsi,%rdx
cmovae %rsi,%rdx
test   %esi,%esi
mov    $0x0,%edi
cmovne %rdx,%rdi
lea    0x0(%rbp,%rbp,1),%edx
mov    %edi,%esi
add    %esi,%esi
setb   %r8b
lea    (%rsi,%rbp,2),%ebx
cmp    %edx,%ebx
jl     2425 <bitmap_decompress2+0x1315>
test   %r8b,%r8b
jne    2425 <bitmap_decompress2+0x1315>
lea    0x1(%rbp,%rbp,1),%ebx
lea    (%rsi,%rbp,2),%esi
add    $0x1,%esi
cmp    %ebx,%esi
jl     2425 <bitmap_decompress2+0x1315>
test   %r8b,%r8b
jne    2425 <bitmap_decompress2+0x1315>
movslq %edx,%r8
lea    (%r14,%r8,1),%rsi
lea    (%rsi,%rdi,2),%rbx
cmp    %rsi,%rbx
jb     2425 <bitmap_decompress2+0x1315>
lea    (%r14,%r8,1),%rbx
add    $0x1,%rbx
lea    (%rsi,%rdi,2),%rsi
add    $0x1,%rsi
cmp    %rbx,%rsi
jb     2425 <bitmap_decompress2+0x1315>
movabs $0x1fffffff8,%rcx
lea    -0x8(%rcx),%r8
and    %r10,%r8
lea    -0x10(%r8),%rsi
mov    %rsi,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2570 <bitmap_decompress2+0x1460>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
add    $0x31,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
lea    -0x30(%rdx),%ebx
lea    -0x20(%rdx),%ecx
movslq %ebx,%rbx
movslq %ecx,%rcx
movdqu %xmm2,-0x1(%r14,%rbx,1)
movdqu %xmm2,-0x1(%r14,%rcx,1)
lea    -0x10(%rdx),%ecx
movslq %ecx,%rcx
movslq %edx,%rdx
movdqu %xmm2,-0x1(%r14,%rcx,1)
movdqu %xmm2,-0x1(%r14,%rdx,1)
add    $0x20,%rsi
add    $0x40,%edx
add    $0xfffffffffffffffe,%rdi
jne    2250 <bitmap_decompress2+0x1140>
test   $0x1,%r9b
je     22b0 <bitmap_decompress2+0x11a0>
add    %esi,%ebp
mov    %ebp,%ecx
add    %ebp,%ecx
lea    0x10(%rbp,%rbp,1),%edx
movslq %ecx,%rcx
movslq %edx,%rdx
movdqu %xmm2,(%r14,%rcx,1)
movdqu %xmm2,(%r14,%rdx,1)
add    %r8,%rax
sub    %r8d,%r12d
cmp    %r8,%r10
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
mov    0xa(%rsp),%bpl
mov    0x9(%rsp),%bl
jne    2442 <bitmap_decompress2+0x1332>
jmp    2479 <bitmap_decompress2+0x1369>
mov    %edx,%r12d
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rdx
jmp    1400 <bitmap_decompress2+0x2f0>
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
jmp    23a1 <bitmap_decompress2+0x1291>
mov    %r11,%r8
movabs $0x1fffffff8,%rcx
and    %rcx,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     2480 <bitmap_decompress2+0x1370>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
add    $0x11,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%r10,%rsi,2),%xmm0
lea    -0x10(%rdx),%ecx
movslq %ecx,%rcx
movups %xmm0,-0x1(%r14,%rcx,1)
movdqu 0x10(%r10,%rsi,2),%xmm0
movslq %edx,%rdx
movdqu %xmm0,-0x1(%r14,%rdx,1)
add    $0x10,%rsi
add    $0x20,%edx
add    $0xfffffffffffffffe,%rdi
jne    2340 <bitmap_decompress2+0x1230>
test   $0x1,%r9b
je     2388 <bitmap_decompress2+0x1278>
add    %esi,%ebp
movdqu (%r10,%rsi,2),%xmm0
add    %ebp,%ebp
movslq %ebp,%rcx
movdqu %xmm0,(%r14,%rcx,1)
add    %r8,%rax
sub    %r8d,%r12d
lea    (%r10,%r8,2),%r10
cmp    %r8,%r11
mov    0x20(%rsp),%r11
mov    0x8(%rsp),%r8b
je     23f4 <bitmap_decompress2+0x12e4>
lea    (%rax,%rax,1),%edx
mov    %r12d,%esi
add    $0xffffffffffffffff,%rsi
xor    %ecx,%ecx
xor    %edi,%edi
nop
movzbl (%r10,%rdi,2),%ebx
movslq %edx,%rbp
mov    %bl,(%r14,%rbp,1)
movzbl 0x1(%r10,%rdi,2),%ebx
add    $0x1,%ebp
movslq %ebp,%rbp
mov    %bl,(%r14,%rbp,1)
lea    0x1(%rdi),%rbx
add    $0xfffffffffffffffe,%rcx
cmp    %edi,%esi
je     23eb <bitmap_decompress2+0x12db>
lea    (%rax,%rdi,1),%rbp
add    $0x1,%rbp
add    $0x2,%edx
mov    %rbx,%rdi
cmp    %r15,%rbp
jl     23b0 <bitmap_decompress2+0x12a0>
add    %rbx,%rax
sub    %ebx,%r12d
sub    %rcx,%r10
mov    %eax,%ebp
mov    0x18(%rsp),%rdi
jmp    2555 <bitmap_decompress2+0x1445>
mov    0x18(%rsp),%rdi
jmp    249b <bitmap_decompress2+0x138b>
mov    0x18(%rsp),%rdi
jmp    250c <bitmap_decompress2+0x13fc>
xor    %esi,%esi
test   $0x1,%r9b
jne    1a04 <bitmap_decompress2+0x8f4>
jmp    1a20 <bitmap_decompress2+0x910>
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%r9d
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
mov    0xa(%rsp),%bpl
mov    0x9(%rsp),%bl
lea    (%rax,%rax,1),%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%edx
movslq %ecx,%rsi
mov    %bpl,(%r14,%rsi,1)
add    $0x1,%esi
movslq %esi,%rsi
mov    %bl,(%r14,%rsi,1)
lea    -0x1(%rdx),%r12d
add    $0x1,%rax
cmp    $0x1,%edx
je     2479 <bitmap_decompress2+0x1369>
add    $0x2,%ecx
cmp    %r15,%rax
jl     2450 <bitmap_decompress2+0x1340>
mov    %eax,%ebp
jmp    255a <bitmap_decompress2+0x144a>
xor    %esi,%esi
test   $0x1,%r9b
jne    2375 <bitmap_decompress2+0x1265>
jmp    2388 <bitmap_decompress2+0x1278>
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
mov    0xa(%rsp),%r9b
mov    0x9(%rsp),%bpl
lea    (%rax,%rax,1),%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%edx
movslq %ecx,%rsi
movzbl (%r11,%rsi,1),%ebx
xor    %r9b,%bl
mov    %bl,(%r14,%rsi,1)
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%r11,%rsi,1),%ebx
xor    %bpl,%bl
mov    %bl,(%r14,%rsi,1)
lea    -0x1(%rdx),%r12d
add    $0x1,%rax
cmp    $0x1,%edx
je     2553 <bitmap_decompress2+0x1443>
add    $0x2,%ecx
cmp    %r15,%rax
jl     24c0 <bitmap_decompress2+0x13b0>
jmp    2553 <bitmap_decompress2+0x1443>
mov    0x20(%rsp),%r11
jmp    24a0 <bitmap_decompress2+0x1390>
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r8b
lea    (%rax,%rax,1),%ecx
nopl   0x0(%rax)
mov    %r12d,%edx
movslq %ecx,%rsi
movzbl (%r11,%rsi,1),%ebx
mov    %bl,(%r14,%rsi,1)
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%r11,%rsi,1),%ebx
mov    %bl,(%r14,%rsi,1)
lea    -0x1(%rdx),%r12d
add    $0x1,%rax
cmp    $0x1,%edx
je     2553 <bitmap_decompress2+0x1443>
add    $0x2,%ecx
cmp    %r15,%rax
jl     2520 <bitmap_decompress2+0x1410>
mov    %eax,%ebp
mov    0xc(%rsp),%r9d
mov    0x30(%rsp),%rdx
mov    0x40(%rsp),%rbx
jmp    1400 <bitmap_decompress2+0x2f0>
mov    0x20(%rsp),%r11
jmp    2511 <bitmap_decompress2+0x1401>
xor    %esi,%esi
test   $0x1,%r9b
jne    2294 <bitmap_decompress2+0x1184>
jmp    22b0 <bitmap_decompress2+0x11a0>
xor    %esi,%esi
test   $0x1,%dil
jne    1e7a <bitmap_decompress2+0xd6a>
jmp    1e95 <bitmap_decompress2+0xd85>
xor    %esi,%esi
test   $0x1,%dil
jne    2110 <bitmap_decompress2+0x1000>
jmp    2127 <bitmap_decompress2+0x1017>
mov    $0x1,%al
mov    %eax,0x3c(%rsp)
mov    $0x2,%eax
mov    %rax,0x30(%rsp)
mov    $0x3,%r9d
movl   $0x3,0x38(%rsp)
jmp    1345 <bitmap_decompress2+0x235>
mov    $0x1,%al
mov    %eax,0x3c(%rsp)
mov    $0x2,%eax
mov    %rax,0x30(%rsp)
mov    $0x5,%r9d
movl   $0x5,0x38(%rsp)
jmp    1345 <bitmap_decompress2+0x235>
xor    %eax,%eax
jmp    25f2 <bitmap_decompress2+0x14e2>
mov    $0x1,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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