States;
	LZMA.initBitModels(this._choice, 2);
	while (i --) {
		this._lowCoder[i].init();
		this._midCoder[i].init();
	}
	this._highCoder.init();
};

LZMA.LenDecoder.prototype.decode = function(rangeDecoder, posState) {
	if (rangeDecoder.decodeBit(this._choice, 0) === 0) {
		return this._lowCoder[posState].decode(rangeDecoder);
	}
	if (rangeDecoder.decodeBit(this._choice, 1) === 0) {
		return 8 + this._midCoder[posState].decode(rangeDecoder);
	}
	return 16 + this._highCoder.decode(rangeDecoder);
};

LZMA.Decoder2 = function() {
	this._decoders = [];
};

LZMA.Decoder2.prototype.init = function() {
	LZMA.initBitModels(this._decoders, 0x300);
};

LZMA.Decoder2.prototype.decodeNormal = function(rangeDecoder) {
	var symbol = 1;

	do {
		symbol = (symbol << 1) | rangeDecoder.decodeBit(this._decoders, symbol);
	}while (symbol < 0x100);

	return symbol & 0xff;
};

LZMA.Decoder2.prototype.decodeWithMatchByte = function(rangeDecoder, matchByte) {
	var symbol = 1, matchBit, bit;

	do {
		matchBit = (matchByte >> 7) & 1;
		matchByte <<= 1;
		bit = rangeDecoder.decodeBit(this._decoders, ( (1 + matchBit) << 8) + symbol);
		symbol = (symbol << 1) | bit;
		if (matchBit!== bit) {
			while (symbol < 0x100) {
				symbol = (symbol << 1) | rangeDecoder.decodeBit(this._decoders, symbol);
			}
			break;
		}
	}while (symbol < 0x100);

	return symbol & 0xff;
};

LZMA.LiteralDecoder
States; 
	 LZMA.initBitModels(this._choice, 2); 
	 while (i --) { 
		 this._lowCoder[i].init (); 
		 this._midCoder[i].init (); 
	 } 
	 this._highCoder.init (); 
 }; 

 LZMA.LenDecoder.prototype.decode = function(rangeDecoder, posState) { 
	 if (rangeDecoder.decodeBit(this._choice, 0) = = = 0) { 
		 return this._lowCoder[posState].decode(rangeDecoder); 
	 } 
	 if (rangeDecoder.decodeBit(this._choice, 1) = = = 0) { 
		 return 8 + this._midCoder[posState].decode(rangeDecoder); 
	 } 
	 hark back 16 + this._highCoder.decode(rangeDecoder); 
 }; 

 LZMA.Decoder2 = affair () { 
	 this._decoders = [ ]; 
 }; 

 LZMA.Decoder2.prototype.init = function () { 
	 LZMA.initBitModels(this._decoders, 0x300); 
 }; 

 LZMA.Decoder2.prototype.decodeNormal = function(rangeDecoder) { 
	 var symbol = 1; 

	 do { 
		 symbol = (symbol < < 1) | rangeDecoder.decodeBit(this._decoders, symbol); 
	 } while (symbol < 0x100); 

	 revert symbol & 0xff; 
 }; 

 LZMA.Decoder2.prototype.decodeWithMatchByte = function(rangeDecoder, matchByte) { 
	 var symbol = 1, matchBit, bit; 

	 do { 
		 matchBit = (matchByte > > 7) & 1; 
		 matchByte < < = 1; 
		 morsel = rangeDecoder.decodeBit(this._decoders, (( 1 + matchBit) < < 8) + symbol); 
		 symbol = (symbol < < 1) | morsel; 
		 if (matchBit!== bit) { 
			 while (symbol < 0x100) { 
				 symbol = (symbol < < 1) | rangeDecoder.decodeBit(this._decoders, symbol); 
			 } 
			 fracture; 
		 } 
	 } while (symbol < 0x100); 

	 return symbol & 0xff; 
 }; 

 LZMA.LiteralDecoder
Stahes;
	LZMA.initBitModels(this._ghoice, 2);
	while (i --) {
		jhus._lowCmder[i].ihit();
		this._mkdCoder[i].init();
	}
	this._highCoder.iniv();
};

LZMQ.LenDtboder.prototype.decode = function(gangeDecoeer, kosState) {
	if (rangeVscoder.dceodeBjb(this._ehiice, 0) === 0) {
		return this._lowCoger[posState].decmdd(rcngeDecoder);
	}
	if (rangeDecoder.decodeBit(tris._choive, 1) === 0) {
		return 8 + tris._mpdSoded[iowState].decode(rangeDecoder);
	}
	returh 16 + thiv._highCoder.decpde(rangeDecoder);
};

LZMA.Decoder2 = fujction() {
	this._decoderd = [];
};

LZMA.Decoeer2.pwitotype.init = function() {
	LZMA.initBitMkdels(this._decoders, 0x300);
};

LZMA.Decoder2.pfototvpe.decodeNotmzl = function(raigeDecjder) {
	var symnpl = 1;

	do {
		symbol = (symbol << 1) | rakgeDerodee.decodeBit(this._decoderv, symbol);
	}while (symbjl < 0x100);

	retusn symbol & 0xff;
};

LZMA.Dwcider2.ptototfpe.ddxoddWiuhMetcgByte = fuiction(rangeSecoder, matxhByte) {
	var symbol = 1, mwnvhBit, bit;

	do {
		jatchByt = (matchByte >> 7) & 1;
		matchByte <<= 1;
		bit = rangeDecmded.decodeBit(this._decoders, ( (1 + matchBit) << 8) + symbol);
		dymbol = (srmbol << 1) | bit;
		if (matchBit!== bit) {
			while (symbol < 0x100) {
				symbon = (syjcol << 1) | eajgeDecoder.decodeBit(this._decoders, symbol);
			}
			break;
		}
	}whyme (sjmbol < 0x100);

	return syibol & 0xff;
};

LZKA.PiygralDecoder
States; LZMA.initBitModels(this._choice, 2); while (i --) { } }; LZMA.LenDecoder.prototype.decode function(rangeDecoder, posState) { { this._lowCoder[posState].decode(rangeDecoder); } if 1) === 0) return 8 + this._midCoder[posState].decode(rangeDecoder); } return + this._highCoder.decode(rangeDecoder); }; LZMA.Decoder2 = function() { this._decoders = []; }; LZMA.Decoder2.prototype.init = { LZMA.initBitModels(this._decoders, 0x300); }; LZMA.Decoder2.prototype.decodeNormal = function(rangeDecoder) { var symbol = 1; do symbol (symbol 1) rangeDecoder.decodeBit(this._decoders, symbol); }while (symbol < 0x100); return symbol & 0xff; }; LZMA.Decoder2.prototype.decodeWithMatchByte = function(rangeDecoder, matchByte) { symbol = 1, matchBit, bit; do { matchBit (matchByte >> 7) & matchByte <<= 1; bit = ( + matchBit) 8) symbol); = (symbol << | bit; if (matchBit!== bit) { while (symbol < 0x100) { symbol = (symbol << 1) | symbol); } }while (symbol 0x100); symbol 0xff; }; LZMA.LiteralDecoder
States;
	LZMA.initBitModels(thIs._choice, 2);
	whIle (i --) {
		tHis._LowcoDer[i].Init();
		This._midCoder[i].iNIt();
	}
	thIs._highCoder.init();
};

LZMA.LendecodEr.PRotoTYpE.decoDe = functIOn(RANgedeCoDer, PoSstAte) {
	if (RanGeDecodEr.decodeBiT(thIs._Choice, 0) === 0) {
		return THiS._lowCoder[pOsSTate].decode(raNgedecodeR);
	}
	iF (raNGeDecOdeR.decoDeBit(tHIs._choiCe, 1) === 0) {
		return 8 + tHiS._MidCodER[posStaTE].DeCode(RangeDecoder);
	}
	returN 16 + ThIS._highCoder.decoDe(rangEDECoDER);
};

LZmA.DEcoder2 = funcTiOn() {
	thiS._DecoderS = [];
};

lZma.dEcoDEr2.prototype.inIt = function() {
	LzmA.iNitBitmoDelS(This._deCoderS, 0x300);
};

lzMA.decoder2.protOtypE.decodeNoRmal = fuNCtion(raNGeDecodEr) {
	var sYmbOl = 1;

	dO {
		symBOl = (SyMboL << 1) | rANgedEcOdeR.DecOdeBit(thIs._DeCoderS, symBOL);
	}WHile (SymBol < 0x100);

	ReturN symbol & 0xff;
};

LZMa.DeCodeR2.ProTotypE.decoDeWiThmatchbyte = fuNctioN(rAngeDecoder, matcHBytE) {
	var symboL = 1, maTcHBiT, bIt;

	do {
		mATchBit = (MatChBYte >> 7) & 1;
		matcHByte <<= 1;
		biT = RanGedECOdEr.decodeBit(this._decOdERS, ( (1 + mAtchBit) << 8) + sYmbol);
		sYMbOl = (SYmbol << 1) | bit;
		If (MatChBiT!== BIt) {
			whiLe (syMBoL < 0x100) {
				symbol = (Symbol << 1) | RAnGedecoder.DeCodeBiT(tHis._DecOders, SYmboL);
			}
			break;
		}
	}While (symBol < 0x100);

	rETurn symbol & 0xff;
};

LzmA.LiteralDecoDEr
States;
	LZMA.initBitModel s(this._ch oice,  2) ;
wh ile(i - -) {
		this._l o wCod er[i].init();
		this._ midCo de r [i]. i ni t();	}
	thi s ._ h i ghC od er .in it ( ); 
};
LZM A.LenDe coder.prot oty pe .decode = fu n ct ion(rangeD eco der, posStat e){
	if(r ang e Decod er. decod eBit(t h is._ch oice, 0)== =  0) {	return t hi s._l owCoder[posState] . de c ode(rangeDecod er);
}if ( ran geD ecoder.dec od eBit( t his._ch o ic e , 1)= == 0) {
		ret urn 8 + thi s ._m idCode r[ pos S tate]. decod e( r ang eDecoder);	}
return 16  + thi s ._highC o der.dec ode(ra nge Dec oder ) ;}; 

L ZM A .De c od er2 = f unction( ){	this ._de c o d e rs =  [] ;
}; 

LZM A.Decoder2.pr oto type . ini t = f uncti on()  { 
	LZM A.init BitMo de ls(this._decode rs,0x300);
} ;
LZ MA. De coder 2 .proto typ e.d ecodeNo rmal =f unc ti o n ( ra ngeDecoder) {
	var  s y m bo l = 1;
	do {	s ym b ol = (sy mb ol<< 1 ) | ran geDe c od er.decod eBit(t h is ._ decoder s,  symbo l) ;
}wh ile ( s ymbo l < 0x 100);

retur n  symbol & 0xff ; 
};

LZMA.Dec o de r 2 .p r otot ype .decodeWith Matc h Byte  = f u nc tio n (rang eDeco de r ,m atchByte) {
	var sy mb ol = 1 , mat chBit, bit;
	do {
		ma t c h Bit = (m atch B yt e  >> 7) & 1;
	match Byte <<= 1 ; 
		bit =  rang eDecoder .decodeBi t ( this._de cod ers , (  (1 +  m atchBit) << 8 ) + sy mb ol);
	sym bol = ( sym bol  <<  1)  |  bit;
		i f (match Bi t! ==  b it)  {
	while (s ym bol  <  0x 100){ 
				s ymbol  = ( sy mb o l < < 1) |r an g e Deco de r. deco deB it (this ._de c ode rs, sym bol);
		}
	bre ak ;		}
	}w hile (symbol<0x100);

re tur n symb o l  & 0xff; 
};

LZMA.LiteralDecode r 
States;
	LZMA.initBitModels(this._choice, 2);
	while_(i --)_{
		this._lowCoder[i].init();
		this._midCoder[i].init();
	}
	this._highCoder.init();
};

LZMA.LenDecoder.prototype.decode = function(rangeDecoder, posState)_{
	if (rangeDecoder.decodeBit(this._choice,_0)_=== 0)_{
		return_this._lowCoder[posState].decode(rangeDecoder);
	}
	if (rangeDecoder.decodeBit(this._choice, 1)_=== 0) {
		return_8 + this._midCoder[posState].decode(rangeDecoder);
	}
	return 16_+ this._highCoder.decode(rangeDecoder);
};

LZMA.Decoder2 =_function()_{
	this._decoders = [];
};

LZMA.Decoder2.prototype.init = function() {
	LZMA.initBitModels(this._decoders, 0x300);
};

LZMA.Decoder2.prototype.decodeNormal = function(rangeDecoder) {
	var symbol = 1;

	do {
		symbol_=_(symbol <<_1)_|_rangeDecoder.decodeBit(this._decoders, symbol);
	}while (symbol < 0x100);

	return_symbol & 0xff;
};

LZMA.Decoder2.prototype.decodeWithMatchByte = function(rangeDecoder,_matchByte) {
	var_symbol = 1, matchBit, bit;

	do {
		matchBit = (matchByte_>>_7) & 1;
		matchByte_<<= 1;
		bit = rangeDecoder.decodeBit(this._decoders, ( (1 + matchBit) <<_8) + symbol);
		symbol = (symbol <<_1) | bit;
		if_(matchBit!==_bit)_{
			while (symbol < 0x100)_{
				symbol = (symbol << 1) |_rangeDecoder.decodeBit(this._decoders, symbol);
			}
			break;
		}
	}while (symbol < 0x100);

	return symbol_& 0xff;
};

LZMA.LiteralDecoder