Keep only base/extractor.[cc|h].

third_party/lzma/v4_65/files/Java/SevenZip/Compression/LZMA/Encoder.java

Index: third_party/lzma/v4_65/files/Java/SevenZip/Compression/LZMA/Encoder.java
diff --git a/third_party/lzma/v4_65/files/Java/SevenZip/Compression/LZMA/Encoder.java b/third_party/lzma/v4_65/files/Java/SevenZip/Compression/LZMA/Encoder.java
deleted file mode 100644
index e421810134ea5e8759c0e0a5cc54fd7b73dd5fb7..0000000000000000000000000000000000000000
--- a/third_party/lzma/v4_65/files/Java/SevenZip/Compression/LZMA/Encoder.java
+++ /dev/null
@@ -1,1416 +0,0 @@
-package SevenZip.Compression.LZMA;
-
-import SevenZip.Compression.RangeCoder.BitTreeEncoder;
-import SevenZip.Compression.LZMA.Base;
-import SevenZip.Compression.LZ.BinTree;
-import SevenZip.ICodeProgress;
-import java.io.IOException;
-
-public class Encoder
-{
-	public static final int EMatchFinderTypeBT2 = 0;
-	public static final int EMatchFinderTypeBT4 = 1;
-
-
-
-
-	static final int kIfinityPrice = 0xFFFFFFF;
-
-	static byte[] g_FastPos = new byte[1 << 11];
-
-	static
-	{
-		int kFastSlots = 22;
-		int c = 2;
-		g_FastPos[0] = 0;
-		g_FastPos[1] = 1;
-		for (int slotFast = 2; slotFast < kFastSlots; slotFast++)
-		{
-			int k = (1 << ((slotFast >> 1) - 1));
-			for (int j = 0; j < k; j++, c++)
-				g_FastPos[c] = (byte)slotFast;
-		}
-	}
-
-	static int GetPosSlot(int pos)
-	{
-		if (pos < (1 << 11))
-			return g_FastPos[pos];
-		if (pos < (1 << 21))
-			return (g_FastPos[pos >> 10] + 20);
-		return (g_FastPos[pos >> 20] + 40);
-	}
-
-	static int GetPosSlot2(int pos)
-	{
-		if (pos < (1 << 17))
-			return (g_FastPos[pos >> 6] + 12);
-		if (pos < (1 << 27))
-			return (g_FastPos[pos >> 16] + 32);
-		return (g_FastPos[pos >> 26] + 52);
-	}
-
-	int _state = Base.StateInit();
-	byte _previousByte;
-	int[] _repDistances = new int[Base.kNumRepDistances];
-
-	void BaseInit()
-	{
-		_state = Base.StateInit();
-		_previousByte = 0;
-		for (int i = 0; i < Base.kNumRepDistances; i++)
-			_repDistances[i] = 0;
-	}
-
-	static final int kDefaultDictionaryLogSize = 22;
-	static final int kNumFastBytesDefault = 0x20;
-
-	class LiteralEncoder
-	{
-		class Encoder2
-		{
-			short[] m_Encoders = new short[0x300];
-
-			public void Init() { SevenZip.Compression.RangeCoder.Encoder.InitBitModels(m_Encoders); }
-
-
-
-			public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte symbol) throws IOException
-			{
-				int context = 1;
-				for (int i = 7; i >= 0; i--)
-				{
-					int bit = ((symbol >> i) & 1);
-					rangeEncoder.Encode(m_Encoders, context, bit);
-					context = (context << 1) | bit;
-				}
-			}
-
-			public void EncodeMatched(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol) throws IOException
-			{
-				int context = 1;
-				boolean same = true;
-				for (int i = 7; i >= 0; i--)
-				{
-					int bit = ((symbol >> i) & 1);
-					int state = context;
-					if (same)
-					{
-						int matchBit = ((matchByte >> i) & 1);
-						state += ((1 + matchBit) << 8);
-						same = (matchBit == bit);
-					}
-					rangeEncoder.Encode(m_Encoders, state, bit);
-					context = (context << 1) | bit;
-				}
-			}
-
-			public int GetPrice(boolean matchMode, byte matchByte, byte symbol)
-			{
-				int price = 0;
-				int context = 1;
-				int i = 7;
-				if (matchMode)
-				{
-					for (; i >= 0; i--)
-					{
-						int matchBit = (matchByte >> i) & 1;
-						int bit = (symbol >> i) & 1;
-						price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[((1 + matchBit) << 8) + context], bit);
-						context = (context << 1) | bit;
-						if (matchBit != bit)
-						{
-							i--;
-							break;
-						}
-					}
-				}
-				for (; i >= 0; i--)
-				{
-					int bit = (symbol >> i) & 1;
-					price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[context], bit);
-					context = (context << 1) | bit;
-				}
-				return price;
-			}
-		}
-
-		Encoder2[] m_Coders;
-		int m_NumPrevBits;
-		int m_NumPosBits;
-		int 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 = (1 << numPosBits) - 1;
-			m_NumPrevBits = numPrevBits;
-			int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
-			m_Coders = new Encoder2[numStates];
-			for (int i = 0; i < numStates; i++)
-				m_Coders[i] = new Encoder2();
-		}
-
-		public void Init()
-		{
-			int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
-			for (int i = 0; i < numStates; i++)
-				m_Coders[i].Init();
-		}
-
-		public Encoder2 GetSubCoder(int pos, byte prevByte)
-		{ return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))]; }
-	}
-
-	class LenEncoder
-	{
-		short[] _choice = new short[2];
-		BitTreeEncoder[] _lowCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax];
-		BitTreeEncoder[] _midCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax];
-		BitTreeEncoder _highCoder = new BitTreeEncoder(Base.kNumHighLenBits);
-
-
-		public LenEncoder()
-		{
-			for (int posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++)
-			{
-				_lowCoder[posState] = new BitTreeEncoder(Base.kNumLowLenBits);
-				_midCoder[posState] = new BitTreeEncoder(Base.kNumMidLenBits);
-			}
-		}
-
-		public void Init(int numPosStates)
-		{
-			SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_choice);
-
-			for (int posState = 0; posState < numPosStates; posState++)
-			{
-				_lowCoder[posState].Init();
-				_midCoder[posState].Init();
-			}
-			_highCoder.Init();
-		}
-
-		public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException
-		{
-			if (symbol < Base.kNumLowLenSymbols)
-			{
-				rangeEncoder.Encode(_choice, 0, 0);
-				_lowCoder[posState].Encode(rangeEncoder, symbol);
-			}
-			else
-			{
-				symbol -= Base.kNumLowLenSymbols;
-				rangeEncoder.Encode(_choice, 0, 1);
-				if (symbol < Base.kNumMidLenSymbols)
-				{
-					rangeEncoder.Encode(_choice, 1, 0);
-					_midCoder[posState].Encode(rangeEncoder, symbol);
-				}
-				else
-				{
-					rangeEncoder.Encode(_choice, 1, 1);
-					_highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols);
-				}
-			}
-		}
-
-		public void SetPrices(int posState, int numSymbols, int[] prices, int st)
-		{
-			int a0 = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[0]);
-			int a1 = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[0]);
-			int b0 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[1]);
-			int b1 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[1]);
-			int 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);
-		}
-	};
-
-	public static final int kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols;
-
-	class LenPriceTableEncoder extends LenEncoder
-	{
-		int[] _prices = new int[Base.kNumLenSymbols<<Base.kNumPosStatesBitsEncodingMax];
-		int _tableSize;
-		int[] _counters = new int[Base.kNumPosStatesEncodingMax];
-
-		public void SetTableSize(int tableSize) { _tableSize = tableSize; }
-
-		public int GetPrice(int symbol, int posState)
-		{
-			return _prices[posState * Base.kNumLenSymbols + symbol];
-		}
-
-		void UpdateTable(int posState)
-		{
-			SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols);
-			_counters[posState] = _tableSize;
-		}
-
-		public void UpdateTables(int numPosStates)
-		{
-			for (int posState = 0; posState < numPosStates; posState++)
-				UpdateTable(posState);
-		}
-
-		public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException
-		{
-			super.Encode(rangeEncoder, symbol, posState);
-			if (--_counters[posState] == 0)
-				UpdateTable(posState);
-		}
-	}
-
-	static final int kNumOpts = 1 << 12;
-	class Optimal
-	{
-		public int State;
-
-		public boolean Prev1IsChar;
-		public boolean Prev2;
-
-		public int PosPrev2;
-		public int BackPrev2;
-
-		public int Price;
-		public int PosPrev;
-		public int BackPrev;
-
-		public int Backs0;
-		public int Backs1;
-		public int Backs2;
-		public int Backs3;
-
-		public void MakeAsChar() { BackPrev = -1; Prev1IsChar = false; }
-		public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }
-		public boolean IsShortRep() { return (BackPrev == 0); }
-	};
-	Optimal[] _optimum = new Optimal[kNumOpts];
-	SevenZip.Compression.LZ.BinTree _matchFinder = null;
-	SevenZip.Compression.RangeCoder.Encoder _rangeEncoder = new SevenZip.Compression.RangeCoder.Encoder();
-
-	short[] _isMatch = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax];
-	short[] _isRep = new short[Base.kNumStates];
-	short[] _isRepG0 = new short[Base.kNumStates];
-	short[] _isRepG1 = new short[Base.kNumStates];
-	short[] _isRepG2 = new short[Base.kNumStates];
-	short[] _isRep0Long = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax];
-
-	BitTreeEncoder[] _posSlotEncoder = new BitTreeEncoder[Base.kNumLenToPosStates]; // kNumPosSlotBits
-
-	short[] _posEncoders = new short[Base.kNumFullDistances-Base.kEndPosModelIndex];
-	BitTreeEncoder _posAlignEncoder = new BitTreeEncoder(Base.kNumAlignBits);
-
-	LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();
-	LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();
-
-	LiteralEncoder _literalEncoder = new LiteralEncoder();
-
-	int[] _matchDistances = new int[Base.kMatchMaxLen*2+2];
-
-	int _numFastBytes = kNumFastBytesDefault;
-	int _longestMatchLength;
-	int _numDistancePairs;
-
-	int _additionalOffset;
-
-	int _optimumEndIndex;
-	int _optimumCurrentIndex;
-
-	boolean _longestMatchWasFound;
-
-	int[] _posSlotPrices = new int[1<<(Base.kNumPosSlotBits+Base.kNumLenToPosStatesBits)];
-	int[] _distancesPrices = new int[Base.kNumFullDistances<<Base.kNumLenToPosStatesBits];
-	int[] _alignPrices = new int[Base.kAlignTableSize];
-	int _alignPriceCount;
-
-	int _distTableSize = (kDefaultDictionaryLogSize * 2);
-
-	int _posStateBits = 2;
-	int _posStateMask = (4 - 1);
-	int _numLiteralPosStateBits = 0;
-	int _numLiteralContextBits = 3;
-
-	int _dictionarySize = (1 << kDefaultDictionaryLogSize);
-	int _dictionarySizePrev = -1;
-	int _numFastBytesPrev = -1;
-
-	long nowPos64;
-	boolean _finished;
-	java.io.InputStream _inStream;
-
-	int _matchFinderType = EMatchFinderTypeBT4;
-	boolean _writeEndMark = false;
-
-	boolean _needReleaseMFStream = false;
-
-	void Create()
-	{
-		if (_matchFinder == null)
-		{
-			SevenZip.Compression.LZ.BinTree bt = new SevenZip.Compression.LZ.BinTree();
-			int numHashBytes = 4;
-			if (_matchFinderType == EMatchFinderTypeBT2)
-				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 BitTreeEncoder(Base.kNumPosSlotBits);
-	}
-
-	void SetWriteEndMarkerMode(boolean writeEndMarker)
-	{
-		_writeEndMark = writeEndMarker;
-	}
-
-	void Init()
-	{
-		BaseInit();
-		_rangeEncoder.Init();
-
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isMatch);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep0Long);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG0);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG1);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG2);
-		SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_posEncoders);
-
-
-
-
-
-
-
-		_literalEncoder.Init();
-		for (int i = 0; i < Base.kNumLenToPosStates; i++)
-			_posSlotEncoder[i].Init();
-
-
-
-		_lenEncoder.Init(1 << _posStateBits);
-		_repMatchLenEncoder.Init(1 << _posStateBits);
-
-		_posAlignEncoder.Init();
-
-		_longestMatchWasFound = false;
-		_optimumEndIndex = 0;
-		_optimumCurrentIndex = 0;
-		_additionalOffset = 0;
-	}
-
-	int ReadMatchDistances() throws java.io.IOException
-	{
-		int 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++;
-		return lenRes;
-	}
-
-	void MovePos(int num) throws java.io.IOException
-	{
-		if (num > 0)
-		{
-			_matchFinder.Skip(num);
-			_additionalOffset += num;
-		}
-	}
-
-	int GetRepLen1Price(int state, int posState)
-	{
-		return SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]) +
-				SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]);
-	}
-
-	int GetPureRepPrice(int repIndex, int state, int posState)
-	{
-		int price;
-		if (repIndex == 0)
-		{
-			price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]);
-			price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]);
-		}
-		else
-		{
-			price = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG0[state]);
-			if (repIndex == 1)
-				price += SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG1[state]);
-			else
-			{
-				price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG1[state]);
-				price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(_isRepG2[state], repIndex - 2);
-			}
-		}
-		return price;
-	}
-
-	int GetRepPrice(int repIndex, int len, int state, int posState)
-	{
-		int price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState);
-		return price + GetPureRepPrice(repIndex, state, posState);
-	}
-
-	int GetPosLenPrice(int pos, int len, int posState)
-	{
-		int price;
-		int 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);
-	}
-
-	int Backward(int cur)
-	{
-		_optimumEndIndex = cur;
-		int posMem = _optimum[cur].PosPrev;
-		int 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;
-				}
-			}
-			int posPrev = posMem;
-			int 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;
-	}
-
-	int[] reps = new int[Base.kNumRepDistances];
-	int[] repLens = new int[Base.kNumRepDistances];
-	int backRes;
-
-	int GetOptimum(int position) throws IOException
-	{
-		if (_optimumEndIndex != _optimumCurrentIndex)
-		{
-			int lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;
-			backRes = _optimum[_optimumCurrentIndex].BackPrev;
-			_optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;
-			return lenRes;
-		}
-		_optimumCurrentIndex = _optimumEndIndex = 0;
-
-		int lenMain, numDistancePairs;
-		if (!_longestMatchWasFound)
-		{
-			lenMain = ReadMatchDistances();
-		}
-		else
-		{
-			lenMain = _longestMatchLength;
-			_longestMatchWasFound = false;
-		}
-		numDistancePairs = _numDistancePairs;
-
-		int numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1;
-		if (numAvailableBytes < 2)
-		{
-			backRes = -1;
-			return 1;
-		}
-		if (numAvailableBytes > Base.kMatchMaxLen)
-			numAvailableBytes = Base.kMatchMaxLen;
-
-		int repMaxIndex = 0;
-		int 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;
-			int 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(0 - _repDistances[0] - 1 - 1);
-
-		if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)
-		{
-			backRes = -1;
-			return 1;
-		}
-
-		_optimum[0].State = _state;
-
-		int posState = (position & _posStateMask);
-
-		_optimum[1].Price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]) +
-				_literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!Base.StateIsCharState(_state), matchByte, currentByte);
-		_optimum[1].MakeAsChar();
-
-		int matchPrice = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]);
-		int repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[_state]);
-
-		if (matchByte == currentByte)
-		{
-			int shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);
-			if (shortRepPrice < _optimum[1].Price)
-			{
-				_optimum[1].Price = shortRepPrice;
-				_optimum[1].MakeAsShortRep();
-			}
-		}
-
-		int 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];
-
-		int len = lenEnd;
-		do
-			_optimum[len--].Price = kIfinityPrice;
-		while (len >= 2);
-
-		for (i = 0; i < Base.kNumRepDistances; i++)
-		{
-			int repLen = repLens[i];
-			if (repLen < 2)
-				continue;
-			int price = repMatchPrice + GetPureRepPrice(i, _state, posState);
-			do
-			{
-				int 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);
-		}
-
-		int normalMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[_state]);
-
-		len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
-		if (len <= lenMain)
-		{
-			int offs = 0;
-			while (len > _matchDistances[offs])
-				offs += 2;
-			for (; ; len++)
-			{
-				int distance = _matchDistances[offs + 1];
-				int 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;
-				}
-			}
-		}
-
-		int cur = 0;
-
-		while (true)
-		{
-			cur++;
-			if (cur == lenEnd)
-				return Backward(cur);
-			int newLen = ReadMatchDistances();
-			numDistancePairs = _numDistancePairs;
-			if (newLen >= _numFastBytes)
-			{
-
-				_longestMatchLength = newLen;
-				_longestMatchWasFound = true;
-				return Backward(cur);
-			}
-			position++;
-			int posPrev = _optimum[cur].PosPrev;
-			int state;
-			if (_optimum[cur].Prev1IsChar)
-			{
-				posPrev--;
-				if (_optimum[cur].Prev2)
-				{
-					state = _optimum[_optimum[cur].PosPrev2].State;
-					if (_optimum[cur].BackPrev2 < Base.kNumRepDistances)
-						state = Base.StateUpdateRep(state);
-					else
-						state = Base.StateUpdateMatch(state);
-				}
-				else
-					state = _optimum[posPrev].State;
-				state = Base.StateUpdateChar(state);
-			}
-			else
-				state = _optimum[posPrev].State;
-			if (posPrev == cur - 1)
-			{
-				if (_optimum[cur].IsShortRep())
-					state = Base.StateUpdateShortRep(state);
-				else
-					state = Base.StateUpdateChar(state);
-			}
-			else
-			{
-				int pos;
-				if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2)
-				{
-					posPrev = _optimum[cur].PosPrev2;
-					pos = _optimum[cur].BackPrev2;
-					state = Base.StateUpdateRep(state);
-				}
-				else
-				{
-					pos = _optimum[cur].BackPrev;
-					if (pos < Base.kNumRepDistances)
-						state = Base.StateUpdateRep(state);
-					else
-						state = Base.StateUpdateMatch(state);
-				}
-				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];
-			int curPrice = _optimum[cur].Price;
-
-			currentByte = _matchFinder.GetIndexByte(0 - 1);
-			matchByte = _matchFinder.GetIndexByte(0 - reps[0] - 1 - 1);
-
-			posState = (position & _posStateMask);
-
-			int curAnd1Price = curPrice +
-				SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]) +
-				_literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)).
-				GetPrice(!Base.StateIsCharState(state), matchByte, currentByte);
-
-			Optimal nextOptimum = _optimum[cur + 1];
-
-			boolean nextIsChar = false;
-			if (curAnd1Price < nextOptimum.Price)
-			{
-				nextOptimum.Price = curAnd1Price;
-				nextOptimum.PosPrev = cur;
-				nextOptimum.MakeAsChar();
-				nextIsChar = true;
-			}
-
-			matchPrice = curPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]);
-			repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state]);
-
-			if (matchByte == currentByte &&
-				!(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))
-			{
-				int shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);
-				if (shortRepPrice <= nextOptimum.Price)
-				{
-					nextOptimum.Price = shortRepPrice;
-					nextOptimum.PosPrev = cur;
-					nextOptimum.MakeAsShortRep();
-					nextIsChar = true;
-				}
-			}
-
-			int 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
-				int t = Math.min(numAvailableBytesFull - 1, _numFastBytes);
-				int lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t);
-				if (lenTest2 >= 2)
-				{
-					int state2 = Base.StateUpdateChar(state);
-
-					int posStateNext = (position + 1) & _posStateMask;
-					int nextRepMatchPrice = curAnd1Price +
-						SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
-						SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
-					{
-						int offset = cur + 1 + lenTest2;
-						while (lenEnd < offset)
-							_optimum[++lenEnd].Price = kIfinityPrice;
-						int 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;
-						}
-					}
-				}
-			}
-
-			int startLen = 2; // speed optimization 
-
-			for (int repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++)
-			{
-				int lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes);
-				if (lenTest < 2)
-					continue;
-				int lenTestTemp = lenTest;
-				do
-				{
-					while (lenEnd < cur + lenTest)
-						_optimum[++lenEnd].Price = kIfinityPrice;
-					int 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)
-				{
-					int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
-					int lenTest2 = _matchFinder.GetMatchLen(lenTest, reps[repIndex], t);
-					if (lenTest2 >= 2)
-					{
-						int state2 = Base.StateUpdateRep(state);
-
-						int posStateNext = (position + lenTest) & _posStateMask;
-						int curAndLenCharPrice =
-								repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) +
-								SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
-								_literalEncoder.GetSubCoder(position + lenTest,
-								_matchFinder.GetIndexByte(lenTest - 1 - 1)).GetPrice(true,
-								_matchFinder.GetIndexByte(lenTest - 1 - (reps[repIndex] + 1)),
-								_matchFinder.GetIndexByte(lenTest - 1));
-						state2 = Base.StateUpdateChar(state2);
-						posStateNext = (position + lenTest + 1) & _posStateMask;
-						int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]);
-						int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
-
-						// for(; lenTest2 >= 2; lenTest2--)
-						{
-							int offset = lenTest + 1 + lenTest2;
-							while (lenEnd < cur + offset)
-								_optimum[++lenEnd].Price = kIfinityPrice;
-							int 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 + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[state]);
-				while (lenEnd < cur + newLen)
-					_optimum[++lenEnd].Price = kIfinityPrice;
-
-				int offs = 0;
-				while (startLen > _matchDistances[offs])
-					offs += 2;
-
-				for (int lenTest = startLen; ; lenTest++)
-				{
-					int curBack = _matchDistances[offs + 1];
-					int 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)
-						{
-							int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
-							int lenTest2 = _matchFinder.GetMatchLen(lenTest, curBack, t);
-							if (lenTest2 >= 2)
-							{
-								int state2 = Base.StateUpdateMatch(state);
-
-								int posStateNext = (position + lenTest) & _posStateMask;
-								int curAndLenCharPrice = curAndLenPrice +
-									SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
-									_literalEncoder.GetSubCoder(position + lenTest,
-									_matchFinder.GetIndexByte(lenTest - 1 - 1)).
-									GetPrice(true,
-									_matchFinder.GetIndexByte(lenTest - (curBack + 1) - 1),
-									_matchFinder.GetIndexByte(lenTest - 1));
-								state2 = Base.StateUpdateChar(state2);
-								posStateNext = (position + lenTest + 1) & _posStateMask;
-								int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]);
-								int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
-
-								int 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;
-					}
-				}
-			}
-		}
-	}
-
-	boolean ChangePair(int smallDist, int bigDist)
-	{
-		int kDif = 7;
-		return (smallDist < (1 << (32 - kDif)) && bigDist >= (smallDist << kDif));
-	}
-
-	void WriteEndMarker(int posState) throws IOException
-	{
-		if (!_writeEndMark)
-			return;
-
-		_rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 1);
-		_rangeEncoder.Encode(_isRep, _state, 0);
-		_state = Base.StateUpdateMatch(_state);
-		int len = Base.kMatchMinLen;
-		_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
-		int posSlot = (1 << Base.kNumPosSlotBits) - 1;
-		int lenToPosState = Base.GetLenToPosState(len);
-		_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
-		int footerBits = 30;
-		int posReduced = (1 << footerBits) - 1;
-		_rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);
-		_posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);
-	}
-
-	void Flush(int nowPos) throws IOException
-	{
-		ReleaseMFStream();
-		WriteEndMarker(nowPos & _posStateMask);
-		_rangeEncoder.FlushData();
-		_rangeEncoder.FlushStream();
-	}
-
-	public void CodeOneBlock(long[] inSize, long[] outSize, boolean[] finished) throws IOException
-	{
-		inSize[0] = 0;
-		outSize[0] = 0;
-		finished[0] = true;
-
-		if (_inStream != null)
-		{
-			_matchFinder.SetStream(_inStream);
-			_matchFinder.Init();
-			_needReleaseMFStream = true;
-			_inStream = null;
-		}
-
-		if (_finished)
-			return;
-		_finished = true;
-
-
-		long progressPosValuePrev = nowPos64;
-		if (nowPos64 == 0)
-		{
-			if (_matchFinder.GetNumAvailableBytes() == 0)
-			{
-				Flush((int)nowPos64);
-				return;
-			}
-
-			ReadMatchDistances();
-			int posState = (int)(nowPos64) & _posStateMask;
-			_rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 0);
-			_state = Base.StateUpdateChar(_state);
-			byte curByte = _matchFinder.GetIndexByte(0 - _additionalOffset);
-			_literalEncoder.GetSubCoder((int)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte);
-			_previousByte = curByte;
-			_additionalOffset--;
-			nowPos64++;
-		}
-		if (_matchFinder.GetNumAvailableBytes() == 0)
-		{
-			Flush((int)nowPos64);
-			return;
-		}
-		while (true)
-		{
-
-			int len = GetOptimum((int)nowPos64);
-			int pos = backRes;
-			int posState = ((int)nowPos64) & _posStateMask;
-			int complexState = (_state << Base.kNumPosStatesBitsMax) + posState;
-			if (len == 1 && pos == -1)
-			{
-				_rangeEncoder.Encode(_isMatch, complexState, 0);
-				byte curByte = _matchFinder.GetIndexByte((int)(0 - _additionalOffset));
-				LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((int)nowPos64, _previousByte);
-				if (!Base.StateIsCharState(_state))
-				{
-					byte matchByte = _matchFinder.GetIndexByte((int)(0 - _repDistances[0] - 1 - _additionalOffset));
-					subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte);
-				}
-				else
-					subCoder.Encode(_rangeEncoder, curByte);
-				_previousByte = curByte;
-				_state = Base.StateUpdateChar(_state);
-			}
-			else
-			{
-				_rangeEncoder.Encode(_isMatch, complexState, 1);
-				if (pos < Base.kNumRepDistances)
-				{
-					_rangeEncoder.Encode(_isRep, _state, 1);
-					if (pos == 0)
-					{
-						_rangeEncoder.Encode(_isRepG0, _state, 0);
-						if (len == 1)
-							_rangeEncoder.Encode(_isRep0Long, complexState, 0);
-						else
-							_rangeEncoder.Encode(_isRep0Long, complexState, 1);
-					}
-					else
-					{
-						_rangeEncoder.Encode(_isRepG0, _state, 1);
-						if (pos == 1)
-							_rangeEncoder.Encode(_isRepG1, _state, 0);
-						else
-						{
-							_rangeEncoder.Encode(_isRepG1, _state, 1);
-							_rangeEncoder.Encode(_isRepG2, _state, pos - 2);
-						}
-					}
-					if (len == 1)
-						_state = Base.StateUpdateShortRep(_state);
-					else
-					{
-						_repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
-						_state = Base.StateUpdateRep(_state);
-					}
-					int distance = _repDistances[pos];
-					if (pos != 0)
-					{
-						for (int i = pos; i >= 1; i--)
-							_repDistances[i] = _repDistances[i - 1];
-						_repDistances[0] = distance;
-					}
-				}
-				else
-				{
-					_rangeEncoder.Encode(_isRep, _state, 0);
-					_state = Base.StateUpdateMatch(_state);
-					_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
-					pos -= Base.kNumRepDistances;
-					int posSlot = GetPosSlot(pos);
-					int lenToPosState = Base.GetLenToPosState(len);
-					_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
-
-					if (posSlot >= Base.kStartPosModelIndex)
-					{
-						int footerBits = (int)((posSlot >> 1) - 1);
-						int baseVal = ((2 | (posSlot & 1)) << footerBits);
-						int posReduced = pos - baseVal;
-
-						if (posSlot < Base.kEndPosModelIndex)
-							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++;
-						}
-					}
-					int distance = pos;
-					for (int i = Base.kNumRepDistances - 1; i >= 1; i--)
-						_repDistances[i] = _repDistances[i - 1];
-					_repDistances[0] = distance;
-					_matchPriceCount++;
-				}
-				_previousByte = _matchFinder.GetIndexByte(len - 1 - _additionalOffset);
-			}
-			_additionalOffset -= len;
-			nowPos64 += len;
-			if (_additionalOffset == 0)
-			{
-				// if (!_fastMode)
-				if (_matchPriceCount >= (1 << 7))
-					FillDistancesPrices();
-				if (_alignPriceCount >= Base.kAlignTableSize)
-					FillAlignPrices();
-				inSize[0] = nowPos64;
-				outSize[0] = _rangeEncoder.GetProcessedSizeAdd();
-				if (_matchFinder.GetNumAvailableBytes() == 0)
-				{
-					Flush((int)nowPos64);
-					return;
-				}
-
-				if (nowPos64 - progressPosValuePrev >= (1 << 12))
-				{
-					_finished = false;
-					finished[0] = false;
-					return;
-				}
-			}
-		}
-	}
-
-	void ReleaseMFStream()
-	{
-		if (_matchFinder != null && _needReleaseMFStream)
-		{
-			_matchFinder.ReleaseStream();
-			_needReleaseMFStream = false;
-		}
-	}
-
-	void SetOutStream(java.io.OutputStream outStream)
-	{ _rangeEncoder.SetStream(outStream); }
-	void ReleaseOutStream()
-	{ _rangeEncoder.ReleaseStream(); }
-
-	void ReleaseStreams()
-	{
-		ReleaseMFStream();
-		ReleaseOutStream();
-	}
-
-	void SetStreams(java.io.InputStream inStream, java.io.OutputStream outStream,
-			long inSize, long outSize)
-	{
-		_inStream = inStream;
-		_finished = false;
-		Create();
-		SetOutStream(outStream);
-		Init();
-
-		// if (!_fastMode)
-		{
-			FillDistancesPrices();
-			FillAlignPrices();
-		}
-
-		_lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
-		_lenEncoder.UpdateTables(1 << _posStateBits);
-		_repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
-		_repMatchLenEncoder.UpdateTables(1 << _posStateBits);
-
-		nowPos64 = 0;
-	}
-
-	long[] processedInSize = new long[1]; long[] processedOutSize = new long[1]; boolean[] finished = new boolean[1];
-	public void Code(java.io.InputStream inStream, java.io.OutputStream outStream,
-			long inSize, long outSize, ICodeProgress progress) throws IOException
-	{
-		_needReleaseMFStream = false;
-		try
-		{
-			SetStreams(inStream, outStream, inSize, outSize);
-			while (true)
-			{
-
-
-
-				CodeOneBlock(processedInSize, processedOutSize, finished);
-				if (finished[0])
-					return;
-				if (progress != null)
-				{
-					progress.SetProgress(processedInSize[0], processedOutSize[0]);
-				}
-			}
-		}
-		finally
-		{
-			ReleaseStreams();
-		}
-	}
-
-	public static final int kPropSize = 5;
-	byte[] properties = new byte[kPropSize];
-
-	public void WriteCoderProperties(java.io.OutputStream outStream) throws IOException
-	{
-		properties[0] = (byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
-		for (int i = 0; i < 4; i++)
-			properties[1 + i] = (byte)(_dictionarySize >> (8 * i));
-		outStream.write(properties, 0, kPropSize);
-	}
-
-	int[] tempPrices = new int[Base.kNumFullDistances];
-	int _matchPriceCount;
-
-	void FillDistancesPrices()
-	{
-		for (int i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++)
-		{
-			int posSlot = GetPosSlot(i);
-			int footerBits = (int)((posSlot >> 1) - 1);
-			int baseVal = ((2 | (posSlot & 1)) << footerBits);
-			tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders,
-				baseVal - posSlot - 1, footerBits, i - baseVal);
-		}
-
-		for (int lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++)
-		{
-			int posSlot;
-			BitTreeEncoder encoder = _posSlotEncoder[lenToPosState];
-
-			int 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) << SevenZip.Compression.RangeCoder.Encoder.kNumBitPriceShiftBits);
-
-			int st2 = lenToPosState * Base.kNumFullDistances;
-			int 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 (int i = 0; i < Base.kAlignTableSize; i++)
-			_alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);
-		_alignPriceCount = 0;
-	}
-
-
-	public boolean SetAlgorithm(int algorithm)
-	{
-		/*
-		_fastMode = (algorithm == 0);
-		_maxMode = (algorithm >= 2);
-		*/
-		return true;
-	}
-
-	public boolean SetDictionarySize(int dictionarySize)
-	{
-		int kDicLogSizeMaxCompress = 29;
-		if (dictionarySize < (1 << Base.kDicLogSizeMin) || dictionarySize > (1 << kDicLogSizeMaxCompress))
-			return false;
-		_dictionarySize = dictionarySize;
-		int dicLogSize;
-		for (dicLogSize = 0; dictionarySize > (1 << dicLogSize); dicLogSize++) ;
-		_distTableSize = dicLogSize * 2;
-		return true;
-	}
-
-	public boolean SetNumFastBytes(int numFastBytes)
-	{
-		if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen)
-			return false;
-		_numFastBytes = numFastBytes;
-		return true;
-	}
-
-	public boolean SetMatchFinder(int matchFinderIndex)
-	{
-		if (matchFinderIndex < 0 || matchFinderIndex > 2)
-			return false;
-		int matchFinderIndexPrev = _matchFinderType;
-		_matchFinderType = matchFinderIndex;
-		if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType)
-		{
-			_dictionarySizePrev = -1;
-			_matchFinder = null;
-		}
-		return true;
-	}
-
-	public boolean SetLcLpPb(int lc, int lp, int pb)
-	{
-		if (
-				lp < 0 || lp > Base.kNumLitPosStatesBitsEncodingMax ||
-				lc < 0 || lc > Base.kNumLitContextBitsMax ||
-				pb < 0 || pb > Base.kNumPosStatesBitsEncodingMax)
-			return false;
-		_numLiteralPosStateBits = lp;
-		_numLiteralContextBits = lc;
-		_posStateBits = pb;
-		_posStateMask = ((1) << _posStateBits) - 1;
-		return true;
-	}
-
-	public void SetEndMarkerMode(boolean endMarkerMode)
-	{
-		_writeEndMark = endMarkerMode;
-	}
-}
-