j = 0;         while (True) {            GET_BIT(BZ_X_SELECTOR_3, uc);            if (uc == 0) break;            j++;            if (j >= nGroups) RETURN(BZ_DATA_ERROR);         }         s->selectorMtf[i] = j;      }      /*--- Undo the MTF values for the selectors. ---*/      {         UChar pos[BZ_N_GROUPS], tmp, v;         for (v = 0; v < nGroups; v++) pos[v] = v;            for (i = 0; i < nSelectors; i++) {            v = s->selectorMtf[i];            tmp = pos[v];            while (v > 0) { pos[v] = pos[v-1]; v--; }            pos[0] = tmp;            s->selector[i] = tmp;         }      }      /*--- Now the coding tables ---*/      for (t = 0; t < nGroups; t++) {         GET_BITS(BZ_X_CODING_1, curr, 5);         for (i = 0; i < alphaSize; i++) {            while (True) {               if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);               GET_BIT(BZ_X_CODING_2, uc);               if (uc == 0) break;               GET_BIT(BZ_X_CODING_3, uc);               if (uc == 0) curr++; else curr--;            }            s->len[t][i] = curr;         }      }      /*--- Create the Huffman decoding tables ---*/      for (t = 0; t < nGroups; t++) {         minLen = 32;         maxLen = 0;         for (i = 0; i < alphaSize; i++) {            if (s->len[t][i] > maxLen) maxLen = s->len[t][i];            if (s->len[t][i] < minLen) minLen = s->len[t][i];         }         BZ2_hbCreateDecodeTables (             &(s->limit[t][0]),             &(s->base[t][0]),             &(s->perm[t][0]),             &(s->len[t][0]),            minLen, maxLen, alphaSize         );         s->minLens[t] = minLen;      }      /*--- Now the MTF values ---*/      EOB      = s->nInUse+1;      nblockMAX = 100000 * s->blockSize100k;      groupNo  = -1;      groupPos = 0;      for (i = 0; i <= 255; i++) s->unzftab[i] = 0;      /*-- MTF init --*/      {         Int32 ii, jj, kk;         kk = MTFA_SIZE-1;         for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {            for (jj = MTFL_SIZE-1; jj >= 0; jj--) {               s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);               kk--;            }            s->mtfbase[ii] = kk + 1;         }      }      /*-- end MTF init --*/      nblock = 0;      GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);      while (True) {         if (nextSym == EOB) break;         if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {            es = -1;            N = 1;            do {               if (nextSym == BZ_RUNA) es = es + (0+1) * N; else               if (nextSym == BZ_RUNB) es = es + (1+1) * N;               N = N * 2;               GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);            }               while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);            es++;            uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];            s->unzftab[uc] += es;            if (s->smallDecompress)               while (es > 0) {                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);                  s->ll16[nblock] = (UInt16)uc;                  nblock++;                  es--;               }            else               while (es > 0) {                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);                  s->tt[nblock] = (UInt32)uc;                  nblock++;                  es--;               };            continue;         } else {            if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);            /*-- uc = MTF ( nextSym-1 ) --*/            {               Int32 ii, jj, kk, pp, lno, off;               UInt32 nn;               nn = (UInt32)(nextSym - 1);               if (nn < MTFL_SIZE) {                  /* avoid general-case expense */                  pp = s->mtfbase[0];                  uc = s->mtfa[pp+nn];                  while (nn > 3) {                     Int32 z = pp+nn;                     s->mtfa[(z)  ] = s->mtfa[(z)-1];                     s->mtfa[(z)-1] = s->mtfa[(z)-2];                     s->mtfa[(z)-2] = s->mtfa[(z)-3];                     s->mtfa[(z)-3] = s->mtfa[(z)-4];                     nn -= 4;                  }                  while (nn > 0) {                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;                   };                  s->mtfa[pp] = uc;               } else {                   /* general case */                  lno = nn / MTFL_SIZE;                  off = nn % MTFL_SIZE;                  pp = s->mtfbase[lno] + off;                  uc = s->mtfa[pp];                  while (pp > s->mtfbase[lno]) {                      s->mtfa[pp] = s->mtfa[pp-1]; pp--;                   };                  s->mtfbase[lno]++;                  while (lno > 0) {                     s->mtfbase[lno]--;                     s->mtfa[s->mtfbase[lno]]                         = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];                     lno--;                  }                  s->mtfbase[0]--;                  s->mtfa[s->mtfbase[0]] = uc;                  if (s->mtfbase[0] == 0) {                     kk = MTFA_SIZE-1;                     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {                        for (jj = MTFL_SIZE-1; jj >= 0; jj--) {                           s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];                           kk--;                        }                        s->mtfbase[ii] = kk + 1;                     }                  }               }            }            /*-- end uc = MTF ( nextSym-1 ) --*/            s->unzftab[s->seqToUnseq[uc]]++;            if (s->smallDecompress)               s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else               s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);            nblock++;            GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);            continue;         }      }      /* Now we know what nblock is, we can do a better sanity         check on s->origPtr.      */      if (s->origPtr < 0 || s->origPtr >= nblock)         RETURN(BZ_DATA_ERROR);      s->state_out_len = 0;      s->state_out_ch  = 0;      BZ_INITIALISE_CRC ( s->calculatedBlockCRC );      s->state = BZ_X_OUTPUT;      if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );      /*-- Set up cftab to facilitate generation of T^(-1) --*/      s->cftab[0] = 0;      for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];      for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];      if (s->smallDecompress) {         /*-- Make a copy of cftab, used in generation of T --*/         for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];         /*-- compute the T vector --*/         for (i = 0; i < nblock; i++) {            uc = (UChar)(s->ll16[i]);            SET_LL(i, s->cftabCopy[uc]);            s->cftabCopy[uc]++;         }         /*-- Compute T^(-1) by pointer reversal on T --*/         i = s->origPtr;         j = GET_LL(i);         do {            Int32 tmp = GET_LL(j);            SET_LL(j, i);            i = j;            j = tmp;         }            while (i != s->origPtr);         s->tPos = s->origPtr;         s->nblock_used = 0;         if (s->blockRandomised) {            BZ_RAND_INIT_MASK;            BZ_GET_SMALL(s->k0); s->nblock_used++;            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;          } else {            BZ_GET_SMALL(s->k0); s->nblock_used++;         }      } else {         /*-- compute the T^(-1) vector --*/         for (i = 0; i < nblock; i++) {            uc = (UChar)(s->tt[i] & 0xff);            s->tt[s->cftab[uc]] |= (i << 8);            s->cftab[uc]++;         }         s->tPos = s->tt[s->origPtr] >> 8;         s->nblock_used = 0;         if (s->blockRandomised) {            BZ_RAND_INIT_MASK;            BZ_GET_FAST(s->k0); s->nblock_used++;            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;          } else {            BZ_GET_FAST(s->k0); s->nblock_used++;         }      }      RETURN(BZ_OK);    endhdr_2:      GET_UCHAR(BZ_X_ENDHDR_2, uc);      if (uc != 0x72) RETURN(BZ_DATA_ERROR);      GET_UCHAR(BZ_X_ENDHDR_3, uc);      if (uc != 0x45) RETURN(BZ_DATA_ERROR);      GET_UCHAR(BZ_X_ENDHDR_4, uc);      if (uc != 0x38) RETURN(BZ_DATA_ERROR);      GET_UCHAR(BZ_X_ENDHDR_5, uc);      if (uc != 0x50) RETURN(BZ_DATA_ERROR);      GET_UCHAR(BZ_X_ENDHDR_6, uc);      if (uc != 0x90) RETURN(BZ_DATA_ERROR);      s->storedCombinedCRC = 0;      GET_UCHAR(BZ_X_CCRC_1, uc);      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);      GET_UCHAR(BZ_X_CCRC_2, uc);      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);      GET_UCHAR(BZ_X_CCRC_3, uc);      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);      GET_UCHAR(BZ_X_CCRC_4, uc);      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);      s->state = BZ_X_IDLE;      RETURN(BZ_STREAM_END);      default: AssertH ( False, 4001 );   }   AssertH ( False, 4002 );   save_state_and_return:   s->save_i           = i;   s->save_j           = j;   s->save_t           = t;   s->save_alphaSize   = alphaSize;   s->save_nGroups     = nGroups;   s->save_nSelectors  = nSelectors;   s->save_EOB         = EOB;   s->save_groupNo     = groupNo;   s->save_groupPos    = groupPos;   s->save_nextSym     = nextSym;   s->save_nblockMAX   = nblockMAX;   s->save_nblock      = nblock;   s->save_es          = es;   s->save_N           = N;   s->save_curr        = curr;   s->save_zt          = zt;   s->save_zn          = zn;   s->save_zvec        = zvec;   s->save_zj          = zj;   s->save_gSel        = gSel;   s->save_gMinlen     = gMinlen;   s->save_gLimit      = gLimit;   s->save_gBase       = gBase;   s->save_gPerm       = gPerm;   return retVal;   }/*-------------------------------------------------------------*//*--- end                                      decompress.c ---*//*-------------------------------------------------------------*/