/// <summary>
		/// Performs inflate decompression on the given data.
		/// </summary>
		/// <param name="input">the data to decompress</param>
		/// <param name="output">the decompressed data</param>
		public static void DecompressZLib(byte[] input, byte[] output)
		{
			Inflater item = new Inflater();

			item.SetInput(input, 0, input.Length);
			item.Inflate(output, 0, output.Length);
		}

 public ZlibStream(Stream inner, Inflater inflater, int buffSize)
 {
     _innerStream = inner;
     _in = inflater;
     _inBuff = new byte[buffSize];
     _outBuff = _inBuff;
     _out = new Deflater();
 }

		void Inflate(MemoryStream ms, byte[] original, int level, bool zlib)
		{
			ms.Seek(0, SeekOrigin.Begin);
			
			Inflater inflater = new Inflater(!zlib);
			InflaterInputStream inStream = new InflaterInputStream(ms, inflater);
			byte[] buf2 = new byte[original.Length];

			int currentIndex  = 0;
			int count = buf2.Length;

			try
			{
				while (true) 
				{
					int numRead = inStream.Read(buf2, currentIndex, count);
					if (numRead <= 0) 
					{
						break;
					}
					currentIndex += numRead;
					count -= numRead;
				}
			}
			catch(Exception ex)
			{
				Console.WriteLine("Unexpected exception - '{0}'", ex.Message);
				throw;
			}

			if ( currentIndex != original.Length )
			{
				Console.WriteLine("Original {0}, new {1}", original.Length, currentIndex);
				Assert.Fail("Lengths different");
			}

			for (int i = 0; i < original.Length; ++i) 
			{
				if ( buf2[i] != original[i] )
				{
					string description = string.Format("Difference at {0} level {1} zlib {2} ", i, level, zlib);
					if ( original.Length < 2048 )
					{
						StringBuilder builder = new StringBuilder(description);
						for (int d = 0; d < original.Length; ++d)
						{
							builder.AppendFormat("{0} ", original[d]);
						}

						Assert.Fail(builder.ToString());
					}
					else
					{
						Assert.Fail(description);
					}
				}
			}
		}

		/// <exception cref="Sharpen.DataFormatException"></exception>
		protected internal override int SetInput(int pos, Inflater inf)
		{
			ByteBuffer s = buffer.Slice();
			s.Position(pos);
			byte[] tmp = new byte[Math.Min(s.Remaining(), 512)];
			s.Get(tmp, 0, tmp.Length);
			inf.SetInput(tmp, 0, tmp.Length);
			return tmp.Length;
		}

		byte[] Decrypt(byte[] encryptedData) {
			var reader = new BinaryReader(new MemoryStream(encryptedData));
			int headerMagic = reader.ReadInt32();
			if (headerMagic == 0x04034B50)
				throw new NotImplementedException("Not implemented yet since I haven't seen anyone use it.");

			byte encryption = (byte)(headerMagic >> 24);
			if ((headerMagic & 0x00FFFFFF) != 0x007D7A7B)	// Check if "{z}"
				throw new ApplicationException(string.Format("Invalid SA header magic 0x{0:X8}", headerMagic));

			switch (encryption) {
			case 1:
				int totalInflatedLength = reader.ReadInt32();
				if (totalInflatedLength < 0)
					throw new ApplicationException("Invalid length");
				var inflatedBytes = new byte[totalInflatedLength];
				int partInflatedLength;
				for (int inflateOffset = 0; inflateOffset < totalInflatedLength; inflateOffset += partInflatedLength) {
					int partLength = reader.ReadInt32();
					partInflatedLength = reader.ReadInt32();
					if (partLength < 0 || partInflatedLength < 0)
						throw new ApplicationException("Invalid length");
					var inflater = new Inflater(true);
					inflater.SetInput(encryptedData, checked((int)reader.BaseStream.Position), partLength);
					reader.BaseStream.Seek(partLength, SeekOrigin.Current);
					int realInflatedLen = inflater.Inflate(inflatedBytes, inflateOffset, inflatedBytes.Length - inflateOffset);
					if (realInflatedLen != partInflatedLength)
						throw new ApplicationException("Could not inflate");
				}
				return inflatedBytes;

			case 2:
				if (resourceDecrypterInfo.DES_Key == null || resourceDecrypterInfo.DES_IV == null)
					throw new ApplicationException("DES key / iv have not been set yet");
				using (var provider = new DESCryptoServiceProvider()) {
					provider.Key = resourceDecrypterInfo.DES_Key;
					provider.IV  = resourceDecrypterInfo.DES_IV;
					using (var transform = provider.CreateDecryptor()) {
						return Decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
					}
				}

			case 3:
				if (resourceDecrypterInfo.AES_Key == null || resourceDecrypterInfo.AES_IV == null)
					throw new ApplicationException("AES key / iv have not been set yet");
				using (var provider = new RijndaelManaged()) {
					provider.Key = resourceDecrypterInfo.AES_Key;
					provider.IV  = resourceDecrypterInfo.AES_IV;
					using (var transform = provider.CreateDecryptor()) {
						return Decrypt(transform.TransformFinalBlock(encryptedData, 4, encryptedData.Length - 4));
					}
				}

			default:
				throw new ApplicationException(string.Format("Unknown encryption type 0x{0:X2}", encryption));
			}
		}

        public static byte[] DecompressDeflate(byte[] data, int decompSize)
        {
            var decompData = new byte[decompSize];

            var inflater = new Inflater(true);
            inflater.SetInput(data);
            inflater.Inflate(decompData);

            return decompData;
        }

        public static byte[] DecompressAlphaValues(byte[] alphaValues, int width, int height)
        {
            var data = new byte[width * height];
            var inflater = new Inflater();
            inflater.SetInput(alphaValues);
            if (inflater.Inflate(data) != data.Length)
                throw new ArgumentException("Alpha values are not in valid compressed format!");

            return data;
        }

 /// <summary>
 /// ��ѹ�ֽ�������
 /// </summary>
 /// <param name="val">��������ֽ�������</param>
 /// <returns>���ؽ�ѹ�������</returns>
 public byte[] Decompress(byte[] val)
 {
     if (val[0] == 1) {
         Inflater inflater = new Inflater(true);
         using (InflaterInputStream decompressStream = new InflaterInputStream(new MemoryStream(UnwrapData(val)), inflater)) {
             return ArrayHelper.ReadAllBytesFromStream(decompressStream);
         }
     }
     else
         return UnwrapData(val);
 }

        public ChunkedChanges(bool compressed, CancellationToken token, ManualResetEventSlim pauseWait)
        {
            _innerStream = new ChunkStream();
            _innerStream.BookmarkReached += (sender, args) => OnCaughtUp?.Invoke(this, null);
            if (compressed) {
                _inflater = new Inflater(true);
            }

            token.Register(Dispose);
            _pauseWait = pauseWait;
            Task.Factory.StartNew(Process, TaskCreationOptions.LongRunning);
        }

 public static void HandleReqUpdateAccountData(Packet packet)
 {
     packet.ReadEnum<AccountDataType>("Type");
     packet.ReadTime("Time");
     int inflatedSize = packet.ReadInt32("Size");
     byte[] compressedData = packet.ReadBytes((int)packet.GetLength() - (int)packet.GetPosition());
     byte[] data = new byte[inflatedSize];
     var inflater = new Inflater();
     inflater.SetInput(compressedData, 0, compressedData.Length);
     inflater.Inflate(data, 0, inflatedSize);
     Console.WriteLine("Data: {0}", encoder.GetString(data));
 }

 public static byte[] Decompress(byte[] compressed, uint unzippedSize)
 {
     byte[] result = new byte[unzippedSize];
     Inflater inf = new Inflater();
     inf.SetInput(compressed);
     int error = inf.Inflate(result, 0, (int)unzippedSize);
     if (error == 0)
     {
         throw new FileLoadException("The a section of the swf file could not be decompressed.");
     }
     return result;
 }

 public CodecInputStream(Stream baseStream)
 {
     BinaryReader br = new BinaryReader(baseStream);
     decompressedSize = br.ReadInt32();
     compressedSize = br.ReadInt32();
     byte[] inbuf = new byte[compressedSize];
     baseStream.Read(inbuf, 0, compressedSize);
     Inflater inflater = new Inflater(false);
     inflater.SetInput(inbuf);
     byte[] buf = new byte[decompressedSize];
     inflater.Inflate(buf);
     this.iis = new MemoryStream(buf);
 }

		protected override void inflateVerify(int pos, Inflater inf)
        {
            while (!inf.IsFinished)
            {
                if (inf.IsNeedingInput)
                {
                    inf.SetInput(_array, pos, _array.Length - pos);
                    break;
                }
                inf.Inflate(VerifyGarbageBuffer, 0, VerifyGarbageBuffer.Length);
            }
            while (!inf.IsFinished && !inf.IsNeedingInput)
                inf.Inflate(VerifyGarbageBuffer, 0, VerifyGarbageBuffer.Length);
        }

 protected override int Inflate(int pos, byte[] b, int o, Inflater inf)
 {
     while (!inf.IsFinished)
     {
         if (inf.IsNeedingInput)
         {
             inf.SetInput(_array, pos, _array.Length - pos);
             break;
         }
         o += inf.Inflate(b, o, b.Length - o);
     }
     while (!inf.IsFinished && !inf.IsNeedingInput)
         o += inf.Inflate(b, o, b.Length - o);
     return o;
 }

		protected override int Inflate(int pos, byte[] dstbuf, int dstoff, Inflater inf)
        {
            while (!inf.IsFinished)
            {
                if (inf.IsNeedingInput)
                {
                    inf.SetInput(_array, pos, _array.Length - pos);
                    break;
                }
                dstoff += inf.Inflate(dstbuf, dstoff, dstbuf.Length - dstoff);
            }
            while (!inf.IsFinished && !inf.IsNeedingInput)
                dstoff += inf.Inflate(dstbuf, dstoff, dstbuf.Length - dstoff);
            return dstoff;
        }

        public static byte[] Decompress(byte[] input, int uncompressedLength, bool header = true)
        {
            Contract.Requires(input != null);
            Contract.Requires(uncompressedLength >= 0);
            Contract.Ensures(Contract.Result<byte[]>() != null);
            Contract.Ensures(Contract.Result<byte[]>().Length == uncompressedLength);

            var inflater = new Inflater(!header);
            var output = new byte[uncompressedLength];

            inflater.SetInput(input, 0, input.Length);
            inflater.Inflate(output);

            return output;
        }

		public static byte[] Decompress(byte[] content, int offset, int count)
		{
			//return content;
			Inflater decompressor = new Inflater();
			decompressor.SetInput(content, offset, count);

			using (MemoryStream bos = new MemoryStream(content.Length))
			{
				var buf = new byte[1024];
				while (!decompressor.IsFinished)
				{
					int n = decompressor.Inflate(buf);
					bos.Write(buf, 0, n);
				}
				return bos.ToArray();
			}
		}

        private void Uncompress(BinaryReader SWFBinary)
        {
            SWFBinary.BaseStream.Position = 4;
            int size = Convert.ToInt32(SWFBinary.ReadUInt32());

            byte[] UncompressedData = new byte[size];
            SWFBinary.BaseStream.Position = 0;
            SWFBinary.Read(UncompressedData, 0, 8);

            byte[] CompressedData = SWFBinary.ReadBytes(size);
            Inflater zipInflator = new Inflater();
            zipInflator.SetInput(CompressedData);
            zipInflator.Inflate(UncompressedData, 8, size - 8);

            MemoryStream m = new MemoryStream(UncompressedData);
            this.SWFBinary = new BinaryReader(m);
        }

 public Stream Open(Stream stream)
 {
     stream.Seek(DataOffset, SeekOrigin.Begin);
     byte[] data;
     if (DataCompression == 0)
     {
         data = stream.ReadBytes(DataSize);
     }
     else
     {
         var dataBuffer = stream.ReadBytes(DataCompressedSize);
         var inflater = new Inflater(false);
         inflater.SetInput(dataBuffer);
         data = new Byte[DataSize];
         inflater.Inflate(data);
     }
     return new MemoryStream(data);
 }

 public InflaterInputStream(Stream baseInputStream, Inflater inflater, int bufferSize)
 {
     this.isStreamOwner = true;
     if (baseInputStream == null)
     {
         throw new ArgumentNullException("baseInputStream");
     }
     if (inflater == null)
     {
         throw new ArgumentNullException("inflater");
     }
     if (bufferSize <= 0)
     {
         throw new ArgumentOutOfRangeException("bufferSize");
     }
     this.baseInputStream = baseInputStream;
     this.inf = inflater;
     this.inputBuffer = new InflaterInputBuffer(baseInputStream, bufferSize);
 }