int LzmaDecode(unsigned char *buffer, unsigned int bufferSize, int lc, int lp,
               int pb, unsigned char *inStream, unsigned int inSize,
               unsigned char *outStream, unsigned int outSize,
               unsigned int *outSizeProcessed) {
  unsigned int numProbs =
      (((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
           (4 << 6)) +
          (1 << (14 >> 1)) - 14) +
         (1 << 4)) +
        (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) +
       (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) +
      ((unsigned int)768 << (lc + lp));
  unsigned short *p = (unsigned short *)buffer;
  unsigned int i;
  int state = 0;
  unsigned char previousByte = 0;
  unsigned int rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
  unsigned int nowPos = 0;
  unsigned int posStateMask = (1 << pb) - 1;
  unsigned int literalPosMask = (1 << lp) - 1;
  int len = 0;
  unsigned char *Buffer;
  unsigned char *BufferLim;
  unsigned int Range;
  unsigned int Code;
  if (bufferSize < numProbs * sizeof(unsigned short))
    return 2;
  for (i = 0; i < numProbs; i++)
    p[i] = (1 << 11) >> 1;
  Buffer = inStream;
  BufferLim = inStream + inSize;
  Code = 0;
  Range = 0xFFFFFFFF;
  {
    int i;
    for (i = 0; i < 5; i++) {
      {
        if (Buffer == BufferLim)
          return 1;
      };
      Code = (Code << 8) | (*Buffer++);
    }
  };
  *outSizeProcessed = 0;
  while (nowPos < outSize) {
    unsigned short *prob;
    unsigned int bound;
    int posState = (int)((nowPos)&posStateMask);
    prob = p + 0 + (state << 4) + posState;
    if (Range < ((unsigned int)1 << 24)) {
      {
        if (Buffer == BufferLim)
          return 1;
      };
      Range <<= 8;
      Code = (Code << 8) | (*Buffer++);
    };
    bound = (Range >> 11) * *(prob);
    if (Code < bound) {
      int symbol = 1;
      Range = bound;
      *(prob) += ((1 << 11) - *(prob)) >> 5;
      prob =
          p +
          (((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
               (4 << 6)) +
              (1 << (14 >> 1)) - 14) +
             (1 << 4)) +
            (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) +
             (1 << 8))) +
           (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) +
          (768 *
           ((((nowPos)&literalPosMask) << lc) + (previousByte >> (8 - lc))));
      if (state >= 7) {
        int matchByte;
        matchByte = outStream[nowPos - rep0];
        do {
          int bit;
          unsigned short *probLit;
          matchByte <<= 1;
          bit = (matchByte & 0x100);
          probLit = prob + 0x100 + bit + symbol;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(probLit);
          if (Code < bound) {
            Range = bound;
            *(probLit) += ((1 << 11) - *(probLit)) >> 5;
            ;
            symbol <<= 1;
            if (bit != 0)
              break;
          } else {
            Range -= bound;
            Code -= bound;
            *(probLit) -= (*(probLit)) >> 5;
            ;
            symbol = (symbol + symbol) + 1;
            if (bit == 0)
              break;
          }
        } while (symbol < 0x100);
      }
      while (symbol < 0x100) {
        unsigned short *probLit = prob + symbol;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(probLit);
        if (Code < bound) {
          Range = bound;
          *(probLit) += ((1 << 11) - *(probLit)) >> 5;
          ;
          symbol <<= 1;
          ;
          ;
        } else {
          Range -= bound;
          Code -= bound;
          *(probLit) -= (*(probLit)) >> 5;
          ;
          symbol = (symbol + symbol) + 1;
          ;
          ;
        }
      }
      previousByte = (unsigned char)symbol;
      outStream[nowPos++] = previousByte;
      if (state < 4)
        state = 0;
      else if (state < 10)
        state -= 3;
      else
        state -= 6;
    } else {
      Range -= bound;
      Code -= bound;
      *(prob) -= (*(prob)) >> 5;
      ;
      prob = p + (0 + (12 << 4)) + state;
      if (Range < ((unsigned int)1 << 24)) {
        {
          if (Buffer == BufferLim)
            return 1;
        };
        Range <<= 8;
        Code = (Code << 8) | (*Buffer++);
      };
      bound = (Range >> 11) * *(prob);
      if (Code < bound) {
        Range = bound;
        *(prob) += ((1 << 11) - *(prob)) >> 5;
        ;
        rep3 = rep2;
        rep2 = rep1;
        rep1 = rep0;
        state = state < 7 ? 0 : 3;
        prob =
            p + (((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
                   (4 << 6)) +
                  (1 << (14 >> 1)) - 14) +
                 (1 << 4));
      } else {
        Range -= bound;
        Code -= bound;
        *(prob) -= (*(prob)) >> 5;
        ;
        prob = p + ((0 + (12 << 4)) + 12) + state;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(prob);
        if (Code < bound) {
          Range = bound;
          *(prob) += ((1 << 11) - *(prob)) >> 5;
          ;
          prob = p + (((((0 + (12 << 4)) + 12) + 12) + 12) + 12) +
                 (state << 4) + posState;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(prob);
          if (Code < bound) {
            Range = bound;
            *(prob) += ((1 << 11) - *(prob)) >> 5;
            ;
            if (nowPos == 0)
              return 1;
            state = state < 7 ? 9 : 11;
            previousByte = outStream[nowPos - rep0];
            outStream[nowPos++] = previousByte;
            continue;
          } else {
            Range -= bound;
            Code -= bound;
            *(prob) -= (*(prob)) >> 5;
            ;
          }
        } else {
          unsigned int distance;
          Range -= bound;
          Code -= bound;
          *(prob) -= (*(prob)) >> 5;
          ;
          prob = p + (((0 + (12 << 4)) + 12) + 12) + state;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(prob);
          if (Code < bound) {
            Range = bound;
            *(prob) += ((1 << 11) - *(prob)) >> 5;
            ;
            distance = rep1;
          } else {
            Range -= bound;
            Code -= bound;
            *(prob) -= (*(prob)) >> 5;
            ;
            prob = p + ((((0 + (12 << 4)) + 12) + 12) + 12) + state;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(prob);
            if (Code < bound) {
              Range = bound;
              *(prob) += ((1 << 11) - *(prob)) >> 5;
              ;
              distance = rep2;
            } else {
              Range -= bound;
              Code -= bound;
              *(prob) -= (*(prob)) >> 5;
              ;
              distance = rep3;
              rep3 = rep2;
            }
            rep2 = rep1;
          }
          rep1 = rep0;
          rep0 = distance;
        }
        state = state < 7 ? 8 : 11;
        prob =
            p + ((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
                    (4 << 6)) +
                   (1 << (14 >> 1)) - 14) +
                  (1 << 4)) +
                 (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) +
                  (1 << 8)));
      }
      {
        int numBits, offset;
        unsigned short *probLen = prob + 0;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(probLen);
        if (Code < bound) {
          Range = bound;
          *(probLen) += ((1 << 11) - *(probLen)) >> 5;
          ;
          probLen = prob + ((0 + 1) + 1) + (posState << 3);
          offset = 0;
          numBits = 3;
        } else {
          Range -= bound;
          Code -= bound;
          *(probLen) -= (*(probLen)) >> 5;
          ;
          probLen = prob + (0 + 1);
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(probLen);
          if (Code < bound) {
            Range = bound;
            *(probLen) += ((1 << 11) - *(probLen)) >> 5;
            ;
            probLen =
                prob + (((0 + 1) + 1) + ((1 << 4) << 3)) + (posState << 3);
            offset = (1 << 3);
            numBits = 3;
          } else {
            Range -= bound;
            Code -= bound;
            *(probLen) -= (*(probLen)) >> 5;
            ;
            probLen =
                prob + ((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3));
            offset = (1 << 3) + (1 << 3);
            numBits = 8;
          }
        }
        {
          int i = numBits;
          len = 1;
          do {
            unsigned short *p = probLen + len;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(p);
            if (Code < bound) {
              Range = bound;
              *(p) += ((1 << 11) - *(p)) >> 5;
              ;
              len <<= 1;
              ;
              ;
            } else {
              Range -= bound;
              Code -= bound;
              *(p) -= (*(p)) >> 5;
              ;
              len = (len + len) + 1;
              ;
              ;
            }
          } while (--i != 0);
          len -= (1 << numBits);
        };
        len += offset;
      }
      if (state < 4) {
        int posSlot;
        state += 7;
        prob = p + ((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
               ((len < 4 ? len : 4 - 1) << 6);
        {
          int i = 6;
          posSlot = 1;
          do {
            unsigned short *p = prob + posSlot;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(p);
            if (Code < bound) {
              Range = bound;
              *(p) += ((1 << 11) - *(p)) >> 5;
              ;
              posSlot <<= 1;
              ;
              ;
            } else {
              Range -= bound;
              Code -= bound;
              *(p) -= (*(p)) >> 5;
              ;
              posSlot = (posSlot + posSlot) + 1;
              ;
              ;
            }
          } while (--i != 0);
          posSlot -= (1 << 6);
        };
        if (posSlot >= 4) {
          int numDirectBits = ((posSlot >> 1) - 1);
          rep0 = (2 | ((unsigned int)posSlot & 1));
          if (posSlot < 14) {
            rep0 <<= numDirectBits;
            prob = p +
                   (((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
                    (4 << 6)) +
                   rep0 - posSlot - 1;
          } else {
            numDirectBits -= 4;
            do {
              if (Range < ((unsigned int)1 << 24)) {
                {
                  if (Buffer == BufferLim)
                    return 1;
                };
                Range <<= 8;
                Code = (Code << 8) | (*Buffer++);
              }
              Range >>= 1;
              rep0 <<= 1;
              if (Code >= Range) {
                Code -= Range;
                rep0 |= 1;
              }
            } while (--numDirectBits != 0);
            prob = p +
                   ((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) +
                     (4 << 6)) +
                    (1 << (14 >> 1)) - 14);
            rep0 <<= 4;
            numDirectBits = 4;
          }
          {
            int i = 1;
            int mi = 1;
            do {
              unsigned short *prob3 = prob + mi;
              if (Range < ((unsigned int)1 << 24)) {
                {
                  if (Buffer == BufferLim)
                    return 1;
                };
                Range <<= 8;
                Code = (Code << 8) | (*Buffer++);
              };
              bound = (Range >> 11) * *(prob3);
              if (Code < bound) {
                Range = bound;
                *(prob3) += ((1 << 11) - *(prob3)) >> 5;
                ;
                mi <<= 1;
                ;
                ;
              } else {
                Range -= bound;
                Code -= bound;
                *(prob3) -= (*(prob3)) >> 5;
                ;
                mi = (mi + mi) + 1;
                rep0 |= i;
              };
              i <<= 1;
            } while (--numDirectBits != 0);
          }
        } else
          rep0 = posSlot;
        if (++rep0 == (unsigned int)(0)) {
          len = -1;
          break;
        }
      }
      len += 2;
      if (rep0 > nowPos)
        return 1;
      do {
        previousByte = outStream[nowPos - rep0];
        len--;
        outStream[nowPos++] = previousByte;
      } while (len != 0 && nowPos < outSize);
    }
  }
  if (Range < ((unsigned int)1 << 24)) {
    {
      if (Buffer == BufferLim)
        return 1;
    };
    Range <<= 8;
    Code = (Code << 8) | (*Buffer++);
  };
  *outSizeProcessed = nowPos;
  return 0;
}


x86 assembly (clang, -O0):
<LzmaDecode>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    $0x300,%eax
shl    %cl,%eax
add    $0x736,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
movb   $0x0,-0x41(%rbp)
movl   $0x1,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x1,-0x50(%rbp)
movl   $0x1,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%rcx
cmp    %rcx,%rax
jae    11bf <LzmaDecode+0xbf>
movl   $0x2,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    11ed <LzmaDecode+0xed>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movw   $0x400,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c6 <LzmaDecode+0xc6>
mov    -0x28(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0xffffffff,-0x7c(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x5,-0x84(%rbp)
jge    1273 <LzmaDecode+0x173>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1242 <LzmaDecode+0x142>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    121b <LzmaDecode+0x11b>
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jae    2630 <LzmaDecode+0x1530>
mov    -0x58(%rbp),%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq -0x98(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    130b <LzmaDecode+0x20b>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    12e5 <LzmaDecode+0x1e5>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    16fe <LzmaDecode+0x5fe>
movl   $0x1,-0x9c(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0xe6c,%rax
mov    -0x58(%rbp),%edx
and    -0x60(%rbp),%edx
mov    -0x18(%rbp),%ecx
shl    %cl,%edx
mov    %edx,-0x10c(%rbp)
movzbl -0x41(%rbp),%edx
mov    $0x8,%ecx
sub    -0x18(%rbp),%ecx
sar    %cl,%edx
mov    -0x10c(%rbp),%ecx
add    %edx,%ecx
imul   $0x300,%ecx,%ecx
mov    %ecx,%ecx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x7,-0x40(%rbp)
jl     1565 <LzmaDecode+0x465>
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    -0x48(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
and    $0x100,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x90(%rbp),%rax
add    $0x200,%rax
movslq -0xa4(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq -0x9c(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    146d <LzmaDecode+0x36d>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1447 <LzmaDecode+0x347>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xb0(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    14e7 <LzmaDecode+0x3e7>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xb0(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xb0(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x9c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0xa4(%rbp)
je     14e2 <LzmaDecode+0x3e2>
jmp    1560 <LzmaDecode+0x460>
jmp    154b <LzmaDecode+0x44b>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xb0(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xb0(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x9c(%rbp),%eax
add    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0xa4(%rbp)
jne    1546 <LzmaDecode+0x446>
jmp    1560 <LzmaDecode+0x460>
jmp    154b <LzmaDecode+0x44b>
jmp    1550 <LzmaDecode+0x450>
cmpl   $0x100,-0x9c(%rbp)
jl     13d0 <LzmaDecode+0x2d0>
jmp    1565 <LzmaDecode+0x465>
jmp    156a <LzmaDecode+0x46a>
cmpl   $0x100,-0x9c(%rbp)
jge    169d <LzmaDecode+0x59d>
mov    -0x90(%rbp),%rax
movslq -0x9c(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    15e3 <LzmaDecode+0x4e3>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    15bd <LzmaDecode+0x4bd>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xb8(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    164b <LzmaDecode+0x54b>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xb8(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xb8(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x9c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1698 <LzmaDecode+0x598>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xb8(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xb8(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x9c(%rbp),%eax
add    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    156a <LzmaDecode+0x46a>
mov    -0x9c(%rbp),%eax
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%dl
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x58(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x4,-0x40(%rbp)
jge    16d3 <LzmaDecode+0x5d3>
movl   $0x0,-0x40(%rbp)
jmp    16f9 <LzmaDecode+0x5f9>
cmpl   $0xa,-0x40(%rbp)
jge    16eb <LzmaDecode+0x5eb>
mov    -0x40(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x40(%rbp)
jmp    16f4 <LzmaDecode+0x5f4>
mov    -0x40(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x40(%rbp)
jmp    16f9 <LzmaDecode+0x5f9>
jmp    262b <LzmaDecode+0x152b>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0x180,%rax
movslq -0x40(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    179f <LzmaDecode+0x69f>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1779 <LzmaDecode+0x679>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    182e <LzmaDecode+0x72e>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%edx
mov    $0x3,%eax
xor    %ecx,%ecx
cmp    $0x7,%edx
cmovl  %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0x664,%rax
mov    %rax,-0x90(%rbp)
jmp    1d13 <LzmaDecode+0xc13>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0x198,%rax
movslq -0x40(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    18cf <LzmaDecode+0x7cf>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    18a9 <LzmaDecode+0x7a9>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1a8a <LzmaDecode+0x98a>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1e0,%rax
mov    -0x40(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq -0x98(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    199f <LzmaDecode+0x89f>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1979 <LzmaDecode+0x879>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1a4d <LzmaDecode+0x94d>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
cmpl   $0x0,-0x58(%rbp)
jne    1a09 <LzmaDecode+0x909>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x40(%rbp),%edx
mov    $0xb,%eax
mov    $0x9,%ecx
cmp    $0x7,%edx
cmovl  %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    -0x48(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%dl
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x58(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    127d <LzmaDecode+0x17d>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
jmp    1cec <LzmaDecode+0xbec>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1b0,%rax
movslq -0x40(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    1b2b <LzmaDecode+0xa2b>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1b05 <LzmaDecode+0xa05>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1b8d <LzmaDecode+0xa8d>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x4c(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1cdd <LzmaDecode+0xbdd>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1c8,%rax
movslq -0x40(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    1c2e <LzmaDecode+0xb2e>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1c08 <LzmaDecode+0xb08>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x90(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1c90 <LzmaDecode+0xb90>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x50(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1cd7 <LzmaDecode+0xbd7>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x90(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x54(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%edx
mov    $0xb,%eax
mov    $0x8,%ecx
cmp    $0x7,%edx
cmovl  %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0xa68,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xd0(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    1d6e <LzmaDecode+0xc6e>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1d48 <LzmaDecode+0xc48>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xd0(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1e00 <LzmaDecode+0xd00>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xd0(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xd0(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    -0x98(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
movl   $0x0,-0xc4(%rbp)
movl   $0x3,-0xc0(%rbp)
jmp    1f90 <LzmaDecode+0xe90>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xd0(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xd0(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xd0(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    1e97 <LzmaDecode+0xd97>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1e71 <LzmaDecode+0xd71>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xd0(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    1f2b <LzmaDecode+0xe2b>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xd0(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xd0(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x90(%rbp),%rax
add    $0x104,%rax
mov    -0x98(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
movl   $0x8,-0xc4(%rbp)
movl   $0x3,-0xc0(%rbp)
jmp    1f8b <LzmaDecode+0xe8b>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xd0(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xd0(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x90(%rbp),%rax
add    $0x204,%rax
mov    %rax,-0xd0(%rbp)
movl   $0x10,-0xc4(%rbp)
movl   $0x8,-0xc0(%rbp)
jmp    1f90 <LzmaDecode+0xe90>
mov    -0xc0(%rbp),%eax
mov    %eax,-0xd4(%rbp)
movl   $0x1,-0x64(%rbp)
mov    -0xd0(%rbp),%rax
movslq -0x64(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    2009 <LzmaDecode+0xf09>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    1fe3 <LzmaDecode+0xee3>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xe0(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    206b <LzmaDecode+0xf6b>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xe0(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xe0(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x64(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    20af <LzmaDecode+0xfaf>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xe0(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xe0(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0x64(%rbp),%eax
add    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    20b4 <LzmaDecode+0xfb4>
mov    -0xd4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd4(%rbp)
cmp    $0x0,%eax
jne    1fa3 <LzmaDecode+0xea3>
mov    -0xc0(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0xc4(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x4,-0x40(%rbp)
jge    259f <LzmaDecode+0x149f>
mov    -0x40(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0x360,%rax
mov    %rax,-0x118(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    212b <LzmaDecode+0x102b>
mov    -0x64(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    213b <LzmaDecode+0x103b>
mov    $0x3,%eax
mov    %eax,-0x11c(%rbp)
jmp    213b <LzmaDecode+0x103b>
mov    -0x118(%rbp),%rax
mov    -0x11c(%rbp),%ecx
shl    $0x6,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
movl   $0x6,-0xe8(%rbp)
movl   $0x1,-0xe4(%rbp)
mov    -0x90(%rbp),%rax
movslq -0xe4(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    21d9 <LzmaDecode+0x10d9>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    21b3 <LzmaDecode+0x10b3>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0xf0(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    2241 <LzmaDecode+0x1141>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0xf0(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0xf0(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0xe4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    228e <LzmaDecode+0x118e>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0xf0(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0xf0(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0xe4(%rbp),%eax
add    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    2293 <LzmaDecode+0x1193>
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
cmp    $0x0,%eax
jne    2170 <LzmaDecode+0x1070>
mov    -0xe4(%rbp),%eax
sub    $0x40,%eax
mov    %eax,-0xe4(%rbp)
cmpl   $0x4,-0xe4(%rbp)
jl     2573 <LzmaDecode+0x1473>
mov    -0xe4(%rbp),%eax
sar    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xe4(%rbp),%eax
and    $0x1,%eax
or     $0x2,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0xe,-0xe4(%rbp)
jge    233a <LzmaDecode+0x123a>
mov    -0xf4(%rbp),%ecx
mov    -0x48(%rbp),%eax
shl    %cl,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
add    $0x560,%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%rcx
add    %rcx,%rax
movslq -0xe4(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x90(%rbp)
jmp    2409 <LzmaDecode+0x1309>
mov    -0xf4(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0xf4(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    2396 <LzmaDecode+0x1296>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    2370 <LzmaDecode+0x1270>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jb     23c8 <LzmaDecode+0x12c8>
mov    -0x7c(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x48(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    23cd <LzmaDecode+0x12cd>
mov    -0xf4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf4(%rbp)
cmp    $0x0,%eax
jne    2349 <LzmaDecode+0x1249>
mov    -0x38(%rbp),%rax
add    $0x644,%rax
mov    %rax,-0x90(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x48(%rbp)
movl   $0x4,-0xf4(%rbp)
movl   $0x1,-0xf8(%rbp)
movl   $0x1,-0xfc(%rbp)
mov    -0x90(%rbp),%rax
movslq -0xfc(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
cmpl   $0x1000000,-0x7c(%rbp)
jae    2486 <LzmaDecode+0x1386>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    2460 <LzmaDecode+0x1360>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
shr    $0xb,%eax
mov    -0x108(%rbp),%rcx
movzwl (%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x94(%rbp),%eax
jae    24ee <LzmaDecode+0x13ee>
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x108(%rbp),%rax
movzwl (%rax),%eax
mov    $0x800,%edx
sub    %eax,%edx
sar    $0x5,%edx
mov    -0x108(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0xfc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    2547 <LzmaDecode+0x1447>
mov    -0x94(%rbp),%ecx
mov    -0x7c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%ecx
mov    -0x80(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x108(%rbp),%rax
movzwl (%rax),%edx
sar    $0x5,%edx
mov    -0x108(%rbp),%rax
movzwl (%rax),%ecx
sub    %edx,%ecx
mov    %cx,(%rax)
mov    -0xfc(%rbp),%eax
add    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xf8(%rbp),%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xf8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf4(%rbp)
cmp    $0x0,%eax
jne    241d <LzmaDecode+0x131d>
jmp    257c <LzmaDecode+0x147c>
mov    -0xe4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jne    259a <LzmaDecode+0x149a>
movl   $0xffffffff,-0x64(%rbp)
jmp    2630 <LzmaDecode+0x1530>
jmp    259f <LzmaDecode+0x149f>
mov    -0x64(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x58(%rbp),%eax
jbe    25c0 <LzmaDecode+0x14c0>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
jmp    25c5 <LzmaDecode+0x14c5>
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    -0x48(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x41(%rbp)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x41(%rbp),%dl
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x58(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
xor    %eax,%eax
cmpl   $0x0,-0x64(%rbp)
mov    %al,-0x11d(%rbp)
je     2618 <LzmaDecode+0x1518>
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
setb   %al
mov    %al,-0x11d(%rbp)
mov    -0x11d(%rbp),%al
test   $0x1,%al
jne    25c5 <LzmaDecode+0x14c5>
jmp    262b <LzmaDecode+0x152b>
jmp    127d <LzmaDecode+0x17d>
cmpl   $0x1000000,-0x7c(%rbp)
jae    267d <LzmaDecode+0x157d>
mov    -0x70(%rbp),%rax
cmp    -0x78(%rbp),%rax
jne    2657 <LzmaDecode+0x1557>
movl   $0x1,-0x4(%rbp)
jmp    268d <LzmaDecode+0x158d>
mov    -0x7c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x80(%rbp),%eax
shl    $0x8,%eax
mov    -0x70(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x70(%rbp)
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x58(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LzmaDecode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%eax
lea    (%rax,%rdx,1),%ecx
mov    $0x300,%ebp
shl    %cl,%ebp
add    $0x736,%ebp
mov    $0xffffffff,%r11d
mov    %r8d,%ecx
shl    %cl,%r11d
mov    $0xffffffff,%r8d
mov    %eax,%ecx
shl    %cl,%r8d
mov    %esi,%ecx
mov    %rbp,%rsi
add    %rbp,%rsi
mov    $0x2,%eax
cmp    %rcx,%rsi
ja     2131 <LzmaDecode+0x1031>
cmp    $0x2,%ebp
mov    $0x1,%eax
cmovae %ebp,%eax
lea    -0x16(%rax),%rcx
cmp    $0x70,%rcx
jae    1169 <LzmaDecode+0x69>
xor    %ebp,%ebp
jmp    11f1 <LzmaDecode+0xf1>
mov    %rcx,%rsi
shr    $0x4,%rsi
and    $0xfffffffffffffff8,%rsi
xor    %ebp,%ebp
movaps 0x1e83(%rip),%xmm0
nopl   (%rax)
movups %xmm0,(%rdi,%rbp,2)
movups %xmm0,0x10(%rdi,%rbp,2)
movups %xmm0,0x20(%rdi,%rbp,2)
movups %xmm0,0x30(%rdi,%rbp,2)
movups %xmm0,0x40(%rdi,%rbp,2)
movups %xmm0,0x50(%rdi,%rbp,2)
movups %xmm0,0x60(%rdi,%rbp,2)
movups %xmm0,0x70(%rdi,%rbp,2)
movups %xmm0,0x80(%rdi,%rbp,2)
movups %xmm0,0x90(%rdi,%rbp,2)
movups %xmm0,0xa0(%rdi,%rbp,2)
movups %xmm0,0xb0(%rdi,%rbp,2)
movups %xmm0,0xc0(%rdi,%rbp,2)
movups %xmm0,0xd0(%rdi,%rbp,2)
movups %xmm0,0xe0(%rdi,%rbp,2)
movups %xmm0,0xf0(%rdi,%rbp,2)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffff8,%rsi
jne    1180 <LzmaDecode+0x80>
mov    0x68(%rsp),%r14
mov    0x50(%rsp),%esi
not    %r11d
not    %r8d
lea    (%rdi,%rbp,2),%rbx
add    $0x10,%rbx
and    $0x60,%ecx
add    %ecx,%ecx
or     $0x20,%rcx
xor    %ebp,%ebp
movdqa 0x1de5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rbx,%rbp,1)
movdqu %xmm0,(%rbx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1220 <LzmaDecode+0x120>
movabs $0x400040004000400,%rcx
mov    %rcx,-0xc(%rdi,%rax,2)
movl   $0x4000400,-0x4(%rdi,%rax,2)
04
mov    %esi,%eax
cmp    $0x4,%rax
mov    $0x4,%ecx
mov    %rax,-0x70(%rsp)
cmovb  %rax,%rcx
mov    $0x1,%eax
cmp    $0x5,%esi
jb     2131 <LzmaDecode+0x1031>
movzbl 0x1(%r9),%esi
movzbl 0x2(%r9),%r13d
movzbl 0x3(%r9),%ebp
movzbl 0x4(%r9),%eax
movl   $0x0,(%r14)
xor    %r10d,%r10d
cmpl   $0x0,0x60(%rsp)
je     212c <LzmaDecode+0x102c>
mov    %r8d,-0x34(%rsp)
add    %r9,-0x70(%rsp)
lea    (%rcx,%r9,1),%r8
add    $0x1,%r8
shl    $0x10,%esi
shl    $0x8,%r13d
or     %esi,%r13d
or     %ebp,%r13d
shl    $0x8,%r13d
or     %eax,%r13d
lea    0x1e0(%rdi),%rax
mov    %rax,-0x18(%rsp)
lea    0xa68(%rdi),%rax
mov    %rax,-0x8(%rsp)
lea    0x664(%rdi),%rax
mov    %rax,(%rsp)
lea    0x360(%rdi),%rax
mov    %rax,-0x10(%rsp)
lea    0x644(%rdi),%rax
mov    %rax,-0x30(%rsp)
lea    0xe6c(%rdi),%rax
mov    %rax,0x8(%rsp)
mov    $0x8,%eax
mov    %rdx,0x10(%rsp)
sub    %edx,%eax
mov    %eax,-0x38(%rsp)
lea    0x55e(%rdi),%rax
mov    %rax,-0x28(%rsp)
mov    0x58(%rsp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rsp)
mov    $0xffffffff,%r12d
xor    %edx,%edx
xor    %esi,%esi
mov    $0x1,%r9d
movl   $0x1,-0x54(%rsp)
movl   $0x1,-0x50(%rsp)
movl   $0x1,-0x4c(%rsp)
xor    %r10d,%r10d
mov    %r11d,-0x64(%rsp)
cmp    $0xffffff,%r12d
mov    %r9,-0x78(%rsp)
ja     1389 <LzmaDecode+0x289>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
mov    %r10d,%ecx
and    %r11d,%ecx
mov    %edx,%eax
shl    $0x4,%eax
movslq %eax,%rbp
lea    (%rdi,%rbp,2),%r14
movslq %ecx,%r15
mov    %edx,%r11d
mov    %r12d,%edx
shr    $0xb,%edx
movzwl (%r14,%r15,2),%ebx
imul   %ebx,%edx
mov    %r13d,%r9d
sub    %edx,%r9d
mov    %r11d,-0x7c(%rsp)
jae    159c <LzmaDecode+0x49c>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
mov    %r10d,%ebp
and    -0x34(%rsp),%ebp
mov    0x10(%rsp),%rcx
shl    %cl,%ebp
movzbl %sil,%esi
mov    -0x38(%rsp),%ecx
shr    %cl,%esi
add    %ebx,%eax
mov    %ax,(%r14,%r15,2)
add    %ebp,%esi
shl    $0x8,%esi
lea    (%rsi,%rsi,2),%eax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,2),%r15
mov    $0x1,%esi
cmp    $0x7,%r11d
jl     1502 <LzmaDecode+0x402>
mov    %r10d,%eax
sub    -0x78(%rsp),%eax
mov    0x58(%rsp),%rcx
movzbl (%rcx,%rax,1),%r11d
lea    0x200(%r15),%r9
mov    $0x1,%esi
jmp    145d <LzmaDecode+0x35d>
nopl   0x0(%rax,%rax,1)
sub    %r12d,%edx
mov    %ebx,%ecx
shr    $0x5,%ecx
sub    %ecx,%ebx
mov    %bx,(%r14,%rsi,2)
add    %esi,%esi
add    $0x1,%esi
mov    %edx,%r12d
mov    %eax,%r13d
test   %ebp,%ebp
je     14c4 <LzmaDecode+0x3c4>
mov    %r12d,%edx
cmp    $0x100,%esi
jge    1560 <LzmaDecode+0x460>
cmp    $0xffffff,%edx
ja     1482 <LzmaDecode+0x382>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%edx
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
add    %r11d,%r11d
mov    %r11d,%ebp
and    $0x100,%ebp
lea    (%r9,%rbp,2),%r14
movslq %esi,%rsi
mov    %edx,%r12d
shr    $0xb,%r12d
movzwl (%r14,%rsi,2),%ebx
imul   %ebx,%r12d
mov    %r13d,%eax
sub    %r12d,%eax
jae    1430 <LzmaDecode+0x330>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,(%r14,%rsi,2)
add    %esi,%esi
test   %ebp,%ebp
je     144e <LzmaDecode+0x34e>
mov    %r12d,%edx
cmp    $0xff,%esi
jle    1502 <LzmaDecode+0x402>
jmp    1560 <LzmaDecode+0x460>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    %r12d,%edx
mov    %ebp,%eax
shr    $0x5,%eax
sub    %eax,%ebp
mov    %bp,(%r15,%rsi,2)
add    %esi,%esi
add    $0x1,%esi
mov    %edx,%r12d
mov    %ecx,%r13d
cmp    $0x100,%esi
jge    1560 <LzmaDecode+0x460>
cmp    $0xffffff,%edx
ja     1527 <LzmaDecode+0x427>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%edx
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
movslq %esi,%rsi
mov    %edx,%r12d
shr    $0xb,%r12d
movzwl (%r15,%rsi,2),%ebp
imul   %ebp,%r12d
mov    %r13d,%ecx
sub    %r12d,%ecx
jae    14e0 <LzmaDecode+0x3e0>
mov    $0x800,%ecx
sub    %ebp,%ecx
shr    $0x5,%ecx
add    %ebp,%ecx
mov    %cx,(%r15,%rsi,2)
add    %esi,%esi
mov    %r12d,%edx
cmp    $0x100,%esi
jl     1502 <LzmaDecode+0x402>
mov    %r10d,%eax
add    $0x1,%r10d
mov    0x58(%rsp),%rcx
mov    %sil,(%rcx,%rax,1)
xor    %edx,%edx
mov    -0x7c(%rsp),%eax
cmp    $0x4,%eax
jge    1681 <LzmaDecode+0x581>
mov    -0x64(%rsp),%r11d
mov    0x60(%rsp),%r15d
mov    -0x78(%rsp),%r9
cmp    %r15d,%r10d
jb     135d <LzmaDecode+0x25d>
jmp    210b <LzmaDecode+0x100b>
mov    %ecx,-0x60(%rsp)
sub    %edx,%r12d
mov    %ebx,%eax
shr    $0x5,%eax
sub    %eax,%ebx
mov    %bx,(%r14,%r15,2)
cmp    $0xffffff,%r12d
ja     15dc <LzmaDecode+0x4dc>
cmp    -0x70(%rsp),%r8
mov    -0x7c(%rsp),%ecx
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r9d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r9d
jmp    15e0 <LzmaDecode+0x4e0>
mov    -0x7c(%rsp),%ecx
movslq %ecx,%rdx
mov    %r12d,%esi
shr    $0xb,%esi
movzwl 0x180(%rdi,%rdx,2),%ebx
imul   %ebx,%esi
mov    %r9d,%r13d
sub    %esi,%r13d
jae    1642 <LzmaDecode+0x542>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,0x180(%rdi,%rdx,2)
xor    %eax,%eax
cmp    $0x7,%ecx
setge  %al
lea    (%rax,%rax,2),%edx
mov    -0x50(%rsp),%eax
mov    %eax,-0x4c(%rsp)
mov    (%rsp),%r11
mov    -0x54(%rsp),%eax
mov    %eax,-0x50(%rsp)
mov    -0x78(%rsp),%rax
mov    0x60(%rsp),%r15d
mov    -0x60(%rsp),%ecx
jmp    1904 <LzmaDecode+0x804>
sub    %esi,%r12d
mov    %ebx,%eax
shr    $0x5,%eax
sub    %eax,%ebx
mov    %bx,0x180(%rdi,%rdx,2)
cmp    $0xffffff,%r12d
ja     16ac <LzmaDecode+0x5ac>
cmp    -0x70(%rsp),%r8
mov    -0x60(%rsp),%ecx
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
jmp    16b0 <LzmaDecode+0x5b0>
cmp    $0x9,%eax
mov    -0x64(%rsp),%r11d
mov    0x60(%rsp),%r15d
mov    -0x78(%rsp),%r9
mov    %eax,%edx
ja     17d1 <LzmaDecode+0x6d1>
add    $0xfffffffd,%edx
cmp    %r15d,%r10d
jb     135d <LzmaDecode+0x25d>
jmp    210b <LzmaDecode+0x100b>
mov    -0x60(%rsp),%ecx
mov    %r12d,%esi
shr    $0xb,%esi
movzwl 0x198(%rdi,%rdx,2),%ebx
imul   %ebx,%esi
mov    %r13d,%r9d
sub    %esi,%r9d
jae    178c <LzmaDecode+0x68c>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,0x198(%rdi,%rdx,2)
cmp    $0xffffff,%esi
ja     1706 <LzmaDecode+0x606>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
mov    -0x18(%rsp),%rax
lea    (%rax,%rbp,2),%rdx
mov    %esi,%r12d
shr    $0xb,%r12d
movzwl (%rdx,%r15,2),%ebx
imul   %ebx,%r12d
mov    %r13d,%r9d
sub    %r12d,%r9d
jae    182c <LzmaDecode+0x72c>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,(%rdx,%r15,2)
test   %r10d,%r10d
mov    0x60(%rsp),%r15d
je     2104 <LzmaDecode+0x1004>
xor    %eax,%eax
cmpl   $0x7,-0x7c(%rsp)
setge  %al
lea    (%rax,%rax,1),%edx
add    $0x9,%edx
mov    %r10d,%eax
mov    -0x78(%rsp),%r9
sub    %r9d,%eax
mov    0x58(%rsp),%rcx
mov    (%rcx,%rax,1),%sil
mov    %r10d,%eax
add    $0x1,%r10d
mov    %sil,(%rcx,%rax,1)
mov    -0x64(%rsp),%r11d
cmp    %r15d,%r10d
jb     135d <LzmaDecode+0x25d>
jmp    210b <LzmaDecode+0x100b>
sub    %esi,%r12d
mov    %ebx,%eax
shr    $0x5,%eax
sub    %eax,%ebx
mov    %bx,0x198(%rdi,%rdx,2)
cmp    $0xffffff,%r12d
ja     17e2 <LzmaDecode+0x6e2>
cmp    -0x70(%rsp),%r8
mov    0x60(%rsp),%r15d
mov    -0x54(%rsp),%r14d
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r9d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r9d
jmp    17ec <LzmaDecode+0x6ec>
add    $0xfffffffa,%edx
cmp    %r15d,%r10d
jb     135d <LzmaDecode+0x25d>
jmp    210b <LzmaDecode+0x100b>
mov    0x60(%rsp),%r15d
mov    -0x54(%rsp),%r14d
mov    %r12d,%esi
shr    $0xb,%esi
movzwl 0x1b0(%rdi,%rdx,2),%ebx
imul   %ebx,%esi
mov    %r9d,%eax
sub    %esi,%eax
jae    1849 <LzmaDecode+0x749>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,0x1b0(%rdi,%rdx,2)
mov    -0x78(%rsp),%rax
mov    %eax,%ebx
mov    %r14d,%eax
mov    %rax,-0x78(%rsp)
jmp    18ed <LzmaDecode+0x7ed>
sub    %r12d,%esi
mov    %ebx,%eax
shr    $0x5,%eax
sub    %eax,%ebx
mov    %bx,(%rdx,%r15,2)
mov    -0x54(%rsp),%ebx
mov    0x60(%rsp),%r15d
jmp    18ed <LzmaDecode+0x7ed>
sub    %esi,%r12d
mov    %ebx,%esi
shr    $0x5,%esi
sub    %esi,%ebx
mov    %bx,0x1b0(%rdi,%rdx,2)
cmp    $0xffffff,%r12d
ja     1880 <LzmaDecode+0x780>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%eax
movzbl (%r8),%esi
add    $0x1,%r8
or     %esi,%eax
mov    %r12d,%esi
shr    $0xb,%esi
movzwl 0x1c8(%rdi,%rdx,2),%ebp
imul   %ebp,%esi
mov    %eax,%ebx
sub    %esi,%ebx
mov    -0x50(%rsp),%r11d
jae    18ae <LzmaDecode+0x7ae>
mov    $0x800,%r9d
sub    %ebp,%r9d
shr    $0x5,%r9d
add    %ebp,%r9d
jmp    18cc <LzmaDecode+0x7cc>
sub    %esi,%r12d
mov    %ebp,%eax
shr    $0x5,%eax
sub    %eax,%ebp
mov    %ebp,%r9d
mov    %r11d,%ebp
mov    %r12d,%esi
mov    %ebx,%eax
mov    -0x4c(%rsp),%r11d
mov    %ebp,-0x4c(%rsp)
mov    -0x78(%rsp),%rbx
mov    %r11d,%ebp
mov    %r9w,0x1c8(%rdi,%rdx,2)
mov    %eax,%r9d
mov    %r11d,%eax
mov    %rax,-0x78(%rsp)
mov    %r14d,-0x50(%rsp)
xor    %eax,%eax
cmpl   $0x7,-0x7c(%rsp)
setge  %al
lea    (%rax,%rax,2),%edx
or     $0x8,%edx
mov    -0x8(%rsp),%r11
mov    %ebx,%eax
mov    %edx,-0x7c(%rsp)
cmp    $0xffffff,%esi
ja     192d <LzmaDecode+0x82d>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%r9d
movzbl (%r8),%edx
add    $0x1,%r8
or     %edx,%r9d
mov    %esi,%r12d
shr    $0xb,%r12d
movzwl (%r11),%ebp
imul   %ebp,%r12d
mov    %r9d,%edx
sub    %r12d,%edx
mov    %eax,-0x54(%rsp)
jae    196a <LzmaDecode+0x86a>
mov    $0x800,%edx
sub    %ebp,%edx
shr    $0x5,%edx
add    %ebp,%edx
mov    %dx,(%r11)
shl    $0x3,%ecx
movslq %ecx,%rcx
lea    (%r11,%rcx,2),%r11
add    $0x4,%r11
xor    %eax,%eax
jmp    19e0 <LzmaDecode+0x8e0>
sub    %r12d,%esi
mov    %ebp,%ebx
shr    $0x5,%ebx
sub    %ebx,%ebp
mov    %bp,(%r11)
cmp    $0xffffff,%esi
ja     199e <LzmaDecode+0x89e>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%edx
movzbl (%r8),%r9d
add    $0x1,%r8
or     %edx,%r9d
jmp    19a1 <LzmaDecode+0x8a1>
mov    %edx,%r9d
mov    %esi,%r12d
shr    $0xb,%r12d
movzwl 0x2(%r11),%edx
imul   %edx,%r12d
mov    %r9d,%ebx
sub    %r12d,%ebx
jae    19ec <LzmaDecode+0x8ec>
mov    $0x800,%esi
sub    %edx,%esi
shr    $0x5,%esi
add    %edx,%esi
mov    %si,0x2(%r11)
shl    $0x3,%ecx
movslq %ecx,%rcx
lea    (%r11,%rcx,2),%r11
add    $0x104,%r11
mov    $0x8,%eax
mov    %rax,-0x60(%rsp)
mov    $0x3,%ecx
jmp    1a17 <LzmaDecode+0x917>
sub    %r12d,%esi
mov    %edx,%ecx
shr    $0x5,%ecx
sub    %ecx,%edx
mov    %dx,0x2(%r11)
add    $0x204,%r11
mov    $0x10,%eax
mov    %rax,-0x60(%rsp)
mov    $0x8,%ecx
mov    %esi,%r12d
mov    %ebx,%r9d
mov    $0x1,%r14d
mov    %r9d,%r13d
mov    %ecx,%edx
mov    -0x78(%rsp),%r9
jmp    1a51 <LzmaDecode+0x951>
nopl   0x0(%rax)
sub    %r12d,%esi
mov    %eax,%ebp
shr    $0x5,%ebp
sub    %ebp,%eax
mov    %ax,(%r11,%r14,2)
add    %r14d,%r14d
add    $0x1,%r14d
mov    %esi,%r12d
mov    %ebx,%r13d
add    $0xffffffff,%edx
je     1aac <LzmaDecode+0x9ac>
cmp    $0xffffff,%r12d
ja     1a78 <LzmaDecode+0x978>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r13d
movzbl (%r8),%esi
add    $0x1,%r8
or     %esi,%r13d
mov    %r12d,%esi
movslq %r14d,%r14
shr    $0xb,%r12d
movzwl (%r11,%r14,2),%eax
imul   %eax,%r12d
mov    %r13d,%ebx
sub    %r12d,%ebx
jae    1a30 <LzmaDecode+0x930>
mov    $0x800,%esi
sub    %eax,%esi
shr    $0x5,%esi
add    %eax,%esi
mov    %si,(%r11,%r14,2)
add    %r14d,%r14d
add    $0xffffffff,%edx
jne    1a51 <LzmaDecode+0x951>
mov    $0xffffffff,%ebp
shl    %cl,%ebp
mov    -0x60(%rsp),%rax
lea    (%rax,%rbp,1),%r11d
add    %r14d,%r11d
cmpl   $0x3,-0x7c(%rsp)
ja     1dec <LzmaDecode+0xcec>
cmp    $0x3,%r11d
mov    $0x3,%ecx
cmovl  %r11d,%ecx
cmp    $0xffffff,%r12d
ja     1afe <LzmaDecode+0x9fe>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r12d
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
shl    $0x6,%ecx
movslq %ecx,%rax
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rax,2),%r9
mov    %r12d,%esi
shr    $0xb,%esi
movzwl 0x2(%r9),%edx
imul   %edx,%esi
mov    %r13d,%eax
sub    %esi,%eax
jae    1b35 <LzmaDecode+0xa35>
mov    $0x800,%ebx
sub    %edx,%ebx
shr    $0x5,%ebx
add    %edx,%ebx
mov    $0x2,%ecx
jmp    1b4c <LzmaDecode+0xa4c>
sub    %esi,%r12d
mov    %edx,%ecx
shr    $0x5,%ecx
sub    %ecx,%edx
mov    $0x3,%ecx
mov    %edx,%ebx
mov    %r12d,%esi
mov    %eax,%r13d
mov    %bx,0x2(%r9)
cmp    $0xffffff,%esi
mov    %rbp,-0x48(%rsp)
ja     1b7b <LzmaDecode+0xa7b>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
mov    %ecx,%ecx
mov    %esi,%edx
shr    $0xb,%edx
movzwl (%r9,%rcx,2),%ebx
imul   %ebx,%edx
mov    %r13d,%ebp
sub    %edx,%ebp
jae    1bb1 <LzmaDecode+0xab1>
mov    $0x800,%eax
sub    %ebx,%eax
shr    $0x5,%eax
add    %ebx,%eax
mov    %ax,(%r9,%rcx,2)
add    %ecx,%ecx
mov    %r13d,%ebp
cmp    $0xffffff,%edx
jbe    1bce <LzmaDecode+0xace>
jmp    1be9 <LzmaDecode+0xae9>
sub    %edx,%esi
mov    %ebx,%eax
shr    $0x5,%eax
sub    %eax,%ebx
mov    %bx,(%r9,%rcx,2)
add    %ecx,%ecx
add    $0x1,%ecx
mov    %esi,%edx
cmp    $0xffffff,%edx
ja     1be9 <LzmaDecode+0xae9>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%edx
shl    $0x8,%ebp
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%ebp
mov    %ecx,%ebx
mov    %edx,%esi
shr    $0xb,%esi
movzwl (%r9,%rbx,2),%ecx
imul   %ecx,%esi
mov    %ebp,%r13d
sub    %esi,%r13d
jae    1c22 <LzmaDecode+0xb22>
mov    $0x800,%eax
sub    %ecx,%eax
shr    $0x5,%eax
add    %ecx,%eax
mov    %ax,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
mov    %ebp,%r13d
cmp    $0xffffff,%esi
jbe    1c42 <LzmaDecode+0xb42>
jmp    1c5f <LzmaDecode+0xb5f>
sub    %esi,%edx
mov    %ecx,%eax
shr    $0x5,%eax
sub    %eax,%ecx
mov    %cx,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
add    $0x1,%r12d
mov    %edx,%esi
cmp    $0xffffff,%esi
ja     1c5f <LzmaDecode+0xb5f>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
mov    %r12d,%ebx
mov    %esi,%edx
shr    $0xb,%edx
movzwl (%r9,%rbx,2),%ecx
imul   %ecx,%edx
mov    %r13d,%ebp
sub    %edx,%ebp
jae    1c98 <LzmaDecode+0xb98>
mov    $0x800,%eax
sub    %ecx,%eax
shr    $0x5,%eax
add    %ecx,%eax
mov    %ax,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
mov    %r13d,%ebp
cmp    $0xffffff,%edx
jbe    1cb8 <LzmaDecode+0xbb8>
jmp    1cd3 <LzmaDecode+0xbd3>
sub    %edx,%esi
mov    %ecx,%eax
shr    $0x5,%eax
sub    %eax,%ecx
mov    %cx,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
add    $0x1,%r12d
mov    %esi,%edx
cmp    $0xffffff,%edx
ja     1cd3 <LzmaDecode+0xbd3>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%edx
shl    $0x8,%ebp
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%ebp
mov    %r12d,%ebx
mov    %edx,%esi
shr    $0xb,%esi
movzwl (%r9,%rbx,2),%ecx
imul   %ecx,%esi
mov    %ebp,%r15d
sub    %esi,%r15d
jae    1d0d <LzmaDecode+0xc0d>
mov    $0x800,%eax
sub    %ecx,%eax
shr    $0x5,%eax
add    %ecx,%eax
mov    %ax,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
mov    %ebp,%r15d
cmp    $0xffffff,%esi
jbe    1d2d <LzmaDecode+0xc2d>
jmp    1d4a <LzmaDecode+0xc4a>
sub    %esi,%edx
mov    %ecx,%eax
shr    $0x5,%eax
sub    %eax,%ecx
mov    %cx,(%r9,%rbx,2)
lea    (%rbx,%rbx,1),%r12d
add    $0x1,%r12d
mov    %edx,%esi
cmp    $0xffffff,%esi
ja     1d4a <LzmaDecode+0xc4a>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%esi
shl    $0x8,%r15d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r15d
mov    %r12d,%edx
mov    %esi,%r12d
shr    $0xb,%r12d
movzwl (%r9,%rdx,2),%ecx
imul   %ecx,%r12d
mov    %r15d,%r13d
sub    %r12d,%r13d
jae    1d7d <LzmaDecode+0xc7d>
mov    $0x800,%eax
sub    %ecx,%eax
shr    $0x5,%eax
add    %ecx,%eax
mov    %ax,(%r9,%rdx,2)
add    %edx,%edx
mov    %r15d,%r13d
jmp    1d94 <LzmaDecode+0xc94>
sub    %r12d,%esi
mov    %ecx,%eax
shr    $0x5,%eax
sub    %eax,%ecx
mov    %cx,(%r9,%rdx,2)
add    %edx,%edx
add    $0x1,%edx
mov    %esi,%r12d
lea    -0x40(%rdx),%eax
cmp    $0x44,%edx
jl     1dca <LzmaDecode+0xcca>
mov    %eax,%ecx
shr    %ecx
and    $0x1,%edx
or     $0x2,%edx
cmp    $0xd,%eax
ja     1eff <LzmaDecode+0xdff>
add    $0xffffffff,%ecx
shl    %cl,%edx
mov    %eax,%eax
mov    -0x28(%rsp),%rsi
lea    (%rsi,%rdx,2),%r9
add    %rax,%rax
sub    %rax,%r9
jmp    2010 <LzmaDecode+0xf10>
mov    %rax,-0x78(%rsp)
mov    -0x78(%rsp),%r9
inc    %r9d
je     210b <LzmaDecode+0x100b>
addl   $0x7,-0x7c(%rsp)
mov    0x60(%rsp),%r15d
mov    -0x48(%rsp),%rbp
mov    %r10d,%edx
sub    %r9d,%edx
jb     2104 <LzmaDecode+0x1004>
add    $0x2,%r11d
mov    -0x60(%rsp),%rcx
or     $0x1,%ecx
add    %r14d,%ecx
add    %ebp,%ecx
lea    0x1(%r10),%esi
cmp    %esi,%r15d
mov    %esi,%ebp
cmova  %r15d,%ebp
mov    %r10d,%r14d
not    %r14d
add    %r14d,%ebp
cmp    %ecx,%ebp
cmovae %ecx,%ebp
add    $0x1,%ebp
test   %ecx,%ecx
mov    $0x1,%eax
cmove  %eax,%ebp
cmp    $0x20,%ebp
jae    1e85 <LzmaDecode+0xd85>
mov    0x58(%rsp),%rdx
mov    %r9d,%ecx
neg    %ecx
add    $0xffffffff,%r11d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%r10,1),%eax
movzbl (%rdx,%rax,1),%esi
mov    %r10d,%eax
add    $0x1,%r10d
mov    %sil,(%rdx,%rax,1)
add    $0xffffffff,%r11d
jae    1e6e <LzmaDecode+0xd6e>
cmp    %r15d,%r10d
jb     1e50 <LzmaDecode+0xd50>
mov    -0x64(%rsp),%r11d
mov    -0x7c(%rsp),%edx
cmp    %r15d,%r10d
jb     135d <LzmaDecode+0x25d>
jmp    210b <LzmaDecode+0x100b>
cmp    %esi,%r15d
mov    %esi,%eax
cmova  %r15d,%eax
add    %r14d,%eax
cmp    %ecx,%eax
cmovae %ecx,%eax
test   %ecx,%ecx
cmove  %ecx,%eax
mov    %r10d,%ebx
add    %eax,%ebx
jb     1e36 <LzmaDecode+0xd36>
lea    (%r9,%r14,1),%ebx
cmp    %eax,%ebx
jb     1e36 <LzmaDecode+0xd36>
mov    %ebp,-0x60(%rsp)
mov    %r9,-0x78(%rsp)
cmp    %esi,%r15d
cmova  %r15d,%esi
add    %r14d,%esi
cmp    %ecx,%esi
cmovae %ecx,%esi
mov    %r10d,%eax
test   %ecx,%ecx
cmove  %ecx,%esi
mov    0x58(%rsp),%r9
lea    (%r9,%rax,1),%r14
lea    (%rsi,%rdx,1),%rbx
mov    -0x20(%rsp),%rbp
add    %rbp,%rbx
cmp    %rbx,%r14
jae    1f51 <LzmaDecode+0xe51>
add    %rsi,%rax
add    %rbp,%rax
add    %r9,%rdx
cmp    %rax,%rdx
jae    1f51 <LzmaDecode+0xe51>
mov    %r9,%rdx
mov    -0x78(%rsp),%r9
jmp    1e3b <LzmaDecode+0xd3b>
add    $0xfffffffb,%ecx
jmp    1f3c <LzmaDecode+0xe3c>
shl    $0x8,%r12d
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
shr    %r12d
xor    %eax,%eax
cmp    %r12d,%r13d
mov    %r12d,%esi
mov    $0x0,%ebp
cmovb  %ebp,%esi
setae  %al
sub    %esi,%r13d
lea    (%rax,%rdx,2),%edx
add    $0xffffffff,%ecx
je     2003 <LzmaDecode+0xf03>
cmp    $0xffffff,%r12d
ja     1f17 <LzmaDecode+0xe17>
cmp    -0x70(%rsp),%r8
jne    1f04 <LzmaDecode+0xe04>
jmp    2104 <LzmaDecode+0x1004>
mov    -0x60(%rsp),%ecx
mov    %ecx,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%eax
mov    %eax,%edx
shr    $0x5,%edx
add    $0x1,%edx
test   %eax,%eax
je     20bb <LzmaDecode+0xfbb>
mov    %rsi,-0x48(%rsp)
mov    %edx,-0x3c(%rsp)
mov    %edx,%esi
and    $0xfffffffe,%esi
mov    $0x20,%r15d
mov    -0x78(%rsp),%rdx
sub    %edx,%r15d
neg    %edx
xor    %ebp,%ebp
mov    %r10d,%ebx
mov    0x58(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rdx,%rbx,1),%eax
movups (%r14,%rax,1),%xmm0
movups 0x10(%r14,%rax,1),%xmm1
mov    %ebx,%eax
movups %xmm0,(%r14,%rax,1)
movups %xmm1,0x10(%r14,%rax,1)
lea    0x20(%rbx),%eax
lea    (%r15,%rbx,1),%r9d
movups (%r14,%r9,1),%xmm1
movdqu 0x10(%r14,%r9,1),%xmm0
movups %xmm1,(%r14,%rax,1)
movdqu %xmm0,0x10(%r14,%rax,1)
add    $0x40,%ebx
add    $0xffffffc0,%ebp
add    $0xfffffffe,%esi
jne    1fa0 <LzmaDecode+0xea0>
neg    %ebp
mov    0x60(%rsp),%r15d
mov    -0x78(%rsp),%r9
mov    -0x60(%rsp),%ecx
mov    -0x48(%rsp),%rsi
mov    -0x3c(%rsp),%edx
jmp    20c2 <LzmaDecode+0xfc2>
shl    $0x4,%edx
mov    $0x4,%ecx
mov    -0x30(%rsp),%r9
mov    %rdx,-0x78(%rsp)
mov    $0x1,%edx
mov    %r12d,%r15d
mov    $0x1,%ebp
jmp    2061 <LzmaDecode+0xf61>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    %r12d,%r15d
mov    %esi,%ebx
shr    $0x5,%ebx
sub    %ebx,%esi
mov    %si,(%r9,%rbp,2)
add    %ebp,%ebp
add    $0x1,%ebp
mov    -0x78(%rsp),%rsi
or     %edx,%esi
mov    %rsi,-0x78(%rsp)
mov    %r15d,%r12d
mov    %eax,%r13d
add    %edx,%edx
add    $0xffffffff,%ecx
je     1dcf <LzmaDecode+0xccf>
cmp    $0xffffff,%r15d
ja     2088 <LzmaDecode+0xf88>
cmp    -0x70(%rsp),%r8
je     2104 <LzmaDecode+0x1004>
shl    $0x8,%r15d
shl    $0x8,%r13d
movzbl (%r8),%eax
add    $0x1,%r8
or     %eax,%r13d
movslq %ebp,%rbp
mov    %r15d,%r12d
shr    $0xb,%r12d
movzwl (%r9,%rbp,2),%esi
imul   %esi,%r12d
mov    %r13d,%eax
sub    %r12d,%eax
jae    2030 <LzmaDecode+0xf30>
mov    $0x800,%eax
sub    %esi,%eax
shr    $0x5,%eax
add    %esi,%eax
mov    %ax,(%r9,%rbp,2)
add    %ebp,%ebp
mov    %r12d,%r15d
jmp    2056 <LzmaDecode+0xf56>
xor    %ebp,%ebp
mov    -0x78(%rsp),%r9
test   $0x1,%dl
mov    0x58(%rsp),%rdx
je     20e8 <LzmaDecode+0xfe8>
add    %r10d,%ebp
mov    %ebp,%eax
sub    %r9d,%eax
movups (%rdx,%rax,1),%xmm1
movdqu 0x10(%rdx,%rax,1),%xmm0
movups %xmm1,(%rdx,%rbp,1)
movdqu %xmm0,0x10(%rdx,%rbp,1)
add    %esi,%r10d
cmp    %esi,%ecx
jne    20fc <LzmaDecode+0xffc>
pextrw $0x7,%xmm0,%esi
shr    $0x8,%esi
jmp    1e6e <LzmaDecode+0xd6e>
sub    %esi,%r11d
jmp    1e3b <LzmaDecode+0xd3b>
mov    $0x1,%eax
jmp    2131 <LzmaDecode+0x1031>
cmp    $0xffffff,%r12d
ja     2127 <LzmaDecode+0x1027>
mov    $0x1,%eax
cmp    -0x70(%rsp),%r8
mov    0x68(%rsp),%r14
je     2131 <LzmaDecode+0x1031>
jmp    212c <LzmaDecode+0x102c>
mov    0x68(%rsp),%r14
mov    %r10d,(%r14)
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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