react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/C/Ppmd7.h

@@ -1,11 +1,13 @@
-/* Ppmd7.h -- Ppmd7 (PPMdH) compression codec
-2023-04-02 : Igor Pavlov : Public domain
-This code is based on:
-  PPMd var.H (2001): Dmitry Shkarin : Public domain */
- 
+/* Ppmd7.h -- PPMdH compression codec
+2018-07-04 : Igor Pavlov : Public domain
+This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
+
+/* This code supports virtual RangeDecoder and includes the implementation
+of RangeCoder from 7z, instead of RangeCoder from original PPMd var.H.
+If you need the compatibility with original PPMd var.H, you can use external RangeDecoder */
 
-#ifndef ZIP7_INC_PPMD7_H
-#define ZIP7_INC_PPMD7_H
+#ifndef __PPMD7_H
+#define __PPMD7_H
 
 #include "Ppmd.h"
 
@@ -19,56 +21,23 @@ EXTERN_C_BEGIN
 
 struct CPpmd7_Context_;
 
-typedef Ppmd_Ref_Type(struct CPpmd7_Context_) CPpmd7_Context_Ref;
-
-// MY_CPU_pragma_pack_push_1
+typedef
+  #ifdef PPMD_32BIT
+    struct CPpmd7_Context_ *
+  #else
+    UInt32
+  #endif
+  CPpmd7_Context_Ref;
 
 typedef struct CPpmd7_Context_
 {
   UInt16 NumStats;
-
-
-  union
-  {
-    UInt16 SummFreq;
-    CPpmd_State2 State2;
-  } Union2;
-
-  union
-  {
-    CPpmd_State_Ref Stats;
-    CPpmd_State4 State4;
-  } Union4;
-
+  UInt16 SummFreq;
+  CPpmd_State_Ref Stats;
   CPpmd7_Context_Ref Suffix;
 } CPpmd7_Context;
 
-// MY_CPU_pragma_pop
-
-#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->Union2)
-
-
-
-
-typedef struct
-{
-  UInt32 Range;
-  UInt32 Code;
-  UInt32 Low;
-  IByteInPtr Stream;
-} CPpmd7_RangeDec;
-
-
-typedef struct
-{
-  UInt32 Range;
-  Byte Cache;
-  // Byte _dummy_[3];
-  UInt64 Low;
-  UInt64 CacheSize;
-  IByteOutPtr Stream;
-} CPpmd7z_RangeEnc;
-
+#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->SummFreq)
 
 typedef struct
 {
@@ -79,30 +48,17 @@ typedef struct
 
   UInt32 Size;
   UInt32 GlueCount;
-  UInt32 AlignOffset;
   Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
+  UInt32 AlignOffset;
 
-
-  
-  
-  union
-  {
-    CPpmd7_RangeDec dec;
-    CPpmd7z_RangeEnc enc;
-  } rc;
-  
-  Byte Indx2Units[PPMD_NUM_INDEXES + 2]; // +2 for alignment
+  Byte Indx2Units[PPMD_NUM_INDEXES];
   Byte Units2Indx[128];
   CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
-
-  Byte NS2BSIndx[256], NS2Indx[256];
-  Byte ExpEscape[16];
+  Byte NS2Indx[256], NS2BSIndx[256], HB2Flag[256];
   CPpmd_See DummySee, See[25][16];
   UInt16 BinSumm[128][64];
-  // int LastSymbol;
 } CPpmd7;
 
-
 void Ppmd7_Construct(CPpmd7 *p);
 BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc);
 void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc);
@@ -112,69 +68,74 @@ void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder);
 
 /* ---------- Internal Functions ---------- */
 
-#define Ppmd7_GetPtr(p, ptr)     Ppmd_GetPtr(p, ptr)
-#define Ppmd7_GetContext(p, ptr) Ppmd_GetPtr_Type(p, ptr, CPpmd7_Context)
-#define Ppmd7_GetStats(p, ctx)   Ppmd_GetPtr_Type(p, (ctx)->Union4.Stats, CPpmd_State)
+extern const Byte PPMD7_kExpEscape[16];
+
+#ifdef PPMD_32BIT
+  #define Ppmd7_GetPtr(p, ptr) (ptr)
+  #define Ppmd7_GetContext(p, ptr) (ptr)
+  #define Ppmd7_GetStats(p, ctx) ((ctx)->Stats)
+#else
+  #define Ppmd7_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
+  #define Ppmd7_GetContext(p, offs) ((CPpmd7_Context *)Ppmd7_GetPtr((p), (offs)))
+  #define Ppmd7_GetStats(p, ctx) ((CPpmd_State *)Ppmd7_GetPtr((p), ((ctx)->Stats)))
+#endif
 
 void Ppmd7_Update1(CPpmd7 *p);
 void Ppmd7_Update1_0(CPpmd7 *p);
 void Ppmd7_Update2(CPpmd7 *p);
-
-#define PPMD7_HiBitsFlag_3(sym) ((((unsigned)sym + 0xC0) >> (8 - 3)) & (1 << 3))
-#define PPMD7_HiBitsFlag_4(sym) ((((unsigned)sym + 0xC0) >> (8 - 4)) & (1 << 4))
-// #define PPMD7_HiBitsFlag_3(sym) ((sym) < 0x40 ? 0 : (1 << 3))
-// #define PPMD7_HiBitsFlag_4(sym) ((sym) < 0x40 ? 0 : (1 << 4))
+void Ppmd7_UpdateBin(CPpmd7 *p);
 
 #define Ppmd7_GetBinSumm(p) \
-    &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1] \
-    [ p->PrevSuccess + ((p->RunLength >> 26) & 0x20) \
-    + p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] \
-    + PPMD7_HiBitsFlag_4(Ppmd7Context_OneState(p->MinContext)->Symbol) \
-    + (p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol)) ]
+    &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1][p->PrevSuccess + \
+    p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] + \
+    (p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol]) + \
+    2 * p->HB2Flag[(unsigned)Ppmd7Context_OneState(p->MinContext)->Symbol] + \
+    ((p->RunLength >> 26) & 0x20)]
 
 CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);
 
 
-/*
-We support two versions of Ppmd7 (PPMdH) methods that use same CPpmd7 structure:
-  1) Ppmd7a_*: original PPMdH
-  2) Ppmd7z_*: modified PPMdH with 7z Range Coder
-Ppmd7_*: the structures and functions that are common for both versions of PPMd7 (PPMdH)
-*/
-
 /* ---------- Decode ---------- */
 
-#define PPMD7_SYM_END    (-1)
-#define PPMD7_SYM_ERROR  (-2)
-
-/*
-You must set (CPpmd7::rc.dec.Stream) before Ppmd7*_RangeDec_Init()
+typedef struct IPpmd7_RangeDec IPpmd7_RangeDec;
 
-Ppmd7*_DecodeSymbol()
-out:
-  >= 0 : decoded byte
-    -1 : PPMD7_SYM_END   : End of payload marker
-    -2 : PPMD7_SYM_ERROR : Data error
-*/
+struct IPpmd7_RangeDec
+{
+  UInt32 (*GetThreshold)(const IPpmd7_RangeDec *p, UInt32 total);
+  void (*Decode)(const IPpmd7_RangeDec *p, UInt32 start, UInt32 size);
+  UInt32 (*DecodeBit)(const IPpmd7_RangeDec *p, UInt32 size0);
+};
 
-/* Ppmd7a_* : original PPMdH */
-BoolInt Ppmd7a_RangeDec_Init(CPpmd7_RangeDec *p);
-#define Ppmd7a_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
-int Ppmd7a_DecodeSymbol(CPpmd7 *p);
+typedef struct
+{
+  IPpmd7_RangeDec vt;
+  UInt32 Range;
+  UInt32 Code;
+  IByteIn *Stream;
+} CPpmd7z_RangeDec;
 
-/* Ppmd7z_* : modified PPMdH with 7z Range Coder */
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p);
+void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p);
+BoolInt Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p);
 #define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
-int Ppmd7z_DecodeSymbol(CPpmd7 *p);
-// Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim);
+
+int Ppmd7_DecodeSymbol(CPpmd7 *p, const IPpmd7_RangeDec *rc);
 
 
 /* ---------- Encode ---------- */
 
-void Ppmd7z_Init_RangeEnc(CPpmd7 *p);
-void Ppmd7z_Flush_RangeEnc(CPpmd7 *p);
-// void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol);
-void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim);
+typedef struct
+{
+  UInt64 Low;
+  UInt32 Range;
+  Byte Cache;
+  UInt64 CacheSize;
+  IByteOut *Stream;
+} CPpmd7z_RangeEnc;
+
+void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc *p);
+void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc *p);
+
+void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol);
 
 EXTERN_C_END
  

package/harmony/pushy/src/main/cpp/lzma/C/Ppmd7Dec.c

@@ -1,312 +1,191 @@
-/* Ppmd7Dec.c -- Ppmd7z (PPMdH with 7z Range Coder) Decoder
-2023-09-07 : Igor Pavlov : Public domain
-This code is based on:
-  PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
+/* Ppmd7Dec.c -- PPMdH Decoder
+2018-07-04 : Igor Pavlov : Public domain
+This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
 
 #include "Precomp.h"
 
 #include "Ppmd7.h"
 
-#define kTopValue ((UInt32)1 << 24)
-
-
-#define READ_BYTE(p) IByteIn_Read((p)->Stream)
+#define kTopValue (1 << 24)
 
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p)
+BoolInt Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p)
 {
   unsigned i;
   p->Code = 0;
   p->Range = 0xFFFFFFFF;
-  if (READ_BYTE(p) != 0)
+  if (IByteIn_Read(p->Stream) != 0)
     return False;
   for (i = 0; i < 4; i++)
-    p->Code = (p->Code << 8) | READ_BYTE(p);
+    p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
   return (p->Code < 0xFFFFFFFF);
 }
 
-#define RC_NORM_BASE(p) if ((p)->Range < kTopValue) \
-  { (p)->Code = ((p)->Code << 8) | READ_BYTE(p); (p)->Range <<= 8;
-
-#define RC_NORM_1(p)  RC_NORM_BASE(p) }
-#define RC_NORM(p)    RC_NORM_BASE(p) RC_NORM_BASE(p) }}
-
-// we must use only one type of Normalization from two: LOCAL or REMOTE
-#define RC_NORM_LOCAL(p)    // RC_NORM(p)
-#define RC_NORM_REMOTE(p)   RC_NORM(p)
+#define GET_Ppmd7z_RangeDec CPpmd7z_RangeDec *p = CONTAINER_FROM_VTBL(pp, CPpmd7z_RangeDec, vt);
+ 
+static UInt32 Range_GetThreshold(const IPpmd7_RangeDec *pp, UInt32 total)
+{
+  GET_Ppmd7z_RangeDec
+  return p->Code / (p->Range /= total);
+}
 
-#define R (&p->rc.dec)
+static void Range_Normalize(CPpmd7z_RangeDec *p)
+{
+  if (p->Range < kTopValue)
+  {
+    p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
+    p->Range <<= 8;
+    if (p->Range < kTopValue)
+    {
+      p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
+      p->Range <<= 8;
+    }
+  }
+}
 
-Z7_FORCE_INLINE
-// Z7_NO_INLINE
-static void Ppmd7z_RD_Decode(CPpmd7 *p, UInt32 start, UInt32 size)
+static void Range_Decode(const IPpmd7_RangeDec *pp, UInt32 start, UInt32 size)
 {
+  GET_Ppmd7z_RangeDec
+  p->Code -= start * p->Range;
+  p->Range *= size;
+  Range_Normalize(p);
+}
 
-  
-  R->Code -= start * R->Range;
-  R->Range *= size;
-  RC_NORM_LOCAL(R)
+static UInt32 Range_DecodeBit(const IPpmd7_RangeDec *pp, UInt32 size0)
+{
+  GET_Ppmd7z_RangeDec
+  UInt32 newBound = (p->Range >> 14) * size0;
+  UInt32 symbol;
+  if (p->Code < newBound)
+  {
+    symbol = 0;
+    p->Range = newBound;
+  }
+  else
+  {
+    symbol = 1;
+    p->Code -= newBound;
+    p->Range -= newBound;
+  }
+  Range_Normalize(p);
+  return symbol;
 }
 
-#define RC_Decode(start, size)  Ppmd7z_RD_Decode(p, start, size);
-#define RC_DecodeFinal(start, size)  RC_Decode(start, size)  RC_NORM_REMOTE(R)
-#define RC_GetThreshold(total)  (R->Code / (R->Range /= (total)))
+void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p)
+{
+  p->vt.GetThreshold = Range_GetThreshold;
+  p->vt.Decode = Range_Decode;
+  p->vt.DecodeBit = Range_DecodeBit;
+}
 
 
-#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))
-// typedef CPpmd7_Context * CTX_PTR;
-#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
-void Ppmd7_UpdateModel(CPpmd7 *p);
+#define MASK(sym) ((signed char *)charMask)[sym]
 
-#define MASK(sym)  ((Byte *)charMask)[sym]
-// Z7_FORCE_INLINE
-// static
-int Ppmd7z_DecodeSymbol(CPpmd7 *p)
+int Ppmd7_DecodeSymbol(CPpmd7 *p, const IPpmd7_RangeDec *rc)
 {
   size_t charMask[256 / sizeof(size_t)];
-
   if (p->MinContext->NumStats != 1)
   {
     CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
     unsigned i;
     UInt32 count, hiCnt;
-    const UInt32 summFreq = p->MinContext->Union2.SummFreq;
-
-    
-    
-    
-    count = RC_GetThreshold(summFreq);
-    hiCnt = count;
-    
-    if ((Int32)(count -= s->Freq) < 0)
+    if ((count = rc->GetThreshold(rc, p->MinContext->SummFreq)) < (hiCnt = s->Freq))
     {
-      Byte sym;
-      RC_DecodeFinal(0, s->Freq)
+      Byte symbol;
+      rc->Decode(rc, 0, s->Freq);
       p->FoundState = s;
-      sym = s->Symbol;
+      symbol = s->Symbol;
       Ppmd7_Update1_0(p);
-      return sym;
+      return symbol;
     }
-  
     p->PrevSuccess = 0;
-    i = (unsigned)p->MinContext->NumStats - 1;
-    
+    i = p->MinContext->NumStats - 1;
     do
     {
-      if ((Int32)(count -= (++s)->Freq) < 0)
+      if ((hiCnt += (++s)->Freq) > count)
       {
-        Byte sym;
-        RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq)
+        Byte symbol;
+        rc->Decode(rc, hiCnt - s->Freq, s->Freq);
         p->FoundState = s;
-        sym = s->Symbol;
+        symbol = s->Symbol;
         Ppmd7_Update1(p);
-        return sym;
+        return symbol;
       }
     }
     while (--i);
-    
-    if (hiCnt >= summFreq)
-      return PPMD7_SYM_ERROR;
-    
-    hiCnt -= count;
-    RC_Decode(hiCnt, summFreq - hiCnt)
-
-    p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol);
-    PPMD_SetAllBitsIn256Bytes(charMask)
-    // i = p->MinContext->NumStats - 1;
-    // do { MASK((--s)->Symbol) = 0; } while (--i);
-    {
-      CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);
-      MASK(s->Symbol) = 0;
-      do
-      {
-        const unsigned sym0 = s2[0].Symbol;
-        const unsigned sym1 = s2[1].Symbol;
-        s2 += 2;
-        MASK(sym0) = 0;
-        MASK(sym1) = 0;
-      }
-      while (s2 < s);
-    }
+    if (count >= p->MinContext->SummFreq)
+      return -2;
+    p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol];
+    rc->Decode(rc, hiCnt, p->MinContext->SummFreq - hiCnt);
+    PPMD_SetAllBitsIn256Bytes(charMask);
+    MASK(s->Symbol) = 0;
+    i = p->MinContext->NumStats - 1;
+    do { MASK((--s)->Symbol) = 0; } while (--i);
   }
   else
   {
-    CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);
     UInt16 *prob = Ppmd7_GetBinSumm(p);
-    UInt32 pr = *prob;
-    UInt32 size0 = (R->Range >> 14) * pr;
-    pr = PPMD_UPDATE_PROB_1(pr);
-
-    if (R->Code < size0)
+    if (rc->DecodeBit(rc, *prob) == 0)
     {
-      Byte sym;
-      *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));
-      
-      // RangeDec_DecodeBit0(size0);
-      R->Range = size0;
-      RC_NORM_1(R)
-      /* we can use single byte normalization here because of
-         (min(BinSumm[][]) = 95) > (1 << (14 - 8)) */
-
-      // sym = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
-      // Ppmd7_UpdateBin(p);
-      {
-        unsigned freq = s->Freq;
-        CPpmd7_Context *c = CTX(SUCCESSOR(s));
-        sym = s->Symbol;
-        p->FoundState = s;
-        p->PrevSuccess = 1;
-        p->RunLength++;
-        s->Freq = (Byte)(freq + (freq < 128));
-        // NextContext(p);
-        if (p->OrderFall == 0 && (const Byte *)c > p->Text)
-          p->MaxContext = p->MinContext = c;
-        else
-          Ppmd7_UpdateModel(p);
-      }
-      return sym;
+      Byte symbol;
+      *prob = (UInt16)PPMD_UPDATE_PROB_0(*prob);
+      symbol = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
+      Ppmd7_UpdateBin(p);
+      return symbol;
     }
-
-    *prob = (UInt16)pr;
-    p->InitEsc = p->ExpEscape[pr >> 10];
-
-    // RangeDec_DecodeBit1(size0);
-    
-    R->Code -= size0;
-    R->Range -= size0;
-    RC_NORM_LOCAL(R)
-    
-    PPMD_SetAllBitsIn256Bytes(charMask)
+    *prob = (UInt16)PPMD_UPDATE_PROB_1(*prob);
+    p->InitEsc = PPMD7_kExpEscape[*prob >> 10];
+    PPMD_SetAllBitsIn256Bytes(charMask);
     MASK(Ppmd7Context_OneState(p->MinContext)->Symbol) = 0;
     p->PrevSuccess = 0;
   }
-
   for (;;)
   {
-    CPpmd_State *s, *s2;
+    CPpmd_State *ps[256], *s;
     UInt32 freqSum, count, hiCnt;
-
     CPpmd_See *see;
-    CPpmd7_Context *mc;
-    unsigned numMasked;
-    RC_NORM_REMOTE(R)
-    mc = p->MinContext;
-    numMasked = mc->NumStats;
-
+    unsigned i, num, numMasked = p->MinContext->NumStats;
     do
     {
       p->OrderFall++;
-      if (!mc->Suffix)
-        return PPMD7_SYM_END;
-      mc = Ppmd7_GetContext(p, mc->Suffix);
+      if (!p->MinContext->Suffix)
+        return -1;
+      p->MinContext = Ppmd7_GetContext(p, p->MinContext->Suffix);
     }
-    while (mc->NumStats == numMasked);
-    
-    s = Ppmd7_GetStats(p, mc);
-
+    while (p->MinContext->NumStats == numMasked);
+    hiCnt = 0;
+    s = Ppmd7_GetStats(p, p->MinContext);
+    i = 0;
+    num = p->MinContext->NumStats - numMasked;
+    do
     {
-      unsigned num = mc->NumStats;
-      unsigned num2 = num / 2;
-      
-      num &= 1;
-      hiCnt = (s->Freq & (UInt32)(MASK(s->Symbol))) & (0 - (UInt32)num);
-      s += num;
-      p->MinContext = mc;
-
-      do
-      {
-        const unsigned sym0 = s[0].Symbol;
-        const unsigned sym1 = s[1].Symbol;
-        s += 2;
-        hiCnt += (s[-2].Freq & (UInt32)(MASK(sym0)));
-        hiCnt += (s[-1].Freq & (UInt32)(MASK(sym1)));
-      }
-      while (--num2);
+      int k = (int)(MASK(s->Symbol));
+      hiCnt += (s->Freq & k);
+      ps[i] = s++;
+      i -= k;
     }
-
+    while (i != num);
+    
     see = Ppmd7_MakeEscFreq(p, numMasked, &freqSum);
     freqSum += hiCnt;
-
-
-
-
-    count = RC_GetThreshold(freqSum);
+    count = rc->GetThreshold(rc, freqSum);
     
     if (count < hiCnt)
     {
-      Byte sym;
-
-      s = Ppmd7_GetStats(p, p->MinContext);
-      hiCnt = count;
-      // count -= s->Freq & (UInt32)(MASK(s->Symbol));
-      // if ((Int32)count >= 0)
-      {
-        for (;;)
-        {
-          count -= s->Freq & (UInt32)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;
-          // count -= s->Freq & (UInt32)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;
-        }
-      }
-      s--;
-      RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq)
-
-      // new (see->Summ) value can overflow over 16-bits in some rare cases
-      Ppmd_See_UPDATE(see)
+      Byte symbol;
+      CPpmd_State **pps = ps;
+      for (hiCnt = 0; (hiCnt += (*pps)->Freq) <= count; pps++);
+      s = *pps;
+      rc->Decode(rc, hiCnt - s->Freq, s->Freq);
+      Ppmd_See_Update(see);
       p->FoundState = s;
-      sym = s->Symbol;
+      symbol = s->Symbol;
       Ppmd7_Update2(p);
-      return sym;
+      return symbol;
     }
-
     if (count >= freqSum)
-      return PPMD7_SYM_ERROR;
-    
-    RC_Decode(hiCnt, freqSum - hiCnt)
-
-    // We increase (see->Summ) for sum of Freqs of all non_Masked symbols.
-    // new (see->Summ) value can overflow over 16-bits in some rare cases
+      return -2;
+    rc->Decode(rc, hiCnt, freqSum - hiCnt);
     see->Summ = (UInt16)(see->Summ + freqSum);
-
-    s = Ppmd7_GetStats(p, p->MinContext);
-    s2 = s + p->MinContext->NumStats;
-    do
-    {
-      MASK(s->Symbol) = 0;
-      s++;
-    }
-    while (s != s2);
+    do { MASK(ps[--i]->Symbol) = 0; } while (i != 0);
   }
 }
-
-/*
-Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim)
-{
-  int sym = 0;
-  if (buf != lim)
-  do
-  {
-    sym = Ppmd7z_DecodeSymbol(p);
-    if (sym < 0)
-      break;
-    *buf = (Byte)sym;
-  }
-  while (++buf < lim);
-  p->LastSymbol = sym;
-  return buf;
-}
-*/
-
-#undef kTopValue
-#undef READ_BYTE
-#undef RC_NORM_BASE
-#undef RC_NORM_1
-#undef RC_NORM
-#undef RC_NORM_LOCAL
-#undef RC_NORM_REMOTE
-#undef R
-#undef RC_Decode
-#undef RC_DecodeFinal
-#undef RC_GetThreshold
-#undef CTX
-#undef SUCCESSOR
-#undef MASK