_forceinline void Unpack::InsertOldDist(uint Distance)

{

  OldDist[3]=OldDist[2];

  OldDist[2]=OldDist[1];

  OldDist[1]=OldDist[0];

  OldDist[0]=Distance;

}

#ifdef _MSC_VER

#define FAST_MEMCPY

#endif

_forceinline void Unpack::CopyString(uint Length,uint Distance)

{

  size_t SrcPtr=UnpPtr-Distance;

  if (SrcPtr<MaxWinSize-MAX_INC_LZ_MATCH && UnpPtr<MaxWinSize-MAX_INC_LZ_MATCH)

  {

    // If we are not close to end of window, we do not need to waste time

    // to "& MaxWinMask" pointer protection.

    byte *Src=Window+SrcPtr;

    byte *Dest=Window+UnpPtr;

    UnpPtr+=Length;

#ifdef FAST_MEMCPY

    if (Distance<Length) // Overlapping strings

#endif

      while (Length>=8)

      {

        Dest[0]=Src[0];

        Dest[1]=Src[1];

        Dest[2]=Src[2];

        Dest[3]=Src[3];

        Dest[4]=Src[4];

        Dest[5]=Src[5];

        Dest[6]=Src[6];

        Dest[7]=Src[7];

        Src+=8;

        Dest+=8;

        Length-=8;

      }

#ifdef FAST_MEMCPY

    else

      while (Length>=8)

      {

        // In theory we still could overlap here.

        // Supposing Distance == MaxWinSize - 1 we have memcpy(Src, Src + 1, 8).

        // But for real RAR archives Distance <= MaxWinSize - MAX_INC_LZ_MATCH

        // always, so overlap here is impossible.

        // This memcpy expanded inline by MSVC. We could also use uint64

        // assignment, which seems to provide about the same speed.

        memcpy(Dest,Src,8); 

        Src+=8;

        Dest+=8;

        Length-=8;

      }

#endif

    // Unroll the loop for 0 - 7 bytes left. Note that we use nested "if"s.

    if (Length>0) { Dest[0]=Src[0];

    if (Length>1) { Dest[1]=Src[1];

    if (Length>2) { Dest[2]=Src[2];

    if (Length>3) { Dest[3]=Src[3];

    if (Length>4) { Dest[4]=Src[4];

    if (Length>5) { Dest[5]=Src[5];

    if (Length>6) { Dest[6]=Src[6]; } } } } } } } // Close all nested "if"s.

  }

  else

    while (Length-- > 0) // Slow copying with all possible precautions.

    {

      Window[UnpPtr]=Window[SrcPtr++ & MaxWinMask];

      // We need to have masked UnpPtr after quit from loop, so it must not

      // be replaced with 'Window[UnpPtr++ & MaxWinMask]'

      UnpPtr=(UnpPtr+1) & MaxWinMask;

    }

}

_forceinline uint Unpack::DecodeNumber(BitInput &Inp,DecodeTable *Dec)

{

  // Left aligned 15 bit length raw bit field.

  uint BitField=Inp.getbits() & 0xfffe;

  if (BitField<Dec->DecodeLen[Dec->QuickBits])

  {

    uint Code=BitField>>(16-Dec->QuickBits);

    Inp.addbits(Dec->QuickLen[Code]);

    return Dec->QuickNum[Code];

  }

  // Detect the real bit length for current code.

  uint Bits=15;

  for (uint I=Dec->QuickBits+1;I<15;I++)

    if (BitField<Dec->DecodeLen[I])

    {

      Bits=I;

      break;

    }

  Inp.addbits(Bits);

  // Calculate the distance from the start code for current bit length.

  uint Dist=BitField-Dec->DecodeLen[Bits-1];

  // Start codes are left aligned, but we need the normal right aligned

  // number. So we shift the distance to the right.

  Dist>>=(16-Bits);

  // Now we can calculate the position in the code list. It is the sum

  // of first position for current bit length and right aligned distance

  // between our bit field and start code for current bit length.

  uint Pos=Dec->DecodePos[Bits]+Dist;

  // Out of bounds safety check required for damaged archives.

  if (Pos>=Dec->MaxNum)

    Pos=0;

  // Convert the position in the code list to position in alphabet

  // and return it.

  return Dec->DecodeNum[Pos];

}

_forceinline uint Unpack::SlotToLength(BitInput &Inp,uint Slot)

{

  uint LBits,Length=2;

  if (Slot<8)

  {

    LBits=0;

    Length+=Slot;

  }

  else

  {

    LBits=Slot/4-1;

    Length+=(4 | (Slot & 3)) << LBits;

  }

  if (LBits>0)

  {

    Length+=Inp.getbits()>>(16-LBits);

    Inp.addbits(LBits);

  }

  return Length;

}