react-native-update 10.34.6 → 10.34.8

package/harmony/pushy/src/main/cpp/lzma/CS/7zip/Compress/LZMA/LzmaEncoder.cs

@@ -1,1480 +0,0 @@
-// 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;
-		}
-		
-	}
-}