Update the 7z installer stub source to 18.05.

Tag #1022

1 files changed, 1480 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LZMA/LzmaEncoder.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LZMA/LzmaEncoder.cs
new file mode 100644
index 000000000..6dc2708bd
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Compress/LZMA/LzmaEncoder.cs
@@ -0,0 +1,1480 @@
+// LzmaEncoder.cs

+

+using System;

+

+namespace SevenZip.Compression.LZMA

+{

+	using RangeCoder;

+

+	public class Encoder : ICoder, ISetCoderProperties, IWriteCoderProperties

+	{

+		enum EMatchFinderType

+		{

+			BT2,

+			BT4,

+		};

+

+		const UInt32 kIfinityPrice = 0xFFFFFFF;

+

+		static Byte[] g_FastPos = new Byte[1 << 11];

+

+		static Encoder()

+		{

+			const Byte kFastSlots = 22;

+			int c = 2;

+			g_FastPos[0] = 0;

+			g_FastPos[1] = 1;

+			for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)

+			{

+				UInt32 k = ((UInt32)1 << ((slotFast >> 1) - 1));

+				for (UInt32 j = 0; j < k; j++, c++)

+					g_FastPos[c] = slotFast;

+			}

+		}

+

+		static UInt32 GetPosSlot(UInt32 pos)

+		{

+			if (pos < (1 << 11))

+				return g_FastPos[pos];

+			if (pos < (1 << 21))

+				return (UInt32)(g_FastPos[pos >> 10] + 20);

+			return (UInt32)(g_FastPos[pos >> 20] + 40);

+		}

+

+		static UInt32 GetPosSlot2(UInt32 pos)

+		{

+			if (pos < (1 << 17))

+				return (UInt32)(g_FastPos[pos >> 6] + 12);

+			if (pos < (1 << 27))

+				return (UInt32)(g_FastPos[pos >> 16] + 32);

+			return (UInt32)(g_FastPos[pos >> 26] + 52);

+		}

+

+		Base.State _state = new Base.State();

+		Byte _previousByte;

+		UInt32[] _repDistances = new UInt32[Base.kNumRepDistances];

+

+		void BaseInit()

+		{

+			_state.Init();

+			_previousByte = 0;

+			for (UInt32 i = 0; i < Base.kNumRepDistances; i++)

+				_repDistances[i] = 0;

+		}

+

+		const int kDefaultDictionaryLogSize = 22;

+		const UInt32 kNumFastBytesDefault = 0x20;

+

+		class LiteralEncoder

+		{

+			public struct Encoder2

+			{

+				BitEncoder[] m_Encoders;

+

+				public void Create() { m_Encoders = new BitEncoder[0x300]; }

+

+				public void Init() { for (int i = 0; i < 0x300; i++) m_Encoders[i].Init(); }

+

+				public void Encode(RangeCoder.Encoder rangeEncoder, byte symbol)

+				{

+					uint context = 1;

+					for (int i = 7; i >= 0; i--)

+					{

+						uint bit = (uint)((symbol >> i) & 1);

+						m_Encoders[context].Encode(rangeEncoder, bit);

+						context = (context << 1) | bit;

+					}

+				}

+

+				public void EncodeMatched(RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol)

+				{

+					uint context = 1;

+					bool same = true;

+					for (int i = 7; i >= 0; i--)

+					{

+						uint bit = (uint)((symbol >> i) & 1);

+						uint state = context;

+						if (same)

+						{

+							uint matchBit = (uint)((matchByte >> i) & 1);

+							state += ((1 + matchBit) << 8);

+							same = (matchBit == bit);

+						}

+						m_Encoders[state].Encode(rangeEncoder, bit);

+						context = (context << 1) | bit;

+					}

+				}

+

+				public uint GetPrice(bool matchMode, byte matchByte, byte symbol)

+				{

+					uint price = 0;

+					uint context = 1;

+					int i = 7;

+					if (matchMode)

+					{

+						for (; i >= 0; i--)

+						{

+							uint matchBit = (uint)(matchByte >> i) & 1;

+							uint bit = (uint)(symbol >> i) & 1;

+							price += m_Encoders[((1 + matchBit) << 8) + context].GetPrice(bit);

+							context = (context << 1) | bit;

+							if (matchBit != bit)

+							{

+								i--;

+								break;

+							}

+						}

+					}

+					for (; i >= 0; i--)

+					{

+						uint bit = (uint)(symbol >> i) & 1;

+						price += m_Encoders[context].GetPrice(bit);

+						context = (context << 1) | bit;

+					}

+					return price;

+				}

+			}

+

+			Encoder2[] m_Coders;

+			int m_NumPrevBits;

+			int m_NumPosBits;

+			uint m_PosMask;

+

+			public void Create(int numPosBits, int numPrevBits)

+			{

+				if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)

+					return;

+				m_NumPosBits = numPosBits;

+				m_PosMask = ((uint)1 << numPosBits) - 1;

+				m_NumPrevBits = numPrevBits;

+				uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);

+				m_Coders = new Encoder2[numStates];

+				for (uint i = 0; i < numStates; i++)

+					m_Coders[i].Create();

+			}

+

+			public void Init()

+			{

+				uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);

+				for (uint i = 0; i < numStates; i++)

+					m_Coders[i].Init();

+			}

+

+			public Encoder2 GetSubCoder(UInt32 pos, Byte prevByte)

+			{ return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits))]; }

+		}

+

+		class LenEncoder

+		{

+			RangeCoder.BitEncoder _choice = new RangeCoder.BitEncoder();

+			RangeCoder.BitEncoder _choice2 = new RangeCoder.BitEncoder();

+			RangeCoder.BitTreeEncoder[] _lowCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax];

+			RangeCoder.BitTreeEncoder[] _midCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax];

+			RangeCoder.BitTreeEncoder _highCoder = new RangeCoder.BitTreeEncoder(Base.kNumHighLenBits);

+

+			public LenEncoder()

+			{

+				for (UInt32 posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++)

+				{

+					_lowCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumLowLenBits);

+					_midCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumMidLenBits);

+				}

+			}

+

+			public void Init(UInt32 numPosStates)

+			{

+				_choice.Init();

+				_choice2.Init();

+				for (UInt32 posState = 0; posState < numPosStates; posState++)

+				{

+					_lowCoder[posState].Init();

+					_midCoder[posState].Init();

+				}

+				_highCoder.Init();

+			}

+

+			public void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)

+			{

+				if (symbol < Base.kNumLowLenSymbols)

+				{

+					_choice.Encode(rangeEncoder, 0);

+					_lowCoder[posState].Encode(rangeEncoder, symbol);

+				}

+				else

+				{

+					symbol -= Base.kNumLowLenSymbols;

+					_choice.Encode(rangeEncoder, 1);

+					if (symbol < Base.kNumMidLenSymbols)

+					{

+						_choice2.Encode(rangeEncoder, 0);

+						_midCoder[posState].Encode(rangeEncoder, symbol);

+					}

+					else

+					{

+						_choice2.Encode(rangeEncoder, 1);

+						_highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols);

+					}

+				}

+			}

+

+			public void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32[] prices, UInt32 st)

+			{

+				UInt32 a0 = _choice.GetPrice0();

+				UInt32 a1 = _choice.GetPrice1();

+				UInt32 b0 = a1 + _choice2.GetPrice0();

+				UInt32 b1 = a1 + _choice2.GetPrice1();

+				UInt32 i = 0;

+				for (i = 0; i < Base.kNumLowLenSymbols; i++)

+				{

+					if (i >= numSymbols)

+						return;

+					prices[st + i] = a0 + _lowCoder[posState].GetPrice(i);

+				}

+				for (; i < Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; i++)

+				{

+					if (i >= numSymbols)

+						return;

+					prices[st + i] = b0 + _midCoder[posState].GetPrice(i - Base.kNumLowLenSymbols);

+				}

+				for (; i < numSymbols; i++)

+					prices[st + i] = b1 + _highCoder.GetPrice(i - Base.kNumLowLenSymbols - Base.kNumMidLenSymbols);

+			}

+		};

+

+		const UInt32 kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols;

+

+		class LenPriceTableEncoder : LenEncoder

+		{

+			UInt32[] _prices = new UInt32[Base.kNumLenSymbols << Base.kNumPosStatesBitsEncodingMax];

+			UInt32 _tableSize;

+			UInt32[] _counters = new UInt32[Base.kNumPosStatesEncodingMax];

+

+			public void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; }

+

+			public UInt32 GetPrice(UInt32 symbol, UInt32 posState)

+			{

+				return _prices[posState * Base.kNumLenSymbols + symbol];

+			}

+

+			void UpdateTable(UInt32 posState)

+			{

+				SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols);

+				_counters[posState] = _tableSize;

+			}

+

+			public void UpdateTables(UInt32 numPosStates)

+			{

+				for (UInt32 posState = 0; posState < numPosStates; posState++)

+					UpdateTable(posState);

+			}

+

+			public new void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)

+			{

+				base.Encode(rangeEncoder, symbol, posState);

+				if (--_counters[posState] == 0)

+					UpdateTable(posState);

+			}

+		}

+

+		const UInt32 kNumOpts = 1 << 12;

+		class Optimal

+		{

+			public Base.State State;

+

+			public bool Prev1IsChar;

+			public bool Prev2;

+

+			public UInt32 PosPrev2;

+			public UInt32 BackPrev2;

+

+			public UInt32 Price;

+			public UInt32 PosPrev;

+			public UInt32 BackPrev;

+

+			public UInt32 Backs0;

+			public UInt32 Backs1;

+			public UInt32 Backs2;

+			public UInt32 Backs3;

+

+			public void MakeAsChar() { BackPrev = 0xFFFFFFFF; Prev1IsChar = false; }

+			public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }

+			public bool IsShortRep() { return (BackPrev == 0); }

+		};

+		Optimal[] _optimum = new Optimal[kNumOpts];

+		LZ.IMatchFinder _matchFinder = null;

+		RangeCoder.Encoder _rangeEncoder = new RangeCoder.Encoder();

+

+		RangeCoder.BitEncoder[] _isMatch = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax];

+		RangeCoder.BitEncoder[] _isRep = new RangeCoder.BitEncoder[Base.kNumStates];

+		RangeCoder.BitEncoder[] _isRepG0 = new RangeCoder.BitEncoder[Base.kNumStates];

+		RangeCoder.BitEncoder[] _isRepG1 = new RangeCoder.BitEncoder[Base.kNumStates];

+		RangeCoder.BitEncoder[] _isRepG2 = new RangeCoder.BitEncoder[Base.kNumStates];

+		RangeCoder.BitEncoder[] _isRep0Long = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax];

+

+		RangeCoder.BitTreeEncoder[] _posSlotEncoder = new RangeCoder.BitTreeEncoder[Base.kNumLenToPosStates];

+		

+		RangeCoder.BitEncoder[] _posEncoders = new RangeCoder.BitEncoder[Base.kNumFullDistances - Base.kEndPosModelIndex];

+		RangeCoder.BitTreeEncoder _posAlignEncoder = new RangeCoder.BitTreeEncoder(Base.kNumAlignBits);

+

+		LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();

+		LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();

+

+		LiteralEncoder _literalEncoder = new LiteralEncoder();

+

+		UInt32[] _matchDistances = new UInt32[Base.kMatchMaxLen * 2 + 2];

+		

+		UInt32 _numFastBytes = kNumFastBytesDefault;

+		UInt32 _longestMatchLength;

+		UInt32 _numDistancePairs;

+

+		UInt32 _additionalOffset;

+

+		UInt32 _optimumEndIndex;

+		UInt32 _optimumCurrentIndex;

+

+		bool _longestMatchWasFound;

+

+		UInt32[] _posSlotPrices = new UInt32[1 << (Base.kNumPosSlotBits + Base.kNumLenToPosStatesBits)];

+		UInt32[] _distancesPrices = new UInt32[Base.kNumFullDistances << Base.kNumLenToPosStatesBits];

+		UInt32[] _alignPrices = new UInt32[Base.kAlignTableSize];

+		UInt32 _alignPriceCount;

+

+		UInt32 _distTableSize = (kDefaultDictionaryLogSize * 2);

+

+		int _posStateBits = 2;

+		UInt32 _posStateMask = (4 - 1);

+		int _numLiteralPosStateBits = 0;

+		int _numLiteralContextBits = 3;

+

+		UInt32 _dictionarySize = (1 << kDefaultDictionaryLogSize);

+		UInt32 _dictionarySizePrev = 0xFFFFFFFF;

+		UInt32 _numFastBytesPrev = 0xFFFFFFFF;

+

+		Int64 nowPos64;

+		bool _finished;

+		System.IO.Stream _inStream;

+

+		EMatchFinderType _matchFinderType = EMatchFinderType.BT4;

+		bool _writeEndMark = false;

+		

+		bool _needReleaseMFStream;

+

+		void Create()

+		{

+			if (_matchFinder == null)

+			{

+				LZ.BinTree bt = new LZ.BinTree();

+				int numHashBytes = 4;

+				if (_matchFinderType == EMatchFinderType.BT2)

+					numHashBytes = 2;

+				bt.SetType(numHashBytes);

+				_matchFinder = bt;

+			}

+			_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits);

+

+			if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)

+				return;

+			_matchFinder.Create(_dictionarySize, kNumOpts, _numFastBytes, Base.kMatchMaxLen + 1);

+			_dictionarySizePrev = _dictionarySize;

+			_numFastBytesPrev = _numFastBytes;

+		}

+

+		public Encoder()

+		{

+			for (int i = 0; i < kNumOpts; i++)

+				_optimum[i] = new Optimal();

+			for (int i = 0; i < Base.kNumLenToPosStates; i++)

+				_posSlotEncoder[i] = new RangeCoder.BitTreeEncoder(Base.kNumPosSlotBits);

+		}

+

+		void SetWriteEndMarkerMode(bool writeEndMarker)

+		{

+			_writeEndMark = writeEndMarker;

+		}

+

+		void Init()

+		{

+			BaseInit();

+			_rangeEncoder.Init();

+

+			uint i;

+			for (i = 0; i < Base.kNumStates; i++)

+			{

+				for (uint j = 0; j <= _posStateMask; j++)

+				{

+					uint complexState = (i << Base.kNumPosStatesBitsMax) + j;

+					_isMatch[complexState].Init();

+					_isRep0Long[complexState].Init();

+				}

+				_isRep[i].Init();

+				_isRepG0[i].Init();

+				_isRepG1[i].Init();

+				_isRepG2[i].Init();

+			}

+			_literalEncoder.Init();

+			for (i = 0; i < Base.kNumLenToPosStates; i++)

+				_posSlotEncoder[i].Init();

+			for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)

+				_posEncoders[i].Init();

+

+			_lenEncoder.Init((UInt32)1 << _posStateBits);

+			_repMatchLenEncoder.Init((UInt32)1 << _posStateBits);

+

+			_posAlignEncoder.Init();

+

+			_longestMatchWasFound = false;

+			_optimumEndIndex = 0;

+			_optimumCurrentIndex = 0;

+			_additionalOffset = 0;

+		}

+

+		void ReadMatchDistances(out UInt32 lenRes, out UInt32 numDistancePairs)

+		{

+			lenRes = 0;

+			numDistancePairs = _matchFinder.GetMatches(_matchDistances);

+			if (numDistancePairs > 0)

+			{

+				lenRes = _matchDistances[numDistancePairs - 2];

+				if (lenRes == _numFastBytes)

+					lenRes += _matchFinder.GetMatchLen((int)lenRes - 1, _matchDistances[numDistancePairs - 1],

+						Base.kMatchMaxLen - lenRes);

+			}

+			_additionalOffset++;

+		}

+

+

+		void MovePos(UInt32 num)

+		{

+			if (num > 0)

+			{

+				_matchFinder.Skip(num);

+				_additionalOffset += num;

+			}

+		}

+

+		UInt32 GetRepLen1Price(Base.State state, UInt32 posState)

+		{

+			return _isRepG0[state.Index].GetPrice0() +

+					_isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0();

+		}

+

+		UInt32 GetPureRepPrice(UInt32 repIndex, Base.State state, UInt32 posState)

+		{

+			UInt32 price;

+			if (repIndex == 0)

+			{

+				price = _isRepG0[state.Index].GetPrice0();

+				price += _isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();

+			}

+			else

+			{

+				price = _isRepG0[state.Index].GetPrice1();

+				if (repIndex == 1)

+					price += _isRepG1[state.Index].GetPrice0();

+				else

+				{

+					price += _isRepG1[state.Index].GetPrice1();

+					price += _isRepG2[state.Index].GetPrice(repIndex - 2);

+				}

+			}

+			return price;

+		}

+

+		UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, Base.State state, UInt32 posState)

+		{

+			UInt32 price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState);

+			return price + GetPureRepPrice(repIndex, state, posState);

+		}

+	

+		UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState)

+		{

+			UInt32 price;

+			UInt32 lenToPosState = Base.GetLenToPosState(len);

+			if (pos < Base.kNumFullDistances)

+				price = _distancesPrices[(lenToPosState * Base.kNumFullDistances) + pos];

+			else

+				price = _posSlotPrices[(lenToPosState << Base.kNumPosSlotBits) + GetPosSlot2(pos)] +

+					_alignPrices[pos & Base.kAlignMask];

+			return price + _lenEncoder.GetPrice(len - Base.kMatchMinLen, posState);

+		}

+

+		UInt32 Backward(out UInt32 backRes, UInt32 cur)

+		{

+			_optimumEndIndex = cur;

+			UInt32 posMem = _optimum[cur].PosPrev;

+			UInt32 backMem = _optimum[cur].BackPrev;

+			do

+			{

+				if (_optimum[cur].Prev1IsChar)

+				{

+					_optimum[posMem].MakeAsChar();

+					_optimum[posMem].PosPrev = posMem - 1;

+					if (_optimum[cur].Prev2)

+					{

+						_optimum[posMem - 1].Prev1IsChar = false;

+						_optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;

+						_optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;

+					}

+				}

+				UInt32 posPrev = posMem;

+				UInt32 backCur = backMem;

+

+				backMem = _optimum[posPrev].BackPrev;

+				posMem = _optimum[posPrev].PosPrev;

+

+				_optimum[posPrev].BackPrev = backCur;

+				_optimum[posPrev].PosPrev = cur;

+				cur = posPrev;

+			}

+			while (cur > 0);

+			backRes = _optimum[0].BackPrev;

+			_optimumCurrentIndex = _optimum[0].PosPrev;

+			return _optimumCurrentIndex;

+		}

+

+		UInt32[] reps = new UInt32[Base.kNumRepDistances];

+		UInt32[] repLens = new UInt32[Base.kNumRepDistances];

+

+

+		UInt32 GetOptimum(UInt32 position, out UInt32 backRes)

+		{

+			if (_optimumEndIndex != _optimumCurrentIndex)

+			{

+				UInt32 lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;

+				backRes = _optimum[_optimumCurrentIndex].BackPrev;

+				_optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;

+				return lenRes;

+			}

+			_optimumCurrentIndex = _optimumEndIndex = 0;

+

+			UInt32 lenMain, numDistancePairs;

+			if (!_longestMatchWasFound)

+			{

+				ReadMatchDistances(out lenMain, out numDistancePairs);

+			}

+			else

+			{

+				lenMain = _longestMatchLength;

+				numDistancePairs = _numDistancePairs;

+				_longestMatchWasFound = false;

+			}

+

+			UInt32 numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1;

+			if (numAvailableBytes < 2)

+			{

+				backRes = 0xFFFFFFFF;

+				return 1;

+			}

+			if (numAvailableBytes > Base.kMatchMaxLen)

+				numAvailableBytes = Base.kMatchMaxLen;

+

+			UInt32 repMaxIndex = 0;

+			UInt32 i;			

+			for (i = 0; i < Base.kNumRepDistances; i++)

+			{

+				reps[i] = _repDistances[i];

+				repLens[i] = _matchFinder.GetMatchLen(0 - 1, reps[i], Base.kMatchMaxLen);

+				if (repLens[i] > repLens[repMaxIndex])

+					repMaxIndex = i;

+			}

+			if (repLens[repMaxIndex] >= _numFastBytes)

+			{

+				backRes = repMaxIndex;

+				UInt32 lenRes = repLens[repMaxIndex];

+				MovePos(lenRes - 1);

+				return lenRes;

+			}

+

+			if (lenMain >= _numFastBytes)

+			{

+				backRes = _matchDistances[numDistancePairs - 1] + Base.kNumRepDistances;

+				MovePos(lenMain - 1);

+				return lenMain;

+			}

+			

+			Byte currentByte = _matchFinder.GetIndexByte(0 - 1);

+			Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - 1));

+

+			if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)

+			{

+				backRes = (UInt32)0xFFFFFFFF;

+				return 1;

+			}

+

+			_optimum[0].State = _state;

+

+			UInt32 posState = (position & _posStateMask);

+

+			_optimum[1].Price = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() +

+					_literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!_state.IsCharState(), matchByte, currentByte);

+			_optimum[1].MakeAsChar();

+

+			UInt32 matchPrice = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();

+			UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();

+

+			if (matchByte == currentByte)

+			{

+				UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);

+				if (shortRepPrice < _optimum[1].Price)

+				{

+					_optimum[1].Price = shortRepPrice;

+					_optimum[1].MakeAsShortRep();

+				}

+			}

+

+			UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);

+

+			if(lenEnd < 2)

+			{

+				backRes = _optimum[1].BackPrev;

+				return 1;

+			}

+			

+			_optimum[1].PosPrev = 0;

+

+			_optimum[0].Backs0 = reps[0];

+			_optimum[0].Backs1 = reps[1];

+			_optimum[0].Backs2 = reps[2];

+			_optimum[0].Backs3 = reps[3];

+

+			UInt32 len = lenEnd;

+			do

+				_optimum[len--].Price = kIfinityPrice;

+			while (len >= 2);

+

+			for (i = 0; i < Base.kNumRepDistances; i++)

+			{

+				UInt32 repLen = repLens[i];

+				if (repLen < 2)

+					continue;

+				UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState);

+				do

+				{

+					UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);

+					Optimal optimum = _optimum[repLen];

+					if (curAndLenPrice < optimum.Price)

+					{

+						optimum.Price = curAndLenPrice;

+						optimum.PosPrev = 0;

+						optimum.BackPrev = i;

+						optimum.Prev1IsChar = false;

+					}

+				}

+				while (--repLen >= 2);

+			}

+

+			UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0();

+			

+			len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);

+			if (len <= lenMain)

+			{

+				UInt32 offs = 0;

+				while (len > _matchDistances[offs])

+					offs += 2;

+				for (; ; len++)

+				{

+					UInt32 distance = _matchDistances[offs + 1];

+					UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);

+					Optimal optimum = _optimum[len];

+					if (curAndLenPrice < optimum.Price)

+					{

+						optimum.Price = curAndLenPrice;

+						optimum.PosPrev = 0;

+						optimum.BackPrev = distance + Base.kNumRepDistances;

+						optimum.Prev1IsChar = false;

+					}

+					if (len == _matchDistances[offs])

+					{

+						offs += 2;

+						if (offs == numDistancePairs)

+							break;

+					}

+				}

+			}

+

+			UInt32 cur = 0;

+

+			while (true)

+			{

+				cur++;

+				if (cur == lenEnd)

+					return Backward(out backRes, cur);

+				UInt32 newLen;

+				ReadMatchDistances(out newLen, out numDistancePairs);

+				if (newLen >= _numFastBytes)

+				{

+					_numDistancePairs = numDistancePairs;

+					_longestMatchLength = newLen;

+					_longestMatchWasFound = true;

+					return Backward(out backRes, cur);

+				}

+				position++;

+				UInt32 posPrev = _optimum[cur].PosPrev;

+				Base.State state;

+				if (_optimum[cur].Prev1IsChar)

+				{

+					posPrev--;

+					if (_optimum[cur].Prev2)

+					{

+						state = _optimum[_optimum[cur].PosPrev2].State;

+						if (_optimum[cur].BackPrev2 < Base.kNumRepDistances)

+							state.UpdateRep();

+						else

+							state.UpdateMatch();

+					}

+					else

+						state = _optimum[posPrev].State;

+					state.UpdateChar();

+				}

+				else

+					state = _optimum[posPrev].State;

+				if (posPrev == cur - 1)

+				{

+					if (_optimum[cur].IsShortRep())

+						state.UpdateShortRep();

+					else

+						state.UpdateChar();

+				}

+				else

+				{

+					UInt32 pos;

+					if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2)

+					{

+						posPrev = _optimum[cur].PosPrev2;

+						pos = _optimum[cur].BackPrev2;

+						state.UpdateRep();

+					}

+					else

+					{

+						pos = _optimum[cur].BackPrev;

+						if (pos < Base.kNumRepDistances)

+							state.UpdateRep();

+						else

+							state.UpdateMatch();

+					}

+					Optimal opt = _optimum[posPrev];

+					if (pos < Base.kNumRepDistances)

+					{

+						if (pos == 0)

+						{

+							reps[0] = opt.Backs0;

+							reps[1] = opt.Backs1;

+							reps[2] = opt.Backs2;

+							reps[3] = opt.Backs3;

+						}

+						else if (pos == 1)

+						{

+							reps[0] = opt.Backs1;

+							reps[1] = opt.Backs0;

+							reps[2] = opt.Backs2;

+							reps[3] = opt.Backs3;

+						}

+						else if (pos == 2)

+						{

+							reps[0] = opt.Backs2;

+							reps[1] = opt.Backs0;

+							reps[2] = opt.Backs1;

+							reps[3] = opt.Backs3;

+						}

+						else

+						{

+							reps[0] = opt.Backs3;

+							reps[1] = opt.Backs0;

+							reps[2] = opt.Backs1;

+							reps[3] = opt.Backs2;

+						}

+					}

+					else

+					{

+						reps[0] = (pos - Base.kNumRepDistances);

+						reps[1] = opt.Backs0;

+						reps[2] = opt.Backs1;

+						reps[3] = opt.Backs2;

+					}

+				}

+				_optimum[cur].State = state;

+				_optimum[cur].Backs0 = reps[0];

+				_optimum[cur].Backs1 = reps[1];

+				_optimum[cur].Backs2 = reps[2];

+				_optimum[cur].Backs3 = reps[3];

+				UInt32 curPrice = _optimum[cur].Price;

+

+				currentByte = _matchFinder.GetIndexByte(0 - 1);

+				matchByte = _matchFinder.GetIndexByte((Int32)(0 - reps[0] - 1 - 1));

+

+				posState = (position & _posStateMask);

+

+				UInt32 curAnd1Price = curPrice +

+					_isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() +

+					_literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)).

+					GetPrice(!state.IsCharState(), matchByte, currentByte);

+

+				Optimal nextOptimum = _optimum[cur + 1];

+

+				bool nextIsChar = false;

+				if (curAnd1Price < nextOptimum.Price)

+				{

+					nextOptimum.Price = curAnd1Price;

+					nextOptimum.PosPrev = cur;

+					nextOptimum.MakeAsChar();

+					nextIsChar = true;

+				}

+

+				matchPrice = curPrice + _isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();

+				repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();

+

+				if (matchByte == currentByte &&

+					!(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))

+				{

+					UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);

+					if (shortRepPrice <= nextOptimum.Price)

+					{

+						nextOptimum.Price = shortRepPrice;

+						nextOptimum.PosPrev = cur;

+						nextOptimum.MakeAsShortRep();

+						nextIsChar = true;

+					}

+				}

+

+				UInt32 numAvailableBytesFull = _matchFinder.GetNumAvailableBytes() + 1;

+				numAvailableBytesFull = Math.Min(kNumOpts - 1 - cur, numAvailableBytesFull);

+				numAvailableBytes = numAvailableBytesFull;

+

+				if (numAvailableBytes < 2)

+					continue;

+				if (numAvailableBytes > _numFastBytes)

+					numAvailableBytes = _numFastBytes;

+				if (!nextIsChar && matchByte != currentByte)

+				{

+					// try Literal + rep0

+					UInt32 t = Math.Min(numAvailableBytesFull - 1, _numFastBytes);

+					UInt32 lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t);

+					if (lenTest2 >= 2)

+					{

+						Base.State state2 = state;

+						state2.UpdateChar();

+						UInt32 posStateNext = (position + 1) & _posStateMask;

+						UInt32 nextRepMatchPrice = curAnd1Price +

+							_isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1() +

+							_isRep[state2.Index].GetPrice1();

+						{

+							UInt32 offset = cur + 1 + lenTest2;

+							while (lenEnd < offset)

+								_optimum[++lenEnd].Price = kIfinityPrice;

+							UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(

+								0, lenTest2, state2, posStateNext);

+							Optimal optimum = _optimum[offset];

+							if (curAndLenPrice < optimum.Price)

+							{

+								optimum.Price = curAndLenPrice;

+								optimum.PosPrev = cur + 1;

+								optimum.BackPrev = 0;

+								optimum.Prev1IsChar = true;

+								optimum.Prev2 = false;

+							}

+						}

+					}

+				}

+

+				UInt32 startLen = 2; // speed optimization 

+

+				for (UInt32 repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++)

+				{

+					UInt32 lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes);

+					if (lenTest < 2)

+						continue;

+					UInt32 lenTestTemp = lenTest;

+					do

+					{

+						while (lenEnd < cur + lenTest)

+							_optimum[++lenEnd].Price = kIfinityPrice;

+						UInt32 curAndLenPrice = repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState);

+						Optimal optimum = _optimum[cur + lenTest];

+						if (curAndLenPrice < optimum.Price)

+						{

+							optimum.Price = curAndLenPrice;

+							optimum.PosPrev = cur;

+							optimum.BackPrev = repIndex;

+							optimum.Prev1IsChar = false;

+						}

+					}

+					while(--lenTest >= 2);

+					lenTest = lenTestTemp;

+

+					if (repIndex == 0)

+						startLen = lenTest + 1;

+

+					// if (_maxMode)

+					if (lenTest < numAvailableBytesFull)

+					{

+						UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);

+						UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, reps[repIndex], t);

+						if (lenTest2 >= 2)

+						{

+							Base.State state2 = state;

+							state2.UpdateRep();

+							UInt32 posStateNext = (position + lenTest) & _posStateMask;

+							UInt32 curAndLenCharPrice = 

+									repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) + 

+									_isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() +

+									_literalEncoder.GetSubCoder(position + lenTest, 

+									_matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)).GetPrice(true,

+									_matchFinder.GetIndexByte((Int32)((Int32)lenTest - 1 - (Int32)(reps[repIndex] + 1))), 

+									_matchFinder.GetIndexByte((Int32)lenTest - 1));

+							state2.UpdateChar();

+							posStateNext = (position + lenTest + 1) & _posStateMask;

+							UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1();

+							UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();

+							

+							// for(; lenTest2 >= 2; lenTest2--)

+							{

+								UInt32 offset = lenTest + 1 + lenTest2;

+								while(lenEnd < cur + offset)

+									_optimum[++lenEnd].Price = kIfinityPrice;

+								UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);

+								Optimal optimum = _optimum[cur + offset];

+								if (curAndLenPrice < optimum.Price) 

+								{

+									optimum.Price = curAndLenPrice;

+									optimum.PosPrev = cur + lenTest + 1;

+									optimum.BackPrev = 0;

+									optimum.Prev1IsChar = true;

+									optimum.Prev2 = true;

+									optimum.PosPrev2 = cur;

+									optimum.BackPrev2 = repIndex;

+								}

+							}

+						}

+					}

+				}

+

+				if (newLen > numAvailableBytes)

+				{

+					newLen = numAvailableBytes;

+					for (numDistancePairs = 0; newLen > _matchDistances[numDistancePairs]; numDistancePairs += 2) ;

+					_matchDistances[numDistancePairs] = newLen;

+					numDistancePairs += 2;

+				}

+				if (newLen >= startLen)

+				{

+					normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0();

+					while (lenEnd < cur + newLen)

+						_optimum[++lenEnd].Price = kIfinityPrice;

+

+					UInt32 offs = 0;

+					while (startLen > _matchDistances[offs])

+						offs += 2;

+

+					for (UInt32 lenTest = startLen; ; lenTest++)

+					{

+						UInt32 curBack = _matchDistances[offs + 1];

+						UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(curBack, lenTest, posState);

+						Optimal optimum = _optimum[cur + lenTest];

+						if (curAndLenPrice < optimum.Price)

+						{

+							optimum.Price = curAndLenPrice;

+							optimum.PosPrev = cur;

+							optimum.BackPrev = curBack + Base.kNumRepDistances;

+							optimum.Prev1IsChar = false;

+						}

+

+						if (lenTest == _matchDistances[offs])

+						{

+							if (lenTest < numAvailableBytesFull)

+							{

+								UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);

+								UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, curBack, t);

+								if (lenTest2 >= 2)

+								{

+									Base.State state2 = state;

+									state2.UpdateMatch();

+									UInt32 posStateNext = (position + lenTest) & _posStateMask;

+									UInt32 curAndLenCharPrice = curAndLenPrice +

+										_isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() +

+										_literalEncoder.GetSubCoder(position + lenTest,

+										_matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)).

+										GetPrice(true,

+										_matchFinder.GetIndexByte((Int32)lenTest - (Int32)(curBack + 1) - 1),

+										_matchFinder.GetIndexByte((Int32)lenTest - 1));

+									state2.UpdateChar();

+									posStateNext = (position + lenTest + 1) & _posStateMask;

+									UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1();

+									UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();

+

+									UInt32 offset = lenTest + 1 + lenTest2;

+									while (lenEnd < cur + offset)

+										_optimum[++lenEnd].Price = kIfinityPrice;

+									curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);

+									optimum = _optimum[cur + offset];

+									if (curAndLenPrice < optimum.Price)

+									{

+										optimum.Price = curAndLenPrice;

+										optimum.PosPrev = cur + lenTest + 1;

+										optimum.BackPrev = 0;

+										optimum.Prev1IsChar = true;

+										optimum.Prev2 = true;

+										optimum.PosPrev2 = cur;

+										optimum.BackPrev2 = curBack + Base.kNumRepDistances;

+									}

+								}

+							}

+							offs += 2;

+							if (offs == numDistancePairs)

+								break;

+						}

+					}

+				}

+			}

+		}

+

+		bool ChangePair(UInt32 smallDist, UInt32 bigDist)

+		{

+			const int kDif = 7;

+			return (smallDist < ((UInt32)(1) << (32 - kDif)) && bigDist >= (smallDist << kDif));

+		}

+

+		void WriteEndMarker(UInt32 posState)

+		{

+			if (!_writeEndMark)

+				return;

+

+			_isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 1);

+			_isRep[_state.Index].Encode(_rangeEncoder, 0);

+			_state.UpdateMatch();

+			UInt32 len = Base.kMatchMinLen;

+			_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);

+			UInt32 posSlot = (1 << Base.kNumPosSlotBits) - 1;

+			UInt32 lenToPosState = Base.GetLenToPosState(len);

+			_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);

+			int footerBits = 30;

+			UInt32 posReduced = (((UInt32)1) << footerBits) - 1;

+			_rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);

+			_posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);

+		}

+

+		void Flush(UInt32 nowPos)

+		{

+			ReleaseMFStream();

+			WriteEndMarker(nowPos & _posStateMask);

+			_rangeEncoder.FlushData();

+			_rangeEncoder.FlushStream();

+		}

+

+		public void CodeOneBlock(out Int64 inSize, out Int64 outSize, out bool finished)

+		{

+			inSize = 0;

+			outSize = 0;

+			finished = true;

+

+			if (_inStream != null)

+			{

+				_matchFinder.SetStream(_inStream);

+				_matchFinder.Init();

+				_needReleaseMFStream = true;

+				_inStream = null;

+				if (_trainSize > 0)

+					_matchFinder.Skip(_trainSize);

+			}

+

+			if (_finished)

+				return;

+			_finished = true;

+

+

+			Int64 progressPosValuePrev = nowPos64;

+			if (nowPos64 == 0)

+			{

+				if (_matchFinder.GetNumAvailableBytes() == 0)

+				{

+					Flush((UInt32)nowPos64);

+					return;

+				}

+				UInt32 len, numDistancePairs; // it's not used

+				ReadMatchDistances(out len, out numDistancePairs);

+				UInt32 posState = (UInt32)(nowPos64) & _posStateMask;

+				_isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 0);

+				_state.UpdateChar();

+				Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));

+				_literalEncoder.GetSubCoder((UInt32)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte);

+				_previousByte = curByte;

+				_additionalOffset--;

+				nowPos64++;

+			}

+			if (_matchFinder.GetNumAvailableBytes() == 0)

+			{

+				Flush((UInt32)nowPos64);

+				return;

+			}

+			while (true)

+			{

+				UInt32 pos;

+				UInt32 len = GetOptimum((UInt32)nowPos64, out pos);

+				

+				UInt32 posState = ((UInt32)nowPos64) & _posStateMask;

+				UInt32 complexState = (_state.Index << Base.kNumPosStatesBitsMax) + posState;

+				if (len == 1 && pos == 0xFFFFFFFF)

+				{

+					_isMatch[complexState].Encode(_rangeEncoder, 0);

+					Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));

+					LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((UInt32)nowPos64, _previousByte);

+					if (!_state.IsCharState())

+					{

+						Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - _additionalOffset));

+						subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte);

+					}

+					else

+						subCoder.Encode(_rangeEncoder, curByte);

+					_previousByte = curByte;

+					_state.UpdateChar();

+				}

+				else

+				{

+					_isMatch[complexState].Encode(_rangeEncoder, 1);

+					if (pos < Base.kNumRepDistances)

+					{

+						_isRep[_state.Index].Encode(_rangeEncoder, 1);

+						if (pos == 0)

+						{

+							_isRepG0[_state.Index].Encode(_rangeEncoder, 0);

+							if (len == 1)

+								_isRep0Long[complexState].Encode(_rangeEncoder, 0);

+							else

+								_isRep0Long[complexState].Encode(_rangeEncoder, 1);

+						}

+						else

+						{

+							_isRepG0[_state.Index].Encode(_rangeEncoder, 1);

+							if (pos == 1)

+								_isRepG1[_state.Index].Encode(_rangeEncoder, 0);

+							else

+							{

+								_isRepG1[_state.Index].Encode(_rangeEncoder, 1);

+								_isRepG2[_state.Index].Encode(_rangeEncoder, pos - 2);

+							}

+						}

+						if (len == 1)

+							_state.UpdateShortRep();

+						else

+						{

+							_repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);

+							_state.UpdateRep();

+						}

+						UInt32 distance = _repDistances[pos];

+						if (pos != 0)

+						{

+							for (UInt32 i = pos; i >= 1; i--)

+								_repDistances[i] = _repDistances[i - 1];

+							_repDistances[0] = distance;

+						}

+					}

+					else

+					{

+						_isRep[_state.Index].Encode(_rangeEncoder, 0);

+						_state.UpdateMatch();

+						_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);

+						pos -= Base.kNumRepDistances;

+						UInt32 posSlot = GetPosSlot(pos);

+						UInt32 lenToPosState = Base.GetLenToPosState(len);

+						_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);

+

+						if (posSlot >= Base.kStartPosModelIndex)

+						{

+							int footerBits = (int)((posSlot >> 1) - 1);

+							UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits);

+							UInt32 posReduced = pos - baseVal;

+

+							if (posSlot < Base.kEndPosModelIndex)

+								RangeCoder.BitTreeEncoder.ReverseEncode(_posEncoders,

+										baseVal - posSlot - 1, _rangeEncoder, footerBits, posReduced);

+							else

+							{

+								_rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);

+								_posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);

+								_alignPriceCount++;

+							}

+						}

+						UInt32 distance = pos;

+						for (UInt32 i = Base.kNumRepDistances - 1; i >= 1; i--)

+							_repDistances[i] = _repDistances[i - 1];

+						_repDistances[0] = distance;

+						_matchPriceCount++;

+					}

+					_previousByte = _matchFinder.GetIndexByte((Int32)(len - 1 - _additionalOffset));

+				}

+				_additionalOffset -= len;

+				nowPos64 += len;

+				if (_additionalOffset == 0)

+				{

+					// if (!_fastMode)

+					if (_matchPriceCount >= (1 << 7))

+						FillDistancesPrices();

+					if (_alignPriceCount >= Base.kAlignTableSize)

+						FillAlignPrices();

+					inSize = nowPos64;

+					outSize = _rangeEncoder.GetProcessedSizeAdd();

+					if (_matchFinder.GetNumAvailableBytes() == 0)

+					{

+						Flush((UInt32)nowPos64);

+						return;

+					}

+

+					if (nowPos64 - progressPosValuePrev >= (1 << 12))

+					{

+						_finished = false;

+						finished = false;

+						return;

+					}

+				}

+			}

+		}

+

+		void ReleaseMFStream()

+		{

+			if (_matchFinder != null && _needReleaseMFStream)

+			{

+				_matchFinder.ReleaseStream();

+				_needReleaseMFStream = false;

+			}

+		}

+

+		void SetOutStream(System.IO.Stream outStream) { _rangeEncoder.SetStream(outStream); }

+		void ReleaseOutStream() { _rangeEncoder.ReleaseStream(); }

+

+		void ReleaseStreams()

+		{

+			ReleaseMFStream();

+			ReleaseOutStream();

+		}

+

+		void SetStreams(System.IO.Stream inStream, System.IO.Stream outStream,

+				Int64 inSize, Int64 outSize)

+		{

+			_inStream = inStream;

+			_finished = false;

+			Create();

+			SetOutStream(outStream);

+			Init();

+

+			// if (!_fastMode)

+			{

+				FillDistancesPrices();

+				FillAlignPrices();

+			}

+

+			_lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);

+			_lenEncoder.UpdateTables((UInt32)1 << _posStateBits);

+			_repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);

+			_repMatchLenEncoder.UpdateTables((UInt32)1 << _posStateBits);

+

+			nowPos64 = 0;

+		}

+

+

+		public void Code(System.IO.Stream inStream, System.IO.Stream outStream,

+			Int64 inSize, Int64 outSize, ICodeProgress progress)

+		{

+			_needReleaseMFStream = false;

+			try

+			{

+				SetStreams(inStream, outStream, inSize, outSize);

+				while (true)

+				{

+					Int64 processedInSize;

+					Int64 processedOutSize;

+					bool finished;

+					CodeOneBlock(out processedInSize, out processedOutSize, out finished);

+					if (finished)

+						return;

+					if (progress != null)

+					{

+						progress.SetProgress(processedInSize, processedOutSize);

+					}

+				}

+			}

+			finally

+			{

+				ReleaseStreams();

+			}

+		}

+

+		const int kPropSize = 5;

+		Byte[] properties = new Byte[kPropSize];

+

+		public void WriteCoderProperties(System.IO.Stream outStream)

+		{

+			properties[0] = (Byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);

+			for (int i = 0; i < 4; i++)

+				properties[1 + i] = (Byte)((_dictionarySize >> (8 * i)) & 0xFF);

+			outStream.Write(properties, 0, kPropSize);

+		}

+		

+		UInt32[] tempPrices = new UInt32[Base.kNumFullDistances];

+		UInt32 _matchPriceCount;

+

+		void FillDistancesPrices()

+		{

+			for (UInt32 i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++)

+			{ 

+				UInt32 posSlot = GetPosSlot(i);

+				int footerBits = (int)((posSlot >> 1) - 1);

+				UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits);

+				tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders, 

+					baseVal - posSlot - 1, footerBits, i - baseVal);

+			}

+

+			for (UInt32 lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++)

+			{

+				UInt32 posSlot;

+				RangeCoder.BitTreeEncoder encoder = _posSlotEncoder[lenToPosState];

+			

+				UInt32 st = (lenToPosState << Base.kNumPosSlotBits);

+				for (posSlot = 0; posSlot < _distTableSize; posSlot++)

+					_posSlotPrices[st + posSlot] = encoder.GetPrice(posSlot);

+				for (posSlot = Base.kEndPosModelIndex; posSlot < _distTableSize; posSlot++)

+					_posSlotPrices[st + posSlot] += ((((posSlot >> 1) - 1) - Base.kNumAlignBits) << RangeCoder.BitEncoder.kNumBitPriceShiftBits);

+

+				UInt32 st2 = lenToPosState * Base.kNumFullDistances;

+				UInt32 i;

+				for (i = 0; i < Base.kStartPosModelIndex; i++)

+					_distancesPrices[st2 + i] = _posSlotPrices[st + i];

+				for (; i < Base.kNumFullDistances; i++)

+					_distancesPrices[st2 + i] = _posSlotPrices[st + GetPosSlot(i)] + tempPrices[i];

+			}

+			_matchPriceCount = 0;

+		}

+

+		void FillAlignPrices()

+		{

+			for (UInt32 i = 0; i < Base.kAlignTableSize; i++)

+				_alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);

+			_alignPriceCount = 0;

+		}

+

+

+		static string[] kMatchFinderIDs = 

+		{

+			"BT2",

+			"BT4",

+		};

+

+		static int FindMatchFinder(string s)

+		{

+			for (int m = 0; m < kMatchFinderIDs.Length; m++)

+				if (s == kMatchFinderIDs[m])

+					return m;

+			return -1;

+		}

+	

+		public void SetCoderProperties(CoderPropID[] propIDs, object[] properties)

+		{

+			for (UInt32 i = 0; i < properties.Length; i++)

+			{

+				object prop = properties[i];

+				switch (propIDs[i])

+				{

+					case CoderPropID.NumFastBytes:

+					{

+						if (!(prop is Int32))

+							throw new InvalidParamException();

+						Int32 numFastBytes = (Int32)prop;

+						if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen)

+							throw new InvalidParamException();

+						_numFastBytes = (UInt32)numFastBytes;

+						break;

+					}

+					case CoderPropID.Algorithm:

+					{

+						/*

+						if (!(prop is Int32))

+							throw new InvalidParamException();

+						Int32 maximize = (Int32)prop;

+						_fastMode = (maximize == 0);

+						_maxMode = (maximize >= 2);

+						*/

+						break;

+					}

+					case CoderPropID.MatchFinder:

+					{

+						if (!(prop is String))

+							throw new InvalidParamException();

+						EMatchFinderType matchFinderIndexPrev = _matchFinderType;

+						int m = FindMatchFinder(((string)prop).ToUpper());

+						if (m < 0)

+							throw new InvalidParamException();

+						_matchFinderType = (EMatchFinderType)m;

+						if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType)

+							{

+							_dictionarySizePrev = 0xFFFFFFFF;

+							_matchFinder = null;

+							}

+						break;

+					}

+					case CoderPropID.DictionarySize:

+					{

+						const int kDicLogSizeMaxCompress = 30;

+						if (!(prop is Int32))

+							throw new InvalidParamException(); ;

+						Int32 dictionarySize = (Int32)prop;

+						if (dictionarySize < (UInt32)(1 << Base.kDicLogSizeMin) ||

+							dictionarySize > (UInt32)(1 << kDicLogSizeMaxCompress))

+							throw new InvalidParamException();

+						_dictionarySize = (UInt32)dictionarySize;

+						int dicLogSize;

+						for (dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)

+							if (dictionarySize <= ((UInt32)(1) << dicLogSize))

+								break;

+						_distTableSize = (UInt32)dicLogSize * 2;

+						break;

+					}

+					case CoderPropID.PosStateBits:

+					{

+						if (!(prop is Int32))

+							throw new InvalidParamException();

+						Int32 v = (Int32)prop;

+						if (v < 0 || v > (UInt32)Base.kNumPosStatesBitsEncodingMax)

+							throw new InvalidParamException();

+						_posStateBits = (int)v;

+						_posStateMask = (((UInt32)1) << (int)_posStateBits) - 1;

+						break;

+					}

+					case CoderPropID.LitPosBits:

+					{

+						if (!(prop is Int32))

+							throw new InvalidParamException();

+						Int32 v = (Int32)prop;

+						if (v < 0 || v > (UInt32)Base.kNumLitPosStatesBitsEncodingMax)

+							throw new InvalidParamException();

+						_numLiteralPosStateBits = (int)v;

+						break;

+					}

+					case CoderPropID.LitContextBits:

+					{

+						if (!(prop is Int32))

+							throw new InvalidParamException();

+						Int32 v = (Int32)prop;

+						if (v < 0 || v > (UInt32)Base.kNumLitContextBitsMax)

+							throw new InvalidParamException(); ;

+						_numLiteralContextBits = (int)v;

+						break;

+					}

+					case CoderPropID.EndMarker:

+					{

+						if (!(prop is Boolean))

+							throw new InvalidParamException();

+						SetWriteEndMarkerMode((Boolean)prop);

+						break;

+					}

+					default:

+						throw new InvalidParamException();

+				}

+			}

+		}

+

+		uint _trainSize = 0;

+		public void SetTrainSize(uint trainSize)

+		{

+			_trainSize = trainSize;

+		}

+		

+	}

+}