tor-browser

LzmaEncoder.cs (45224B)

---

// 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;
	}
	
}
}